如何让鼠标点击子标签传递到父画布，以便我可以执行我的回调功能？

Question

I'm converting my old Sudoku program from Ruby 1.8 to Python 2.7.8.10 . Worked just fine in Ruby. I use Tkinter rectangles (create_rectangle) for the sudoku board's cells/tiles and Tkinter text (create_text) for the Sudoku numbers. Both widgets are drawn on a canvas ( middleCenterCanvas ).

Problem : the numbers ( entryNumbers ) cover the canvas and block my mouse clicks, forcing me to click around the numbers' edges to do my bind callback functionality (mainCellClickedProc()) . See this Sudoku screen shot. Been all through stackoverflow.com, TkDocs.com and a slew of books and tutorials, with no luck so far. Can't figure why the tag_bind below (in createCellEntryNumbers()) won't work either.

Question : how to do I get the mouse clicks on the numbers to pass through to the canvas so I can fire off my callback function?

self.middleCenterFrame.pack(side=LEFT, fill=BOTH, expand=True)
self.middleCenterCanvas = Canvas(
        self.middleCenterFrame, borderwidth=0,
        width=435, height=455, relief=GROOVE, 
        highlightthickness=0, background=self.fillColor)
self.middleCenterCanvas.pack(fill=BOTH, expand=True, padx=0, pady=0)


def drawCells(self, cellSize, xr1c1, yr1c1):
        for i in range (9):  #  Cell Rows
            xul = xr1c1
            yul = yr1c1 + (i * cellSize) 
            xlr = xul + cellSize
            ylr = yul + cellSize
            for j in range(9):  #  Cell Columns
                self.boardRects[(i * 9) + j] = \
                    self.middleCenterCanvas.create_rectangle(\
                    xul, yul, xlr, ylr, fill=self.fillColor, \
                    outline=self.lineColor, width=self.cellLineWidth\
                )
                xul += cellSize
                xlr += cellSize
        self.middleCenterCanvas.pack()

def createCellEntryNumbers(self):
        xul = self.xr1c1
        yul = self.yr1c1
        xlr = self.xr1c1 + self.cellSize
        ylr = self.yr1c1 + self.cellSize

        #  Cell Rows
        for i in range (9):
            xul = self.xr1c1
            yul = self.yr1c1 + (i * self.cellSize) 
            xlr = xul + self.cellSize
            ylr = yul + self.cellSize
            for j in range(9):
                self.entryNumberTags [(i * 9) + j] = \
                    self.middleCenterCanvas.create_text( \
                    (xul+(self.cellSize/2)), (yul+(self.cellSize/2)), \
                    fill=self.lineColor, \
                    width=self.cellNumberWidth, font=self.cellNumberFont
                )
                self.entryNumbersWindow [(i * 9) + j] = \
                    self.middleCenterCanvas.create_window( \
                    (xul+(self.cellSize/2)), (yul+(self.cellSize/2)), \
                    anchor=NW, window=self.entryNumberTags [(i * 9) + j])
                xul += self.cellSize
                xlr += self.cellSize
                self.middleCenterCanvas.tag_bind(self.entryNumberTags[(i     * 9) + j], \
                    '<Button>', lambda e:     self.mainCellClickedProc(e.num, e.x, e.y))

def writeEntryNumber(self, num, x, y, fgCol, bgCol):
        if self.cellValues[self.calcCellFromXYCoords(x, y)] == self.sillyNilly:
            entryNumText = " "
        else:
            entryNumText = str(num)
        self.entryNumbers[self.calcCellFromXYCoords(x, y)] = \
            Label(self.middleCenterCanvas)
        self.entryNumbers[self.calcCellFromXYCoords(x, y)].configure(
            text= entryNumText,
            #font= 'arial 16 bold',
            font= self.cellLabelFont,
            foreground= fgCol,
            background= bgCol
        )
        self.entryNumbers[self.calcCellFromXYCoords(x, y)].place(
            x=x + 15, 
            y=y + 16, 
            width=self.cellLabelWidth, 
            height=self.cellLabelHeight
        )

def mainCellClickedProc(self, btn, x, y):
        self.clearStatusLine()
        if self.num_x != self.sillyNilly and self.num_y != self.sillyNilly:
            x = self.num_x
            y = self.num_y
        if ((x >= self.xr1c1) and (x <= ((self.xr1c1 - 2) + (9 * self.cellSize)))) and \
                (y >= (self.yr1c1) and (y <= ((self.yr1c1 - 2) + (9 * self.cellSize)))):
            #self.tell_it(btn, x, y)
            self.drawCells(self.cellSize, self.xr1c1, self.yr1c1)
            x1 = ((((x + self.xr1c1) / self.cellSize) - 1) * self.cellSize) + self.xr1c1
            y1 = ((((y + self.yr1c1) / self.cellSize) - 1) * self.cellSize) + self.yr1c1
            x2 = x1 + self.cellSize
            y2 = y1 + self.cellSize

            self.rw = ((y + self.yr1c1) / self.cellSize)
            self.col = ((x + self.xr1c1) / self.cellSize)
            self.cel = (((self.rw ) * 9) + self.col)
            self.grw = ((y + self.yr1c1 + (2 * self.cellSize)) / self.gridSize)
            self.gcol = ((x + self.xr1c1 + (2 * self.cellSize)) / self.gridSize)
            self.grid = (((self.grw - 1) * 3) + self.gcol)

            if  btn == 1:
                self.clearLastUnit()
                self.loadUnitRowValues(self.rw, self.bgColor)
                self.loadUnitColumnValues(self.col, self.bgColor)
                self.loadUnitGridValues(self.grid, self.bgColor)
                self.drawGrids(self.cellSize, self.xr1c1, self.yr1c1)
                self.cellOutline(x1, y1, x2, y2, self.outlineColor)
                self.writeInfoLine()
                if btn == 1:
                    self.enterProc()
                if self.numBtnToggleOnFlag == True:
                    self.numBtnPressed(self.entryNumber)
            elif btn == 3:
                self.loadUnitRowValues(self.rw, self.bgColor)
                self.loadUnitColumnValues(self.col, self.bgColor)
                self.loadUnitGridValues(self.grid, self.bgColor)
                self.loadRow(self.rw)
                self.loadColumn(self.col)
                self.loadGrid(self.grid)
                self.drawGrids(self.cellSize, self.xr1c1, self.yr1c1)
                self.cellOutline(x1, y1, x2, y2, self.outlineColor)
        self.num_x = self.num_y = self.sillyNilly
        return self.cell

Answer 1

Solution: Okay, I think this is HUGE!!!! Not only because it took me days to solve it, but because, well ...

Original Problem: My mouse clicks on my Sudoku entry numbers in the cells appeared not to be firing my mainCellClickedProc() function ... Except that they were firing it off!!! It was just that Tk(inter) was sending coordinates relative to the Label widget (between 0 and 23), and not the canvas object (between 25 and 475, from which I calculated my Sudoku game cells), therefore the if condition (right at the top of my button event's main callback that I used to locate the cells, and which kicked off all of my "gull derned" game logic, continually failed. Specifically the (x >= self.xr1c1 and (y >= self.yr1c1) conditions, since self.xr1c1 and self.tr1c1 are both 25, were always False! Now, the kicker is that this did not happen in the Ruby Tcl/Tk version of the program, so I did not even look in this area at all. It was only after paring the program down to a Hello, World-sized unit, that I stumbled upon what was happening. What a stinker of a problem! It had nothing to do with binding after all!!!

Below is the code. Unfortunately, the Hello, world!-size is still almost 300 lines long!

The other thing was the "journey", wherein ...

I go to the 'net and try to find some good reference material to unconfuse me about what the heck is going with my (cough) "binding" (cough). I stumble upon the Tcl/Tk site. I read the assertion that Tk code created for one environment can be run unmodified on all platforms. I believe the hype. I read further about the system's background and history. The maintainers talk about active development over time. They imply things chage under the hood as time goes on. They don't say how this affects an application written in one language (Ruby 1.8.2 w/ Tcl/Tk) a decade ago and run on a different language (Python 2.7.8.10 w/ Tkinter 8.5) today.

I determine that I need solid reference material, not the sketchy tutorial stuff found at effbot.org, or even tkdocs.com, or even the one at the New Mexico Tech site. It's not that they're necessarily bad, but that they're all weak in the example department. Anyway, I settle primarily on Tkinter 8.5 reference: a GUI for Python by John Shipman, because, after all, that's the platform I'm porting to. But, I still use other material, too, including the book Python and Tkinter Programming by John Grayson, and a few others.

Days pass. Over the course of those days that I (*) spent reading, researching, exploring and debugging, the only thing other than the solution is that I'm not sure if I'm productively learning or just flitting away time. I come away pondering the thought in the back of my mind that "a little ignorance is a dangerous thing!"

(*) "I" includes the gracious soul who passed on his invaluable knowledge during this process (yeah, you know who you are ... (cough) "Bryan" (cough)) (:>)

PS I may get scolded for this "diatribe", but it can't be any more painfull than what I've had to endure so far anyway. I can only say, my apologies and Lord, forgive me!

The solution code (tagged with the comment "# Binderooney-related Solution Stuff" in all of the pertinent places ...

#!/usr/bin/env python
from Tkinter import *

mouseClickNumber = 1

class LabelsAsEventFodderPOC (Frame):
    """ Labels as Event Fodder for Proof of Concept class """
    def __init__(self, cellSize, xr1c1, yr1c1, master=None):
        #Frame.__init__(self, master)
        self.cellSize = cellSize
        self.xr1c1 = xr1c1
        self.yr1c1 = yr1c1
        self.button = 0
        self.xcoord = 0
        self.ycoord = 0
        self.sillyNilly = 0
        self.gridSize = cellSize * 3; 
        self.fillColor = 'steelblue'
        self.highlightColor = 'steelblue3'
        self.outlineColor = 'red'
        self.lineColor = 'black'
        self.cellLineWidth = 2
        self.gridLineWidth = 5
        self.rootFont = 'arial 20 bold'
        self.timerLabelFont = 'arial 9 bold'
        self.msgLabelFont = 'arial 11 bold'
        self.buttonTextFont = 'arial 10 bold'
        self.numberFont = 'arial 20 bold'
        self.numberFontHeight = 23
        self.numberFontWidth = 20
        self.bgColor = self.fillColor
        self.fgColor = self.lineColor
        self.hlColor = self.highlightColor
        self.olColor = self.outlineColor
        self.gridRects = [None] * 9
        self.gridL = [None] * 9
        self.cell = self.sillyNilly
        self.root = Tk()
        self.root.option_add('*font', self.rootFont)
        self.frame = Frame(self.root)
        self.frame.pack(fill=BOTH, expand=True)
        self.canvas = Canvas(
            self.frame, borderwidth=0,  #  Set up Canvas
            width=200, height=260, relief=GROOVE, 
            highlightthickness=0, background=self.fillColor)
        self.canvas.pack(fill=BOTH, expand=True, padx=0, pady=0)
        self.drawCells(cellSize, xr1c1, yr1c1)
        self.drawGrid(cellSize, xr1c1, yr1c1)
        self.numberLabels = [None] * 9  #  Binderooney-related Solution Stuff ...
        self.numberLabelsWindow = [None] * 9  #  Binderooney-related Solution Stuff ...
        self.numberLabelsCellCoords = [] * 9  #  Binderooney-related Solution Stuff ...
        self.labelID = self.sillyNilly  #  Binderooney-related Solution Stuff ...
        for i in range (3):  #  Cell Rows  #  Binderooney-related Solution Stuff ...
            xul = self.xr1c1 + (3 * self.cellSize)  #  Binderooney-related Solution Stuff ...
            yul = self.yr1c1 + (i * self.cellSize) + (3 * self.cellSize)  #  Binderooney-related Solution Stuff ...
            xlr = xul + self.cellSize  #  Binderooney-related Solution Stuff ...
            ylr = yul + self.cellSize  #  Binderooney-related Solution Stuff ...
            for j in range(3):  #  Cell Columns  #  Binderooney-related Solution Stuff ...
                self.numberLabels[(i * 3) + j] = Label(self.numberLabelsWindow[(i * 3) + j])  #  Binderooney-related Solution Stuff ...
                xul += self.cellSize  #  Binderooney-related Solution Stuff ...
                xlr += self.cellSize  #  Binderooney-related Solution Stuff ...
                #  Bind the mouse clicks to the numberLabels  #  Binderooney-related Solution Stuff ...
                self.numberLabels[(i * 3) + j].bind("<Button>", \
                    lambda e, k=((i * 3) + j): self.binderooney(e.num, e.x, e.y, k), add='+') # !!!!!  #  Binderooney-related Solution Stuff ...
        for i in range (3):  #  Cell Rows  #  Binderooney-related Solution Stuff ...
            xul = xr1c1  #  Binderooney-related Solution Stuff ...
            yul = yr1c1 + (i * cellSize)  #  Binderooney-related Solution Stuff ...
            xlr = xul + cellSize  #  Binderooney-related Solution Stuff ...
            ylr = yul + cellSize  #  Binderooney-related Solution Stuff ...
            for j in range(3):  #  Cell Columns  #  Binderooney-related Solution Stuff ...
                print "In constructor, index is %r!!!!!!!!!!!!!!!!!!!" % ((i * 3) + j)  #  Binderooney-related Solution Stuff ...
                self.numberLabelsCellCoords.append([xul, yul])  #  Binderooney-related Solution Stuff ...
                xul += cellSize  #  Binderooney-related Solution Stuff ...
                xlr += cellSize  #  Binderooney-related Solution Stuff ...
        print "In constructor, self.numberLabelsCellCoords is %r!!!!!!!!!!!!!!!!" % self.numberLabelsCellCoords  #  Binderooney-related Solution Stuff ...
        self.setupGrid()  #  Binderooney-related Solution Stuff ...


        #  Capture the mouse click in the canvas
        self.canvas.bind("<Button>", \
            lambda e: self.mainCallbackFunction(e.num, e.x, e.y)) # !!!!!

    def drawCells(self, cellSize, xr1c1, yr1c1):
        """ Draw the grid's 3 by 3 cells """
        for i in range (3):  #  Cell Rows  #  Binderooney-related Solution Stuff ...
            xul = xr1c1
            yul = yr1c1 + (i * cellSize) 
            xlr = xul + cellSize
            ylr = yul + cellSize
            for j in range(3):  #  Cell Columns  #  Binderooney-related Solution Stuff ...
                self.gridRects[(i * 3) + j] = \
                    self.canvas.create_rectangle(\
                    xul, yul, xlr, ylr, fill=self.fillColor, \
                    outline=self.lineColor, width=self.cellLineWidth\
                )  #  Binderooney-related Solution Stuff ...
                xul += cellSize
                xlr += cellSize
        self.canvas.pack()

    def drawGrid(self, cellSize, xr1c1, yr1c1):
        """ Draw a 3 by 3 grid """
        gridSize = cellSize * 3 #  Grid size
        for i in range (1):  #  Grid Rows  #  Binderooney-related Solution Stuff ...
            xul = xr1c1
            yul = yr1c1 + (i * gridSize) 
            xlr = xul + gridSize
            ylr = yul + gridSize
            for j in range(1):  #  Grid Columns  #  Binderooney-related Solution Stuff ...
                self.gridL [(i * 1) + j] = self.canvas.create_rectangle(  #  Binderooney-related Solution Stuff ...
                    xul, yul, xlr, ylr,  
                    outline=self.lineColor, width=self.gridLineWidth
                )
                xul += gridSize
                xlr += gridSize
        self.canvas.pack()

    def setupGrid(self):  #  Binderooney-related Solution Stuff ...
        """ setup the grid """
        self.drawCells(self.cellSize, self.xr1c1, self.yr1c1)
        self.drawGrid(self.cellSize, self.xr1c1, self.yr1c1)
        #  Toss in a quit button
        pbx = 61
        pby = 210
        pbw = 75
        pbh = 25
        pbp = 10
        self.quitBtn = Button(
            self.frame, 
            text = 'Quit', 
            activebackground = self.hlColor,
            font =  self.buttonTextFont,
            bg = self.fillColor,
            command = lambda: quit()
        )
        self.quitBtn.place(
            x=pbx, 
            y=pby, 
            width=pbw, 
            height=pbh
        )

    def cellOutline(self, x1, y1, x2, y2, color):
        """ Display an outline around the cell that is clicked """
        self.lastCell = self.canvas.create_rectangle(
            x1, y1, x2, y2, outline=color, width=self.cellLineWidth
        )
        self.cellSelectedFlag = True
        self.last_x1 = x1
        self.last_y1 = y1
        self.last_x2 = x2
        self.last_y2 = y2
        self.canvas.pack()
        return self.lastCell

    def cellHighlight(self, x1, y1, x2, y2, color):
        """ Display an outline around the cell that is clicked """
        self.lastCell = self.canvas.create_rectangle(
            x1, y1, x2, y2, fill=color, width=self.cellLineWidth
        )
        self.cellSelectedFlag = True
        self.last_x1 = x1
        self.last_y1 = y1
        self.last_x2 = x2
        self.last_y2 = y2
        self.canvas.pack()
        return self.lastCell

    def writeEntryNumber(self, num, x, y, fgCol, bgCol):
        """ Write the cell's entry number """
        entryNumText = " "
        entryNumText = str(num)
        self.numberLabels[self.calcCellFromXYCoords(x, y)].configure(
            text= entryNumText,
            font= self.numberFont,
            foreground= fgCol,
            background= bgCol
        )
        self.numberLabels[self.calcCellFromXYCoords(x, y)].place(
            x=x + 15, 
            y=y + 15, 
            width=self.numberFontWidth, 
            height=self.numberFontHeight
        )

    def calcCellFromXYCoords(self, x, y):
        """ Calculate the cell from the provided x and y coordinates """
        row = ((y -  self.yr1c1) / self.cellSize)
        col = ((x -  self.xr1c1) / self.cellSize)
        self.cell = (((row ) * 3) + col)  #  Binderooney-related Solution Stuff ...
        return self.cell

    def tell_it(self, btn, x, y):
        """ Display the mouse button clicked and its coordinates """
        global mouseClickNumber
        print "In tell_it(), mouse click number %d, button %d, coordinates (%d, %d)" % \
            (mouseClickNumber, btn, x, y)
        mouseClickNumber += 1

    def binderooney(self, btn, x, y, labelIndex):  #  Binderooney-related Solution Stuff ...
        """ Test-bed for the cell coordinates binding solution! """
        print "In binderooney(), labelIndex is %r!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" % labelIndex  #  Binderooney-related Solution Stuff ...
        cx = self.numberLabelsCellCoords[labelIndex] [0]  #  Binderooney-related Solution Stuff ...
        cy = self.numberLabelsCellCoords[labelIndex] [1]  #  Binderooney-related Solution Stuff ...
        self.tell_it(btn, cx, cy)  #  Binderooney-related Solution Stuff ...
        if ((cx >= self.xr1c1) and (cx <= ((self.xr1c1 - 2) + (3 * self.cellSize))) and (cy >= self.yr1c1) and (cy <= ((self.yr1c1 - 2) + (3 * self.cellSize)))):  #  Binderooney-related Solution Stuff ...
            self.button = btn  #  Binderooney-related Solution Stuff ...
            self.xcoord = x  #  Binderooney-related Solution Stuff ...
            self.ycoord - y  #  Binderooney-related Solution Stuff ...
            self.drawCells(self.cellSize, self.xr1c1, self.yr1c1)  #  Binderooney-related Solution Stuff ...
            x1 = ((((x + self.xr1c1) / self.cellSize) - 1) * self.cellSize) + self.xr1c1  #  Binderooney-related Solution Stuff ...
            y1 = ((((y + self.yr1c1) / self.cellSize) - 1) * self.cellSize) + self.yr1c1  #  Binderooney-related Solution Stuff ...
            x2 = x1 + self.cellSize  #  Binderooney-related Solution Stuff ...
            y2 = y1 + self.cellSize  #  Binderooney-related Solution Stuff ...

            self.rw = ((y + self.yr1c1) / self.cellSize)  #  Binderooney-related Solution Stuff ...
            self.col = ((x + self.xr1c1) / self.cellSize)  #  Binderooney-related Solution Stuff ...
            self.cel = (((self.rw ) * 3) + self.col)  #  Binderooney-related Solution Stuff ...
            self.grw = ((y + self.yr1c1 + (2 * self.cellSize)) / self.gridSize)  #  Binderooney-related Solution Stuff ...
            self.gcol = ((x + self.xr1c1 + (2 * self.cellSize)) / self.gridSize)  #  Binderooney-related Solution Stuff ...
            self.grid = (((self.grw - 1) * 3) + self.gcol)  #  Binderooney-related Solution Stuff ...

            if  btn == 1:  #  Binderooney-related Solution Stuff ...
                self.drawGrid(self.cellSize, self.xr1c1, self.yr1c1)  #  Binderooney-related Solution Stuff ...
                self.cellOutline(cx, cy, cx+self.cellSize, cy+self.cellSize, self.outlineColor)  #  Binderooney-related Solution Stuff ...
                if btn == 1:  #  Binderooney-related Solution Stuff ...
                    self.writeEntryNumber(1, cx, cy, self.fgColor, self.bgColor)  #  Binderooney-related Solution Stuff ...
            elif btn == 3:  #  Binderooney-related Solution Stuff ...
                self.cellHighlight(cx, cy, cx+self.cellSize, cy+self.cellSize, self.highlightColor)  #  Binderooney-related Solution Stuff ...
                self.cellOutline(cx, cy, cx+self.cellSize, cy+self.cellSize, self.outlineColor)  #  Binderooney-related Solution Stuff ...
                self.drawGrid(self.cellSize, self.xr1c1, self.yr1c1)  #  Binderooney-related Solution Stuff ...
                self.cellOutline(cx, cy, cx+self.cellSize, cy+self.cellSize, self.outlineColor)  #  Binderooney-related Solution Stuff ...
        return self.cell  #  Binderooney-related Solution Stuff ...

    def mainCallbackFunction(self, btn, x, y):
        """
        #  On left mouse click, return cell in which it was clicked, drawing a 
        #  red boundary around the cell; on right click, return the cell in which 
        #  it was clicked, removing the red boundary around the clicked cell 
        """
        if ((x >= self.xr1c1) and (x <= ((self.xr1c1 - 2) + (3 * self.cellSize)))) and \
                (y >= (self.yr1c1) and (y <= ((self.yr1c1 - 2) + (3 * self.cellSize)))):  #  Binderooney-related Solution Stuff ...
            print "in mainCallbackFunction(), cell is %r" % (self.calcCellFromXYCoords(x, y))  #  Binderooney-related Solution Stuff ...
            self.tell_it(btn, x, y)
            self.button = btn
            self.xcoord = x
            self.ycoord - y
            self.drawCells(self.cellSize, self.xr1c1, self.yr1c1)
            x1 = ((((x + self.xr1c1) / self.cellSize) - 1) * self.cellSize) + self.xr1c1
            y1 = ((((y + self.yr1c1) / self.cellSize) - 1) * self.cellSize) + self.yr1c1
            x2 = x1 + self.cellSize
            y2 = y1 + self.cellSize

            self.rw = ((y + self.yr1c1) / self.cellSize)
            self.col = ((x + self.xr1c1) / self.cellSize)
            self.cel = (((self.rw ) * 3) + self.col)  #  Binderooney-related Solution Stuff ...
            self.grw = ((y + self.yr1c1 + (2 * self.cellSize)) / self.gridSize)
            self.gcol = ((x + self.xr1c1 + (2 * self.cellSize)) / self.gridSize)
            self.grid = (((self.grw - 1) * 3) + self.gcol)  #  Binderooney-related Solution Stuff ...

            if  btn == 1:
                self.drawGrid(self.cellSize, self.xr1c1, self.yr1c1)
                self.cellOutline(x1, y1, x2, y2, self.outlineColor)
                if btn == 1:
                     self.writeEntryNumber(1, x1, y1, self.fgColor, self.bgColor)
            elif btn == 3:
                self.cellHighlight(x1, y1, x2, y2, self.highlightColor)
                self.cellOutline(x1, y1, x2, y2, self.outlineColor)
                self.drawGrid(self.cellSize, self.xr1c1, self.yr1c1)
                self.cellOutline(x1, y1, x2, y2, self.outlineColor)
        return self.cell

#  Cell and Grid sizes, X amd Y Coordinates of Row 1 Col 1 (Upper Left Position)
cellSize = 50; xr1c1 = 25; yr1c1 = 25  

#  Instantiate the Label POC class
lPOC = LabelsAsEventFodderPOC(cellSize, xr1c1, yr1c1)  #  Binderooney-related Solution Stuff ...

#  Loop-Dee-Doo
if __name__ == '__main__':
    lPOC.root.mainloop()

Answer 2

You could just use

label.bind("<MouseButton1Down>",function)

instead