itcl(n) [incr Tcl] itcl(n)
NAME
itcl - object-oriented extensions to Tcl
DESCRIPTION
[incr Tcl] provides object-oriented extensions to Tcl, much as C++ provides object-oriented exten-sions extensions
sions to C. The emphasis of this work, however, is not to create a whiz-bang object-oriented pro-gramming programming
gramming 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 encap-sulating encapsulating
sulating 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.
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 exe-cuting executing
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.
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 exe-cute execute
cute in the class context, and therefore have automatic access to all "common" data members. How-ever, However,
ever, 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 public
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 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 encap-sulation encapsulation
sulation 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 man-ner. manner.
ner. 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 com-mand command
mand 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 con-tained contained
tained 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 para-digm, paradigm,
digm, 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 differ-ent different
ent 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(n)
|