tepam::argument_dialogbox(n) Tcl�s Enhanced Procedure and Argument Manager tepam::argument_dialogbox(n) 







tepam::argument_dialogbox - TEPAM argument_dialogbox, reference
    manual








package require Tcl 8.3


package require Tk 8.3


package require tepam ?0.1?


tepam::argument_dialogbox item_name item_attributes
    ?item_name item_attributes? ?...?


tepam::argument_dialogbox {item_name item_attributes
    ?item_name item_attributes? ?...?}


















TEPAM's argument_dialogbox is a flexible and easily usable
    entry form generator. Each entry element of a form is defined via a data
    entry item that can be provided to argument_dialogbox in two
    formats:



  

  
Using this first format, each data entry item is defined via a
      named argument. The item name defines thereby the entry element type that
      has to be used in the form. The item data, called item attributes,
      defines the variable which is attributed to the data entry element as well
      as eventual formatting and context information.
    
The argument_dialogbox returns ok if the entered
        data have been acknowledged (via the OK button) and validated by
        a data checker. If the entered data have been rejected (via the
        Cancel button) the argument_dialogbox returns
        cancel.

    
A small example is the simplest way to illustrate how the
        argument_dialogbox can be employed:

    
set DialogResult [tepam::argument_dialogbox \
   -title "Itinerary selection" \
   -file {-label "Itinerary report" -variable report_file} \
   -frame {-label "Itinerary start"} \
      -comment {-text "Specify your itinerary start location"} \
      -entry {-label "City" -variable start_city -type string} \
      -entry {-label "Street" -variable start_street -type string -optional 1} \
      -entry {-label "Street number" -variable start_street_nbr -type integer -optional 1} \
   -frame {-label "Itinerary destination"} \
      -comment {-text "Specify your itinerary destination"} \
      -entry {-label "City" -variable dest_city -type string} \
      -entry {-label "Street" -variable dest_street -type string -optional 1} \
      -entry {-label "Street number" -variable dest_street_nbr -type integer -optional 1} \
   -frame {} \
   -checkbutton {-label "Don't use highways" -variable no_highway}]

    This example opens a dialog box that has the title Itinerary
      selection. A first entry element in this box allows selecting a report
      file. It follows two frames to define respectively an itinerary start and
      end location. Each of these locations, that is described with a comment,
      has three entry elements to specify respectively the city, street and the
      street number. Bellow the second frame there is a checkbutton that allows
      specifying if eventual highways should be ignored.

  

  
Sometimes it is simpler to provide all the data entry item definitions in
      form of a single list to argument_dialogbox, and not as individual
      arguments. The second format that is supported by
      argument_dialogbox corresponds exactly to the first one, except
      that all item definitions are packed into a single list that is provided
      to argument_dialogbox. The previous example can therefore also be
      written in the following way:
    
set DialogResult [tepam::argument_dialogbox {
   -title "Itinerary selection"
   -file {-label "Itinerary report" -variable report_file}
   ...
   -checkbutton {-label "Don't use highways" -variable no_highway} }]

  




The commands argument_dialogbox as well as procedure
    are exported from the namespace tepam. To use these commands without
    the tepam:: namespace prefix, it is sufficient to import them into
    the main namespace:


namespace import tepam::*
set DialogResult [argument_dialogbox \
   -title "Itinerary selection"
   ...

The following subsections explain the different items that are accepted by the
  argument_dialogbox, classified into three groups. The first data entry
  item definition format will be used in the remaining document, knowing that
  this format can always be transformed into the second format by putting all
  arguments into a single list that is then provided to
  argument_dialogbox.





The first item group allows specifying some context aspects of an
    argument dialog box. These items are taking a simple character string as
    item data:


tepam::argument_dialogbox \
   -<argument_name> string \
   ...


The following items are classified into this group:



  

  
The dialog box window's title which is by default Dialog can be
      changed with the -title item:
    
tepam::argument_dialogbox \
   -title "System configuration" \
   ...

  

  

  
The argument dialog box uses by default .dialog as dialog top level
      window. This path can be changed with the -window item:
    
tepam::argument_dialogbox \
   -window .dialog \
   ...

  

  

  
By defining a parent window, the argument dialog box will be displayed
      beside this one. Without explicit parent window definition, the top-level
      window will be considered as parent window.
    
tepam::argument_dialogbox \
   -parent .my_appl \
   ...

  

  

  
The dialog box's state, e.g. the entered data as well as the window size
      and position, is saved and restored the next time the argument dialog box
      is called if a context is defined. The assignment of a context allows
      saving the dialog box' state in its context to distinguish between
      different usages of the argument dialog box.
    
tepam::argument_dialogbox \
   -context destination_definitions \
   ...

  










Especially for big, complex forms it becomes important that the
    different data entry widgets are graphically well organized and commented to
    provide an immediate and clear overview to the user. A couple of items allow
    structuring and commenting the dialog boxes.


The items of this classification group require as item data an
    attribute definition list. The attribute definition list contains itself
    attribute name and data pairs:


tepam::argument_dialogbox \
   ...
   -<argument_name> { 
      ?-<attribute_name> <attribute_data>?
      ?-<attribute_name> <attribute_data>?
      ?...?
   }
   ...

The following items are classified into this group:


  

  
The -frame item allows packing all following entry widgets into a
      labeled frame, until a next frame item is defined or until the last entry
      widgets. It recognizes the following attributes inside the item data
    list:







  

  
An optional frame label can be specified with the -label
    statement.





Example:

tepam::argument_dialogbox \
   ...
   -frame {-label "Destination address"}
   ...


To close an open frame without opening a new one, an empty list
    has to be provided to the -frame statement.


tepam::argument_dialogbox \
   ...
   -frame {}
   ...



  

  
Entry widgets can be separated with the -sep statement which
      doesn't require additional definitions. The related definition list has to
      exist, but its content is ignored.
    
tepam::argument_dialogbox \
   ...
   -sep {}
   ...

  

  

  
Comments and descriptions can be added with the -text attribute of
      the -comment item. Please note that each entry widget itself can
      also contain a -text attribute for comments and descriptions. But
      the -comment item allows for example adding a description between
      two frames.
    
tepam::argument_dialogbox \
   ...
   -comment {-text "Specify bellow the destination address"}
   ...

  










Data entry widgets are created with the widget items. These items
    require as the formatting items an attribute definition list as item
  data:


tepam::argument_dialogbox \
   ...
   -<argument_name> { 
      ?-<attribute_name> <attribute_data>?
      ?-<attribute_name> <attribute_data>?
      ?...?
   }
   ...


The attribute list can contain various attributes to describe and
    comment an entry widget and to constrain its entered data. All entry widgets
    are accepting a common set of attributes that are described in the section
    Entry Widget Item Attributes.


TEPAM defines a rich set of entry widgets. If necessary, this set
    can be extended with additional application specific entry widgets (see
    APPLICATION SPECIFIC ENTRY WIDGETS):



  

  
The -entry item generates the simplest but most universal data
      entry widget. It allows entering any kind of data.
    
tepam::argument_dialogbox \
   -entry {-label Name -variable Entry}

  

  

  
A group of check boxes is created with the -checkbox item. The
      number of check boxes and their option values are specified with a list
      assigned to the -choices attribute or via a variable declared with
      the -choicevariable attribute:
    
tepam::argument_dialogbox \
   -checkbox {-label "Font sytle" -variable FontStyle \
               -choices {bold italic underline} -default italic}

    If the check boxes' texts should differ from the option values, they can be
      defined with the -choicelabels attribute:
    
tepam::argument_dialogbox \
   -checkbox {-label "Font sytle" -variable FontStyle \
              -choices {bold italic underline} \
              -choicelabels {Bold Italic Underline} \
              -default italic}

    In contrast to a radio box group, a check box group allows selecting
      simultaneously several choice options. The selection is stored for this
      reason inside the defined variable in form of a list, even if only one
      choice option has been selected.

  

  
A group of radio boxes is created with the -radiobox item. The
      number of radio boxes and their option values are specified with a list
      assigned to the -choices attribute or via a variable declared with
      the -choicevariable attribute.
    
In contrast to a check box group, a radio box group allows
        selecting simultaneously only one choice option. The selected option
        value is stored directly, and not in form of a list, inside the defined
        variable.

    
tepam::argument_dialogbox \
   -radiobox {-label "Text adjustment" -variable Adjustment \
              -choices {left center right} -default left}

    If the radio boxes' texts should differ from the option values, they can be
      defined with the -choicelabels attribute:
    
tepam::argument_dialogbox \
   -radiobox {-label "Text adjustment" -variable Adjustment \
              -choices {left center right} \
              -choicelabels {Left Center Right} -default left}

  

  

  
The -checkbutton entry widget allows activating or deactivating a
      single choice option. The result written into the variable will either be
      0 when the check button was not activated or 1 if it was
      activated. An eventually provided default value has also to be either
      0 or 1.
    
tepam::argument_dialogbox \
   -checkbutton {-label Capitalize -variable Capitalize -default 1}

  




Several types of list and combo boxes are available to handle
    selection lists.



  

  
The combobox is a combination of a normal entry widget together with a
      drop-down list box. The combobox allows selecting from this drop-down list
      box a single element. The list of the available elements can be provided
      either as a list to the -choices attribute, or via a variable that
      is specified with the -choicevariable attribute.
    
tepam::argument_dialogbox \
   -combobox {-label "Text size" -variable Size -choices {8 9 10 12 15 18} -default 12}

    And here is an example of using a variable to define the selection list:
    
set TextSizes {8 9 10 12 15 18}
tepam::argument_dialogbox \
   -combobox {-label "Text size" -variable Size -choicevariable TextSizes -default 12}

  

  

  
In contrast to the combo box, the list box is always displayed by the
      listbox entry widget. Only one element is selectable unless the
      -multiple_selection attribute is set. The list box height can be
      selected with the -height attribute. If the height is not
      explicitly defined, the list box height is automatically adapted to the
      argument dialog box' size. The first example uses a variable to define the
      available choices:
    
set set AvailableSizes
for {set k 0} {$k<16} {incr k} {lappend AvailableSizes [expr 1<<$k]}
tepam::argument_dialogbox \
   -listbox {-label "Distance" -variable Distance \
             -choicevariable AvailableSizes -default 6 -height 5}

    Here is a multi element selection example. Please note that also the default
      selection can contain multiple elements:
    
tepam::argument_dialogbox \
   -listbox {-label "Text styles" -variable Styles \
             -choices {bold italic underline overstrike} \
             -choicelabels {Bold Italic Underline Overstrike} \
             -default {bold underline} -multiple_selection 1 \
             -height 3}

  

  

  
A disjoint list box has to be used instead of a normal list box if the
      selection order is important. The disjoint list box entry widget is in
      fact displaying two list boxes, one for the selected elements and one for
      the unselected elements.
    
Disjoint listboxes allow always selecting multiple elements.
        With the exception of the -multiple_selection attribute,
        disjointed list boxes are accepting the same attributes as the normal
        listbox, e.g. -height, -choices, -choicevariable, -default.

    
tepam::argument_dialogbox \
   -disjointlistbox {-label "Preferred scripting languages" -variable Languages \
             -comment "Please select your preferred languanges in the order" \
             -choices {JavaScript Lisp Lua Octave PHP Perl Python Ruby Scheme Tcl} \
             -default {Tcl Perl Python}}

  




The file and directory selectors are building a next group of
    entry widgets. A paragraph of section Entry Widget Item Attributes
    explains the dedicated attributes of these widgets to specify the targeted
    file types, active directory etc.



  

  
The item -file creates a group composed by an entry widget together
      with a button that allows opening a file browser. The data type
      file is automatically selected for this entry if no data type has
      been explicitly defined with the -type attribute.
    
tepam::argument_dialogbox \
   -file {-label "Image file" -variable ImageF \
          -filetypes {{"GIF" {*.gif}} {"JPG" {*.jpg}}} \
          -initialfile "picture.gif"}

  

  

  
The item -existingfile creates a group composed by an entry widget
      together with a button that allows opening a browser to select an existing
      file. The data type existingfile is automatically selected for this
      entry if no data type has been explicitly defined with the -type
      attribute.
    
tepam::argument_dialogbox \
   -existingfile {-label "Image file" -variable ImageF \
                  -filetypes {{"GIF" {*.gif}} {"JPG" {*.jpg}}} \
                  -initialfile "picture.gif"}

  

  

  
The item -directory creates a group composed by an entry widget
      together with a button that allows opening a directory browser. The data
      type directory is automatically selected for this entry if no data
      type has been explicitly defined with the -type attribute.
    
tepam::argument_dialogbox \
   -directory {-label "Report directory" -variable ReportDir}

  

  

  
The item -existingdirectory creates a group composed by an entry
      widget together with a button that allows opening a browser to select an
      existing directory. The data type existingdirectory is
      automatically selected for this entry if no data type has been explicitly
      defined with the -type attribute.
    
tepam::argument_dialogbox \
   -existingdirectory {-label "Report directory" -variable ReportDir}

  




Finally, there is a last group of some other special entry
    widgets.



  

  
The color selector is composed by an entry widget together with a button
      that allows opening a color browser. The data type color is
      automatically selected for this entry widget type if no data type has been
      explicitly defined with the -type attribute.
    
tepam::argument_dialogbox \
   -color {-label "Background color" -variable Color -default red}

  

  

  
The font selector is composed by an entry widget together with a button
      that allows opening a font browser. The data type font is
      automatically selected for this entry widget type if no data type has been
      explicitly defined with the -type attribute. The entry widget
      displays an example text using the selected font.
    
The font browser allows selecting by default the font families
        provided by the font families command as well as a reasonable set
        of different font sizes between 6 points and 40 points. Different sets
        of font families and font sizes can be specified respectively via the
        -font_families or -font_sizes attributes.

    
If no default font is provided via the -default
        attribute, the font of the label widget to display the selected font
        will be used as default selected font. If the font family of this label
        widget is not part of the available families the first available family
        is used as default. If the font size of this label widget is not part of
        the available sizes the next close available size is selected as
        default.

    
tepam::argument_dialogbox \
   -font {-label "Font" -variable Font \
          -font_sizes {8 10 12 16} \
          -default {Arial 20 italic}}

  










All the entry widget items are accepting the following
  attributes:



  

  
Eventual descriptions and comments specified with the -text
      attribute are displayed above the entry widget.
    
tepam::argument_dialogbox \
   -entry {-text "Please enter your name bellow" -variable Name}

  

  

  
The label attribute creates left to the entry widget a label using the
      provided string as label text:
    
tepam::argument_dialogbox \
   -entry {-label Name -variable Name}

  

  

  
All entry widgets require a specified variable. After accepting the
      entered information with the OK button, the entry widget's data are stored
      inside the defined variables.
    
tepam::argument_dialogbox \
   -existingdirectory {-label "Report directory" -variable ReportDir}

  

  

  
Eventual default data for the entry widgets can be provided via the
      -default attribute. The default value is overridden when an
      argument dialog box with a defined context is called another time. The
      data acknowledged in a previous call will be used in this case as default
      data.
    
tepam::argument_dialogbox \
   -checkbox {-label "Font sytle" -variable FontStyle \
               -choices {bold italic underline} -default italic}

  

  

  
Data can be specified as optional or mandatory with the -optional
      attribute that requires either 0 (mandatory) or 1 (optional)
      as attribute data.
    
In case an entry is optional and no data has been entered,
        e.g. the entry contains an empty character string, the entry will be
        considered as undefined and the assigned variable will not be
      defined.

    
tepam::argument_dialogbox \
   -entry {-label "City" -variable start_city -type string} \
   -entry {-label "Street" -variable start_street -type string -optional 0} \
   -entry {-label "Street number" -variable start_street_nbr -type integer -optional 1} \

  

  

  
If the data type is defined with the -type attribute the argument
      dialog box will automatically perform a data type check after
      acknowledging the entered data and before the dialog box is closed. If a
      type incompatible data is found an error message box appears and the user
      can correct the data.
    
The argument dialog box accepts all types that have been
        specified by the TEPAM package and that are also used by
        tepam::procedure (see the tepam::procedure reference
        manual).

    
Some entry widgets like the file and directory widgets, as
        well as the color and font widgets are specifying automatically a
        default data type if no type has been specified explicitly with the
        -type attribute.

    
tepam::argument_dialogbox \
   -entry {-label "Street number" -variable start_street_nbr -type integer} \

  

  

  
Data can be constrained with the -range attribute. The valid range
      is defined with a list containing the minimum valid value and a maximum
      valid value.
    
The -range attribute has to be used only for numerical
        arguments, like integers and doubles.

    
tepam::argument_dialogbox \
   -entry {-label Month -variable Month -type integer -range {1 12}}

  

  

  
More complex argument data validations than type checks can be performed
      via specific validation commands that are declared via the
      -validatecommand attribute. The provided validation command can be
      a complete script in which the pattern %P is replaced by the
      argument data that has to be validated.
    
tepam::argument_dialogbox \
   -entry {-label "Your comment" -variable YourCom \
           -validatecommand "IllegalWordDetector %P"} ]

  




Some other attributes are supported by the list and combo boxes as
    well as by the radio and check buttons.



  

  
Choice lists can directly be defined with the -choices attribute.
      This way to define choice lists is especially adapted for smaller, fixed
      selection lists.
    
tepam::argument_dialogbox \
   -listbox {-label "Text styles" -variable Styles \
             -choices {bold italic underline} -default underline

  

  

  
If the check and radio boxes' texts should differ from the option values,
      they can be defined with the -choicelabels attribute:
    
tepam::argument_dialogbox \
   -checkbox {-label "Font sytle" -variable FontStyle \
              -choices {bold italic underline} \
              -choicelabels {Bold Italic Underline}

  

  

  
Another way to define the choice lists is using the -choicevariable
      attribute. This way to define choice lists is especially adapted for huge
      and eventually variable lists.
    
set TextSizes {8 9 10 12 15 18}
tepam::argument_dialogbox \
   -combobox {-label "Text size" -variable Size -choicevariable TextSizes}

  

  

  
The list box item (-listbox) allows by default selecting only one
      list element. By setting the -multiple_selection attribute to
      1, multiple elements can be selected.
    
tepam::argument_dialogbox \
   -listbox {-label "Text styles" -variable Styles \
             -choices {bold italic underline} -default underline \
             -multiple_selection 1 -height 3}

  




Some additional attributes are supported by the file and directory
    selection widgets.



  

  
The file type attribute is used by the -file and
      -existingfile items to define the file endings that are searched by
      the file browser.
    
tepam::argument_dialogbox \
   -file {-label "Image file" -variable ImageF \
          -filetypes {{"GIF" {*.gif}} {"JPG" {*.jpg}}}}

  

  

  
The initial file used by the file browsers of the -file and
      -existingfile widgets are by default the file defined with the
      -default attribute, unless a file is specified with the
      -initialfile attribute.
    
tepam::argument_dialogbox \
   -file {-variable ImageF -initialfile "picture.gif"}

  

  

  
The -activedir attribute will override the default active search
      directory used by the file browsers of all file and directory entry
      widgets. The default active search directory is defined by the directory
      of a specified initial file (-initialfile) if defined, and
      otherwise by the directory of the default file/directory, specified with
      the -default attribute.
    
tepam::argument_dialogbox \
   -file "-variable ImageF -activedir $pwd"

  




Finally, there is a last attribute supported by some widgets:



  

  
All widgets containing a selection list (-listbox,
      -disjointlistbox, -font) are accepting the -height
      attribute that defines the number of displayed rows of the selection
      lists.
    
tepam::argument_dialogbox \
   -listbox {-label "Text size" -variable Size \
             -choices {8 9 10 12 15 18} -default 12 -height 3}

    If the no height has been explicitly specified the height of the widget will
      be adapted to the argument dialog box' size.












An application specific entry widget can be made available to the
    argument dialog box by adding a dedicated procedure to the tepam
    namespace. This procedure has three arguments; the first one is the widget
    path, the second one a subcommand and the third argument has various
    purposes:


proc tepam::ad_form(<WidgetName>) {W Command {Par ""}} {
   upvar Option Option; # if required
   variable argument_dialogbox; # if required
   switch $Command {
      "create" <CreateCommandSequence>
      "set_choice" <SetChoiceCommandSequence>
      "set" <SetCommandv>
      "get" <GetCommandSequence>
   }
}


Argument_dialogbox takes care about the -label and
    -text attributes for all entry widgets. For the entry widget it
    creates a frame into which the entry widget components can be placed. The
    path to this frame is provided via the W argument. The entry widget
    procedure has to support 3 mandatory and an optional command, defined via
    the Command argument:



  

  
The entry widget is called a first time with the command create to
      build the entry widget.
    
The frames that are made available by
        argument_dialogbox for the entry widgets are by default only
        extendable in the X direction. To make them also extendable in the Y
        direction, for example for extendable list boxes, the command
        ad_form(make_expandable) $W has to be executed when an entry
        widget is built.

  

  

  
The entry widget procedure is only called with the set_choice
      command when the -choices or -choicevariable has been
      specified. The command is therefore only relevant for list and combo
      boxes.
    
The available selection list, either specified with the
        -choices or -choicevariable attribute is provided via the
        Par argument to the entry widget procedure which can initialize
        the selection list with this data.

  

  

  
If a default value is either defined via the -default attribute or
      via a preceding call the entry widget procedure is called with the
      set command. The argument Par contains in this case the
      value to which the entry widget has to be initialized.

  

  
The entry widget procedure's command get has to return the actual
      value of the entry widget.




Eventually specified entry widget item attributes are available
    via the Option array variable of the calling procedure. This variable
    becomes accessible inside the entry widget procedure via the upvar
    command.


There may be a need to store some information in a variable. The
    array variable argument_dialogbox has to be used for this purpose
    together with array indexes starting with "$W,", e.g.
    argument_dialogbox($W,values).


Examples of entry widget procedures are directly provided by the
    TEPAM package source file that specifies the standard entry widget
    procedures. The simplest procedure is certainly the one for the basic
    entry widget:


proc tepam::ad_form(entry) {W Command {Par ""}} {
   switch $Command {
      "create" {pack [entry \$W.entry] -fill x \
                        -expand yes -pady 4 -side left}
      "set" {\$W.entry insert 0 $Par}
      "get" {return [\$W.entry get]}
   }
}

It is also possible to relay on an existing entry widget procedure to create a
  new, more specific one. The radiobox widget is used for example, to
  create a new entry widget that allows selecting either the option left,
  center or right. The original radiobox widget is called
  with the set_choice command immediately after the create
  command, to define the fixed list of selection options.

proc tepam::ad_form(rcl) {W Command {Par ""}} {
   set Res [ad_form(radiobox) $W $Command $Par]
   if {$Command=="create"} {
      ad_form(radiobox) $W set_choice {left center right}
   }
   return $Res
}

Please consult the TEPAM package source file to find additional and more complex
  examples of entry widget procedures.







The argument_dialogbox is using two variables inside the
    ::tepam namespace:



  

  
Application specific entry widget procedures can use this array variable
      to store their own data, using as index the widget path provided to the
      procedure, e.g. argument_dialogbox($W,<sub_index>).

  

  
This array variable is only used by an argument dialog box when its
      context has been specified via the -context attribute. The argument
      dialog box' position and size as well as its entered data are stored
      inside this variable when the data are acknowledged and the form is
      closed. This allows the form to restore its previous state once it is
      called another time.
    
To reuse the saved parameters not just in the actual
        application session but also in another one, it is sufficient to store
        the last_parameter variable array in a configuration file which
        is loaded the next time an application is launched.

  










tepam_introduction(n), tepam_procedure(n)








entry mask, parameter entry form








Argument entry form, mega widget








Copyright (c) 2009/2010, Andreas Drollinger








  

    0.1.0
    tepam