Unix/Linux Go Back    

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

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

XmResolveAllPartOffsets(library call)			    XmResolveAllPartOffsets(library call)

       XmResolveAllPartOffsets	--  A  function that allows writing of upward-compatible applica-
       tions and widgets

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


	      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 vari-
       ables consist of pointers to arrays of offsets  into  the  widget  record  and  constraint
       record  for each part of the widget structure.  The XmResolveAllPartOffsets function allo-
       cates 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),
		 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 off-
       set 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:

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

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

	  o  Allocates an array based upon the number of superclasses

	  o  If the widget is a subclass of the constraint class, allocates an array for the con-
	     straint offset record

	  o  Fills in the offsets of all the widget parts and constraint parts with the appropri-
	     ate values, determined by examining the size fields of all superclass records

	  o  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.  Con-
       stants 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

       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) \

       The parameters for XmResolveAllPartOffsets are

		 Specifies the widget class pointer for the created widget

       offset	 Returns the offset record

		 Returns the constraint offset record


							    XmResolveAllPartOffsets(library call)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 06:03 AM.