Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
XmeResolvePartOffsets(3)    Library Functions Manual	XmeResolvePartOffsets(3)

NAME
     XmeResolvePartOffsets  -- A function that allows writing of upward-compati-
     ble applications and widgets

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

DESCRIPTION
     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  XmeResolvePartOffsets  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  Xm-
     PartOffset  macro.  The XmPartResource data structure looks just like a re-
     source 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  addi-
     tional  constraint  resources,  create an offset resource list for the con-
     straint 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 XtVer-
     sionDontCheck 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 XmeResolvePartOffsets, passing it
     pointers to the class record, the address of the offset record, and the ad-
     dress  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 initial-
	   ized) size field to the part size field

	*  If the widget is a subclass of the Constraint class, adds the  super-
	   class 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 ar-
	   ray 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 re-
	   source 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  inte-
     ger 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 XmeResolvePartOffsets 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).

							XmeResolvePartOffsets(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=XmeResolvePartOffsets&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help