itcl(n) [incr Tcl] itcl(n)
itcl - object-oriented extensions to Tcl
[incr Tcl] provides object-oriented extensions to Tcl, much as C++ provides object-ori-
ented 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 pro-
gramming 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 proce-
dures 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 avail-
able. 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-spe-
cific "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
Each of the elements in a class can be declared "public", "protected" or "private". Pub-
lic 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 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 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 interac-
tions 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 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 applica-
tions. Each widget class has its own man page describing the features available.
class, object, object-oriented, namespace, mega-widget
itcl 3.0 itcl(n)