Tk - An overview of an Object Oriented Tk8.0 extension for perl5


Tk - An overview of an Object Oriented Tk8.0 extension for perl5

use Tk;

$main = MainWindow->new();

$widget = $main->*Widget*(...);




In writing the perl Tk extension, the goals were to provide a complete
interface to the latest production version of John Ousterhout's Tk,
while providing an Object Oriented interface to perl code.

The package is composed of three loosely connected parts:

*pTk* - Converted Tk source
The *pTk* sub-directory is a copy of the C code of Tk4.0, modified
to allow use by languages other than the original Tcl. (The pTk can
be read as 'perl' Tk or 'portable' Tk, depending on your

Tk to Perl 'Glue'
The top level directory provides *Tk.xs* and *tkGlue.c* which
provide the perl-callable interfaces to pTk

Perl code for 'Widget' Classes
The *Tk/Tk* sub-directory contains the various perl modules that
comprise the "Classes" that are visible to Tk applications.

The "major" widgets such as Tk::Text are actually in separate
directories at the top level (e.g. *Text/** for Tk::Text) and are
dynamically loaded as needed on platforms which support perl5's

package Tk; - the 'base class'
All the "command names" documented in Tcl/Tk are made to look like
perl sub's and reside in the Tk package. Their names are all lower
case. Typically there are very few commands at this level which are
called directly by applications.

package Tk::Widget; - the 'Widget class'
There are no actual objects of the Tk::Widget class; however all the
various Tk window "widgets" inherit from it, and it in turn inherits
all the core Tk functions from Tk.

Tk::Widget provides various functions and interfaces which are
common to all Widgets.

A widget is represented to perl as a blessed reference to a hash.
There are some members of the hash which are private to Tk and its
tkGlue code. Keys starting with '.' and of the form
/_[A-Z][A-Za-z_]+_/ (i.e. starting and ending in _ and with first
char after _ being upper case) should be considered reserved to Tk.

Tk::Button, Tk::Entry, Tk::Text ...
There is one class for each of the "Tk" widget item types. Some of
them like Tk::Frame do very little indeed, and really only exist so
that they can be derived from or so that focus or menu traversal can
discover the "kind" of window being processed.

Other classes, Tk::Text for example, provide a lot of methods used
with Tk's "bind" to provide a rich keyboard/mouse interface to the
widgets' data.

These widget classes also include conversions of the Tcl code for
event bindings, keyboard focus traversal, menu bars, and menu
keyboard traversal. All the Tcl functions have been converted, but
the names have changed (systematically) and they have been split up
between the various classes in what I hope is an appropriate manner.
Name changes are normally: dropping initial tk_ as the Tk-ness is
implicit in the Tk:: prefix, and similarly dropping say Menu from
the name if it has been moved the Tk::Menu class. Thus 'proc
tkMenuNextEntry' becomes 'sub NextEntry' in the Tk::Menu package.

This does for Tk4.0's "images" what Tk::Widget does for widgets.
Images are new to Tk4.0 and the class structure is not mature

There are three sub-classes Tk::Bitmap, Tk::Pixmap and Tk::Photo.

It is expected that Tk::Image hierarchy will evolve during the
"beta" phase of Tk to allow dynamic or auto-loaded image types or
photo formats (e.g. support for JPEG format for photos).

Composite Widgets
A composite is some kind of 'frame' with subwidgets which give it
useful behaviour. Tk::Dialog is an example of a composite widget
classes built from the basic Tk ones. It is intended that user code
should not need to be aware that a particular class is a composite,
and create and configure such widgets in the same manner as any
other kind. The configure mechanism and the methods of the class
manipulate the subwidgets as required.

Composite widgets are implemented via Tk::Frame and multiple
inheritance. The two 'frame' base classes Tk::Frame and Tk::Toplevel
include the additional class Tk::Derived in their inheritance.
Tk::Derived provides methods to allow additional configure options
to be defined for a widget.

A Composite widget is typically defined as derived from Tk::Frame or
Tk::Toplevel (e.g. Tk::Dialog).