ensemble(n) [incr Tcl] ensemble(n)

NAME
       ensemble - create or modify a composite command

SYNOPSIS
       eennsseemmbbllee ensName ?command arg arg...?
       or
       eennsseemmbbllee ensName {
           ppaarrtt partName args body
           ...
           eennsseemmbbllee partName {
               ppaarrtt subPartName args body
               ppaarrtt subPartName args body
           ...
           }
       }


DESCRIPTION
       The  eennsseemmbbllee  command is used to create or modify a composite command.
       See the section WWHHAATT IISS AANN EENNSSEEMMBBLLEE?? below  for  a  brief  overview  of
       ensembles.

       If  the  eennsseemmbbllee command finds an existing ensemble called ensName, it
       updates that  ensemble.   Otherwise,  it  creates  an  ensemble  called
       ensName.   If the ensName is a simple name like "foo", then an ensemble
       command named "foo" is added to the current namespace  context.   If  a
       command named "foo" already exists in that context, then it is deleted.
       If the ensName contains namespace qualifiers like "a::b::foo", then the
       namespace  path  is  resolved,  and  the ensemble command is added that
       namespace context.  Parent namespaces like  "a"  and  "b"  are  created
       automatically, as needed.

       If  the  ensName  contains  spaces like "a::b::foo bar baz", then addi-
       tional words like "bar" and "baz" are treated as  sub-ensembles.   Sub-
       ensembles  are  merely parts within an ensemble; they do not have a Tcl
       command associated with them.  An ensemble like "foo" can have  a  sub-
       ensemble called "foo bar", which in turn can have a sub-ensemble called
       "foo bar baz".  In this case, the sub-ensemble "foo bar" must  be  cre-
       ated before the sub-ensemble "foo bar baz" that resides within it.

       If  there are any arguments following ensName, then they are treated as
       commands, and they are executed to update the ensemble.  The  following
       commands are recognized in this context:  ppaarrtt and eennsseemmbbllee.

       The  ppaarrtt  command  defines a new part for the ensemble.  Its syntax is
       identical to the usual pprroocc command, but it defines a  part  within  an
       ensemble,  instead of a Tcl command.  If a part called partName already
       exists within the ensemble, then the ppaarrtt command returns an error.

       The eennsseemmbbllee command can be nested inside another eennsseemmbbllee  command  to
       define a sub-ensemble.


WWHHAATT IISS AANN EENNSSEEMMBBLLEE??
       The  usual "info" command is a composite command-the command name iinnffoo
       must be followed by a sub-command like bbooddyy or gglloobbaallss.  We will  refer
       to a command like iinnffoo as an ensemble, and to sub-commands like bbooddyy or
       gglloobbaallss as its parts.

       Ensembles can be nested.  For example, the iinnffoo command has an ensemble
       iinnffoo  nnaammeessppaaccee within it.  This ensemble has parts like iinnffoo nnaammeessppaaccee
       aallll and iinnffoo nnaammeessppaaccee cchhiillddrreenn.

       With ensembles, composite commands can be created and  extended  in  an
       automatic  way.   Any package can find an existing ensemble and add new
       parts to it.  So extension writers can add their own parts,  for  exam-
       ple, to the iinnffoo command.

       The  ensemble facility manages all of the part names and keeps track of
       unique abbreviations.  Normally, you can abbreviate  iinnffoo  ccoommpplleettee  to
       iinnffoo ccoommpp.  But if an extension adds the part iinnffoo ccoommpplleexxiittyy, the min-
       imum abbreviation for iinnffoo ccoommpplleettee becomes iinnffoo ccoommpplleett.

       The ensemble facility not only automates the construction of  composite
       commands,  but  it automates the error handling as well.  If you invoke
       an ensemble command without specifying a part name, you get an automat-
       ically  generated  error message that summarizes the usage information.
       For example, when the iinnffoo command is invoked without any arguments, it
       produces the following error message: wrong # args: should be one of...
         info args procname
         info body procname
         info cmdcount
         info commands ?pattern?
         info complete command
         info context
         info default procname arg varname
         info exists varName
         info globals ?pattern?
         info level ?number?
         info library
         info locals ?pattern?
         info namespace option ?arg arg ...?
         info patchlevel
         info procs ?pattern?
         info protection ?-command? ?-variable? name
         info script
         info tclversion
         info vars ?pattern?
         info which ?-command? ?-variable? ?-namespace? name You can also cus-
       tomize  the  way  an  ensemble  responds  to  errors.  When an ensemble
       encounters an unspecified or ambiguous part name, it looks for  a  part
       called  @@eerrrroorr.   If  it  exists,  then it is used to handle the error.
       This part will receive all of the arguments on the command line  start-
       ing with the offending part name.  It can find another way of resolving
       the command, or generate its own error message.


EEXXAAMMPPLLEE
       We could use an ensemble to clean up the syntax of the  various  "wait"
       commands in Tcl/Tk.  Instead of using a series of strange commands like
       this: vwait x tkwait visibility .top tkwait window .  we could use com-
       mands with a uniform syntax, like this: wait variable x wait visibility
       .top wait window .  The Tcl package could define the  following  ensem-
       ble: ensemble wait part variable {name} {
           uplevel vwait $name } The Tk package could add some options to this
       ensemble, with a command like this: ensemble wait {
           part visibility {name} {
               tkwait visibility $name
           }
           part window {name} {
               tkwait window $name
           } } Other extensions could add their own parts to the wwaaiitt  command
       too.


KKEEYYWWOORRDDSS
       ensemble, part, info



itcl                                  3.0                          ensemble(n)