itcl User Commands - itcl






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  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  inheri-
     tance.



CLASSES

     The fundamental construct in [incr Tcl] is the class defini-
     tion.  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 exam-
     ple, "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  defini-
     tion,  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  com-
     mand 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 quali-
     fied 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 pub-
     lic  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 implementa-
     tion 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 natur-
     ally 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 inheri-
     tance,  allowing classes to share common behaviors by inher-
     iting 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 intro-
     duction is presented in the paper included with this distri-
     bution.   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 list-
     boxes,  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