NAME

       XmResolveAllPartOffsets — A function that allows writing of upward-compatible applications
       and widgets "XmResolveAllPartOffsets"

SYNOPSIS

       #include <Xm/Xm.h>
       void XmResolveAllPartOffsets(
       WidgetClass widget_class,
       XmOffsetPtr * offset,
       XmOffsetPtr * constraint_offset);

DESCRIPTION

              Note:

              This routine is obsolete and exists for compatibility with previous  releases.  You
              should call XmeResolvePartOffsets instead.

       The  use  of  offset  records  requires  two extra global variables per widget class.  The
       variables consist of pointers to arrays of offsets into the widget record  and  constraint
       record  for  each  part  of  the  widget  structure.  The XmResolveAllPartOffsets function
       allocates the offset records needed  by  an  application  to  guarantee  upward-compatible
       access  to  widget  instance  and  constraint  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 steps described in the following paragraphs.

       Instead  of  creating  a  resource  list,  the widget creates an offset resource list.  To
       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 structure 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.

       If the widget is a subclass of the Constraint class and it defines  additional  constraint
       resources,  create  an  offset  resource list for the constraint part as well.  Instead of
       using XtOffset for the offset, the widget uses XmConstraintPartOffset  in  the  constraint
       resource list.

       XmPartResource resources[] = {
               {       BarNxyz, BarCXyz, XmRBoolean, sizeof(Boolean),
                       XmPartOffset(Bar,xyz), XmRImmediate, (XtPointer)False } };
       XmPartResource constraints[] = {
               {       BarNmaxWidth, BarNMaxWidth,
                 XmRDimension, sizeof(Dimension),
                 XmConstraintPartOffset(Bar,max_width),
                 XmRImmediate, (XtPointer)100 } };

       Instead  of  putting  the widget size in the class record, the widget puts the widget part
       size in the same field.  If the widget is a subclass of the Constraint class,  instead  of
       putting  the widget constraint record size in the class record, the widget puts the widget
       constraint part size in the same field.

       Instead of putting XtVersion in the class record, the widget  puts  XtVersionDontCheck  in
       the class record.

       Define a variable, of type XmOffsetPtr, to point to the offset record.  If the widget is a
       subclass of the Constraint class, define a variable of type XmOffsetPtr to  point  to  the
       constraint  offset  record.   These  can  be part of the widget's class record or separate
       global variables.

       In class initialization, the widget calls XmResolveAllPartOffsets, passing it pointers  to
       the  class  record,  the  address  of the offset record, and the address of the constraint
       offset record.  If the widget not is a subclass of the Constraint class,  it  should  pass
       NULL as the address of the constraint offset record.  This does several things:

          ·  Adds  the superclass (which, by definition, has already been initialized) size field
             to the part size field

          ·  If the widget is a subclass of the Constraint class, adds the superclass  constraint
             size field to the constraint size field

          ·  Allocates an array based upon the number of superclasses

          ·  If  the  widget  is  a  subclass of the constraint class, allocates an array for the
             constraint offset record

          ·  Fills in the offsets  of  all  the  widget  parts  and  constraint  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, in place

       The  widget defines a constant that 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 and XmConstraintField macros  help  you  access  these  fields.   Because  the
       XmPartOffset,  XmConstraintPartOffset,  XmField,  and XmConstraintField macros concatenate
       things, 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)))

       For constraint field max_width:

       #define BarMaxWidth(w) \
               XmConstraintField(w,constraint_offsets,Bar,max_width,Dimension)

       The parameters for XmResolveAllPartOffsets are

       widget_class
                 Specifies the widget class pointer for the created widget

       offset    Returns the offset record

       constraint_offset
                 Returns the constraint offset record

RELATED INFORMATION

       XmResolvePartOffsets(3).

                                                                       XmResolveAllPartOffsets(3)