Страницы справочника OS X

Эта страница руководства для  версии 10.9 Mac OS X

Читать страницы руководства

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)