itcl(n) [incr Tcl] itcl(n)

NAME
       itcl - object-oriented extensions to Tcl


DESCRIPTION
       [[iinnccrr TTccll]] provides object-oriented extensions to Tcl, much as C++ pro-
       vides object-oriented extensions to C.  The emphasis of this work, how-
       ever, is not to create a whiz-bang object-oriented programming environ-
       ment.  Rather, it is to support more structured  programming  practices
       in Tcl without changing the flavor of the language.  More than anything
       else, [[iinnccrr TTccll]] 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.


CCLLAASSSSEESS
       The fundamental construct in [[iinnccrr TTccll]] 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 "meth-
       ods" are used to manipulate individual objects.  Methods are just  like
       the  operations  that  are used to manipulate Tk widgets.  The "bbuuttttoonn"
       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  gglloobbaall  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 mem-
       bers 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  gglloobbaall  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 gglloobbaall 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 com-
       mand-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 can-
       not  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 exter-
       nal  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.   Insulat-
       ing  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 encap-
       sulation that makes object-oriented programs easier to  understand  and
       maintain.

       The  fact  that [[iinnccrr TTccll]] objects look like Tk widgets is no accident.
       [[iinnccrr TTccll]] was designed this way, to  blend  naturally  into  a  Tcl/Tk
       application.   But [[iinnccrr TTccll]] 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 appli-
       ances.  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  appli-
       ances) can be added or removed more easily.

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


NAMESPACES
       [[iinnccrr TTccll]] 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 nnaammeessppaaccee command for details on creating and using namespaces.


MMEEGGAA-WWIIDDGGEETTSS
       Mega-widgets  are high-level widgets that are constructed using Tk wid-
       gets as component parts, usually without any C code.  A  fileselection-
       box, 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.

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

       [[iinnccrr WWiiddggeettss]]  is a library of mega-widgets built using [[iinnccrr TTkk]].  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.


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



itcl                                  3.0                              itcl(n)