Bdtjtk

I'm relatively new to Python and I'm sure this is an error with the structure of my code, but I cannot seem to get the filemenu to display in my GUI. Can someone tell me what errors I have made with the filemenu inclusion? Also, I am sorry, but the spacing after copying and pasting is a little off. The class indentation level is proper on my side. I am using Python 3.71

Any other comments on better or more Pythonic ways to accomplish what I have here are also welcome and thank you for your help in advance!

from tkinter import *

from tkinter import ttk

import tkinter.scrolledtext as tkst

import os

import tkinter as tk

from functools import partial

from PIL import Image, ImageTk



class UserGui(tk.Tk):



    def __init__(self,parent):

        self.parent=parent

        self.widgets()



    def widgets(self):

        self.parent.configure(bg='white')

        self.frame1_style = ttk.Style()

        self.frame1_style.configure('My.TFrame', background='white')

        self.frame2_style = ttk.Style()

        self.frame2_style.configure('My2.TFrame',background='white')

        self.parent.title("TGUI")





        self.frame1 = ttk.Frame(self.parent, style='My.TFrame') #Creating Total Window Frame 1

        self.frame1.grid(row=0, column=0, sticky=(N, S, E, W))



        self.frame2 = ttk.Frame(self.parent, width=100, height=20, style='My2.TFrame')

        self.frame2.grid(row=0, column=6, padx=20, pady=5)





        #Menu Creation

        self.menu1 = tk.Menu(self.parent, tearoff=0)

        self.parent.config(menu=self.menu1)

        self.fileMenu = tk.Menu(self.menu1, tearoff=0)

        self.fileMenu.add_command(label="Open", command=self.donothing)

        self.fileMenu.add_command(label="Save", command=self.donothing)



        self.fileMenu.add_separator()



        self.fileMenu.add_command(label="Exit", command=self.parent.quit)

        self.fileMenu.add_cascade(label="File", menu=self.menu1)



        self.editMenu = tk.Menu(self.menu1, tearoff=0)

        self.editMenu.add_command(label="Cut", command=self.donothing)

        self.editMenu.add_command(label="Copy", command=self.donothing)

        self.editMenu.add_command(label="Paste", command=self.donothing)

        self.editMenu.add_cascade(label="Edit", menu=self.menu1)    



    def donothing(self):

        filewin = Toplevel(self.parent)

        button = Button(filewin, text="Do nothing button")

        button.pack()







def main():

    root=tk.Tk()

    ug=UserGui(root)

    root.mainloop()



if __name__ == '__main__':

    main()

Edit 1,2,3: I have corrected the add_cascade option for menu with menu=self.menu1 and I still do not have a file menu displaying.

EDIT: I'm sorry I didn't notice the Python-3 tag in time, it's all the same except when inherriting you would call super().__init__ instead of the Frame.__init__ directly. That would make it more Py3-like. Even so, this should still work.

Weirdly, pushing the menu.config down to the run function worked for me - even though it looks like it should work the way you did it.

def main():

    root=tk.Tk()

    ug=UserGui(root)

    root.config(menu=ug.fileMenu)

    root.mainloop()



if __name__ == '__main__':

    main()

Oterwise there are some things you can work on to make it more OOP like and readable. THis is how I usually handle making GUIs. The idea is to split the GUI's into Frames that then do simmilar things. I.e. your app could have left and right Frame where the RightFrame would hold the textbox ad the left Frame would actually have 2 sub frames - one for the names and dropdowns and the other for the buttons. That way each individual functionality is handled by the Frames themselves and it's not all in one giant class, the elements in those Frames are placed relative to the Frame's grid itself, while all the Frames are placed in the MainFrame's grid. This lets you split a lot of code into modules as well and helps with maintainability.

The sub-frames emit "global" events (events bothering other frames) by propagating them through the MainFrame, that's why they all carry a self.parent - their parent frame, and a self.root - the MainFrame. The MainFrame is also the Frame in which I like to put something like self.data which itself is a class on its own (outside Tkinter) that handles all the data input/output and logic so that you don't clutter the GUI code logic with data calculations and logic. Ideally the Data class would handle data errors and GUI would only then have to handle any errors in logic (such as selecting two impossible-to-combine options from the dropdown menus.

from tkinter import *

from tkinter import ttk



class SubFrame(Frame):

    def __init__(self, parent, text="Top Right"):

        Frame.__init__(self)

        self.pack()  

        self.parent = parent

        self.root = parent.root

        self.label=Label(self, text=text).pack()





class RightFrame(Frame):

    def __init__(self, parent):

        Frame.__init__(self, relief=RAISED, borderwidth=1)

        self.pack(side=RIGHT, fill=BOTH, expand=1)

        self.root = parent

        self.label = Label(self, text="Right Frame").pack()





class LeftFrame(Frame):

    def __init__(self, parent):

        Frame.__init__(self, relief=RAISED, borderwidth=1)

        self.pack(side=LEFT, fill=BOTH, expand=1)

        self.root = parent

        self.label = Label(self, text="Left Frame").pack()



        #again Frames which would have a parent class RightFrame and root MainFrame

        self.subFrame1 = SubFrame(self)

        self.subFrame2 = SubFrame(self, text="Top Right SubFrame 2") 



class MainFrame(Tk):

    def __init__(self):

        Tk.__init__(self)

        self.geometry("1100x600")

        self.title("Working Example")



        self.leftFrame = LeftFrame(self)

        self.rightFrame = RightFrame(self)

        #self.data = MagicalDataHandlingClass()







def run():

    app = MainFrame()

    app.mainloop()

EDIT answer to comments that are too long to fit

The call to Frame.__init__(...) is made because the class definition looks like class LeftFrame(Frame). Usually to declare a class what you would write is just class LeftFrame. When you add the bit in the () what is happening is called inheritance. When you inherit from a class (called parent), your class (called child) inherits all of the methods and attributes of parent. But much like you have to initialize your class to get an object, i.e. lf = LeftFrame(...) the parent class has to be initialized too. In Python this initialization is done by calling the special dunder __init__(...) function. So that call to Frame.__init__(...) happens because you need to tell the parent class what are all the values it needs to work properly. In Python 3 however it is recommended that instead of instantiating the parent by name like that you use the super function like super().__init__(....). This happens for a lot of complicated reasons most of which you probably don't have to worry about for a while yet (such as what if you inherit from multiple classes at the same time, what if you inherit from a class that inherited from a different one, etc...). I wouldn't try to feel overwhelmed by understanding the complete power of super() if you're just starting because 99% of the time in Python 3 just doing super().__init__(...) will do exactly what you want even if you don't understand. If you feel like getting in over your head Raymond Hettinger has a good writeup of Super is Super and why exactly it's so much better than old way.

I will post this answer for completeness considering @JasonHarper has not copied it to an answer format and I want others to be able to benefit from the post.

The key was the object that I was calling the add_cascade on the child Menu widget object instead of the main Menu widget object called self.menu1. The key was changing:

self.fileMenu.add_cascade(label="File", menu=self.menu1)

to :

self.menu1.add_cascade(label="File", menu=self.fileMenu)

This was the proper way of adding the fileMenu Menu object to the total Menu widget object of self.menu1.