How to add multiple entries in tkinter? - python-3.x

I am extremely new to Tkinter. I have been trying to create something that basically calculates the average of the marks inputted. I am trying to give the user the option to choose the number of subjects, and accordingly create that many entries.
from tkinter import *
root = Tk()
x, y, d = 0, 0, {}
for i in range(1, int(input('Enter no of subjects')) + 1):
sub1 = Entry(root, width=15, borderwidth=5)
sub1.grid(row=x, column=y)
max1 = Entry(root, width=15, borderwidth=5)
max1.grid(row=x, column=y+2)
sub1label = Label(root, text='Marks attained', bg='grey', fg='white')
sub1label.grid(row=x, column=y+1)
max_sub1label = Label(root, text='Max Marks', bg='grey', fg='white')
max_sub1label.grid(row=x, column=y+3)
x += 1
root.mainloop()
Is there a way to store the data inputted each time so as to compute the percentage acquired? Or is there another method I can use?

You can store the values in the list and then index the list later on with the required value and get the items you wants. Here is your corrected code:
from tkinter import *
root = Tk()
def show():
for i in range(tot_sub): # Loop through the number of subjects
attained = attained_marks[i].get() # Get the indexed item from the list and use get()
max_mark = max_marks[i].get()
print(f'Attained marks: {attained}, Max marks: {max_mark}') # Print the values out
attained_marks = [] # Empty list to populate later
max_marks = [] # Empty list to populate later
tot_sub = int(input('Enter no. of subjects: ')) # Number of subjects
for i in range(tot_sub):
sub1 = Entry(root, width=15, borderwidth=5)
sub1.grid(row=i, column=0)
attained_marks.append(sub1) # Append each entry to the list
max1 = Entry(root, width=15, borderwidth=5)
max1.grid(row=i, column=2)
max_marks.append(sub1) # Append each entry to the list
sub1label = Label(root, text='Marks attained', bg='grey', fg='white')
sub1label.grid(row=i, column=1, padx=5)
max_sub1label = Label(root, text='Max Marks', bg='grey', fg='white')
max_sub1label.grid(row=i, column=3, padx=5)
root.bind('<Return>',lambda e: show()) # For demonstration of getting all the data
root.mainloop()
I have also changed the loop a bit as you don't need to initialize x,y,d and so on, as it can be easily achieved from inside the loop itself. I have also expanded the code so you can understand easily. Also I dont recommend using input() as it is for the terminal, use an Entry instead.
Alternatively: You can also use a dict and avoid the use of 2 lists, the dictionary would be something like {'Alternative Marks':[att1,att2,...],'Maximum Mark':[max1,max2,...]}, but this would make looping through and indexing a bit more lengthy.

Related

Updating label inside of function in tkinter

So i have problem with updating labels(i want to change colors of text) inside of function in tkinter. It works correctly when I use variable to store label however when i use list to do that, It doesnt. This how define labels.
for i in range(9):
for a in range(9):
if (NumbersSudoku[a][i] != 0):
label_frame = Frame(root, width=35, height=35, bg="white")
label_frame.grid_propagate(False)
label_frame.grid(row=i, column=a)
label[i][a] = Label(label_frame, text=NumbersSudoku[a][i], fg="blue", borderwidth=2, width=4, height=2,
relief="groove")
label[i][a].grid(row=i, column=a)
else:
label_frame = Frame(root, width=35, height=35, bg="white")
label_frame.grid_propagate(False)
label_frame.grid(row=i, column=a)
label[i][a] = Label(label_frame, borderwidth=2, textvariable=v[i][a], relief="groove", width=4, height=2,
fg='brown')
label[i][a].grid(row=i, column=a)
print(type(label[i][a]))
gnabel = Label(root, borderwidth=2, text='', relief="groove", width=4, height=2,
fg='brown')
gnabel.grid(row=14, column=14)
This is how i define list.
label = []
for x in range(9):
label.append([])
for y in range(9):
label[x].append([])
Inside a function printing types of variable and list returns diffrent results even tho when checked outside of function it returns the same <class 'tkinter.Label'>.
def base_info():
global gnabel
global label
print(type(gnabel)) # <class 'tkinter.Label'>
print(type(label)) # <class 'NoneType'>
............
# label[y][x] = Label(root, text=NumbersSudoku[y][x], fg="green").grid(row=y,column=x) # doesnt work
# gnabel = Label(root, text=NumbersSudoku[y][x], fg="orange").grid(row=14, column=14) # work
I can't really give you an answer in relation to your example, but I can give you an example using the function .config()
label = Label(root, fg = "green")
label.pack()
def update_label():
label.config(fg = "red")
update_label()
An explanation of what I've done is I've created the label with a foreground of green, and called a function which is going to change that to red. You can do this with text, with size, etc, as long as you use the config() function.
If you don't really understand what I'm saying, there are many youtube videos you can find which will give a better explanation of the config() function.

How to reproduce class within tkinter

I built a little Synchronizer GUI program, using tkinter. I recently tried adding a +-Button, which reproduces the filebrowsing buttons and entry fields, so I can sync more than 2 directories. (I.e. personally, I have my Documents as well as Pictures backed up on a USB drive that I want to keep updated, but I dont want to copy my whole /home directory.)
I have run into two issues. The first issue is with the positioning of the plus Button: I have initialized the rowcount to zero, so everytime I click the +-Button, the new line of Buttons/fields is actually on a new line. sadly, this does not work for the plus button, that is defined outside the fuction, but shouldn't self.rowcount += 1 adjust rowcount for the whole class?
Secondly, I am not sure how to handle self.sourcefile and self.targetfile: When I select a new folder, it replaces the previous input, which is not the idea.
I would really appreciate any help!
from tkinter import *
from tkinter import filedialog
class Application():
def __init__(self):
self.root = Tk()
self.rowcount = 0
self.sourcefile = ""
self.targetfile = ""
self.sourceDirectory = Entry(self.root, width=10)
self.targetDirectory = Entry(self.root, width=10)
self.sourceDirectory.insert(0, "Source")
self.targetDirectory.insert(1, "Target")
selectSource = Button(self.root, text = "browse source", command=self.select_source, height=15, width=15)
selectTarget = Button(self.root, text = "browse target", command=self.select_target, height=15, width=15)
plusButton = Button(self.root, text = "+", command=self.create_new)
self.sourceDirectory.grid(row=0, column=0)
self.targetDirectory.grid(row=0, column=5)
selectSource.grid(row=0, column=1)
selectTarget.grid(row=0, column=10)
plusButton.grid(row=self.rowcount + 1, column=10)
self.root.mainloop()
def create_new(self):
self.rowcount += 1
print(self.rowcount)
self.sourceDirectory = Entry(self.root, width=10)
self.targetDirectory = Entry(self.root, width=10)
self.sourceDirectory.insert(0, "Source")
self.targetDirectory.insert(1, "Target")
selectSource = Button(self.root, image=self.browsericon, command=self.select_source, height=15, width=15)
selectTarget = Button(self.root, image=self.browsericon, command=self.select_target, height=15, width=15)
self.sourceDirectory.grid(row=self.rowcount, column=0)
self.targetDirectory.grid(row=self.rowcount, column=5)
selectSource.grid(row=self.rowcount, column=1)
selectTarget.grid(row=self.rowcount, column=10)
def select_source(self):
source = filedialog.askdirectory(title="Select Source")
self.sourceDirectory.delete(0, END)
self.sourceDirectory.insert(0, source)
self.sourcefile = source
def select_target(self):
target = filedialog.askdirectory(title="Select Target")
self.targetDirectory.delete(0, END)
self.targetDirectory.insert(1, target)
self.targetfile = target
Application()
shouldn't self.rowcount += 1 adjust rowcount for the whole class?
Yes, and it does in your code. However, changing the variable won't change the location of a widget that used that variable in a grid command.
My advice is to put the rows in one frame and the buttons in another. That way you don't have to keep adjusting the location of the buttons. For example:
self.row_frame = Frame(self.root)
self.button_frame = Frame(self.root)
self.button_frame.pack(side="bottom", fill="x")
self.row_frame.pack(side="top", fill="both", expand=True
Also, if the "+" button creates a new row, it shouldn't be duplicating code. You need to have a single function for adding a row. Since you already have a function to do that, you can call that function in __init__.
Putting it all together it looks something like this:
class Application():
def __init__(self):
self.root = Tk()
self.root.title("File Synchronizer")
self.rowcount = 0
self.sourcefile = ""
self.targetfile = ""
self.row_frame = Frame(self.root)
self.button_frame = Frame(self.root)
self.button_frame.pack(side="bottom", fill="x")
self.row_frame.pack(side="top", fill="both", expand=True)
startSync = Button(self.button_frame, text="Start", command=self.synchronize)
plusButton = Button(self.button_frame, text = "+", command=self.create_new)
startSync.grid(row=1, column=2)
plusButton.grid(row=0, column=10)
self.create_new()
self.root.mainloop()
def create_new(self):
self.rowcount += 1
self.sourceDirectory = Entry(self.row_frame, width=10)
self.targetDirectory = Entry(self.row_frame, width=10)
self.sourceDirectory.insert(0, "Source")
self.targetDirectory.insert(1, "Target")
selectSource = Button(self.row_frame, text = "browse source", command=self.select_source)
selectTarget = Button(self.row_frame, text = "browse source", command=self.select_target)
self.sourceDirectory.grid(row=self.rowcount, column=0)
self.targetDirectory.grid(row=self.rowcount, column=5)
selectSource.grid(row=self.rowcount, column=1)
selectTarget.grid(row=self.rowcount, column=10)
This doesn't put the "plus" and "Start" button in exactly the same place, but that's just because it's somewhat irrelevant to the answer. You can use whatever options you want to place it in the button frame. Since the two frames are independent, you can adjust rows, columns, and weights in one without affecting the other. Or, you can use pack in one frame and grid in another.
The other problem with your code is that self.sourceDirectory and self.targetDirectory can only hold one value so it will always refer to the last widgets that were created.
Since you are creating multiple source and target widgets, you need to save them in a list.
For example, start by adding an empty list to your application in the __init__ method:
self.sources = []
self.targets = []
Then, when you add a new row, append it to the list:
source_entry = Entry(self.row_frame, width=10)
target_entry = Entry(self.row_frame, width=10)
self.sources.append(source_entry)
self.targets.append(target_entry)
You can then iterate over these two lists to process all source and target values.
You will also have to modify the callback for the browse functions to accept an index so that the button knows which entry to update.

Tkinter : Recording entries dynamically created by buttons

I'm trying to allow the user to enter as many strings as he wants by clicking some sort of '+' button, and keep the strings in a list. (He enters a first string, clicks '+', another entry box appears, etc.)
For the moment, here's what I've got:
def addEntry(window, r, e):
if r < 9:
global entries
entries.append(e.get())
r += 1
e = tk.Entry(window)
e.grid(column=1, row=r)
add = tk.Button(window, text=' + ', command=lambda:addEntry(window, r, e))
add.grid(column=2, row=r, sticky=tk.W)
else:
errmsg = 'Max. 10 items'
tk.Label(window, text=errmsg).grid(column=1, row=r+1)
import tkinter as tk
global entries # the main list of strings
entries = []
r = 0 # index for rows ; will not be 0 in the final code as there will be other widgets
win = tk.Tk()
e = tk.Entry(win)
e.grid(column=1, row=r)
add = tk.Button(win, text=' + ', command=lambda:addEntry(win, r, e))
add.grid(column=2, row=r, sticky=tk.W)
win.mainloop()
This isn't elegant, and the last entry is not recorded.
I've tried making entries a list of Entry() items (not e.get() items), but then I can't access the strings (TclError: invalid command name ".!entry4"). I've tried emulating this, which led me to make entries a global variable ; I've tried using this, but I don't fully understand the first answer, and as far as I can tell the strings aren't recorded ; I've tried adapting the class defined in the second answer, but I wasn't able to add buttons dynamically. (I like the idea of making a class, though.) I feel like I should be able to do this, but after a wasting a day on it, might as well ask for help.
Don't put the value in a list, put the actual widget. You should only call the get method when you actually need the values.
Also, I strongly recommend you put the entries in a dedicated frame. That way you don't have to worry about what other widgets might be in the window, and you don't have to juggle row and column numbers. Put them in a frame and use pack since they are stacked top-to-bottom and all share the same size.
Example:
import tkinter as tk
def addEntry(window):
global entries
if len(entries) > 10:
error_message.configure(text="Max. 10 items")
else:
error_message.configure(text="")
entry = tk.Entry(window)
entry.pack(side="top", fill="x")
entries.append(entry)
def show():
for entry in entries:
print("=>", entry.get())
entries = []
win = tk.Tk()
entry_frame = tk.Frame(win)
error_message = tk.Label(win)
error_message.grid(row=1, column=0, sticky="nsew")
add = tk.Button(win, text=' + ', command=lambda: addEntry(entry_frame))
show = tk.Button(win, text="Show values", command=show)
add.grid(row=0, column=1, sticky=tk.NW)
show.grid(row=0, column=2, sticky=tk.NW)
entry_frame.grid(row=0, column=0, sticky="nsew")
# create the first entry automatically
addEntry(entry_frame)
win.mainloop()

Passing OptionMenu into a callback (or retrieving a reference to the used widget)

I'm working on a (toplevel in a) GUI that consists of an array of 8 OptionMenus, each of them containing the same option list. Currently, Im building these widgets using a for-loop, and I save references in a dictionary. All OptionMenus link to the same (lambda) callback function.
To stay practical: the items in the option list represent a sequence of processing steps, and the user can alter the order of processes.
A change in one of the lists will result in one process being executed twice, and one process not at all. However, I want each item to occur only once. Hence, each user input should be accompanied by a second OptionMenu alteration.
For example: initial order 1-2-3 --> user changes the second process: 1-3-3, which autocorrects to: 1-3-2, where each process is again executed only once.
To my understanding, I can only get this to work if I have a reference to the OptionMenu that was just altered (from within the callback function). I was looking into passing the widget into the callback. The sample code is an attempt to implement the second suggested method, but the result is not what I would have expected.
The thing is that the OptionMenu widget seems to behave somewhat differently from other widgets. The OptionMenu does not allow for a re-defintion of the command function. No matter what input I pass along with the command function, the callback only seems to retrieve the OptionMenu selection, which is insufficient information for me to determine my process order.
Suggestions would be much apreciated!
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.grid(row=0, column=0, sticky=tk.N+tk.S+tk.E+tk.W)
self.create_widgets()
def create_widgets(self):
self.active_procs = ['proc 1','proc 2','proc 3','proc 4',
'proc 5','proc 6','proc 7','proc 8']
itemnr, widgets = dict(), dict()
for index in range(8):
name_construct = 'nr' + str(index)
itemnr[name_construct] = tk.StringVar(root)
itemnr[name_construct].set(self.active_procs[index])
widgets[name_construct] = tk.OptionMenu(self, itemnr[name_construct], *self.active_procs,
command=lambda widget=name_construct:
self.order_change(widget))
widgets[name_construct].grid(row=index+2, column=2, columnspan=2,
sticky="nwse", padx=10, pady=10)
def order_change(self,widget):
print(widget)
root = tk.Tk()
root.title("OptionMenu test")
app = Application(master=root)
root.mainloop()
The OptionMenu will pass the new value to the callback, so you don't have to do anything to get the new value. That's why your widget value isn't the value of name_construct -- the value that is passed in is overwriting the default value that you're supplying in the lambda.
To remedy this you simply need to add another argument so that you can pass the value of name_construct to the callback to go along with the value which is automatically sent.
It would look something like this:
widgets[name_construct] = tk.OptionMenu(..., command=lambda value, widget=name_construct: self.order_change(value, widget))
...
def order_change(self, value, widget):
print(value, widget)
Note: the OptionMenu isn't actually a tkinter widget. It's just a convenience function that creates a standard Menubutton with an associated Menu. It then creates one item on the menu for each option, and ties it all together with a StringVar.
You can get the exact same behavior yourself fairly easily. Doing so would make it possible to change what each item in the menu does when selected.
For those interested, below you can find an example code of how I got the widget behaviour I wanted. I took Bryan's advice to replace the OptionMenu for a Menubutton/Menu combination. I also made use of this post to find duplicate entries in my process order list.
Any thoughts or suggestions on how to implement this in a cleaner or shorter way, or how to get the same functionality with a different interface (e.g. drag and drop), are ofcourse welcome!
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.grid(row=0, column=0, sticky=tk.N+tk.S+tk.E+tk.W)
self.create_widgets()
def create_widgets(self):
# Assisting text
l1 = tk.Label(self, text = "Data in", font=(None, 15))
l1.grid(row=0, column=2)
l2 = tk.Label(self, text = u'\N{BLACK DOWN-POINTING TRIANGLE}', font=(None, 15))
l2.grid(row=1, column=2)
l3 = tk.Label(self, text = "Data out", font=(None, 15))
l3.grid(row=11, column=2)
l4 = tk.Label(self, text = u'\N{BLACK DOWN-POINTING TRIANGLE}', font=(None, 15))
l4.grid(row=10, column=2)
# Process list
self.active_procs = ['proc a','proc b','proc c','proc d',
'proc e','proc f','proc g','proc h']
self.the_value, self.widgets, self.topmenu = dict(), dict(), dict()
for index in range(8):
name_construct = 'nr' + str(index)
self.the_value[name_construct] = tk.StringVar(root)
self.the_value[name_construct].set(self.active_procs[index])
self.widgets[name_construct] = tk.Menubutton(self, textvariable=
self.the_value[name_construct],
indicatoron=True)
self.topmenu[name_construct] = tk.Menu(self.widgets[name_construct],
tearoff=False)
self.widgets[name_construct].configure(menu=self.topmenu[name_construct])
for proc in self.active_procs:
self.topmenu[name_construct].add_radiobutton(label=proc, variable=
self.the_value[name_construct],
command=lambda proc=proc,
widget=name_construct:
self.order_change(proc,widget))
self.widgets[name_construct].grid(row=index+2, column=2, columnspan=2,
sticky="nwse", padx=10, pady=10)
def order_change(self,proc,widget):
# Get the index of the last changed Menubutton
index_user_change = list(self.widgets.keys()).index(widget)
procs_order = [] # Current order from widgets
for index in range(8):
name_construct = 'nr' + str(index)
procs_order.append(self.widgets[name_construct].cget("text"))
# 1 change may lead to 1 double and 1 missing process
doubles = self.list_duplicates_of(procs_order,proc)
if len(doubles) == 2: # If double processes are present...
doubles.remove(index_user_change) # ...remove user input, change the other
missing_proc = str(set(self.active_procs)^set(procs_order)).strip('{"\'}')
index_change_along = int(doubles[0])
# Update references
self.active_procs[index_user_change] = proc
self.active_procs[index_change_along] = missing_proc
# Update widgets
name_c2 = 'nr'+str(index_change_along)
self.the_value[name_c2].set(self.active_procs[index_change_along])
self.widgets[name_c2].configure(text=missing_proc)
def list_duplicates_of(self,seq,item):
start_at = -1
locs = []
while True:
try:
loc = seq.index(item,start_at+1)
except ValueError:
break
else:
locs.append(loc)
start_at = loc
return locs
root = tk.Tk()
root.title("OptionMenu test")
app = Application(master=root)
root.mainloop()

Imposible change text in a tkinter label

I'm making an editor with tkinter, I've made a status bar and i have 2 labels to show the actual line and column, and the total number of lines but the text of the labels don't change anything.
My code is very very long to show here.
I figure out the line, column and lines with these 2 functions:
def get_position(self, event=None):
"""get the line and column number of the text insertion point"""
self.line = tk.StringVar()
self.column = tk.StringVar()
self.line, self.column = self.textView.index('insert').split('.')
self.s = tk.StringVar()
self.s.set(('Line : {0} - Column : {1}'.format(self.line, self.column)))
print(self.s)
return self.s
def getwindowlines(self, event=None):
self.numberoflines = int(self.textView.index('end-1c').split('.')[0])
return self.numberoflines
And the function of my status bar is the next one:
def statusBar(self):
self.frameStatus = tk.Frame(self.master, border=2, bg='#272822',
relief='sunken')
self.frameStatus.pack(side='bottom', after=self.toolbar,
fill='x', padx=5, pady=1)
numberoflinestxt = str(self.getwindowlines())
self.labelNumberOfLines = tk.Label(self.frameStatus,
text='Lines: {0} '.format(numberoflinestxt))
self.labelNumberOfLines.configure(bg='#272822', fg='white')
self.labelNumberOfLines.pack(side='right', fill='x', padx=10, pady=2)
self.labelLinePosition = tk.Label(self.frameStatus,
textvariable=self.get_position())
self.labelLinePosition.configure(bg='#272822', fg='white')
self.labelLinePosition.pack(side='left', fill='x', padx=10, pady=2)
All the code is in Github Code Link in the file IdlePlus.py
With print console all works fine, but with a Label the numbers of lines and columns don't change.
Thanks
Your code doesn't seem to be trying to change the labels in the statusbar. I don't understand why you think they should change. In your get_position function you're creating new StringVars each time it is called.
I wouldn't use StringVars at all here, though you can. If you want to use them, you create them exactly once and associate them with Label widgets, and then whenever you want the labels to change, you change the variables. If you want to use .format(...), you have to call that when you change the values, not when you create the label.
For example:
def statusBar(self):
...
self.line = tk.StringVar()
self.column = tk.StringVar()
self.labelLinePosition = tk.Label(self.frameStatus,
textvariable=self.self.column)
self.labelLinePosition = tk.Label(self.frameStatus,
textvariable=self.column)
...
def get_position(self):
line, column = self.textView.index('insert').split('.')
self.line.set("Line: {0}".format(line))
self.column.set("Position: {0}".format(column)
That will cause the labels to update every time get_position is called.
However, there's really no need for the special StringVars. You can directly set the text of the label, eliminating a couple of objects and thus reducing the complexity of your code slightly:
def statusbar(self):
...
self.labelNumberOfLines = tk.Label(self.frameStatus)
self.labelLinePosition = tk.Label(self.frameStatus)
...
def get_position(self):
line, column = self.textView.index('insert').split('.')
self.labelNumberOfLines.configure(text="Lines: {0}".format(lines))
self.labelLinePosition.configure(text="Character: {0}".format(column))

Resources