Provided by: tcl-itcl4-doc_4.1.2-1_all bug


       itcl - object-oriented extensions to Tcl


       [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 encapsulating 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-oriented "library" mindset.  It also
       allows for code re-use through inheritance.


       The fundamental construct in [incr Tcl] is the class definition.  Each  class  acts  as  a
       template for actual objects that can be created.  Each object has its own unique bundle 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 button 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 executing 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.

       Classes can also have ordinary procedures  declared  as  "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  "className::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 accessible in
       the class where they are defined.

       The  "public"  elements within a class define its interface to the external world.  Public
       methods define the operations 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 maintain, and derived classes (e.g., specialized appliances) can be added  or  removed
       more easily.

       This   description  was  merely  a  brief  overview  of  object-oriented  programming  and
       [incr Tcl].  A more tutorial introduction is presented in the  paper  included  with  this
       distribution.  See the class command for more details on creating and using classes.


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


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