Programming Python (59 page)

from tkinter import *
def showPosEvent(event):
print('Widget=%s X=%s Y=%s' % (event.widget, event.x, event.y))
def showAllEvent(event):
print(event)
for attr in dir(event):
if not attr.startswith('__'):
print(attr, '=>', getattr(event, attr))
def onKeyPress(event):
print('Got key press:', event.char)
def onArrowKey(event):
print('Got up arrow key press')
def onReturnKey(event):
print('Got return key press')
def onLeftClick(event):
print('Got left mouse button click:', end=' ')
showPosEvent(event)
def onRightClick(event):
print('Got right mouse button click:', end=' ')
showPosEvent(event)
def onMiddleClick(event):
print('Got middle mouse button click:', end=' ')
showPosEvent(event)
showAllEvent(event)
def onLeftDrag(event):
print('Got left mouse button drag:', end=' ')
showPosEvent(event)
def onDoubleLeftClick(event):
print('Got double left mouse click', end=' ')
showPosEvent(event)
tkroot.quit()
tkroot = Tk()
labelfont = ('courier', 20, 'bold')                # family, size, style
widget = Label(tkroot, text='Hello bind world')
widget.config(bg='red', font=labelfont)            # red background, large font
widget.config(height=5, width=20)                  # initial size: lines,chars
widget.pack(expand=YES, fill=BOTH)
widget.bind('',  onLeftClick)            # mouse button clicks
widget.bind('',  onRightClick)
widget.bind('',  onMiddleClick)          # middle=both on some mice
widget.bind('',  onDoubleLeftClick)      # click left twice
widget.bind('', onLeftDrag)             # click left and move
widget.bind('',  onKeyPress)             # all keyboard presses
widget.bind('',        onArrowKey)             # arrow button pressed
widget.bind('',    onReturnKey)            # return/enter key pressed
widget.focus()                                     # or bind keypress to tkroot
tkroot.title('Click Me')
tkroot.mainloop()

Figure 8-20. A bind window for the clicking

• 
fires
  when a button is released (
  
is run when the button
  first goes down).
  

• 
is triggered
  when a mouse pointer is moved.
  

• 
and
  
handlers intercept mouse
  entry and exit in a window’s display area (useful for automatically
  highlighting a widget).
  

• 
is
  invoked when the window is resized, repositioned, and so on (e.g.,
  the event object’s
  width
and
  height
give the new window size).
  We’ll make use of this to resize the display on window resizes in
  the PyClock example of
  Chapter 11
  .
  

• 
is invoked
  when the window widget is destroyed (and differs from the
  protocol
mechanism for window manager
  close button presses). Since this interacts with widget
  quit
and
  destroy
methods, I’ll say more about the
  event later in this section.
  

• 
and
  
are run as the
  widget gains and loses focus.
  

• and
  
are run when a window is
  opened and iconified.
  

• 
,
  
, and
  
catch other special key
  presses.
  

• 
,
  
, and
  
catch other arrow key
  presses.
  

• Modifiers
  can be added to event
  identifiers to make them even more specific; for instance,
  
means moving the mouse
  with the left button pressed, and
  
refers to pressing the
  “a” key only.
  

• Synonyms
  can be used for some common
  event names; for instance,
  
,
  
, and
  <1>
mean a left mouse button press,
  and
  
and
  
mean the “a” key.
  All forms are case sensitive: use
  
, not
  
.
  

• Virtual
  event identifiers can be defined
  within double bracket pairs (e.g.,
  <>
) to refer to a
  selection of one or more event sequences.
  

Before we move on, one event merits a few extra words: the

event (whose name
is case significant) is run when a widget is being destroyed, as a
result of both script method calls and window closures in general,
including those at program exit. If you bind this on a window, it will
be triggered once for each widget in the window; the callback’s event
argument
widget
attribute gives the
widget being destroyed, and you can check this to detect a particular
widget’s destruction. If you bind this on a specific widget instead,
it will be triggered once for that widget’s destruction only.

It’s important to know that a widget is in a “half dead” state
(Tk’s terminology) when this event is triggered—it still exists, but
most operations on it fail. Because of that, the

event is not intended for
GUI activity in general; for instance, checking a text widget’s
changed state or fetching its content in a

handler can both fail with
exceptions. In addition, this event’s handler cannot cancel the
destruction in general and resume the GUI; if you wish to intercept
and verify or suppress window closes when a user clicks on a window’s
X
button, use
WM_DELETE_WINDOW
in top-level windows’
protocol
methods as described
earlier in this chapter.

You should also know that running a tkinter widget’s
quit
method does not trigger any

events on exit, and even
leads to a fatal Python error on program exit in 3.X if any

event handlers are
registered. Because of this, programs that bind this event for non-GUI
window exit actions should usually call
destroy
instead of
quit
to close, and rely on the fact that a
program exits when the last remaining or only
Tk
root window (default or explicit) is
destroyed as described earlier. This precludes using
quit
for immediate shutdowns, though you can
still run
sys.exit
for brute-force
exits.

A script can also perform program exit actions in code run after
the
mainloop
call returns, but the
GUI is gone completely at this point, and this code is not associated
with any particular widget. Watch for more on this event when we study
the PyEdit example program in
Chapter 11
; at the risk of spoiling the end of
this story, we’ll find it unusable for verifying changed text
saves.