How to recognize a button from its command?

Question

I have created a list of entries in a for-loop. All entries are stored in a list so I can just obtain all of the inputs later:

inputs = [e.get() for e in self.entries]

However, I have also created a button next to each entry in the for-loop (so they each call the same function). How can I make it so that it recognizes which button belongs to which row/entry? Is there something I can do with event?

row = 0
self.entries = []
self.comments = []
for n in names:
   e = Entry(self.top, bd = 5)
   e.insert(0, n)
   e.grid(column = 1, row = self.row, sticky = 'NSWE', padx = 5, pady = 5)
   self.entries.append(e)
   self.comments += [""]
   commentButton = Button(self.top, text = "comment", command = self.commentSelected)
   commentButton.grid(column = 3, row = self.row, sticky = 'NSWE', padx = 5, pady = 5)
   self.row = self.row + 1

Answer 1

Yes -- use Callback Shims ( Currying Functions )

( courtesy Russell Owen )

I find I often wish to pass extra data to a callback function, in addition that that normally given. For instance the Button widget sends no arguments to its command callback, but I may want to use one callback function to handle multiple buttons, in which case I need to know which button was pressed.

The way to handle this is to define the callback function just before you pass it to the widget and include any extra information that you require. Unfortunately, like most languages, Python doesn't handle the mixing of early binding (information known when the function is defined) and late binding (informtation known when the function is called) particularly well. I personally find the easiest and cleanest solution is:

Write my callback function to take all desired data as arguments. Use a callback shim class to create a callable object that stores my function and the extra arguments and does the right thing when called. In other words, it calls my function with the saved data plus the data that the caller supplies. I hope the example given below makes this clearer.

The callback shim I use is RO.Alg.GenericCallback, which is available in my RO package. A simplified version that does not handle keyword arguments is given in the example below. All shim code is based on a python recipe by Scott David Daniels, who calls this "currying a function" (a term that is probably more common than "callback shim").

#!/usr/local/bin/Python
"""                       Example showing use of a callback shim"""
import Tkinter

def doButton(buttonName):
    """                   My desired callback.
                          I'll need a callback shim
                          because Button command callbacks receive no arguments.
    """
    print buttonName, "pressed"

class SimpleCallback:
    """                   Create a callback shim.
                          Based on code by Scott David Daniels
                          (which also handles keyword arguments).
    """
    def __init__(self, callback, *firstArgs):
        self.__callback = callback
        self.__firstArgs = firstArgs

    def __call__(self, *args):
        return self.__callback (*(self.__firstArgs + args))


root = Tkinter.Tk()

buttonNames = ( "Button 1", "Button 2", "Button 3" )
for name in buttonNames:
    callback = SimpleCallback( doButton, name )
    Tkinter.Button( root, text = name, command = callback ).pack()

root.mainloop()