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

FreeBSD Manual Pages


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

       XmResolveAllPartOffsets	--  A  function	that allows writing of upward-
       compatible applications 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  pre-
	      vious releases. You should call XmeResolvePartOffsets instead.

       The  use	of offset records requires two extra global variables per wid-
       get 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 wid-
       get'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 re-
       source 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  off-
       set, the	widget uses XmPartOffset.

       If  the widget is a subclass of the Constraint class and	it defines ad-
       ditional	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 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:

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

	  o  If	the widget is a	subclass of the	Constraint class, adds the su-
	     perclass 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 constraint offset record

	  o  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

	  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	struc-
       ture  in	the offsets array.  The	value should be	1 greater than the in-
       dex 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  en-
       sure  that there	is no space after the part argument.  For example, the
       following macros	do not work because of the space after the  part  (La-
       bel) argument:

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

       Therefore,  you	must  not have any spaces after	the part (Label) argu-
       ment, 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) \

       The parameters for XmResolveAllPartOffsets are

		 Specifies the widget class pointer for	the created widget

       offset	 Returns the offset record

		 Returns the constraint	offset record




Want to link to this manual page? Use this URL:

home | help