NAME

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

SYNOPSIS

       "use Tk;"

       "$main = MainWindow->new();"

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

       "$widget->pack(...);"

       ...

       "MainLoop;"

DESCRIPTION

       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.

CONTENTS

       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 Tk8.x, 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
           sensibilities.)

       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 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
           DynaLoader.

CLASS HIERARCHY

       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.

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

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

           It  is possible to create dynamic or auto-loaded image types inherited from Tk::Image for other image
           types or photo formats (e.g. support for TIFF format).

       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).

perl v5.38.2                                       2024-04-01                                      overview(3pm)