tk::callbacks(3) [suse man page]

callbacks(3)						User Contributed Perl Documentation					      callbacks(3)

NAME

       Tk::callbacks - Specifying code for Tk to call.

SYNOPSIS

       One can specify a callback in one of the following ways:

       Without arguments:

	   ... => &subname, ...
	   ... => sub { ... }, ...
	   ... => 'methodname', ...

       or with arguments:

	   ... => [ &subname, args ... ], ...
	   ... => [ sub { ... }, args... ], ...
	   ... => [ 'methodname', args... ], ...

DESCRIPTION

       Perl/Tk has a callback, where Tcl/Tk has a command string (i.e. a fragment of Tcl to be executed).  A perl/Tk callback can take one of the
       following basic forms:

       o   Reference to a subroutine "&subname"

       o   Anonymous subroutine (closure) "sub { ... }"

       o   A method name 'methodname'

       Any of these can be provided with arguments by enclosing them and the arguments in []. Here are some examples:

       $mw->bind($class, "<Delete>" => 'Delete');

       This will call $widget->Delete, the $widget being provided (by bind) as the one where the Delete key was pressed.

       While having bind provide a widget object for you is ideal in many cases it can be irritating in others. Using the list form this behaviour
       can be modified:

       $a->bind("<Delete>",[$b => 'Delete']);

       because the first element $b is an object bind will call $b->Delete.

       Note that method/object ordering only matters for "bind" callbacks, the auto-quoting in perl5.001 makes the first of these a little more
       readable:

	   $w->configure(-yscrollcommand => [ set => $ysb]);
	   $w->configure(-yscrollcommand => [ $ysb => 'set' ]);

       but both will call $ysb->set(args provided by Tk)

       Another use of arguments allows you to write generalized methods which are easier to re-use:

	   $a->bind("<Next>",['Next','Page']);
	   $a->bind("<Down>",['Next','Line']);

       This will call $a->Next('Page') or $a->Next('Line') respectively.

       Note that the contents of the "[]" are evaluated by perl when the callback is created. It is often desirable for the arguments provided to
       the callback to depend on the details of the event which caused it to be executed. To allow for this callbacks can be nested using the
       "Ev(...)" "constructor".  "Ev(...)" inserts callback objects into the argument list. When perl/Tk glue code is preparing the argument list
       for the callback it is about to call it spots these special objects and recursively applies the callback process to them.

EXAMPLES

	   $entry->bind('<Return>' => [$w , 'validate', Ev(['get'])]);

	   $toplevel->bind('all', '<Visibility>', [&unobscure, Ev('s')]);

	   $mw->bind($class, '<Down>', ['SetCursor', Ev('UpDownLine',1)]);

SEE ALSO

       Tk::bind Tk::after Tk::options Tk::fileevent

KEYWORDS

       callback, closure, anonymous subroutine, bind

perl v5.12.1							    2007-05-05							      callbacks(3)

bindtags(3pm)						User Contributed Perl Documentation					     bindtags(3pm)

NAME

       Tk::bindtags - Determine which bindings apply to a window, and order of evaluation

SYNOPSIS

       $widget->bindtags([tagList]);

       @tags = $widget->bindtags;

DESCRIPTION

       When a binding is created with the bind command, it is associated either with a particular window such as $widget, a class name such as
       Tk::Button, the keyword all, or any other string.  All of these forms are called binding tags.  Each window has a list of binding tags that
       determine how events are processed for the window.  When an event occurs in a window, it is applied to each of the window's tags in order:
       for each tag, the most specific binding that matches the given tag and event is executed.  See the Tk::bind documentation for more
       information on the matching process.

       By default, each window has four binding tags consisting of the the window's class name, name of the window, the name of the window's
       nearest toplevel ancestor, and all, in that order.  Toplevel windows have only three tags by default, since the toplevel name is the same
       as that of the window.

       Note that this order is different from order used by Tcl/Tk.  Tcl/Tk has the window ahead of the class name in the binding order.  This is
       because Tcl is procedural rather than object oriented and the normal way for Tcl/Tk applications to override class bindings is with an
       instance binding. However, with perl/Tk the normal way to override a class binding is to derive a class. The perl/Tk order causes instance
       bindings to execute after the class binding, and so instance bind callbacks can make use of state changes (e.g. changes to the selection)
       than the class bindings have made.

       The bindtags command allows the binding tags for a window to be read and modified.

       If $widget->bindtags is invoked without an argument, then the current set of binding tags for $widget is returned as a list.  If the
       tagList argument is specified to bindtags, then it must be a reference to and array; the tags for $widget are changed to the elements of
       the array. (A reference to an anonymous array can be created by enclosin the elements in [ ].)  The elements of tagList may be arbitrary
       strings or widget objects, if no window exists for an object at the time an event is processed, then the tag is ignored for that event.
       The order of the elements in tagList determines the order in which binding callbacks are executed in response to events.  For example, the
       command

	$b->bindtags([$b,ref($b),$b->toplevel,'all'])

       applies the Tcl/Tk binding order which binding callbacks will be evaluated for a button (say) $b so that $b's instance bindings are invoked
       first, following by bindings for $b's class, followed by bindings for $b's toplevel, followed by 'all' bindings.

       If tagList is an empty list i.e. [], then the binding tags for $widget are returned to the perl/Tk default state described above.

       The bindtags command may be used to introduce arbitrary additional binding tags for a window, or to remove standard tags.  For example, the
       command

	$b->bindtags(['TrickyButton',$b->toplevel,'all'])

       replaces the (say) Tk::Button tag for $b with TrickyButton.  This means that the default widget bindings for buttons, which are associated
       with the Tk::Button tag, will no longer apply to $b, but any bindings associated with TrickyButton (perhaps some new button behavior) will
       apply.

BUGS

       The current mapping of the 'native' Tk behaviour of this method i.e. returning a list but only accepting a reference to an array is counter
       intuitive. The perl/Tk interface  may be tidied up, returning a list is sensible so, most likely fix will be to allow a list to be passed
       to set the bindtags.

SEE ALSO

       Tk::bind Tk::callbacks

KEYWORDS

       binding, event, tag

perl v5.14.2							    2010-05-29							     bindtags(3pm)