I use .place command to indicate the place of "TEXT" (100, 70), but cannot reflect in the window even if changing it to any coordinate.
Could you specify the problem?
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.pack()
self.create_widgets()
self.master.geometry("600x300")
def create_widgets(self):
self.msg1 = tk.Label(self, text = "TEXT")
self.msg1.place(x = 100, y = 70)
self.msg1.pack()
if __name__ == "__main__":
root = tk.Tk()
app = Application(master = root)
app.mainloop()
Few corrections to make:
Don't use .pack() geometry manager after .place geometry manager, or pack() will over ride .place() manager:
def create_widgets(self):
self.msg1 = tk.Label(self, text = "TEXT")
self.msg1.place(x = 100, y = 230)
Use fill and expand parameter to pack the Frame:
self.pack(fill=tk.BOTH,expand=1)
Here is the code:
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.pack(fill=tk.BOTH,expand=1)
self.create_widgets()
self.master.geometry("600x300")
def create_widgets(self):
self.msg1 = tk.Label(self, text = "TEXT")
self.msg1.place(x = 100, y = 230)
if __name__ == "__main__":
root = tk.Tk()
app = Application(master = root)
app.mainloop()
Don't use both .pack() and .place(), use one of them instead.
Let's say to use .place():
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.create_widgets()
self.place(relwidth = 1, relheight = 1)
self.master.geometry("600x300")
def create_widgets(self):
self.msg1 = tk.Label(self, text = "TEXT")
self.msg1.place(x = 100, y = 70)
if __name__ == "__main__":
root = tk.Tk()
app = Application(master = root)
app.mainloop()
I replaced self.pack() with self.place(relwidth = 1, relheight = 1), so the frame will be always wide as the window.
Then I deleted self.msg1.pack().
Now it should work.
Related
i am trying to create parts of my customtkinter-app in other classes so i can then assign them to the App class. But i must do something wrong. As you can see the goal is to place the labeltext from "self.label" to the middle of the frame "self.frame_rot"
Please check my code:
import tkinter
import customtkinter as ctk
class Frame1(ctk.CTkFrame):
def __init__(self, master):
super().__init__(master)
self.frame_rot = ctk.CTkFrame(master, height = 100, width = 100, fg_color = 'red').grid(row = 0, column = 0)
self.label = ctk.CTkLabel(self.frame_rot, text = 'hallo').place(relx = 0.5, rely = 0.5, anchor = 'center')
class App(ctk.CTk):
def __init__(self):
super().__init__()
self.geometry('500x500')
self.title('TestApp')
self.frame = Frame1(self)
if __name__ == "__main__":
app = App()
app.mainloop()
I just dont know what to do from here on!!
try this:
import tkinter
import customtkinter as ctk
class App(ctk.CTk):
def __init__(self):
super().__init__()
self.geometry('500x500')
self.title('TestApp')
self.frame = Frame1(self)
class Frame1(ctk.CTkFrame):
def __init__(self, master):
super().__init__(master)
#if you remove this, the "red block" will stick to the upper left corner
master.grid_columnconfigure(0, weight=1)
master.grid_rowconfigure(0, weight=1)
self.frame_rot = ctk.CTkFrame(master=master, fg_color='red')
self.frame_rot.grid(row=0, column=0)
#sticky "ns" will centralize the label vertically
self.label = ctk.CTkLabel(master=self.frame_rot, text='hallo', height=130)
self.label.grid(row=0, column=0, sticky="ns")
if __name__ == "__main__":
app = App()
app.mainloop()
I am writing a GUI with the screen of Raspberry.Each time I destroy a GUI and call a new GUI there will be a delay of about a few seconds to make the user see the raspberry's desktop. I want to draw a loading interface down to the background so that when I switch the screen the user won't see the raspberry desktop. I use this code:
from tkinter import *
class Load_Screen:
def __init__(self, master):
self.master = master
self.master.configure(background='white')
self.frame = Frame(self.master)
self.frame.pack()
self.canvas = Canvas(self.frame, width = 350, height = 250)
self.canvas.configure(background='white')
self.canvas.pack()
self.img = PhotoImage(file="image/loading.png")
self.canvas.create_image(55,150, anchor=W, image=self.img)
newWindow = Toplevel(self.master)
newWindow.geometry("700x500")
app = Main_Screen(newWindow)
class Main_Screen:
def __init__(self, master):
self.master = master
self.frame = Frame(self.master)
self.frame.pack()
def main():
root = Tk()
root.geometry("760x600")
app = Load_Screen(root)
root.mainloop()
if __name__ == '__main__':
main()
However, the loading screen overrides the main screen. And I want the opposite, the bottom loading screen and the main screen above
This is my solution which i have found at
How to make a Tkinter window jump to the front?
from tkinter import *
class Load_Screen:
def __init__(self, master):
self.master = master
self.master.configure(background='white')
self.frame = Frame(self.master)
self.frame.pack()
self.canvas = Canvas(self.frame, width = 350, height = 250)
self.canvas.configure(background='white')
self.canvas.pack()
self.img = PhotoImage(file="image/loading.png")
self.canvas.create_image(55,150, anchor=W, image=self.img)
newWindow = Toplevel(self.master)
newWindow.geometry("700x500")
app = Main_Screen(newWindow)
class Main_Screen:
def __init__(self, master):
self.master = master
self.frame = Frame(self.master)
self.frame.pack()
def main():
root = Tk()
root.geometry("760x600")
root.lift()
app = Load_Screen(root)
root.mainloop()
if __name__ == '__main__':
main()
Use root.lift() make Load_Screen below Main_Screen
I am trying to create multiple windows using tkinter , but i am having no success so far ... When i create a child window and put a button on it , the button is created in the parent window!
from tkinter import *
class Login_screen(Frame):
def __init__(self,master):
Frame.__init__(self, master)
self.grid()
self.button1 = Button(text = "Open",command = lambda: self.open_login())
self.button1.grid()
def open_login(self):
self.root2 = Toplevel()
self.root2.geometry("400x200")
self.app2 = Main_screen(self.root2)
class Main_screen(Frame):
def __init__(self,master):
Frame.__init__(self,master)
self.grid()
self.button = Button(text = "Close",command = lambda: self.close_windows())
self.button.grid()
def close_windows(self):
self.grid_forget()
root = Tk()
root.geometry("800x600")
app = Login_screen(root)
root.mainloop()
You need to supply the Button() with the master argument:
self.button = Button(master = self, text = "Close",command = lambda: self.close_windows())
master is the first arg to a widget so it can also be done via: Button(self, text=...)
This is good practice and you should get in the habit of always explicitly providing master, otherwise Tk defaults this arg to None and will place it on the root window.
I am trying to create a main screen that is displayed only if the login is successful, but i cant figure out how to make the main screen visible/invisible
from tkinter import *
class Login_screen(Frame):
def __init__(self,master):
self.open_login()
def open_login(self):
self.root2 = Toplevel()
self.root2.geometry("400x200")
self.grid_forget()
self.app2 = Main_screen(self.root2)
class Main_screen(Frame):
def __init__(self,master):
Frame.__init__(self,master)
self.master.grid()
self.button = Button(master = self,text = "Close",command = lambda: self.close_windows())
self.button.grid()
def close_windows(self):
self.master.destroy()
Login_screen.master.grid()
root = Tk()
root.geometry("800x600")
app = Login_screen(root)
root.mainloop()
I figured out how it works:
from tkinter import *
class Main_screen(Frame):
def __init__(self,master):
Frame.__init__(self, master)
self.grid()
self.text = Label(text="Janela")
self.text.grid()
root.withdraw()
self.create_login()
def create_login(self):
self.root2 = Toplevel()
self.app2 = Login_screen(self.root2)
class Login_screen(Frame):
def __init__(self,master):
Frame.__init__(self,master)
self.grid()
self.botao1 = Button(self,text="Appear",command = lambda: self.show_main())
self.botao1.grid()
def show_main(self):
self.master.destroy()
root.deiconify()
root = Tk()
app = Main_screen(root)
root.mainloop()
I am trying to create a program in tkinter which allows me to open an initial window then to keep it throughout all classes used. For example, if I was to create a button in a window then when I click this button, it would exuecute a method that destroys the widget, and then executes a new class that builds a new screen within the same window, such as text opposed to a button.
from tkinter import *
class Window1:
def __init__(self, master):
self.master = master
self.label = Button(self.master, text = "Example", command = self.load_new)
self.label.pack()
def load_new(self):
self.label.destroy()
## Code to execute next class
class Window2:
def __init__(self, master):
self.master = master
self.label = Label(self.master, text = "Example")
self.label.pack()
def main():
root = Tk()
run = Window1(root)
root.mainloop()
if __name__ == '__main__':
main()
I understand this is less practical, but I am curious. Cheers.
Tk() creates main window and variable root gives you access to this window. You can use root as argument for Window2 and you will have access to main window inside Window2
from tkinter import *
class Window1:
def __init__(self, master):
# keep `root` in `self.master`
self.master = master
self.label = Button(self.master, text="Example", command=self.load_new)
self.label.pack()
def load_new(self):
self.label.destroy()
# use `root` with another class
self.another = Window2(self.master)
class Window2:
def __init__(self, master):
# keep `root` in `self.master`
self.master = master
self.label = Label(self.master, text="Example")
self.label.pack()
root = Tk()
run = Window1(root)
root.mainloop()
--
Probably nobody use another class to create Label in place of Button ;)
--
EDIT: In this example using names Window1 and Windows2 is misleading because there is only one window and two classes which use this window. I would rather use names FirstOwner, SecondOwner
Everything is implemented in one Tk class and in this case there always is only one window.
from tkinter import *
from tkinter import ttk
class MainWindow():
def __init__(self, mainWidget):
self.main_frame = ttk.Frame(mainWidget, width=300, height=150, padding=(0, 0, 0, 0))
self.main_frame.grid(row=0, column=0)
self.some_kind_of_controler = 0
self.main_gui()
def main_gui(self):
root.title('My Window')
self.main_label_1 = ttk.Label(self.main_frame, text='Object_1')
self.main_label_1.grid(row=0, column=0)
self.main_label_2 = ttk.Label(self.main_frame, text='Object_2')
self.main_label_2.grid(row=1, column=0)
self.main_label_3 = ttk.Label(self.main_frame, text='Object_3')
self.main_label_3.grid(row=2, column=0)
self.setings_button = ttk.Button(self.main_frame, text='Setings')
self.setings_button.grid(row=0, column=1)
self.setings_button.bind('<Button-1>', self.setings_gui)
self.gui_elements = [self.main_label_1,
self.main_label_2,
self.main_label_3,
self.setings_button]
def setings_gui(self, event):
self.gui_elements_remove(self.gui_elements)
root.title('Setings')
self.main_label_1 = ttk.Label(self.main_frame, text='Object_1')
self.main_label_1.grid(row=2, column=0)
self.main_menu_button = ttk.Button(self.main_frame, text='Main menu')
self.main_menu_button.grid(row=0, column=1)
self.main_menu_button.bind('<Button-1>', self.back_to_main)
self.some_kind_of_controler = 1
self.gui_elements = [self.main_label_1,
self.main_menu_button]
def back_to_main(self, event):
if self.some_kind_of_controler == 1:
self.gui_elements_remove(self.gui_elements)
else:
pass
self.main_gui()
def gui_elements_remove(self, elements):
for element in elements:
element.destroy()
def main():
global root
root = Tk()
root.geometry('300x150+50+50')
window = MainWindow(root)
root.mainloop()
if __name__ == '__main__':
main()