itcl - object-oriented extensions to 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
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 "
" widget, for example, has methods such as "flash"
and "invoke" that cause a particular button to blink and invoke its
Within the body of a method, the "variables" defined in the class are
automatically available. They need not be declared with anything like the
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
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 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
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
. 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.
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
is a framework for building mega-widgets. It uses
to support the object paradigm, and adds base classes
which provide default widget behaviors. See the itk
man page for more
is a library of mega-widgets built using
. 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