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 encapsulat
ing 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-ori
ented "library" mindset. It also allows for code re-use
through inheritance.
CLASSES
The fundamental construct in [incr Tcl] is the class defi
nition. Each class acts as a template for actual objects
that can be created. Each object has its own unique bun
dle 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 but
ton 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 exe
cuting 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.
"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 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 acces
sible in the class where they are defined.
The "public" elements within a class define its interface
to the external world. Public methods define the opera
tions 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 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 main
tain, and derived classes (e.g., specialized appliances)
can be added or removed more easily.
This description was merely a brief overview of object-
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 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 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
Man(1) output converted with
man2html