Unix/Linux Go Back    

RedHat 9 (Linux i386) - man page for itcl (redhat section n)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

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)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 10:42 PM.