NAME    [Toc]    [Back]

       XmResolvePartOffsets  -  A function that allows writing of
       upward-compatible applications and widgets

SYNOPSIS    [Toc]    [Back]

       #include <Xm/XmP.h>

       void XmResolvePartOffsets (widget_class, offset)
               WidgetClass widget_class;
               XmOffsetPtr * offset;

DESCRIPTION    [Toc]    [Back]

       The use of offset records requires one extra global  variable
  per widget class. The variable consists of a pointer
       to an array of offsets into the  widget  record  for  each
       part  of  the  widget  structure. The XmResolvePartOffsets
       function allocates the offset records needed by an  application
  to  guarantee  upward-compatible  access to widget
       instance records by applications and widgets.  These  offset
  records  are  used by the widget to access all of the
       widget's variables. A widget needs to take  the  following
       steps:  Instead  of  creating  a resource list, the widget
       creates an offset resource list. To  help  you  accomplish
       this,  use the XmPartResource structure and the XmPartOffset
 macro. The XmPartResource data  structure  looks  just
       like  a  resource  list, but instead of having one integer
       for its offset, it has two shorts. This is  put  into  the
       class  record  as  if  it  were  a  normal  resource list.
       Instead of using XtOffset for the offset, the widget  uses
       XmPartOffset.

              XmPartResource resources[] = {
                { BarNxyz, BarCXyz, XmRBoolean,
                  sizeof(Boolean), XmPartOffset(Bar,xyz),
                  XmRImmediate,  (XtPointer)False } }; Instead of
              putting the widget size in the  class  record,  the
              widget puts the widget part size in the same field.
              Instead of putting XtVersion in the  class  record,
              the  widget  puts  XtVersionDontCheck  in the class
              record.  The widget defines  a  variable,  of  type
              XmOffsetPtr,  to  point  to the offset record. This
              can be part of the widget's class record or a separate
 global variable.  In class initialization, the
              widget calls  XmResolvePartOffsets,  passing  it  a
              pointer to contain the address of the offset record
              and the class record.  This  does  several  things:
              Adds  the  superclass  (which,  by  definition, has
              already been initialized) size field  to  the  part
              size field.  Allocates an array based upon the number
 of superclasses.  Fills in the offsets  of  all
              the  widget  parts  with  the  appropriate  values,
              determined by examining  the  size  fields  of  all
              superclass  records.  Uses the part offset array to
              modify the offset entries in the resource  list  to
              be  real  offsets.   The  widget defines a constant
              which will be the index to its  part  structure  in
              the  offsets  array.  The value should be 1 greater
              than the index of  the  widget's  superclass.  Constants
  defined  for all Xm widgets can be found in
              <XmP.h>.

              #define BarIndex (XmBulletinBIndex + 1) Instead  of
              accessing  fields  directly, the widget must always
              go through the  offset  table.  The  XmField  macro
              helps   you   access   these  fields.  Because  the
              XmPartOffset and XmField macros concatenate  things
              together,  you  must  ensure that there is no space
              after the part argument. For example, the following
              macros  do  not work because of the space after the
              part (Label) argument:

              XmField(w, offset, Label , text, char *) XmPartOffset(Label
 , text)

              Therefore,  you  must not have any spaces after the
              part (Label) argument, as illustrated here:

              XmField(w, offset, Label, text, char *)

              You can define macros for each field to  make  this
              easier. Assume an integer field xyz:

              #define BarXyz(w) (*(int *)(((char *) w) + \
                offset[BarIndex] + XtOffset(BarPart,xyz)))


       The parameters for XmResolvePartOffsets are defined below:
       Specifies the widget class pointer for the created widget.
       Returns the offset record.

SEE ALSO    [Toc]    [Back]

       XmResolveAllPartOffsets(3X)



                                         XmResolvePartOffsets(3X)