itcl man page on Archlinux

Man page or keyword search:  
man Server   11224 pages
apropos Keyword Search (all sections)
Output format
Archlinux logo
[printable version]

itcl(n)				  [incr Tcl]			       itcl(n)


       itcl - object-oriented extensions to Tcl

       [incr Tcl] provides object-oriented extensions to Tcl, much as C++ pro‐
       vides object-oriented extensions to C.  The emphasis of this work, how‐
       ever, is not to create a whiz-bang object-oriented programming environ‐
       ment.  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 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 procedures called "meth‐
       ods" 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 mem‐
       bers 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 com‐
       mand-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 can‐
       not  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 exter‐
       nal  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.   Insulat‐
       ing  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 that makes object-oriented programs easier to  understand  and

       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 appli‐
       ances.  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	appli‐
       ances) can be added or removed more easily.

       This  description  was  merely a brief overview of object-oriented pro‐
       gramming 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 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  wid‐
       gets  as component parts, usually without any C code.  A fileselection‐
       box, 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.

       class, object, object-oriented, namespace, mega-widget

itcl				      3.0			       itcl(n)

List of man pages available for Archlinux

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net