ABCDEFGHIJKLMNOPQRSTUVWXYZ

Tk_GetOptionValue

Tk_SetOptions(3)             Tk Library Procedures            Tk_SetOptions(3)



______________________________________________________________________________

NAME
       Tk_CreateOptionTable,  Tk_DeleteOptionTable,  Tk_InitOptions, Tk_SetOp-
       tions, Tk_FreeSavedOptions, Tk_RestoreSavedOptions,  Tk_GetOptionValue,
       Tk_GetOptionInfo,  Tk_FreeConfigOptions, Tk_Offset - process configura-
       tion options

SYNOPSIS
       #include <tk.h>

       Tk_OptionTable
       Tk_CreateOptionTable(interp, templatePtr)

       Tk_DeleteOptionTable(optionTable)

       int
       Tk_InitOptions(interp, recordPtr, optionTable, tkwin)

       int
       Tk_SetOptions(interp, recordPtr, optionTable, objc, objv, tkwin, savePtr, maskPtr)

       Tk_FreeSavedOptions(savedPtr)

       Tk_RestoreSavedOptions(savedPtr)

       Tcl_Obj *
       Tk_GetOptionValue(interp, recordPtr, optionTable, namePtr, tkwin)

       Tcl_Obj *
       Tk_GetOptionInfo(interp, recordPtr, optionTable, namePtr, tkwin)

       Tk_FreeConfigOptions(recordPtr, optionTable, tkwin)

       int
       Tk_Offset(type, field)

ARGUMENTS
       Tcl_Interp        *interp         (in)      A  Tcl  interpreter.   Most
                                                   procedures  use  this  only
                                                   for  returning  error  mes-
                                                   sages;  if  it is NULL then
                                                   no   error   messages   are
                                                   returned.  For Tk_CreateOp-
                                                   tionTable the value  cannot
                                                   be   NULL;   it  gives  the
                                                   interpreter  in  which  the
                                                   option  table will be used.

       Tk_OptionSpec     *templatePtr    (in)      Points  to  an   array   of
                                                   static   information   that
                                                   describes the configuration
                                                   options that are supported.
                                                   Used     to     build     a
                                                   Tk_OptionTable.  The infor-
                                                   mation pointed to  by  this
                                                   argument must exist for the
                                                   lifetime       of       the
                                                   Tk_OptionTable.

       Tk_OptionTable    optionTable     (in)      Token  for an option table.
                                                   Must have been returned  by
                                                   a  previous call to Tk_Cre-
                                                   ateOptionTable.

       char              *recordPtr      (in/out)  Points  to   structure   in
                                                   which  values of configura-
                                                   tion  options  are  stored;
                                                   fields  of  this record are
                                                   modified by procedures such
                                                   as  Tk_SetOptions  and read
                                                   by   procedures   such   as
                                                   Tk_GetOptionValue.

       Tk_Window         tkwin           (in)      For    options    such   as
                                                   TK_OPTION_COLOR, this argu-
                                                   ment  indicates  the window
                                                   in which the option will be
                                                   used.   If optionTable uses
                                                   no         window-dependent
                                                   options,  then a NULL value
                                                   may be  supplied  for  this
                                                   argument.

       int               objc            (in)      Number of values in objv.

       Tcl_Obj           *CONST objv[]   (in)      Command-line  arguments for
                                                   setting         configuring
                                                   options.

       Tk_SavedOptions   *savePtr        (out)     If  not NULL, the structure
                                                   pointed to by this argument
                                                   is  filled  in with the old
                                                   values of any options  that
                                                   were  modified and old val-
                                                   ues are restored  automati-
                                                   cally if an error occurs in
                                                   Tk_SetOptions.

       int               *maskPtr        (out)     If  not  NULL,   the   word
                                                   pointed  to  by  maskPtr is
                                                   filled in with the bit-wise
                                                   OR  of  the typeMask fields
                                                   for the options  that  were
                                                   modified.

       Tk_SavedOptions   *savedPtr       (in/out)  Points  to a structure pre-
                                                   viously   filled   in    by
                                                   Tk_SetOptions with old val-
                                                   ues of modified options.

       Tcl_Obj           *namePtr        (in)      The value of this object is
                                                   the  name  of  a particular
                                                   option.  If NULL is  passed
                                                   to   Tk_GetOptionInfo  then
                                                   information is returned for
                                                   all  options.   Must not be
                                                   NULL when Tk_GetOptionValue
                                                   is called.

       type name         type            (in)      The  name  of the type of a
                                                   record.

       field name        field           (in)      The  name  of  a  field  in
                                                   records of type type.
_________________________________________________________________

DESCRIPTION
       These  procedures  handle  most of the details of parsing configuration
       options such as those for Tk widgets.   Given  a  description  of  what
       options are supported, these procedures handle all the details of pars-
       ing options and storing their values into a C structure associated with
       the  widget  or object. The procedures were designed primarily for wid-
       gets in Tk, but they can also be used for other kinds of  objects  that
       have configuration options.  In the rest of this manual page ``widget''
       will be used to refer to the object whose options are being managed; in
       practice  the  object  may not actually be a widget.  The term ``widget
       record'' is used to refer to the C-level structure in which information
       about a particular widget or object is stored.

       Note:  the  easiest way to learn how to use these procedures is to look
       at a working example.  In Tk, the simplest example  is  the  code  that
       implements the button family of widgets, which is an tkButton.c.  Other
       examples are in tkSquare.c and tkMenu.c.

       In order to use these procedures, the code that implements  the  widget
       must contain a static array of Tk_OptionSpec structures. This is a tem-
       plate that describes the various options supported  by  that  class  of
       widget; there is a separate template for each kind of widget.  The tem-
       plate contains information such as the name of each option,  its  type,
       its  default  value, and where the value of the option is stored in the
       widget record.  See TEMPLATES below for more detail.

       In order to process configuration options efficiently, the static  tem-
       plate  must  be augmented with additional information that is available
       only at  runtime.   The  procedure  Tk_CreateOptionTable  creates  this
       dynamic  information  from  the  template  and returns a Tk_OptionTable
       token that describes both the static and dynamic information.   All  of
       the  other  procedures,  such  as  Tk_SetOptions, take a Tk_OptionTable
       token as argument.  Typically, Tk_CreateOptionTable is called the first
       time  that  a widget of a particular class is created and the resulting
       Tk_OptionTable is used in the future for all widgets of that class.   A
       Tk_OptionTable  may  be used only in a single interpreter, given by the
       interp argument to Tk_CreateOptionTable.  When an option  table  is  no
       longer  needed Tk_DeleteOptionTable should be called to free all of its
       resources.  All of the option tables for a Tcl  interpreter  are  freed
       automatically if the interpreter is deleted.

       Tk_InitOptions  is  invoked  when  a  new  widget is created to set the
       default values for all of the widget's configuration options.   Tk_Ini-
       tOptions  is  passed  a  token  for an option table (optionTable) and a
       pointer to a widget record (recordPtr), which is the C  structure  that
       holds  information  about this widget. Tk_InitOptions uses the informa-
       tion in the option table to choose  an  appropriate  default  for  each
       option,  then  it  stores  the  default  value directly into the widget
       record, overwriting any information that was  already  present  in  the
       widget  record.   Tk_InitOptions  normally returns TCL_OK.  If an error
       occurred while setting the default  values  (e.g.,  because  a  default
       value was erroneous) then TCL_ERROR is returned and an error message is
       left in interp's result if interp isn't NULL.

       Tk_SetOptions is invoked  to  modify  configuration  options  based  on
       information  specified in a Tcl command.  The command might be one that
       creates a new widget, or a command that modifies options on an existing
       widget.   The  objc and objv arguments describe the values of the argu-
       ments from the Tcl command.   Objv  must  contain  an  even  number  of
       objects:  the first object of each pair gives the name of an option and
       the second object gives the new value for that  option.   Tk_SetOptions
       looks  up  each  name  in optionTable, checks that the new value of the
       option conforms to the type in optionTable, and stores the value of the
       option  into  the widget record given by recordPtr.  Tk_SetOptions nor-
       mally returns TCL_OK.  If an error occurred (such as an unknown  option
       name  or  an  illegal  option  value) then TCL_ERROR is returned and an
       error message is left in interp's result if interp isn't NULL.

       Tk_SetOptions has two additional features.  First, if the maskPtr argu-
       ment  isn't  NULL  then it points to an integer value that is filled in
       with information about the options that were modified.  For each option
       in  the  template  passed  to  Tk_CreateOptionTable there is a typeMask
       field.  The bits of this field are defined by the code that  implements
       the widget; for example, each bit might correspond to a particular con-
       figuration option.  Alternatively, bits  might  be  used  functionally.
       For  example,  one  bit  might  be used for redisplay: all options that
       affect the widget's display, such that changing the option requires the
       widget  to  be redisplayed, might have that bit set.  Another bit might
       indicate that the geometry of the widget must be recomputed, and so on.
       Tk_SetOptions  OR's  together  the typeMask fields from all the options
       that were modified and returns this value at *maskPtr; the  caller  can
       then  use  this information to optimize itself so that, for example, it
       doesn't redisplay the widget if the modified options don't  affect  the
       widget's appearance.

       The  second  additional  feature  of Tk_SetOptions has to do with error
       recovery.  If an error occurs while processing  configuration  options,
       this feature makes it possible to restore all the configuration options
       to their previous values.  Errors can  occur  either  while  processing
       options  in  Tk_SetOptions  or  later in the caller.  In many cases the
       caller does additional  processing  after  Tk_SetOptions  returns;  for
       example,  it might use an option value to set a trace on a variable and
       may detect an error if the variable is an array instead  of  a  scalar.
       Error  recovery  is  enabled  by  passing  in  a non-NULL value for the
       savePtr argument to Tk_SetOptions; this  should  be  a  pointer  to  an
       uninitialized   Tk_SavedOptions   structure   on  the  caller's  stack.
       Tk_SetOptions overwrites the  structure  pointed  to  by  savePtr  with
       information  about the old values of any options modified by the proce-
       dure.  If Tk_SetOptions  returns  successfully,  the  caller  uses  the
       structure  in  one of two ways.  If the caller completes its processing
       of the new options without any errors, then it must pass the  structure
       to  Tk_FreeSavedOptions  so  that  the old values can be freed.  If the
       caller detects an error in its processing of the new options,  then  it
       should  pass  the  structure to Tk_RestoreSavedOptions, which will copy
       the old values back into the widget record and free the new values.  If
       Tk_SetOptions  detects  an  error  then  it  automatically restores any
       options that had already been modified and leaves *savePtr in an  empty
       state:   the   caller  need  not  call  either  Tk_FreeSavedOptions  or
       Tk_RestoreSavedOptions.  If the savePtr argument  to  Tk_SetOptions  is
       NULL then Tk_SetOptions frees each old option value immediately when it
       sets a new value for the option.  In this case, if an error  occurs  in
       the  third  option,  the old values for the first two options cannot be
       restored.

       Tk_GetOptionValue returns the current value of a  configuration  option
       for  a particular widget.  The namePtr argument contains the name of an
       option; Tk_GetOptionValue uses optionTable to  lookup  the  option  and
       extract  its value from the widget record pointed to by recordPtr, then
       it returns an object containing that value.  If an error occurs  (e.g.,
       because  namePtr contains an unknown option name) then NULL is returned
       and an error message is left in interp's result unless interp is  NULL.

       Tk_GetOptionInfo  returns  information about configuration options in a
       form suitable for configure widget commands.  If the  namePtr  argument
       is not NULL, it points to an object that gives the name of a configura-
       tion option; Tk_GetOptionInfo returns an object containing a list  with
       five  elements,  which  are  the name of the option, the name and class
       used for the option in the option database, the default value  for  the
       option,  and the current value for the option.  If the namePtr argument
       is NULL, then Tk_GetOptionInfo returns information about all options in
       the  form  of a list of lists; each sublist describes one option.  Syn-
       onym options are handled differently depending on  whether  namePtr  is
       NULL:  if  namePtr is NULL then the sublist for each synonym option has
       only two elements, which are the name of the option and the name of the
       other option that it refers to; if namePtr is non-NULL and names a syn-
       onym option then the object returned is the five-element list  for  the
       other  option  that  the  synonym refers to.  If an error occurs (e.g.,
       because namePtr contains an unknown option name) then NULL is  returned
       and  an error message is left in interp's result unless interp is NULL.

       Tk_FreeConfigOptions must be invoked when  a  widget  is  deleted.   It
       frees  all  of  the  resources associated with any of the configuration
       options defined in recordPtr by optionTable.

       The Tk_Offset macro is provided as a safe way of generating the objOff-
       set  and internalOffset values for entries in Tk_OptionSpec structures.
       It takes two arguments: the name of a type of record, and the name of a
       field  in that record. It returns the byte offset of the named field in
       records of the given type.


TEMPLATES
       The array of Tk_OptionSpec structures  passed  to  Tk_CreateOptionTable
       via  its  templatePtr argument describes the configuration options sup-
       ported by a particular class of widgets.  Each structure specifies  one
       configuration option and has the following fields:
              typedef struct {
                Tk_OptionType type;
                char *optionName;
                char *dbName;
                char *dbClass;
                char *defValue;
                int objOffset;
                int internalOffset;
                int flags;
                ClientData clientData;
                int typeMask;
              } Tk_OptionSpec;
       The  type  field  indicates  what  kind of configuration option this is
       (e.g. TK_OPTION_COLOR for a color value, or TK_OPTION_INT for an  inte-
       ger  value).   Type  determines  how  the value of the option is parsed
       (more on this below).  The optionName field is a string such  as  -font
       or  -bg;  it is the name used for the option in Tcl commands and passed
       to procedures via the  objc  or  namePtr  arguments.   The  dbName  and
       dbClass  fields  are  used by Tk_InitOptions to look up a default value
       for this option in the option database; if  dbName  is  NULL  then  the
       option  database  is  not  used by Tk_InitOptions for this option.  The
       defValue field specifies a default value for this configuration  option
       if  no  value  is  specified in the option database.  The objOffset and
       internalOffset fields indicate where to store the value of this  option
       in  widget  records  (more on this below); values for the objOffset and
       internalOffset fields should always be  generated  with  the  Tk_Offset
       macro.   The flags field contains additional information to control the
       processing of  this  configuration  option  (see  below  for  details).
       ClientData  provides  additional  type-specific  data needed by certain
       types.  For instance, for TK_OPTION_COLOR types, clientData is a string
       giving  the  default  value  to  use  on  monochrome displays.  See the
       descriptions of the different types below for details.  The last field,
       typeMask,  is  used  by Tk_SetOptions to return information about which
       options were modified; see the description of Tk_SetOptions  above  for
       details.

       When Tk_InitOptions and Tk_SetOptions store the value of an option into
       the widget record, they can do it  in  either  of  two  ways.   If  the
       objOffset  field of the Tk_OptionSpec is greater than or equal to zero,
       then the value of the option is stored as a (Tcl_Obj *) at the location
       in  the  widget record given by objOffset.  If the internalOffset field
       of the Tk_OptionSpec is greater than or equal to zero, then  the  value
       of  the  option is stored in a type-specific internal form at the loca-
       tion in the widget record given by internalOffset.  For example, if the
       option's  type  is  TK_OPTION_INT then the internal form is an integer.
       If the objOffset or internalOffset field is negative then the value  is
       not  stored  in that form.  At least one of the offsets must be greater
       than or equal to zero.

       The flags field consists of one or more bits ORed together.  At present
       only a single flag is supported: TK_OPTION_NULL_OK.  If this bit is set
       for an option then an empty string will be accepted as  the  value  for
       the  option  and  the resulting internal form will be a NULL pointer or
       None, depending on the type of the option.  If the flag is not set then
       empty  strings  will  result in errors.  TK_OPTION_NULL_OK is typically
       used to allow a feature to be turned off entirely, e.g.  set  a  cursor
       value  to  None  so  that a window simply inherits its parent's cursor.
       Not all option types support the TK_OPTION_NULL_OK flag; for those that
       do,  there  is  an explicit indication of that fact in the descriptions
       below.

       The type field of each Tk_OptionSpec structure determines how to  parse
       the  value  of that configuration option. The legal value for type, and
       the corresponding actions, are described below.  If the type requires a
       tkwin  value  to be passed into procedures like Tk_SetOptions, or if it
       uses the clientData field of the Tk_OptionSpec, then  it  is  indicated
       explicitly;  if  not  mentioned,  the  type  requires neither tkwin nor
       clientData.

       TK_OPTION_ANCHOR
              The value must be a standard anchor position such as ne or  cen-
              ter.   The  internal  form  is  a  Tk_Anchor value like the ones
              returned by Tk_GetAnchorFromObj.

       TK_OPTION_BITMAP
              The value must be a standard Tk bitmap name. The  internal  form
              is  a  Pixmap token like the ones returned by Tk_AllocBitmapFro-
              mObj.  This option type requires tkwin to be supplied to  proce-
              dures    such    as   Tk_SetOptions,   and   it   supports   the
              TK_OPTION_NULL_OK flag.

       TK_OPTION_BOOLEAN
              The value must be a standard boolean value such as true  or  no.
              The internal form is an integer with value 0 or 1.

       TK_OPTION_BORDER
              The  value must be a standard color name such as red or #ff8080.
              The internal form is a Tk_3DBorder token like the ones  returned
              by  Tk_Alloc3DBorderFromObj.  This option type requires tkwin to
              be supplied to procedures such as Tk_SetOptions, and it supports
              the TK_OPTION_NULL_OK flag.

       TK_OPTION_COLOR
              The  value must be a standard color name such as red or #ff8080.
              The internal form is an (XColor *) token like the ones  returned
              by  Tk_AllocColorFromObj.  This option type requires tkwin to be
              supplied to procedures such as Tk_SetOptions,  and  it  supports
              the TK_OPTION_NULL_OK flag.

       TK_OPTION_CURSOR
              The  value must be a standard cursor name such as cross or @foo.
              The internal form is a Tk_Cursor token like the ones returned by
              Tk_AllocCursorFromObj.   This  option  type requires tkwin to be
              supplied to procedures  such  as  Tk_SetOptions,  and  when  the
              option  is  set  the cursor for the window is changed by calling
              XDefineCursor.    This   option   type   also    supports    the
              TK_OPTION_NULL_OK flag.

       TK_OPTION_DOUBLE
              The  string  value must be a floating-point number in the format
              accepted by strtol.  The internal form is a C double value.

       TK_OPTION_END
              Marks the end of the template.  There must  be  a  Tk_OptionSpec
              structure  with  type TK_OPTION_END at the end of each template.
              If the clientData field of this structure isn't  NULL,  then  it
              points  to  an  additional  array  of  Tk_OptionSpec's, which is
              itself terminated by another TK_OPTION_END entry.  Templates may
              be  chained  arbitrarily  deeply.   This  feature  allows common
              options to be shared by several widget classes.

       TK_OPTION_FONT
              The value must be a standard font name such as  Times  16.   The
              internal  form  is  a  Tk_Font  handle like the ones returned by
              Tk_AllocFontFromObj.  This option type requires tkwin to be sup-
              plied  to  procedures such as Tk_SetOptions, and it supports the
              TK_OPTION_NULL_OK flag.

       TK_OPTION_INT
              The string value must be an integer in the  format  accepted  by
              strtol  (e.g.  0 and 0x prefixes may be used to specify octal or
              hexadecimal numbers, respectively).  The internal form  is  a  C
              int value.

       TK_OPTION_JUSTIFY
              The  value  must be a standard justification value such as left.
              The internal form is a Tk_Justify like the  values  returned  by
              Tk_GetJustifyFromObj.

       TK_OPTION_PIXELS
              The value must specify a screen distance such as 2i or 6.4.  The
              internal form is an integer value giving a distance  in  pixels,
              like  the  values returned by Tk_GetPixelsFromObj.  Note: if the
              objOffset field isn't used then information about  the  original
              value  of  this  option  will be lost.  See OBJOFFSET VS. INTER-
              NALOFFSET below for details.

       TK_OPTION_RELIEF
              The value must be standard relief such as raised.  The  internal
              form is an integer relief value such as TK_RELIEF_RAISED.

       TK_OPTION_STRING
              The  value  may  be any string.  The internal form is a (char *)
              pointer that points to  a  dynamically  allocated  copy  of  the
              value.  This option type supports the TK_OPTION_NULL_OK flag.

       TK_OPTION_STRING_TABLE
              For  this  type,  clientData is a pointer to an array of strings
              suitable for passing to Tcl_GetIndexFromObj.  The value must  be
              one of the strings in the table, or a unique abbreviation of one
              of the strings.  The internal form  is  an  integer  giving  the
              index  into  the  table  of the matching string, like the return
              value from Tcl_GetStringFromObj.

       TK_OPTION_SYNONYM
              This type is used to provide alternative  names  for  an  option
              (for  example,  -bg is often used as a synonym for -background).
              The clientData field is a (char *) pointer that gives  the  name
              of  another  option  in  the  same  table.  Whenever the synonym
              option is used, the information from the other  option  will  be
              used instead.

       TK_OPTION_WINDOW
              The  value  must  be a window path name.  The internal form is a
              Tk_Window token for the window.  This option type requires tkwin
              to  be supplied to procedures such as Tk_SetOptions (in order to
              identify the application), and it supports the TK_OPTION_NULL_OK
              flag.


STORAGE MANAGEMENT ISSUES
       If a field of a widget record has its offset stored in the objOffset or
       internalOffset field of a Tk_OptionSpec structure then  the  procedures
       described  here  will handle all of the storage allocation and resource
       management issues associated with the field.   When  the  value  of  an
       option is changed, Tk_SetOptions (or Tk_FreeSavedOptions will automati-
       cally free any  resources  associated  with  the  old  value,  such  as
       Tk_Fonts for TK_OPTION_FONT options or dynamically allocated memory for
       TK_OPTION_STRING options.  For an option stored as an object using  the
       objOffset field of a Tk_OptionSpec, the widget record shares the object
       pointed to by the objv value from the call to Tk_SetOptions.  The  ref-
       erence  count  for  this  object is incremented when a pointer to it is
       stored in the widget record and decremented when the  option  is  modi-
       fied.   When  the  widget  is  deleted  Tk_FreeConfigOptions  should be
       invoked; it will free the resources associated  with  all  options  and
       decrement reference counts for any objects.

       However, the widget code is responsible for storing NULL or None in all
       pointer and token  fields  before  invoking  Tk_InitOptions.   This  is
       needed  to  allow proper cleanup in the rare case where an error occurs
       in Tk_InitOptions.


OBJOFFSET VS. INTERNALOFFSET
       In most cases it is simplest to  use  the  internalOffset  field  of  a
       Tk_OptionSpec  structure  and  not the objOffset field.  This makes the
       internal form of the value immediately available to the widget code  so
       the  value  doesn't have to be extracted from an object each time it is
       used.  However, there are two cases where the objOffset field  is  use-
       ful.   The  first  case is for TK_OPTION_PIXELS options.  In this case,
       the internal form is an integer pixel value that is valid  only  for  a
       particular screen.  If the value of the option is retrieved, it will be
       returned as a simple number.  For example, after the command .b config-
       ure -borderwidth 2m, the command .b configure -borderwidth might return
       7, which is the integer pixel  value  corresponding  to  2m.   Unfortu-
       nately,  this  loses  the  original screen-independent value.  Thus for
       TK_OPTION_PIXELS options it is better to use the objOffset  field.   In
       this  case  the  original value of the option is retained in the object
       and can be returned when the option is retrieved.  In most cases it  is
       convenient  to  use the internalOffset field field as well, so that the
       integer value is immediately available  for  use  in  the  widget  code
       (alternatively,  Tk_GetPixelsFromObj can be used to extract the integer
       value from the object whenever it is needed).   Note:  the  problem  of
       losing  information  on  retrievals  exists  only  for TK_OPTION_PIXELS
       options.

       The second reason to use the objOffset field is in order  to  implement
       new types of options not supported by these procedures.  To implement a
       new type of option, use TK_OPTION_STRING as the type in the  Tk_Option-
       Spec  structure  and set the objOffset field but not the internalOffset
       field.  Then, after calling Tk_SetOptions, convert the object to inter-
       nal form yourself.


KEYWORDS
       anchor,  bitmap,  boolean, border, color, configuration option, cursor,
       double, font, integer, justify, pixels, relief, screen  distance,  syn-
       onym



Tk                                    8.1                     Tk_SetOptions(3)