Unix/Linux Go Back    


CentOS 7.0 - man page for tk_freeoptions (centos section 3)

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


Tk_ConfigureWidget(3)		      Tk Library Procedures		    Tk_ConfigureWidget(3)

_________________________________________________________________________________________________

NAME
       Tk_ConfigureWidget, Tk_ConfigureInfo, Tk_ConfigureValue, Tk_FreeOptions - process configu-
       ration options for widgets

SYNOPSIS
       #include <tk.h>

       int
       Tk_ConfigureWidget(interp, tkwin, specs, argc, argv, widgRec, flags)

       int
       Tk_ConfigureInfo(interp, tkwin, specs, widgRec, argvName, flags)

       int
       Tk_ConfigureValue(interp, tkwin, specs, widgRec, argvName, flags)

       Tk_FreeOptions(specs, widgRec, display, flags)

ARGUMENTS
       Tcl_Interp *interp (in)		    Interpreter to use for returning error messages.

       Tk_Window tkwin (in)		    Window used to represent widget (needed to set  up	X
					    resources).

       Tk_ConfigSpec *specs (in)	    Pointer   to  table  specifying  legal  configuration
					    options for this widget.

       int argc (in)			    Number of arguments in argv.

       const char **argv (in)		    Command-line options for configuring widget.

       char *widgRec (in/out)		    Points to widget record structure.	 Fields  in  this
					    structure  get modified by Tk_ConfigureWidget to hold
					    configuration information.

       int flags (in)			    If non-zero, then it specifies an  OR-ed  combination
					    of flags that control the processing of configuration
					    information.  TK_CONFIG_ARGV_ONLY causes  the  option
					    database  and  defaults  to be ignored, and flag bits
					    TK_CONFIG_USER_BIT and higher are used to selectively
					    disable entries in specs.

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

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

       const char *argvName (in)	    The name used on Tcl command lines to refer to a par-
					    ticular option (e.g. when creating a widget or invok-
					    ing the configure widget command).	If non-NULL, then
					    information is returned only  for  this  option.   If
					    NULL,  then information is returned for all available
					    options.

       Display *display (in)		    Display  containing  widget  whose	record	is  being
					    freed;  needed in order to free up resources.
_________________________________________________________________

DESCRIPTION
       Note:  Tk_ConfigureWidget should be replaced with the new Tcl_Obj based API Tk_SetOptions.
       The old interface is retained for backward compatibility.

       Tk_ConfigureWidget is called to configure various aspects of a  widget,	such  as  colors,
       fonts,  border width, etc.  It is intended as a convenience procedure to reduce the amount
       of code that must be written in individual widget managers to handle configuration  infor-
       mation.	 It  is  typically invoked when widgets are created, and again when the configure
       command is invoked for a widget.  Although  intended  primarily	for  widgets,  Tk_Config-
       ureWidget  can  be  used  in other situations where argc-argv information is to be used to
       fill in a record structure, such as configuring graphical elements for a canvas widget  or
       entries of a menu.

       Tk_ConfigureWidget  processes  a  table specifying the configuration options that are sup-
       ported (specs) and a collection of command-line arguments  (argc  and  argv)  to  fill  in
       fields of a record (widgRec).  It uses the option database and defaults specified in specs
       to fill in fields of widgRec that are not specified in argv.  Tk_ConfigureWidget  normally
       returns the value TCL_OK; in this case it does not modify interp.  If an error occurs then
       TCL_ERROR is returned and Tk_ConfigureWidget will leave an error message in interp->result
       in  the standard Tcl fashion.  In the event of an error return, some of the fields of wid-
       gRec could already have been set, if configuration information for them	was  successfully
       processed  before  the error occurred.  The other fields will be set to reasonable initial
       values so that Tk_FreeOptions can be called for cleanup.

       The specs array specifies the kinds of configuration options expected by the widget.  Each
       of its entries specifies one configuration option and has the following structure:
	      typedef struct {
		  int type;
		  char *argvName;
		  char *dbName;
		  char *dbClass;
		  char *defValue;
		  int offset;
		  int specFlags;
		  Tk_CustomOption *customPtr;
	      } Tk_ConfigSpec;
       The  type  field indicates what type of configuration option this is (e.g. TK_CONFIG_COLOR
       for a color value, or TK_CONFIG_INT for an integer value).  The type field  indicates  how
       to  use the value of the option (more on this below).  The argvName field is a string such
       as "-font" or "-bg", which is compared with the values in argv (if  argvName  is  NULL  it
       means this is a grouped entry;  see GROUPED ENTRIES below).  The dbName and dbClass fields
       are used to look up a value for this option in the option database.   The  defValue  field
       specifies a default value for this configuration option if no value is specified in either
       argv or the option database.  Offset indicates where in widgRec to store information about
       this  option,  and  specFlags contains additional information to control the processing of
       this configuration option (see FLAGS below).  The last field, customPtr, is only  used  if
       type is TK_CONFIG_CUSTOM;  see CUSTOM OPTION TYPES below.

       Tk_ConfigureWidget  first  processes  argv to see which (if any) configuration options are
       specified there.  Argv must contain an even number of fields;  the first of each  pair  of
       fields  must  match  the argvName of some entry in specs (unique abbreviations are accept-
       able), and the second field of the pair contains the value for that configuration  option.
       If  there are entries in spec for which there were no matching entries in argv, Tk_Config-
       ureWidget uses the dbName and dbClass fields of the specs entry to probe the option  data-
       base;   if  a value is found, then it is used as the value for the option.  Finally, if no
       entry is found in the option database, the defValue field of the specs entry  is  used  as
       the  value  for	the  configuration  option.   If  the defValue is NULL, or if the TK_CON-
       FIG_DONT_SET_DEFAULT bit is set in flags, then there is no default value  and  this  specs
       entry will be ignored if no value is specified in argv or the option database.

       Once  a	string	value  has been determined for a configuration option, Tk_ConfigureWidget
       translates the string value into a more useful form, such as a color if	type  is  TK_CON-
       FIG_COLOR or an integer if type is TK_CONFIG_INT.  This value is then stored in the record
       pointed to by widgRec.  This record is assumed to contain information relevant to the man-
       ager of the widget;  its exact type is unknown to Tk_ConfigureWidget.  The offset field of
       each specs entry indicates where in widgRec to store the information about this configura-
       tion  option.  You should use the Tk_Offset macro to generate offset values (see below for
       a description of Tk_Offset).  The  location  indicated  by  widgRec  and  offset  will  be
       referred to as the "target" in the descriptions below.

       The  type field of each entry in specs determines what to do with the string value of that
       configuration option.  The legal values for type, and the corresponding actions, are:

       TK_CONFIG_ACTIVE_CURSOR
	      The value must be an ASCII string identifying a cursor in a form suitable for pass-
	      ing to Tk_GetCursor.  The value is converted to a Tk_Cursor by calling Tk_GetCursor
	      and the result is stored in the target.  In addition, the resulting cursor is  made
	      the  active  cursor  for	tkwin  by calling XDefineCursor.  If TK_CONFIG_NULL_OK is
	      specified in specFlags then the value may be an empty string,  in  which	case  the
	      target and tkwin's active cursor will be set to None.  If the previous value of the
	      target was not None, then it is freed by passing it to Tk_FreeCursor.

       TK_CONFIG_ANCHOR
	      The value must be an ASCII string identifying an anchor point in one  of	the  ways
	      accepted	by  Tk_GetAnchor.   The  string  is  converted	to a Tk_Anchor by calling
	      Tk_GetAnchor and the result is stored in the target.

       TK_CONFIG_BITMAP
	      The value must be an ASCII string identifying a bitmap in a form suitable for pass-
	      ing  to  Tk_GetBitmap.   The value is converted to a Pixmap by calling Tk_GetBitmap
	      and the result is stored in the  target.	 If  TK_CONFIG_NULL_OK	is  specified  in
	      specFlags then the value may be an empty string, in which case the target is set to
	      None.  If the previous value of the target was not None, then it is freed by  pass-
	      ing it to Tk_FreeBitmap.

       TK_CONFIG_BOOLEAN
	      The  value  must	be an ASCII string specifying a boolean value.	Any of the values
	      "true", "yes", "on", or "1", or an abbreviation of one of these values, means true;
	      any  of the values "false", "no", "off", or "0", or an abbreviation of one of these
	      values, means false.  The target is expected to be an integer;  for true values  it
	      will be set to 1 and for false values it will be set to 0.

       TK_CONFIG_BORDER
	      The value must be an ASCII string identifying a border color in a form suitable for
	      passing to Tk_Get3DBorder.  The value is converted to a (Tk_3DBorder *) by  calling
	      Tk_Get3DBorder  and  the	result	is stored in the target.  If TK_CONFIG_NULL_OK is
	      specified in specFlags then the value may be an empty string,  in  which	case  the
	      target will be set to NULL.  If the previous value of the target was not NULL, then
	      it is freed by passing it to Tk_Free3DBorder.

       TK_CONFIG_CAP_STYLE
	      The value must be an ASCII string identifying a  cap  style  in  one  of	the  ways
	      accepted	by  Tk_GetCapStyle.   The  string is converted to an integer value corre-
	      sponding to the cap style by calling Tk_GetCapStyle and the result is stored in the
	      target.

       TK_CONFIG_COLOR
	      The  value must be an ASCII string identifying a color in a form suitable for pass-
	      ing to Tk_GetColor.  The value is converted to an (XColor *) by calling Tk_GetColor
	      and  the	result	is  stored  in	the target.  If TK_CONFIG_NULL_OK is specified in
	      specFlags then the value may be an empty string, in which case the target  will  be
	      set to None.  If the previous value of the target was not NULL, then it is freed by
	      passing it to Tk_FreeColor.

       TK_CONFIG_CURSOR
	      This option is identical to TK_CONFIG_ACTIVE_CURSOR except that the new  cursor  is
	      not made the active one for tkwin.

       TK_CONFIG_CUSTOM
	      This option allows applications to define new option types.  The customPtr field of
	      the entry points to a structure defining the new option type.  See the section CUS-
	      TOM OPTION TYPES below for details.

       TK_CONFIG_DOUBLE
	      The  value must be an ASCII floating-point number in the format accepted by strtol.
	      The string is converted to a double value, and the value is stored in the target.

       TK_CONFIG_END
	      Marks the end of the table.  The last entry in specs must have this type;   all  of
	      its other fields are ignored and it will never match any arguments.

       TK_CONFIG_FONT
	      The value must be an ASCII string identifying a font in a form suitable for passing
	      to Tk_GetFont.  The value is converted to a Tk_Font by calling Tk_GetFont  and  the
	      result  is  stored  in  the target.  If TK_CONFIG_NULL_OK is specified in specFlags
	      then the value may be an empty string, in which case the	target	will  be  set  to
	      NULL.   If the previous value of the target was not NULL, then it is freed by pass-
	      ing it to Tk_FreeFont.

       TK_CONFIG_INT
	      The value must be an ASCII integer string in the format accepted	by  strtol  (e.g.
	      "0"  and "0x" prefixes may be used to specify octal or hexadecimal numbers, respec-
	      tively).	The string is converted to an integer value and the integer is stored  in
	      the target.

       TK_CONFIG_JOIN_STYLE
	      The  value  must	be  an	ASCII  string identifying a join style in one of the ways
	      accepted by Tk_GetJoinStyle.  The string is converted to an  integer  value  corre-
	      sponding	to  the join style by calling Tk_GetJoinStyle and the result is stored in
	      the target.

       TK_CONFIG_JUSTIFY
	      The value must be an ASCII string identifying a justification method in one of  the
	      ways accepted by Tk_GetJustify.  The string is converted to a Tk_Justify by calling
	      Tk_GetJustify and the result is stored in the target.

       TK_CONFIG_MM
	      The value must specify a	screen	distance  in  one  of  the  forms  acceptable  to
	      Tk_GetScreenMM.	The  string  is converted to double-precision floating-point dis-
	      tance in millimeters and the value is stored in the target.

       TK_CONFIG_PIXELS
	      The value must specify screen units in one of the forms acceptable to Tk_GetPixels.
	      The string is converted to an integer distance in pixels and the value is stored in
	      the target.

       TK_CONFIG_RELIEF
	      The value must be an ASCII string identifying a relief in a form suitable for pass-
	      ing  to Tk_GetRelief.  The value is converted to an integer relief value by calling
	      Tk_GetRelief and the result is stored in the target.

       TK_CONFIG_STRING
	      A copy of the value is made by allocating memory space with Tcl_Alloc  and  copying
	      the  value  into	the  dynamically-allocated space.  A pointer to the new string is
	      stored in the target.  If TK_CONFIG_NULL_OK is  specified  in  specFlags	then  the
	      value may be an empty string, in which case the target will be set to NULL.  If the
	      previous value of the target was not NULL, then  it  is  freed  by  passing  it  to
	      Tcl_Free.

       TK_CONFIG_SYNONYM
	      This  type  value  identifies  special entries in specs that are synonyms for other
	      entries.	If an argv value matches the argvName of a TK_CONFIG_SYNONYM  entry,  the
	      entry  is not used directly. Instead, Tk_ConfigureWidget searches specs for another
	      entry whose argvName is the same as  the	dbName	field  in  the	TK_CONFIG_SYNONYM
	      entry;   this new entry is used just as if its argvName had matched the argv value.
	      The synonym mechanism allows multiple argv values to be used for a single  configu-
	      ration option, such as "-background" and "-bg".

       TK_CONFIG_UID
	      The  value  is  translated to a Tk_Uid (by passing it to Tk_GetUid).  The resulting
	      value is stored in the target.  If TK_CONFIG_NULL_OK is specified in specFlags  and
	      the value is an empty string then the target will be set to NULL.

       TK_CONFIG_WINDOW
	      The  value  must	be a window path name.	It is translated to a Tk_Window token and
	      the token is stored in the target.

GROUPED ENTRIES
       In some cases it is useful to generate multiple	resources  from  a  single  configuration
       value.	For example, a color name might be used both to generate the background color for
       a widget (using TK_CONFIG_COLOR) and to generate a 3-D border to draw  around  the  widget
       (using  TK_CONFIG_BORDER).  In cases like this it is possible to specify that several con-
       secutive entries in specs are to be treated as a group.	The first entry is used to deter-
       mine  a	value (using its argvName, dbName, dbClass, and defValue fields).  The value will
       be processed several times (one for each entry in the group), generating multiple  differ-
       ent  resources  and  modifying multiple targets within widgRec.	Each of the entries after
       the first must have a NULL value in its argvName field;	this indicates that the entry  is
       to  be  grouped with the entry that precedes it.  Only the type and offset fields are used
       from these follow-on entries.

FLAGS
       The flags argument passed to Tk_ConfigureWidget is used in conjunction with the	specFlags
       fields  in  the entries of specs to provide additional control over the processing of con-
       figuration options.  These values are used in three different ways as described below.

       First, if the flags argument to Tk_ConfigureWidget has  the  TK_CONFIG_ARGV_ONLY  bit  set
       (i.e., flags | TK_CONFIG_ARGV_ONLY != 0), then the option database and defValue fields are
       not used.  In this case, if an entry in specs does not match a field in argv then  nothing
       happens:  the  corresponding target is not modified.  This feature is useful when the goal
       is to modify certain configuration options while leaving others in  their  current  state,
       such as when a configure widget command is being processed.

       Second,	the specFlags field of an entry in specs may be used to control the processing of
       that entry.  Each specFlags field may consists of an OR-ed combination  of  the	following
       values:

       TK_CONFIG_COLOR_ONLY
	      If  this bit is set then the entry will only be considered if the display for tkwin
	      has more than one bit plane.  If the display is monochromatic then this specs entry
	      will be ignored.

       TK_CONFIG_MONO_ONLY
	      If  this bit is set then the entry will only be considered if the display for tkwin
	      has exactly one bit plane.  If the display is not  monochromatic	then  this  specs
	      entry will be ignored.

       TK_CONFIG_NULL_OK
	      This  bit  is  only relevant for some types of entries (see the descriptions of the
	      various entry types above).  If this bit is set, it indicates that an empty  string
	      value for the field is acceptable and if it occurs then the target should be set to
	      NULL or None, depending on the type of the target.  This flag 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.  If this bit is not  set  then  empty
	      strings are processed as strings, which generally results in an error.

       TK_CONFIG_DONT_SET_DEFAULT
	      If  this	bit  is one, it means that the defValue field of the entry should only be
	      used for returning the default value in Tk_ConfigureInfo.  In calls  to  Tk_Config-
	      ureWidget  no  default  will  be	supplied  for  entries with this flag set;  it is
	      assumed that the caller has already supplied a default value in  the  target  loca-
	      tion.   This  flag  provides  a  performance  optimization where it is expensive to
	      process the default string:  the client can compute  the	default  once,	save  the
	      value, and provide it before calling Tk_ConfigureWidget.

       TK_CONFIG_OPTION_SPECIFIED
	      This bit is deprecated. It used to be set and cleared by Tk_ConfigureWidget so that |
	      callers could detect what entries were  specified  in  argv,  but  it  was  removed |
	      because  it  was	inherently thread-unsafe. Code that wishes to detect what options |
	      were specified should use Tk_SetOptions instead.

       The TK_CONFIG_MONO_ONLY and TK_CONFIG_COLOR_ONLY flags are typically used to specify  dif-
       ferent  default	values	for  monochrome and color displays.  This is done by creating two
       entries in specs that are identical except for their defValue and specFlags  fields.   One
       entry should have the value TK_CONFIG_MONO_ONLY in its specFlags and the default value for
       monochrome displays in its defValue;  the  other  entry	should	have  the  value  TK_CON-
       FIG_COLOR_ONLY in its specFlags and the appropriate defValue for color displays.

       Third,  it  is  possible  to  use flags and specFlags together to selectively disable some
       entries.  This feature is not needed very often.  It is useful in cases where several sim-
       ilar  kinds of widgets are implemented in one place.  It allows a single specs table to be
       created with all the configuration options for all the widget types.   When  processing	a
       particular  widget  type, only entries relevant to that type will be used.  This effect is
       achieved by setting the high-order bits (those in  positions  equal  to	or  greater  than
       TK_CONFIG_USER_BIT)  in	specFlags values or in flags.  In order for a particular entry in
       specs to be used, its high-order bits must match exactly the high-order bits of the  flags
       value passed to Tk_ConfigureWidget.  If a specs table is being used for N different widget
       types, then N of the high-order bits will be used.  Each specs entry will have one of more
       of those bits set in its specFlags field to indicate the widget types for which this entry
       is valid.  When calling Tk_ConfigureWidget, flags will have a single one of these bits set
       to select the entries for the desired widget type.  For a working example of this feature,
       see the code in tkButton.c.

TK_OFFSET
       The Tk_Offset macro is provided as a safe way of generating the offset values for  entries
       in  Tk_ConfigSpec  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.

TK_CONFIGUREINFO
       The  Tk_ConfigureInfo  procedure may be used to obtain information about one or all of the
       options for a given widget.  Given a token for a window (tkwin), a  table  describing  the
       configuration  options  for  a class of widgets (specs), a pointer to a widget record con-
       taining the current information for a widget (widgRec),	and  a	NULL  argvName	argument,
       Tk_ConfigureInfo  generates  a  string describing all of the configuration options for the
       window.	The string is placed in interp->result.  Under normal  circumstances  it  returns
       TCL_OK;	if an error occurs then it returns TCL_ERROR and interp->result contains an error
       message.

       If argvName is NULL, then the value left in interp->result by Tk_ConfigureInfo consists of
       a  list of one or more entries, each of which describes one configuration option (i.e. one
       entry in specs).  Each entry in the list will contain either two or five values.   If  the
       corresponding  entry  in  specs has type TK_CONFIG_SYNONYM, then the list will contain two
       values:	the argvName for the entry and the dbName (synonym  name).   Otherwise	the  list
       will  contain  five  values:  argvName, dbName, dbClass, defValue, and current value.  The
       current value is computed from the appropriate field of widgRec by calling procedures like
       Tk_NameOfColor.

       If  the	argvName  argument  to	Tk_ConfigureInfo  is non-NULL, then it indicates a single
       option, and  information  is  returned  only  for  that	option.   The  string  placed  in
       interp->result will be a list containing two or five values as described above;	this will
       be identical to the corresponding sublist that would have been returned	if  argvName  had
       been NULL.

       The  flags argument to Tk_ConfigureInfo is used to restrict the specs entries to consider,
       just as for Tk_ConfigureWidget.

TK_CONFIGUREVALUE
       Tk_ConfigureValue takes arguments similar to Tk_ConfigureInfo; instead of returning a list
       of  values,  it	just  returns the current value of the option given by argvName (argvName
       must not be NULL).  The value  is  returned  in	interp->result	and  TCL_OK  is  normally
       returned  as the procedure's result.  If an error occurs in Tk_ConfigureValue (e.g., argv-
       Name is not a valid option name), TCL_ERROR is returned and an error message  is  left  in
       interp->result.	This procedure is typically called to implement cget widget commands.

TK_FREEOPTIONS
       The  Tk_FreeOptions  procedure  may be invoked during widget cleanup to release all of the
       resources associated with configuration options.  It scans  through  specs  and	for  each
       entry  corresponding  to  a  resource  that must be explicitly freed (e.g. those with type
       TK_CONFIG_COLOR), it frees the resource in the widget record.  If the field in the  widget
       record does not refer to a resource (e.g.  it contains a null pointer) then no resource is
       freed for that entry.  After freeing a resource,  Tk_FreeOptions  sets  the  corresponding
       field of the widget record to null.

CUSTOM OPTION TYPES
       Applications  can  extend  the  built-in configuration types with additional configuration
       types by writing procedures to parse and print options of the a type and creating a struc-
       ture pointing to those procedures:
	      typedef struct Tk_CustomOption {
		  Tk_OptionParseProc *parseProc;
		  Tk_OptionPrintProc *printProc;
		  ClientData clientData;
	      } Tk_CustomOption;

	      typedef int Tk_OptionParseProc(
		  ClientData clientData,
		  Tcl_Interp *interp,
		  Tk_Window tkwin,
		  char *value,
		  char *widgRec,
		  int offset);

	      typedef char *Tk_OptionPrintProc(
		  ClientData clientData,
		  Tk_Window tkwin,
		  char *widgRec,
		  int offset,
		  Tcl_FreeProc **freeProcPtr);
       The  Tk_CustomOption structure contains three fields, which are pointers to the two proce-
       dures and a clientData value to be passed to those procedures when they are invoked.   The
       clientData  value typically points to a structure containing information that is needed by
       the procedures when they are parsing and printing options.

       The parseProc procedure is invoked by Tk_ConfigureWidget to parse a string and  store  the
       resulting value in the widget record.  The clientData argument is a copy of the clientData
       field in the Tk_CustomOption structure.	The interp argument points to a  Tcl  interpreter
       used  for  error  reporting.  Tkwin is a copy of the tkwin argument to Tk_ConfigureWidget.
       The value argument is a string describing the value for the option;  it	could  have  been
       specified  explicitly  in  the call to Tk_ConfigureWidget or it could come from the option
       database or a default.  Value will never be a null pointer but it may point  to	an  empty
       string.	 RecordPtr  is the same as the widgRec argument to Tk_ConfigureWidget;	it points
       to the start of the widget record to modify.  The last argument, offset, gives the  offset
       in  bytes from the start of the widget record to the location where the option value is to
       be placed.  The procedure should translate the string to whatever form is appropriate  for
       the  option  and  store the value in the widget record.	It should normally return TCL_OK,
       but if an error occurs in translating  the  string  to  a  value  then  it  should  return
       TCL_ERROR and store an error message in interp->result.

       The printProc procedure is called by Tk_ConfigureInfo to produce a string value describing
       an existing option.  Its clientData, tkwin, widgRec, and offset	arguments  all	have  the
       same meaning as for Tk_OptionParseProc procedures.  The printProc procedure should examine
       the option whose value is stored at offset in widgRec, produce a  string  describing  that
       option,	and return a pointer to the string.  If the string is stored in dynamically-allo-
       cated memory, then the procedure must set *freeProcPtr to the address of  a  procedure  to
       call  to  free  the string's memory;  Tk_ConfigureInfo will call this procedure when it is
       finished with the string.  If the result string is stored in static memory then	printProc
       need not do anything with the freeProcPtr argument.

       Once  parseProc	and  printProc have been defined and a Tk_CustomOption structure has been
       created for them, options of this new type may be manipulated with  Tk_ConfigSpec  entries
       whose  type  fields are TK_CONFIG_CUSTOM and whose customPtr fields point to the Tk_Custo-
       mOption structure.

EXAMPLES
       Although the explanation of Tk_ConfigureWidget is fairly complicated, its  actual  use  is
       pretty straightforward.	The easiest way to get started is to copy the code from an exist-
       ing widget.  The library implementation of frames (tkFrame.c) has a  simple  configuration
       table,  and the library implementation of buttons (tkButton.c) has a much more complex ta-
       ble that uses many of the fancy specFlags mechanisms.

SEE ALSO
       Tk_SetOptions(3)

KEYWORDS
       anchor, bitmap, boolean, border, cap style, color, configuration options, cursor,  custom,
       double, font, integer, join style, justify, millimeters, pixels, relief, synonym, uid

Tk					       4.1			    Tk_ConfigureWidget(3)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums


All times are GMT -4. The time now is 11:32 AM.