XFree86 4.3.0.1xf86-4_3_0_1PRE_xf86-4_3_0_1

1 files changed, 335 insertions, 279 deletions

diff --git a/src/Box.c b/src/Box.c
index 8e40b89..0d01988 100644
--- a/src/Box.c
+++ b/src/Box.c
@@ -46,121 +46,161 @@ ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 SOFTWARE.
 
 ******************************************************************/
+/* $XFree86: xc/lib/Xaw/Box.c,v 1.15 2001/12/14 19:54:39 dawes Exp $ */
 
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+#include <X11/Xmu/Misc.h>
+#include <X11/Xaw/BoxP.h>
+#include <X11/Xaw/XawInit.h>
+#include "Private.h"
 
-/* 
- * Box.c - Box composite widget
- * 
+/*
+ * Class Methods
  */
+static void XawBoxChangeManaged(Widget);
+static void XawBoxClassInitialize(void);
+#ifndef OLDXAW
+static void XawBoxExpose(Widget, XEvent*, Region);
+#endif
+static XtGeometryResult XawBoxGeometryManager(Widget, XtWidgetGeometry*,
+					      XtWidgetGeometry*);
+static void XawBoxInitialize(Widget, Widget, ArgList, Cardinal*);
+static XtGeometryResult XawBoxQueryGeometry(Widget, XtWidgetGeometry*,
+					    XtWidgetGeometry*);
+static void XawBoxRealize(Widget, Mask*, XSetWindowAttributes*);
+static void XawBoxResize(Widget);
+static Boolean XawBoxSetValues(Widget, Widget, Widget,
+			       ArgList, Cardinal*);
 
-#include	<X11/IntrinsicP.h>
-#include	<X11/StringDefs.h>
-#include	<X11/Xmu/Misc.h>
-#include	<X11/Xaw/XawInit.h>
-#include	<X11/Xaw/BoxP.h>
+/*
+ * Prototypes
+ */
+static void DoLayout(BoxWidget, unsigned int, unsigned int,
+		     Dimension*, Dimension*, Bool);
+static Bool TryNewLayout(BoxWidget);
 
-/****************************************************************
- *
- * Box Resources
- *
- ****************************************************************/
+/*
+ * Initialization
+ */
+#ifndef OLDXAW
+static XtActionsRec actions[] = {
+  {"set-values", XawSetValuesAction},
+  {"get-values", XawGetValuesAction},
+  {"declare",    XawDeclareAction},
+  {"call-proc",  XawCallProcAction},
+};
+#endif
 
 static XtResource resources[] = {
-    { XtNhSpace, XtCHSpace, XtRDimension, sizeof(Dimension),
-		XtOffsetOf(BoxRec, box.h_space),
-		XtRImmediate, (XtPointer)4 },
-    { XtNvSpace, XtCVSpace, XtRDimension, sizeof(Dimension),
-		XtOffsetOf(BoxRec, box.v_space),
-		XtRImmediate, (XtPointer)4 },
-    { XtNorientation, XtCOrientation, XtROrientation, sizeof(XtOrientation),
-		XtOffsetOf(BoxRec, box.orientation),
-		XtRImmediate, (XtPointer)XtorientVertical },
+  {
+    XtNhSpace,
+    XtCHSpace,
+    XtRDimension,
+    sizeof(Dimension),
+    XtOffsetOf(BoxRec, box.h_space),
+    XtRImmediate,
+    (XtPointer)4
+  },
+  {
+    XtNvSpace,
+    XtCVSpace,
+    XtRDimension,
+    sizeof(Dimension),
+    XtOffsetOf(BoxRec, box.v_space),
+    XtRImmediate,
+    (XtPointer)4
+  },
+  {
+    XtNorientation,
+    XtCOrientation,
+    XtROrientation,
+    sizeof(XtOrientation),
+    XtOffsetOf(BoxRec, box.orientation),
+    XtRImmediate,
+    (XtPointer)XtorientVertical
+  },
+#ifndef OLDXAW
+  {
+    XawNdisplayList,
+    XawCDisplayList,
+    XawRDisplayList,
+    sizeof(XawDisplayList*),
+    XtOffsetOf(BoxRec, box.display_list),
+    XtRImmediate,
+    NULL
+  },
+#endif
 };
 
-/****************************************************************
- *
- * Full class record constant
- *
- ****************************************************************/
-
-static void ClassInitialize();
-static void Initialize();
-static void Realize();
-static void Resize();
-static Boolean SetValues();
-static XtGeometryResult GeometryManager();
-static void ChangeManaged();
-static XtGeometryResult PreferredSize();
-
 BoxClassRec boxClassRec = {
+  /* core */
+  {
+    (WidgetClass)&compositeClassRec,	/* superclass */
+    "Box",				/* class_name */
+    sizeof(BoxRec),			/* widget_size */
+    XawBoxClassInitialize,		/* class_initialize */
+    NULL,				/* class_part_init */
+    False,				/* class_inited */
+    XawBoxInitialize,			/* initialize */
+    NULL,				/* initialize_hook */
+    XawBoxRealize,			/* realize */
+#ifndef OLDXAW
+    actions,				/* actions */
+    XtNumber(actions),			/* num_actions */
+#else
+    NULL,				/* actions */
+    0,					/* num_actions */
+#endif
+    resources,				/* resources */
+    XtNumber(resources),		/* num_resources */
+    NULLQUARK,				/* xrm_class */
+    True,				/* compress_motion */
+    True,				/* compress_exposure */
+    True,				/* compress_enterleave */
+    False,				/* visible_interest */
+    NULL,				/* destroy */
+    XawBoxResize,			/* resize */
+#ifndef OLDXAW
+    XawBoxExpose,			/* expose */
+#else
+    NULL,				/* expose */
+#endif
+    XawBoxSetValues,			/* set_values */
+    NULL,				/* set_values_hook */
+    XtInheritSetValuesAlmost,		/* set_values_almost */
+    NULL,				/* get_values_hook */
+    NULL,				/* accept_focus */
+    XtVersion,				/* version */
+    NULL,				/* callback_private */
+    NULL,				/* tm_table */
+    XawBoxQueryGeometry,		/* query_geometry */
+    XtInheritDisplayAccelerator,	/* display_accelerator */
+    NULL,				/* extension */
+  },
+  /* composite */
+  {
+    XawBoxGeometryManager,		/* geometry_manager */
+    XawBoxChangeManaged,		/* change_managed */
+    XtInheritInsertChild,		/* insert_child */
+    XtInheritDeleteChild,		/* delete_child */
+    NULL,				/* extension */
+  },
+  /* box */
   {
-/* core_class fields      */
-    /* superclass         */    (WidgetClass) &compositeClassRec,
-    /* class_name         */    "Box",
-    /* widget_size        */    sizeof(BoxRec),
-    /* class_initialize   */    ClassInitialize,
-    /* class_part_init    */	NULL,
-    /* class_inited       */	FALSE,
-    /* initialize         */    Initialize,
-    /* initialize_hook    */	NULL,
-    /* realize            */    Realize,
-    /* actions            */    NULL,
-    /* num_actions	  */	0,
-    /* resources          */    resources,
-    /* num_resources      */    XtNumber(resources),
-    /* xrm_class          */    NULLQUARK,
-    /* compress_motion	  */	TRUE,
-    /* compress_exposure  */	TRUE,
-    /* compress_enterleave*/	TRUE,
-    /* visible_interest   */    FALSE,
-    /* destroy            */    NULL,
-    /* resize             */    Resize,
-    /* expose             */    NULL,
-    /* set_values         */    SetValues,
-    /* set_values_hook    */	NULL,
-    /* set_values_almost  */    XtInheritSetValuesAlmost,
-    /* get_values_hook    */	NULL,
-    /* accept_focus       */    NULL,
-    /* version            */	XtVersion,
-    /* callback_private   */    NULL,
-    /* tm_table           */    NULL,
-    /* query_geometry     */	PreferredSize,
-    /* display_accelerator*/	XtInheritDisplayAccelerator,
-    /* extension          */	NULL
-  },{
-/* composite_class fields */
-    /* geometry_manager   */    GeometryManager,
-    /* change_managed     */    ChangeManaged,
-    /* insert_child	  */	XtInheritInsertChild,
-    /* delete_child	  */	XtInheritDeleteChild,
-    /* extension          */	NULL
-  },{
-/* Box class fields */
-    /* empty		  */	0,
-  }
+    NULL,				/* extension */
+  },
 };
 
 WidgetClass boxWidgetClass = (WidgetClass)&boxClassRec;
 
-
-/****************************************************************
- *
- * Private Routines
- *
- ****************************************************************/
-
 /*
- *
  * Do a layout, either actually assigning positions, or just calculating size.
  * Returns minimum width and height that will preserve the same layout.
- *
  */
-
-static void DoLayout(bbw, width, height, reply_width, reply_height, position)
-    BoxWidget	bbw;
-    Dimension	width, height;
-    Dimension	*reply_width, *reply_height; /* bounding box */
-    Boolean	position;	/* actually reposition the windows? */
+static void
+DoLayout(BoxWidget bbw, unsigned int width, unsigned int height,
+	 Dimension *reply_width, Dimension *reply_height, Bool position)
 {
     Boolean vbox = (bbw->box.orientation == XtorientVertical);
     Cardinal  i;
@@ -169,18 +209,20 @@ static void DoLayout(bbw, width, height, reply_width, reply_height, position)
     Dimension bw, bh;	/* Width and height needed for current widget 	*/
     Dimension h_space;  /* Local copy of bbw->box.h_space 		*/
     Widget widget;	/* Current widget	 			*/
-    int num_mapped_children = 0;
+    unsigned int num_mapped_children = 0;
  
     /* Box width and height */
     h_space = bbw->box.h_space;
 
     w = 0;
     for (i = 0; i < bbw->composite.num_children; i++) {
-	if ( bbw->composite.children[i]->core.width > w )
-            w = bbw->composite.children[i]->core.width;
+	if (XtIsManaged(bbw->composite.children[i])
+	    && bbw->composite.children[i]->core.width > w)
+	    w = bbw->composite.children[i]->core.width;
     }
     w += h_space;
-    if ( w > width ) width = w;
+    if (w > width)
+	width = w;
     h = bbw->box.v_space;
    
     /* Line width and height */
@@ -190,13 +232,14 @@ static void DoLayout(bbw, width, height, reply_width, reply_height, position)
     for (i = 0; i < bbw->composite.num_children; i++) {
 	widget = bbw->composite.children[i];
 	if (widget->core.managed) {
-	    if (widget->core.mapped_when_managed) num_mapped_children++;
+	    if (widget->core.mapped_when_managed)
+		num_mapped_children++;
 	    /* Compute widget width */
-	    bw = widget->core.width + 2*widget->core.border_width + h_space;
+	    bw = XtWidth(widget) + (XtBorderWidth(widget)<<1) + h_space;
 	    if ((Dimension)(lw + bw) > width) {
 		if (lw > h_space) {
 		    /* At least one widget on this line, and
-		     * can't fit any more.  Start new line if vbox.
+		     * can't fit any more.  Start new line if vbox
 		     */
 		    AssignMax(w, lw);
 		    if (vbox) {
@@ -207,12 +250,12 @@ static void DoLayout(bbw, width, height, reply_width, reply_height, position)
 		}
 		else if (!position) {
 		    /* too narrow for this widget; we'll assume we can grow */
-		    DoLayout(bbw, lw + bw, height, reply_width,
+		    DoLayout(bbw, (unsigned)(lw + bw), height, reply_width,
 			     reply_height, position);
 		    return;
 		}
 	    }
-	    if (position && (lw != widget->core.x || h != widget->core.y)) {
+	    if (position && (lw != XtX(widget) || h != XtY(widget))) {
 		/* It would be nice to use window gravity, but there isn't
 		 * sufficient fine-grain control to nicely handle all
 		 * situations (e.g. when only the height changes --
@@ -226,47 +269,51 @@ static void DoLayout(bbw, width, height, reply_width, reply_height, position)
 		 * force extra exposures as children occlude each other.
 		 */
 		if (XtIsRealized(widget) && widget->core.mapped_when_managed)
-		    XUnmapWindow( XtDisplay(widget), XtWindow(widget) );
+		XUnmapWindow( XtDisplay(widget), XtWindow(widget));
 		XtMoveWidget(widget, (int)lw, (int)h);
 	    }
 	    lw += bw;
-	    bh = widget->core.height + 2*widget->core.border_width;
+	    bh = XtHeight(widget) + (XtBorderWidth(widget) << 1);
 	    AssignMax(lh, bh);
-	} /* if managed */
-    } /* for */
+	}
+    }
 
     if (!vbox && width && lw > width && lh < height) {
 	/* reduce width if too wide and height not filled */
 	Dimension sw = lw, sh = lh;
-	Dimension width_needed;
+	Dimension width_needed = width;
 	XtOrientation orientation = bbw->box.orientation;
+
 	bbw->box.orientation = XtorientVertical;
 	while (sh < height && sw > width) {
 	    width_needed = sw;
-	    DoLayout(bbw, sw-1, height, &sw, &sh, False);
+	    DoLayout(bbw, (unsigned)(sw-1), height, &sw, &sh, False);
 	}
-	if (sh < height) width_needed = sw;
+	if (sh < height)
+	  width_needed = sw;
 	if (width_needed != lw) {
-	    DoLayout(bbw,width_needed,height,reply_width,reply_height,position);
+	    DoLayout(bbw, width_needed, height,
+		     reply_width, reply_height, position);
 	    bbw->box.orientation = orientation;
 	    return;
 	}
 	bbw->box.orientation = orientation;
     }
-   if ( vbox && ( ( width < w ) || ( width < lw ) ) ) {
-        AssignMax(w, lw);
-        DoLayout( bbw, w, height, reply_width, reply_height, position );
-        return;
+    if (vbox && (width < w || width < lw)) {
+	AssignMax(w, lw);
+	DoLayout(bbw, w, height, reply_width, reply_height, position);
+	return;
     }
-    if (position && XtIsRealized((Widget)bbw)) {
+     if (position && XtIsRealized((Widget)bbw)) {
 	if (bbw->composite.num_children == num_mapped_children)
-	    XMapSubwindows( XtDisplay((Widget)bbw), XtWindow((Widget)bbw) );
+	    XMapSubwindows(XtDisplay((Widget)bbw), XtWindow((Widget)bbw));
 	else {
-	    int i = bbw->composite.num_children;
+	    int ii = bbw->composite.num_children;
 	    Widget *childP = bbw->composite.children;
-	    for (; i > 0; childP++, i--)
-		if (XtIsRealized(*childP) && XtIsManaged(*childP) &&
-		    (*childP)->core.mapped_when_managed)
+
+	    for (; ii > 0; childP++, ii--)
+		if (XtIsRealized(*childP) && XtIsManaged(*childP)
+		    && (*childP)->core.mapped_when_managed)
 		    XtMapWidget(*childP);
 	}
     }
@@ -282,17 +329,14 @@ static void DoLayout(bbw, width, height, reply_width, reply_height, position)
 }
 
 /*
- *
- * Calculate preferred size, given constraining box, caching it in the widget.
- *
+ * Calculate preferred size, given constraining box, caching it in the widget
  */
-
-static XtGeometryResult PreferredSize(widget, constraint, preferred)
-    Widget widget;
-    XtWidgetGeometry *constraint, *preferred;
+static XtGeometryResult
+XawBoxQueryGeometry(Widget widget, XtWidgetGeometry *constraint,
+		    XtWidgetGeometry *preferred)
 {
     BoxWidget w = (BoxWidget)widget;
-    Dimension width /*, height */;
+    Dimension width;
     Dimension preferred_width = w->box.preferred_width;
     Dimension preferred_height = w->box.preferred_height;
 
@@ -300,23 +344,23 @@ static XtGeometryResult PreferredSize(widget, constraint, preferred)
 
     if (constraint->request_mode == 0)
 	/* parent isn't going to change w or h, so nothing to re-compute */
-	return XtGeometryYes;
+    return (XtGeometryYes);
 
-    if (constraint->request_mode == w->box.last_query_mode &&
-	(!(constraint->request_mode & CWWidth) ||
-	 constraint->width == w->box.last_query_width) &&
-	(!(constraint->request_mode & CWHeight) ||
-	 constraint->height == w->box.last_query_height)) {
+    if (constraint->request_mode == w->box.last_query_mode
+	&& (!(constraint->request_mode & CWWidth)
+	  || constraint->width == w->box.last_query_width)
+	&& (!(constraint->request_mode & CWHeight)
+	  || constraint->height == w->box.last_query_height)) {
 	/* same query; current preferences are still valid */
 	preferred->request_mode = CWWidth | CWHeight;
 	preferred->width = preferred_width;
 	preferred->height = preferred_height;
-	if (constraint->request_mode == (CWWidth | CWHeight) &&
-	    constraint->width == preferred_width &&
-	    constraint->height == preferred_height)
-	    return XtGeometryYes;
+	if (constraint->request_mode == (CWWidth | CWHeight)
+	    && constraint->width == preferred_width
+	    && constraint->height == preferred_height)
+	    return (XtGeometryYes);
 	else
-	    return XtGeometryAlmost;
+	    return (XtGeometryAlmost);
     }
 	
     /* else gotta do it the long way...
@@ -330,8 +374,8 @@ static XtGeometryResult PreferredSize(widget, constraint, preferred)
 
     if (constraint->request_mode & CWWidth)
 	width = constraint->width;
-    else /* if (constraint->request_mode & CWHeight) */ {
-	 /* let's see if I can become any narrower */
+    else { /* if (constraint->request_mode & CWHeight) */
+	   /* let's see if I can become any narrower */
 	width = 0;
 	constraint->width = 65535;
     }
@@ -340,31 +384,28 @@ static XtGeometryResult PreferredSize(widget, constraint, preferred)
        height = (constraint->request_mode & CWHeight) ? constraint->height
 		       : *preferred_height;
      */
-    DoLayout(w, width, (Dimension)0,
-	     &preferred_width, &preferred_height, FALSE);
+    DoLayout(w, width, 0, &preferred_width, &preferred_height, False);
 
-    if (constraint->request_mode & CWHeight &&
-	preferred_height > constraint->height) {
+    if (constraint->request_mode & CWHeight
+	&& preferred_height > constraint->height) {
 	/* find minimum width for this height */
-	if (preferred_width > constraint->width) {
-	    /* punt; over-constrained */
-	}
-	else {
+	if (preferred_width <= constraint->width) {
 	    width = preferred_width;
 	    do { /* find some width big enough to stay within this height */
-		width *= 2;
-		if (width > constraint->width) width = constraint->width;
-		DoLayout(w, width, 0, &preferred_width, &preferred_height, FALSE);
-	    } while (preferred_height > constraint->height &&
-		     width < constraint->width);
+		width <<= 1;
+		if (width > constraint->width)
+		    width = constraint->width;
+		DoLayout(w, width, 0, &preferred_width, &preferred_height, False);
+	    } while (preferred_height > constraint->height
+		     && width < constraint->width);
 	    if (width != constraint->width) {
 		do { /* find minimum width */
 		    width = preferred_width;
-		    DoLayout(w, preferred_width-1, 0,
-			     &preferred_width, &preferred_height, FALSE);
+		    DoLayout(w, (unsigned)(preferred_width - 1), 0,
+			     &preferred_width, &preferred_height, False);
 		} while (preferred_height < constraint->height);
 		/* one last time */
-		DoLayout(w, width, 0, &preferred_width, &preferred_height, FALSE);
+		DoLayout(w, width, 0, &preferred_width, &preferred_height, False);
 	    }
 	}
     }
@@ -376,241 +417,256 @@ static XtGeometryResult PreferredSize(widget, constraint, preferred)
     if (constraint->request_mode == (CWWidth|CWHeight)
 	&& constraint->width == preferred_width
 	&& constraint->height == preferred_height)
-	return XtGeometryYes;
-    else
-	return XtGeometryAlmost;
+	return (XtGeometryYes);
 
+    return (XtGeometryAlmost);
 }
 
 /*
- *
  * Actually layout the box
- *
  */
-
-static void Resize(w)
-    Widget	w;
+static void
+XawBoxResize(Widget w)
 {
-    Dimension junk;
-
-    DoLayout((BoxWidget)w, w->core.width, w->core.height, &junk, &junk, TRUE);
+    Dimension tmp;
 
-} /* Resize */
+    DoLayout((BoxWidget)w, XtWidth(w), XtHeight(w), &tmp, &tmp, True);
+}
 
 /*
- *
  * Try to do a new layout within the current width and height;
  * if that fails try to resize and do it within the box returne
- * by PreferredSize.
+ * by XawBoxQueryGeometry
  *
  * TryNewLayout just says if it's possible, and doesn't actually move the kids
  */
-
-static Boolean TryNewLayout(bbw)
-    BoxWidget	bbw;
+static Bool
+TryNewLayout(BoxWidget bbw)
 {
     Dimension 	preferred_width, preferred_height;
     Dimension	proposed_width, proposed_height;
     int		iterations;
 
-    DoLayout( bbw, bbw->core.width, bbw->core.height,
-	      &preferred_width, &preferred_height, FALSE );
+    DoLayout(bbw, bbw->core.width, bbw->core.height,
+	     &preferred_width, &preferred_height, False);
 
     /* at this point, preferred_width is guaranteed to not be greater
        than bbw->core.width unless some child is larger, so there's no
        point in re-computing another layout */
 
-    if ((bbw->core.width == preferred_width) &&
-	(bbw->core.height == preferred_height)) {
-        /* Same size */
-	return (TRUE);
-    }
+    if (XtWidth(bbw) == preferred_width && XtHeight(bbw) == preferred_height)
+	return (True);
 
-    /* let's see if our parent will go for a new size. */
+    /* let's see if our parent will go for a new size */
     iterations = 0;
     proposed_width = preferred_width;
     proposed_height = preferred_height;
     do {
 	switch (XtMakeResizeRequest((Widget)bbw,proposed_width,proposed_height,
-				     &proposed_width, &proposed_height))
-	{
+				     &proposed_width, &proposed_height)) {
 	    case XtGeometryYes:
-		return (TRUE);
-
+		return (True);
 	    case XtGeometryNo:
 		if (iterations > 0)
 		    /* protect from malicious parents who change their minds */
-		    DoLayout( bbw, bbw->core.width, bbw->core.height,
-			      &preferred_width, &preferred_height, FALSE );
-		if ((preferred_width <= bbw->core.width) &&
-		    (preferred_height <= bbw->core.height))
-		    return (TRUE);
+		    DoLayout(bbw, bbw->core.width, bbw->core.height,
+			     &preferred_width, &preferred_height, False);
+		if (preferred_width <= XtWidth(bbw)
+		    && preferred_height <= XtHeight(bbw))
+		    return (True);
 		else
-		    return (FALSE);
-
+		    return (False);
 	    case XtGeometryAlmost:
 		if (proposed_height >= preferred_height &&
 		    proposed_width >= preferred_width) {
-
 		    /*
 		     * Take it, and assume the parent knows what it is doing.
 		     *
 		     * The parent must accept this since it was returned in
 		     * almost.
-		     *
 		     */
-		    (void) XtMakeResizeRequest( (Widget)bbw,
-				       proposed_width, proposed_height,
-				       &proposed_width, &proposed_height);
-		    return(TRUE);
+		    (void)XtMakeResizeRequest((Widget)bbw,
+					       proposed_width, proposed_height,
+					       &proposed_width, &proposed_height);
+		    return (True);
 		}
 		else if (proposed_width != preferred_width) {
 		    /* recalc bounding box; height might change */
 		    DoLayout(bbw, proposed_width, 0,
-			     &preferred_width, &preferred_height, FALSE);
+			     &preferred_width, &preferred_height, False);
 		    proposed_height = preferred_height;
 		}
-		else { /* proposed_height != preferred_height */
+		else {	/* proposed_height != preferred_height */
 		    XtWidgetGeometry constraints, reply;
+
 		    constraints.request_mode = CWHeight;
 		    constraints.height = proposed_height;
-		    (void)PreferredSize((Widget)bbw, &constraints, &reply);
+		    (void)XawBoxQueryGeometry((Widget)bbw, &constraints, &reply);
 		    proposed_width = preferred_width;
 		}
+		/*FALLTHROUGH*/
+	    default:
+		break;
 	}
 	iterations++;
     } while (iterations < 10);
-    return (FALSE);
+
+    return (False);
 }
 
 /*
- *
  * Geometry Manager
  *
  * 'reply' is unused; we say only yeay or nay, never almost.
- *
  */
-
 /*ARGSUSED*/
-static XtGeometryResult GeometryManager(w, request, reply)
-    Widget		w;
-    XtWidgetGeometry	*request;
-    XtWidgetGeometry	*reply;	/* RETURN */
-
+static XtGeometryResult
+XawBoxGeometryManager(Widget w, XtWidgetGeometry *request,
+		      XtWidgetGeometry *reply)
 {
     Dimension	width, height, borderWidth;
     BoxWidget bbw;
 
     /* Position request always denied */
-    if ((request->request_mode & CWX && request->x != w->core.x) ||
-	(request->request_mode & CWY && request->y != w->core.y))
+    if (((request->request_mode & CWX) && request->x != XtX(w))
+	|| ((request->request_mode & CWY) && request->y != XtY(w)))
         return (XtGeometryNo);
 
     /* Size changes must see if the new size can be accomodated */
     if (request->request_mode & (CWWidth | CWHeight | CWBorderWidth)) {
-
 	/* Make all three fields in the request valid */
 	if ((request->request_mode & CWWidth) == 0)
-	    request->width = w->core.width;
+	    request->width = XtWidth(w);
 	if ((request->request_mode & CWHeight) == 0)
-	    request->height = w->core.height;
+	    request->height = XtHeight(w);
         if ((request->request_mode & CWBorderWidth) == 0)
-	    request->border_width = w->core.border_width;
+	    request->border_width = XtBorderWidth(w);
 
 	/* Save current size and set to new size */
-	width = w->core.width;
-	height = w->core.height;
-	borderWidth = w->core.border_width;
-	w->core.width = request->width;
-	w->core.height = request->height;
-	w->core.border_width = request->border_width;
-
-	/* Decide if new layout works: (1) new widget is smaller,
-	   (2) new widget fits in existing Box, (3) Box can be
-	   expanded to allow new widget to fit */
+      width = XtWidth(w);
+      height = XtHeight(w);
+      borderWidth = XtBorderWidth(w);
+      XtWidth(w) = request->width;
+      XtHeight(w) = request->height;
+      XtBorderWidth(w) = request->border_width;
+
+      /* Decide if new layout works:
+	 (1) new widget is smaller,
+	 (2) new widget fits in existing Box,
+	 (3) Box can be expanded to allow new widget to fit
+      */
 
 	bbw = (BoxWidget) w->core.parent;
 
-/* whenever a child changes his geometry, we attempt to
- * change ours to be the minimum enclosing size...
-	if (((request->width + request->border_width <= width + borderWidth) &&
-	    (request->height + request->border_width <= height + borderWidth))
-	|| bbw->box.preferred_width < bbw->core.width
-	|| bbw->box.preferred_height < bbw->core.height
-	|| TryNewLayout(bbw)) {
- */
 	if (TryNewLayout(bbw)) {
 	    /* Fits in existing or new space, relayout */
 	    (*XtClass((Widget)bbw)->core_class.resize)((Widget)bbw);
 	    return (XtGeometryYes);
-	} else {
+	}
+	else {
 	    /* Cannot satisfy request, change back to original geometry */
-	    w->core.width = width;
-	    w->core.height = height;
-	    w->core.border_width = borderWidth;
+	    XtWidth(w) = width;
+	    XtHeight(w) = height;
+	    XtBorderWidth(w) = borderWidth;
 	    return (XtGeometryNo);
 	}
-    }; /* if any size changes requested */
+    }
 
     /* Any stacking changes don't make a difference, so allow if that's all */
     return (XtGeometryYes);
 }
 
-static void ChangeManaged(w)
-    Widget w;
+static void
+XawBoxChangeManaged(Widget w)
 {
     /* Reconfigure the box */
-    (void) TryNewLayout((BoxWidget)w);
-    Resize(w);
+    (void)TryNewLayout((BoxWidget)w);
+    XawBoxResize(w);
 }
 
-static void ClassInitialize()
+static void
+XawBoxClassInitialize(void)
 {
     XawInitializeWidgetSet();
-    XtAddConverter( XtRString, XtROrientation, XmuCvtStringToOrientation,
-		    (XtConvertArgList)NULL, (Cardinal)0 );
+    XtAddConverter(XtRString, XtROrientation, XmuCvtStringToOrientation,
+		   NULL, 0);
+    XtSetTypeConverter(XtROrientation, XtRString, XmuCvtOrientationToString,
+		       NULL, 0, XtCacheNone, NULL);
 }
 
-/* ARGSUSED */
-static void Initialize(request, new, args, num_args)
-    Widget request, new;
-    ArgList args;
-    Cardinal *num_args;
+/*ARGSUSED*/
+static void
+XawBoxInitialize(Widget request, Widget cnew,
+		 ArgList args, Cardinal *num_args)
 {
-    BoxWidget newbbw = (BoxWidget)new;
+    BoxWidget newbbw = (BoxWidget)cnew;
 
     newbbw->box.last_query_mode = CWWidth | CWHeight;
     newbbw->box.last_query_width = newbbw->box.last_query_height = 0;
     newbbw->box.preferred_width = Max(newbbw->box.h_space, 1);
     newbbw->box.preferred_height = Max(newbbw->box.v_space, 1);
 
-    if (newbbw->core.width == 0)
-        newbbw->core.width = newbbw->box.preferred_width;
+    if (XtWidth(newbbw) == 0)
+	XtWidth(newbbw) = newbbw->box.preferred_width;
 
-    if (newbbw->core.height == 0)
-	newbbw->core.height = newbbw->box.preferred_height;
+    if (XtHeight(newbbw) == 0)
+	XtHeight(newbbw) = newbbw->box.preferred_height;
+}
 
-} /* Initialize */
+static void
+XawBoxRealize(Widget w, Mask *valueMask, XSetWindowAttributes *attributes)
+{
+#ifndef OLDXAW
+    XawPixmap *pixmap;
+#endif
+
+    XtCreateWindow(w, InputOutput, (Visual *)CopyFromParent,
+		   *valueMask, attributes);
+
+#ifndef OLDXAW
+    if (w->core.background_pixmap > XtUnspecifiedPixmap) {
+	pixmap = XawPixmapFromXPixmap(w->core.background_pixmap, XtScreen(w),
+				      w->core.colormap, w->core.depth);
+	if (pixmap && pixmap->mask)
+	    XawReshapeWidget(w, pixmap);
+    }
+#endif
+}
 
-static void Realize(w, valueMask, attributes)
-    Widget w;
-    Mask *valueMask;
-    XSetWindowAttributes *attributes;
+/*ARGSUSED*/
+static Boolean
+XawBoxSetValues(Widget current, Widget request, Widget cnew,
+		ArgList args, Cardinal *num_args)
 {
-    attributes->bit_gravity = NorthWestGravity;
-    *valueMask |= CWBitGravity;
-
-    XtCreateWindow( w, (unsigned)InputOutput, (Visual *)CopyFromParent,
-		    *valueMask, attributes);
-} /* Realize */
-
-/* ARGSUSED */
-static Boolean SetValues(current, request, new, args, num_args)
-    Widget current, request, new;
-    ArgList args;
-    Cardinal *num_args;
+     /* need to relayout if h_space or v_space change */
+#ifndef OLDXAW
+    BoxWidget b_old = (BoxWidget)current;
+    BoxWidget b_new = (BoxWidget)cnew;
+
+    if (b_old->core.background_pixmap != b_new->core.background_pixmap) {
+	XawPixmap *opix, *npix;
+
+	opix = XawPixmapFromXPixmap(b_old->core.background_pixmap,
+				    XtScreen(b_old), b_old->core.colormap,
+				    b_old->core.depth);
+	npix = XawPixmapFromXPixmap(b_new->core.background_pixmap,
+				    XtScreen(b_new), b_new->core.colormap,
+				    b_new->core.depth);
+	if ((npix && npix->mask) || (opix && opix->mask))
+	    XawReshapeWidget(cnew, npix);
+    }
+#endif /* OLDXAW */
+
+  return (False);
+}
+
+#ifndef OLDXAW
+static void
+XawBoxExpose(Widget w, XEvent *event, Region region)
 {
-   /* need to relayout if h_space or v_space change */
+    BoxWidget xaw = (BoxWidget)w;
 
-    return False;
+    if (xaw->box.display_list)
+	XawRunDisplayList(w, xaw->box.display_list, event, region);
 }
+#endif /* OLDXAW */