NAME

       itcl - object-oriented extensions to Tcl
_________________________________________________________________


DESCRIPTION

       [incr Tcl]  provides  object-oriented  extensions  to Tcl,
       much as C++ provides object-oriented extensions to C.  The
       emphasis  of  this work, however, is not to create a whiz-
       bang object-oriented programming environment.  Rather,  it
       is to support more structured programming practices in Tcl
       without changing the flavor of the  language.   More  than
       anything  else, [incr Tcl] provides a means of encapsulat­
       ing related procedures together with their shared data  in
       a  namespace  that  is  hidden from the outside world.  It
       encourages better programming by promoting the object-ori­
       ented  "library"  mindset.  It also allows for code re-use
       through inheritance.


CLASSES

       The fundamental construct in [incr Tcl] is the class defi­
       nition.   Each class acts as a template for actual objects
       that can be created.  Each object has its own unique  bun­
       dle  of  data, which contains instances of the "variables"
       defined in the class.  Special procedures called "methods"
       are  used  to  manipulate individual objects.  Methods are
       just like the operations that are used  to  manipulate  Tk
       widgets.   The  "button"  widget, for example, has methods
       such as "flash" and "invoke" that cause a particular  but­
       ton to blink and invoke its command.

       Within  the  body  of a method, the "variables" defined in
       the class are automatically available.  They need  not  be
       declared  with  anything  like the global command.  Within
       another class method, a method can  be  invoked  like  any
       other  command-simply  by  using its name.  From any other
       context, the method name must be  prefaced  by  an  object
       name,  which  provides  a  context  for  the data that the
       method can access.

       Each class has its own namespace  containing  things  that
       are  common to all objects which belong to the class.  For
       example, "common" data members are shared by  all  objects
       in the class.  They are global variables that exist in the
       class namespace, but since they are included in the  class
       definition,  they  need  not  be declared using the global
       command; they are automatically available to any code exe­
       cuting  in  the  class  context.   A class can also create
       ordinary global variables,  but  these  must  be  declared
       using the global command each time they are used.

       "procs".  Within another class method or proc, a proc  can
       be  invoked  like  any  other  command-simply by using its
       name.  From any other context, the procedure  name  should
       be   qualified  with  the  class  namespace  like  "class­
       Name::proc".  Class procs execute in  the  class  context,
       and  therefore  have automatic access to all "common" data
       members.   However,  they  cannot  access  object-specific
       "variables",  since  they are invoked without reference to
       any specific object.  They are  usually  used  to  perform
       generic  operations  which affect all objects belonging to
       the class.

       Each of the elements in a class can be declared  "public",
       "protected" or "private".  Public elements can be accessed
       by the class,  by  derived  classes  (other  classes  that
       inherit  this class), and by external clients that use the
       class.  Protected elements can be accessed by  the  class,
       and  by derived classes.  Private elements are only acces­
       sible in the class where they are defined.

       The "public" elements within a class define its  interface
       to  the  external world.  Public methods define the opera­
       tions that can be used to manipulate  an  object.   Public
       variables  are  recognized as configuration options by the
       "configure" and "cget" methods that are  built  into  each
       class.   The  public interface says what an object will do
       but not how it will do it.  Protected and private members,
       along  with the bodies of class methods and procs, provide
       the implementation details.   Insulating  the  application
       developer  from  these  details  leaves the class designer
       free to change them at  any  time,  without  warning,  and
       without  affecting programs that rely on the class.  It is
       precisely this encapsulation  that  makes  object-oriented
       programs easier to understand and maintain.

       The  fact  that [incr Tcl] objects look like Tk widgets is
       no accident.  [incr Tcl] was designed this way,  to  blend
       naturally  into  a  Tcl/Tk  application.   But  [incr Tcl]
       extends the Tk paradigm from being merely object-based  to
       being  fully  object-oriented.   An object-oriented system
       supports inheritance, allowing  classes  to  share  common
       behaviors  by  inheriting  them  from  an ancestor or base
       class.  Having a base class as a common abstraction allows
       a programmer to treat related classes in a similar manner.
       For example, a toaster and  a  blender  perform  different
       (specialized) functions, but both share the abstraction of
       being appliances.  By abstracting common behaviors into  a
       base  class,  code  can be shared rather than copied.  The
       resulting application is easier to  understand  and  main­
       tain,  and  derived classes (e.g., specialized appliances)
       can be added or removed more easily.

       This description was merely a brief  overview  of  object-

       introduction is presented in the paper included with  this
       distribution.   See  the class command for more details on
       creating and using classes.


NAMESPACES

       [incr Tcl] now includes a complete namespace facility.   A
       namespace is a collection of commands and global variables
       that is kept apart from  the  usual  global  scope.   This
       allows Tcl code libraries to be packaged in a well-defined
       manner, and  prevents  unwanted  interactions  with  other
       libraries.   A  namespace  can  also have child namespaces
       within it, so one library can contain its own private copy
       of  many other libraries.  A namespace can also be used to
       wrap up a group of  related  classes.   The  global  scope
       (named "::") is the root namespace for an interpreter; all
       other namespaces are contained within it.

       See the namespace command  for  details  on  creating  and
       using namespaces.


MEGA-WIDGETS

       Mega-widgets  are  high-level widgets that are constructed
       using Tk widgets as component parts, usually without any C
       code.   A  fileselectionbox,  for  example, may have a few
       listboxes, some entry widgets and  some  control  buttons.
       These  individual  widgets  are put together in a way that
       makes them act like one big widget.

       [incr Tk] is a framework for  building  mega-widgets.   It
       uses  [incr Tcl]  to support the object paradigm, and adds
       base classes which provide default widget behaviors.   See
       the itk man page for more details.

       [incr Widgets]  is  a  library of mega-widgets built using
       [incr Tk].  It contains  more  than  30  different  widget
       classes  that  can  be  used right out of the box to build
       Tcl/Tk applications.  Each widget class has  its  own  man
       page describing the features available.


KEYWORDS

       class, object, object-oriented, namespace, mega-widget


Man(1) output converted with man2html