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