itcl(3itcl)							    [incr Tcl]							       itcl(3itcl)

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  prac-
       tices  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  pro-
       moting the object-oriented "library" mindset.  It also allows for code re-use through inheritance.

CLASSES

       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 "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 per-
       form 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  per-
       form  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.

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

       [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

itcl									3.0							       itcl(3itcl)