/*
 * Copyright 1991 Massachusetts Institute of Technology
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of M.I.T. not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  M.I.T. makes no representations about the
 * suitability of this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 *
 * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Author:  Keith Packard, MIT X Consortium
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>

#include <X11/Xmu/Misc.h>
#include <X11/Xmu/Converters.h>

#ifdef MOTIF
# include <Xm/XmP.h>
#endif

#if defined(LAYOUT)
# include "LayoutP.h"
#else
# include <X11/Xaw3d/LayoutP.h>
#endif

#include <ctype.h>
#include <stdio.h>

#include "LayYY.h"

#undef DEBUG
#ifdef DEBUG
static char *DBUG_currentproc, *DBUG_lastproc;
static int DBUG_level = 0;
# define DBUG_ENTER(s)        \
    {DBUG_lastproc=DBUG_currentproc;DBUG_currentproc=s;\
    fprintf(stderr,"begin: (%d) %s\n",++DBUG_level,s);}
# define DBUG_VOID_RETURN \
    {fprintf(stderr,"end:   (%d) %s\n",DBUG_level--,DBUG_currentproc); \
    DBUG_currentproc=DBUG_lastproc;return;}
# define DBUG_RETURN(f,v) \
    {fprintf(stderr,"return (%d) %s (",DBUG_level--,DBUG_currentproc); \
    fprintf(stderr,(f),(v)); \
    fprintf(stderr,")\n"); DBUG_currentproc=DBUG_lastproc;return (v);}
# define DBUG_PRINT(f,s)        \
    {fprintf(stderr,"       (%d) %s:",DBUG_level, DBUG_currentproc); \
    fprintf(stderr,f,s);fprintf(stderr,"\n");}
#else
# define DBUG_ENTER(s)
# define DBUG_VOID_RETURN return
# define DBUG_PRINT(f,s)
# define DBUG_RETURN(f,v) return(v)
#endif

/*****************************************************************************
 *
 * Full instance record declaration
 *
 ****************************************************************************/

#define offset(field) XtOffsetOf(LayoutRec, layout.field)

static XtResource resources[] = {
    {XtNlayout, XtCLayout, XtRLayout, sizeof (BoxPtr),
	offset(layout), XtRLayout, NULL },
    {XtNdebug, XtCBoolean, XtRBoolean, sizeof(Boolean),
	 offset(debug), XtRImmediate, (XtPointer) FALSE},
};

#undef offset

static void ClassInitialize(void);
static void Initialize(Widget, Widget, ArgList, Cardinal *);
static void Resize(Widget);
static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal *);
static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry *, XtWidgetGeometry *);
static void ChangeManaged(Widget);
static void InsertChild(Widget);
static XtGeometryResult QueryGeometry (Widget, XtWidgetGeometry *, XtWidgetGeometry *);
static void GetDesiredSize (Widget);
#ifdef MOTIF
static void Redisplay (Widget, XEvent *, Region);
#endif

static void LayoutLayout (LayoutWidget, Bool);
static void LayoutGetNaturalSize (LayoutWidget, Dimension *, Dimension *);
static void LayoutFreeLayout (BoxPtr);

#ifdef MOTIF
#define SuperClass ((ConstraintWidgetClass)&xmManagerClassRec)
#else
#define SuperClass ((ConstraintWidgetClass)&constraintClassRec)
#endif

LayoutClassRec layoutClassRec = {
   {
/* core class fields */
    /* superclass         */   (WidgetClass) SuperClass,
    /* class name         */   "Layout",
    /* size               */   sizeof(LayoutRec),
    /* class_initialize   */   ClassInitialize,
    /* class_part init    */   NULL,
    /* class_inited       */   FALSE,
    /* initialize         */   Initialize,
    /* initialize_hook    */   NULL,
    /* realize            */   XtInheritRealize,
    /* actions            */   NULL,
    /* num_actions        */   0,
    /* resources          */   resources,
    /* resource_count     */   XtNumber(resources),
    /* xrm_class          */   NULLQUARK,
    /* compress_motion    */   FALSE,
    /* compress_exposure  */   0,
    /* compress_enterleave*/   FALSE,
    /* visible_interest   */   FALSE,
    /* destroy            */   NULL,
    /* resize             */   Resize,
#ifdef MOTIF
    /* expose             */   Redisplay,
#else
    /* expose             */   NULL,
#endif
    /* set_values         */   SetValues,
    /* set_values_hook    */   NULL,
    /* set_values_almost  */   XtInheritSetValuesAlmost,
    /* get_values_hook    */   NULL,
    /* accept_focus       */   NULL,
    /* version            */   XtVersion,
    /* callback_private   */   NULL,
#ifdef MOTIF
    /* tm_table           */   XtInheritTranslations,
#else
    /* tm_table           */   NULL,
#endif
    /* query_geometry	  */   QueryGeometry,
    /* display_accelerator*/   XtInheritDisplayAccelerator,
    /* extension          */   NULL
   }, {
/* composite class fields */
    /* geometry_manager   */   GeometryManager,
    /* change_managed     */   ChangeManaged,
    /* insert_child       */   InsertChild,
    /* delete_child       */   XtInheritDeleteChild,
    /* extension          */   NULL
   }, {
/* constraint class fields */
    /* subresources       */   NULL,
    /* subresource_count  */   0,
    /* constraint_size    */   sizeof(LayoutConstraintsRec),
    /* initialize         */   NULL,
    /* destroy            */   NULL,
    /* set_values         */   NULL,
    /* extension          */   NULL
   },
#ifdef MOTIF
   {
    /* manager class */
    XtInheritTranslations,                /* translations           */
    NULL,                                 /* syn resources          */
    0,                                    /* num syn_resources      */
    NULL,                                 /* get_cont_resources     */
    0,                                    /* num_get_cont_resources */
    XmInheritParentProcess,               /* parent_process       */
    NULL,                                 /* extension              */
   },
#endif
   { /* layout_class fields */
    0
   }
};

WidgetClass layoutWidgetClass = (WidgetClass) &layoutClassRec;

#define ForAllChildren(pw, childP) \
  for ( (childP) = (pw)->composite.children ; \
        (childP) < (pw)->composite.children + (pw)->composite.num_children ; \
        (childP)++ ) if (!XtIsManaged(*childP)) ; else

/************************************************************
 *
 * Semi-public routines.
 *
 ************************************************************/

/*	Function Name: ClassInitialize
 *	Description: The Layout widgets class initialization proc.
 *	Arguments: none.
 *	Returns: none.
 */

/*ARGSUSED*/
static Boolean
CvtStringToLayout (Display *dpy, XrmValue *args, Cardinal *num_args,
                   XrmValue *from, XrmValue *to, XtPointer *converter_data)
{
    static BoxPtr tmp;

    LayYYsetsource ((char *) from->addr);
    if (!to->addr) to->addr = (XtPointer)&tmp;
    LayYYsetdest ((BoxPtr *) to->addr);
    to->size = sizeof (BoxPtr *);
    return  LayYYparse() ? FALSE : TRUE;
}

/*ARGSUSED*/
static void
DisposeLayout (XtAppContext app, XrmValue *to, XtPointer data, XrmValuePtr args,
               Cardinal *num_args)
{
    LayoutFreeLayout (* (LayoutPtr *) to->addr);
}

static void
ClassInitialize(void)
{
    XtSetTypeConverter ( XtRString, XtRLayout, CvtStringToLayout,
		    (XtConvertArgList)NULL, (Cardinal)0, XtCacheNone,
 		    DisposeLayout );
}

#ifdef MOTIF
static void
Redisplay (Widget gw, XEvent *event, Region region)
{
   /*
    * If the Layout widget is visible, redraw gadgets.
    */

    if ( XtIsRealized ( gw ) && gw->core.visible )
    {
        _XmRedisplayGadgets ( gw, event, region );
    }
    /* ChangeManaged(gw);*/
}
#endif

/*ARGSUSED*/
static XtGeometryResult
GeometryManager(Widget child, XtWidgetGeometry *request, XtWidgetGeometry *reply)
{
    LayoutWidget    w = (LayoutWidget) XtParent(child);
    SubInfoPtr	    p = SubInfo(child);
    int		    bw;
    Bool	    changed, bwChanged;

    bw = p->naturalBw;
    changed = FALSE;
    bwChanged = FALSE;
    if (request->request_mode & CWBorderWidth &&
	request->border_width != child->core.border_width)
    {
	p->naturalBw = bw;
	bw = request->border_width;
	changed = TRUE;
	bwChanged = TRUE;
    }
    if (bwChanged || ((request->request_mode & CWWidth) &&
	request->width != child->core.width))
    {
	p->naturalSize[LayoutHorizontal] = request->width + bw * 2;
	changed = TRUE;
    }
    if (bwChanged || ((request->request_mode & CWHeight) &&
	request->height != child->core.height))
    {
	p->naturalSize[LayoutVertical] = request->height + bw * 2;
	changed = TRUE;
    }
    if (changed)
	LayoutLayout (w, TRUE);
    return XtGeometryDone;
}

/* ARGSUSED */
static void
Initialize(Widget request, Widget new, ArgList args, Cardinal *num_args)
{
/*    LayoutWidget w = (LayoutWidget)new; */
}

static void
ChangeManaged(Widget gw)
{
    LayoutWidget	w = (LayoutWidget) gw;
    Widget		*children;

    DBUG_ENTER("changeManaged");

    ForAllChildren (w, children)
	GetDesiredSize (*children);
    LayoutLayout ((LayoutWidget) w, TRUE);
#ifdef MOTIF
    _XmNavigChangeManaged ( gw );
#endif
    DBUG_VOID_RETURN;
}

static void
GetDesiredSize (Widget child)
{
    XtWidgetGeometry	desired;
    SubInfoPtr		p;

    XtQueryGeometry (child, (XtWidgetGeometry *) NULL, &desired);
    p = SubInfo (child);
    p->naturalBw = desired.border_width;
    p->naturalSize[LayoutHorizontal] = desired.width + desired.border_width * 2;
    p->naturalSize[LayoutVertical] = desired.height + desired.border_width * 2;
}

static void
InsertChild (Widget child)
{
    (*SuperClass->composite_class.insert_child) (child);
    GetDesiredSize (child);
}

static void
Resize(Widget gw)
{
    LayoutLayout ((LayoutWidget) gw, FALSE);
}

/* ARGSUSED */
static Boolean
SetValues(Widget gold, Widget greq, Widget gnew, ArgList args, Cardinal *num_args)
{
    LayoutWidget    old = (LayoutWidget) gold,
		    new = (LayoutWidget) gnew;

    if (old->layout.layout != new->layout.layout)
	LayoutLayout (new, TRUE);
    return FALSE;
} /* SetValues */

static XtGeometryResult
QueryGeometry (Widget gw, XtWidgetGeometry *request, XtWidgetGeometry *prefered_return)
{
    LayoutWidget	w = (LayoutWidget) gw;
    XtGeometryResult	result;
    XtWidgetGeometry	prefered_size;

    if (request && !(request->request_mode & (CWWidth|CWHeight)))
	return XtGeometryYes;
    LayoutGetNaturalSize (w, &prefered_size.width, &prefered_size.height);
    prefered_return->request_mode = 0;
    result = XtGeometryYes;
    if (!request) {
	prefered_return->width = prefered_size.width;
	prefered_return->height= prefered_size.height;
	if (prefered_size.width != w->core.width) {
	    prefered_return->request_mode |= CWWidth;
	    result = XtGeometryAlmost;
	}
	if (prefered_size.height != w->core.height) {
	    prefered_return->request_mode |= CWHeight;
	    result = XtGeometryAlmost;
	}
    } else {
    	if (request->request_mode & CWWidth) {
	    if (prefered_size.width > request->width)
	    {
	    	if (prefered_size.width == w->core.width)
		    result = XtGeometryNo;
	    	else if (result != XtGeometryNo) {
		    result = XtGeometryAlmost;
		    prefered_return->request_mode |= CWWidth;
		    prefered_return->width = prefered_size.width;
	    	}
	    }
    	}
    	if (request->request_mode & CWHeight) {
	    if (prefered_size.height > request->height)
	    {
	    	if (prefered_size.height == w->core.height)
		    result = XtGeometryNo;
	    	else if (result != XtGeometryNo) {
		    result = XtGeometryAlmost;
		    prefered_return->request_mode |= CWHeight;
		    prefered_return->height = prefered_size.height;
	    	}
	    }
    	}
    }
    return result;
}

/*
 * Layout section.  Exports LayoutGetNaturalSize and
 * LayoutLayout to above section
 */

static void
PrintGlue (GlueRec g)
{
    if (g.order == 0 || g.value != 1.0)
	(void) printf ("%g", g.value);
    if (g.order > 0)
    {
	(void) printf ("%s", " inf");
	if (g.order > 1)
	    (void) printf (" %d", g.order);
    }
}

static void
PrintDirection (LayoutDirection dir)
{
    switch (dir) {
    case LayoutHorizontal:
	(void) printf ("%s", "horizontal");
	break;
    case LayoutVertical:
	(void) printf ("%s", "vertical");
	break;
    default:
	(void) printf ("Unknown layout direction %d\n", dir);
	break;

    }
}

static void
TabTo(int level)
{
    while (level--)
	(void) printf ("%s", "  ");
}

static void
PrintBox (BoxPtr box, int level)
{
    BoxPtr	child;

    TabTo (level);
    (void) printf ("%s", "< ");
    (void) printf ("%s", " + ");
    PrintGlue (box->params.stretch[LayoutHorizontal]);
    (void) printf ("%s", " - ");
    PrintGlue (box->params.shrink[LayoutHorizontal]);
    (void) printf ("%s", " * ");
    (void) printf ("%s", " + ");
    PrintGlue (box->params.stretch[LayoutVertical]);
    (void) printf ("%s", " - ");
    PrintGlue (box->params.shrink[LayoutVertical]);
    (void) printf ("%s", " >");
    (void) printf (" size: %d x %d", box->size[0], box->size[1]);
    (void) printf (" natural: %d x %d ", box->natural[0], box->natural[1]);
    switch (box->type) {
    case BoxBox:
	PrintDirection (box->u.box.dir);
	(void) printf ("%s\n", "");
	for (child = box->u.box.firstChild; child; child = child->nextSibling)
	    PrintBox (child, level+1);
	break;
    case WidgetBox:
	(void) printf (" %s\n", XrmQuarkToString (box->u.widget.quark));
	break;
    case GlueBox:
	(void) printf ("%s\n", " glue");
	break;
    case VariableBox:
	(void) printf (" variable %s\n", XrmQuarkToString (box->u.variable.quark));
	break;
    }
}

static ExprPtr
LookupVariable (BoxPtr child, XrmQuark quark)
{
    BoxPtr	parent, box;

    DBUG_ENTER("LookupVariable");
    DBUG_PRINT("name = <%s>",XrmQuarkToString(quark));
    DBUG_PRINT("child = %p",child);
    while ((parent = child->parent))
    {
	for (box = parent->u.box.firstChild;
	     box != child;
	     box = box->nextSibling)
	{
	    if (box->type == VariableBox && box->u.variable.quark == quark)
		DBUG_RETURN("%p", box->u.variable.expr);
	}
	child = parent;
    }
    DBUG_RETURN("failure -> %d",0);
}

static double
Evaluate (LayoutWidget l, BoxPtr box, ExprPtr expr, double natural)
{
    double	left, right, down;
    Widget	widget;
    SubInfoPtr	info;

    DBUG_PRINT("Evaluate %d", expr->type);
    switch (expr->type) {
    case Constant:
	return expr->u.constant;
    case Binary:
	left = Evaluate (l, box, expr->u.binary.left, natural);
	right = Evaluate (l, box, expr->u.binary.right, natural);
	switch (expr->u.binary.op) {
        case Plus:
	    return left + right;
	case Minus:
	    return left - right;
	case Times:
	    return left * right;
	case Divide:
	    return left / right;
	case Percent:
	    return right * left / 100.0;
	}
    case Unary:
	down = Evaluate (l, box, expr->u.unary.down, natural);
	switch (expr->u.unary.op) {
	case Percent:
	    return natural * down / 100.0;
	case Minus:
	    return -down;
	case Plus:
	case Times:
	case Divide:
	    break;
	}
    case Width:
	widget = QuarkToWidget (l, expr->u.width);
	if (!widget)
	    return 0;
	info = SubInfo (widget);
	return info->naturalSize[LayoutHorizontal];
    case Height:
	widget = QuarkToWidget (l, expr->u.height);
	if (!widget)
	    return 0;
	info = SubInfo (widget);
	return info->naturalSize[LayoutVertical];
    case Variable:
        {
	/* in the original code there was no nexpr,
	   expr was overwritten by LookupVariable and
	   the expression "expr->u.variable" to obtain the
	   variable name for the errormessage cause a segmentation
	   violation */
	ExprPtr    nexpr;
	nexpr = LookupVariable (box, expr->u.variable);
	if (!nexpr)
	    {
	    char    buf[256];
	    (void) sprintf (buf, "Layout: undefined variable %s\n",
			    XrmQuarkToString (expr->u.variable));
	    XtError (buf);
	    return 0.0;
	    }
	return Evaluate (l, box, nexpr, natural);
	}
    }
    return 0.0;
}

static void
DisposeExpr (ExprPtr expr)
{
    if (!expr)
	return;
    switch (expr->type) {
    case Constant:
	break;
    case Binary:
	DisposeExpr (expr->u.binary.left);
	DisposeExpr (expr->u.binary.right);
	break;
    case Unary:
	DisposeExpr (expr->u.unary.down);
	break;
    case Width:
    case Height:
    case Variable:
	break;
    }
    Dispose (expr);
}

#define CheckGlue(l, box, glue, n) { \
    if (glue.expr) \
	glue.value = Evaluate (l, box, glue.expr, n); \
    if (glue.order == 0 && glue.value == 0) \
	glue.order = -1; \
    else if (glue.order == -1 && glue.value != 0) \
	glue.order = 0; \
}

#define DoStretch(l, box, dir) \
    CheckGlue (l, box, box->params.stretch[dir], (double) box->natural[dir]);

#define DoShrink(l, box, dir) \
    CheckGlue (l, box, box->params.shrink[dir], (double) box->natural[dir])

/* compute the natural sizes of a box */
static void
ComputeNaturalSizes (LayoutWidget l, BoxPtr box, LayoutDirection dir)
{
    BoxPtr	child;
    Widget	w;
    SubInfoPtr	info;
    int		minStretchOrder, minShrinkOrder;
    LayoutDirection thisDir;

    DBUG_ENTER("ComputeNaturalSizes");
    DBUG_PRINT("box->type=%d",box->type);
    switch (box->type) {
    case WidgetBox:
	w = box->u.widget.widget = QuarkToWidget (l, box->u.widget.quark);
	if (!w)
	{
	    box->natural[LayoutHorizontal] = 0;
	    box->natural[LayoutVertical] = 0;
	}
	else
	{
	    info = SubInfo (w);
	    box->natural[LayoutHorizontal] = info->naturalSize[LayoutHorizontal];
	    box->natural[LayoutVertical] = info->naturalSize[LayoutVertical];
	}
	DoStretch (l, box, dir);
	DoShrink (l, box, dir);
	DoStretch (l, box, !dir);
	DoShrink (l, box, !dir);
	break;
    case GlueBox:
	box->natural[dir] = Evaluate (l, box, box->u.glue.expr, 0.0);
	box->natural[!dir] = 0;
	DoStretch (l, box, dir);
	DoShrink (l, box, dir);
	break;
    case BoxBox:
	thisDir = box->u.box.dir;
	box->natural[0] = 0;
	box->natural[1] = 0;
	minStretchOrder = 100000;
	minShrinkOrder = 100000;
	ZeroGlue (box->params.shrink[thisDir]);
	ZeroGlue (box->params.stretch[thisDir]);
	box->params.shrink[!thisDir].order = 100000;
	box->params.stretch[!thisDir].order = 100000;
	for (child = box->u.box.firstChild; child; child = child->nextSibling)
	{
	    ComputeNaturalSizes (l, child, thisDir);
	    /*
	     * along box axis:
	     *  normal size += child normal size
	     *  shrink += child shrink
	     *  stretch += child stretch
	     */
	    box->natural[thisDir] += child->natural[thisDir];
	    AddGlue (box->params.shrink[thisDir],
		     box->params.shrink[thisDir],
		     child->params.shrink[thisDir]);
	    AddGlue (box->params.stretch[thisDir],
		     box->params.stretch[thisDir],
		     child->params.stretch[thisDir]);
	    /*
	     * normal to box axis:
	     *  normal size = maximum child normal size of minimum shrink order
	     *  shrink = difference between normal size and minimum shrink
	     *  stretch = minimum child stretch
	     */
	    if (box->natural[!thisDir] >= child->natural[!thisDir])
	    {
		if (child->params.stretch[!thisDir].order < minShrinkOrder)
		{
		    box->natural[!thisDir] = child->natural[!thisDir];
		    minStretchOrder = child->params.stretch[!thisDir].order;
		    if (child->params.shrink[!thisDir].order < minShrinkOrder)
			minShrinkOrder = child->params.shrink[!thisDir].order;
		}
	    }
	    else
	    {
		if (child->params.shrink[!thisDir].order <= minStretchOrder)
		{
		    box->natural[!thisDir] = child->natural[!thisDir];
		    minShrinkOrder = child->params.shrink[!thisDir].order;
		    if (child->params.stretch[!thisDir].order < minStretchOrder)
			minStretchOrder = child->params.stretch[!thisDir].order;
		}
	    }
	    MinGlue (box->params.stretch[!thisDir],
		     box->params.stretch[!thisDir],
		     child->params.stretch[!thisDir]);
	    MinGlue (box->params.shrink[!thisDir],
		     box->params.shrink[!thisDir],
		     child->params.shrink[!thisDir]);
	}
	if (box->params.shrink[!thisDir].order <= 0)
	{
	    int	    minSize;
	    int	    largestMinSize;

	    largestMinSize = 0;
	    for (child = box->u.box.firstChild; child; child = child->nextSibling)
	    {
		if (child->params.shrink[!thisDir].order <= 0)
		{
		    minSize = child->natural[!thisDir] -
			      child->params.shrink[!thisDir].value;
		    if (minSize > largestMinSize)
			largestMinSize = minSize;
		}
	    }
	    box->params.shrink[!thisDir].value = box->natural[!thisDir] -
						 largestMinSize;
	    if (box->params.shrink[!thisDir].value == 0)
		box->params.shrink[!thisDir].order = -1;
	    else
		box->params.shrink[!thisDir].order = 0;
	}
        break;
    case VariableBox:
        break;
    }
    DBUG_VOID_RETURN;
}

/* given the boxs geometry, set the geometry of the pieces */

#define GluePart(a,b,dist)	((a) ? ((int) (((a) * (dist)) / (b) + \
					((dist >= 0) ? 0.5 : -0.5))) : 0)

static Bool
ComputeSizes (BoxPtr box)
{
    LayoutDirection dir;
    BoxPtr	    child;
    GlueRec	    stretch;
    GlueRec	    shrink;
    GlueRec	    totalGlue[2];
    double	    remainingGlue;
    GluePtr	    glue;
    int		    size;
    int		    totalSizes;
    int		    totalChange[2];
    int		    change;
    int		    remainingChange;
    Bool	    shrinking;
    Bool	    happy;
    int		    i;
    int		    maxGlue;

    dir = box->u.box.dir;
    size = box->size[dir];

    stretch = box->params.stretch[dir];
    shrink = box->params.shrink[dir];

    /* pick the correct adjustment parameters based on the change direction */

    totalChange[0] = size - box->natural[dir];

    shrinking = totalChange[0] < 0;

    totalChange[1] = 0;
    totalGlue[1].order = 100000;
    totalGlue[1].value = 0;
    maxGlue = 1;
    if (shrinking)
    {
	totalGlue[0] = shrink;
	/* for first-order infinites, shrink it to zero and then
	 * shrink the zero-orders
	 */
	if (shrink.order == 1) {
	    totalSizes = 0;
	    remainingGlue = 0;
	    for (child = box->u.box.firstChild;
		 child;
		 child = child->nextSibling)
	    {
		switch (child->params.shrink[dir].order) {
		case 0:
		    remainingGlue += child->params.shrink[dir].value;
		    break;
		case 1:
		    totalSizes += child->natural[dir];
		    break;
		}
	    }
	    if (totalSizes < -totalChange[0])
	    {
		totalGlue[1] = shrink;
		totalGlue[0].order = 0;
		totalGlue[0].value = remainingGlue;
		totalChange[1] = -totalSizes;
		totalChange[0] = totalChange[0] - totalChange[1];
		maxGlue = 2;
	    }
	}
	if (totalGlue[0].order <= 0 &&
	    totalChange[0] > totalGlue[0].value)
	{
	    totalChange[0] = totalGlue[0].value;
	}
    }
    else
	totalGlue[0] = stretch;

    /* adjust each box */
    totalSizes = 0;
    remainingGlue = totalGlue[0].value + totalGlue[1].value;
    remainingChange = totalChange[0] + totalChange[1];
    happy = True;
    for (child = box->u.box.firstChild; child; child = child->nextSibling)
    {
        /* never add glue or stretch to a VariableBox! */
        if (child->type == VariableBox) continue;

	if (shrinking)
	    glue = &child->params.shrink[dir];
	else
	    glue = &child->params.stretch[dir];

	child->size[dir] = child->natural[dir];
	for (i = 0; i < maxGlue; i++)
	{
	    if (glue->order == totalGlue[i].order)
	    {
		remainingGlue -= glue->value;
		if (remainingGlue <= 0)
		    change = remainingChange;
		else
		    change = GluePart (glue->value,
				       totalGlue[i].value,
				       totalChange[i]);
		child->size[dir] += change;
		remainingChange -= change;
	    }
	}
	child->size[!dir] = box->size[!dir];
	totalSizes += child->size[dir];
	if (child->type == BoxBox)
	    if (!ComputeSizes (child))
		happy = False;
    }
    return totalSizes == box->size[dir] && happy;
}

static void
SetSizes (BoxPtr box, Position x, Position y)
{
    BoxPtr	child;
    int		width, height;
    int		bw;
    Widget	w;
    SubInfoPtr	info;

    switch (box->type) {
    case WidgetBox:
	w = box->u.widget.widget;
	if (w)
	{
	    info = SubInfo(w);
	    /* info = (SubInfoPtr) w->core.constraints; */
	    width = box->size[LayoutHorizontal];
	    height = box->size[LayoutVertical];
	    bw = info->naturalBw;
	    width -= bw * 2;
	    height -= bw * 2;
	    /* Widgets which grow too small are placed off screen */
	    if (width <= 0 || height <= 0)
	    {
		width = 1;
		height = 1;
		bw = 0;
		x = -1;
		y = -1;
	    }
	    XtConfigureWidget (w, x, y,
			      (Dimension)width, (Dimension)height,
			      (Dimension)bw);
	}
	break;
    case BoxBox:
	for (child = box->u.box.firstChild; child; child = child->nextSibling)
	{
	    SetSizes (child, x, y);
	    if (box->u.box.dir == LayoutHorizontal)
		x += child->size[LayoutHorizontal];
	    else
		y += child->size[LayoutVertical];
	}
	break;
    case GlueBox:
    case VariableBox:
	break;
    }
}

static void
LayoutFreeLayout (BoxPtr box)
{
    BoxPtr  child, next;

    switch (box->type) {
    case BoxBox:
	for (child = box->u.box.firstChild; child; child = next)
	{
	    next = child->nextSibling;
	    LayoutFreeLayout (child);
	}
	break;
    case GlueBox:
	DisposeExpr (box->u.glue.expr);
	break;
    case WidgetBox:
    case VariableBox:
    default:
	break;
    }
    DisposeExpr (box->params.stretch[LayoutHorizontal].expr);
    DisposeExpr (box->params.shrink[LayoutHorizontal].expr);
    DisposeExpr (box->params.stretch[LayoutVertical].expr);
    DisposeExpr (box->params.shrink[LayoutVertical].expr);
    Dispose (box);
}


static void
LayoutGetNaturalSize (LayoutWidget l, Dimension *widthp, Dimension *heightp)
{
    BoxPtr		box;

    DBUG_ENTER("LayoutGetNaturalSize");
    box = l->layout.layout;
    if (box)
    {
	ComputeNaturalSizes (l, box, LayoutHorizontal);
	*widthp = box->natural[LayoutHorizontal];
	*heightp = box->natural[LayoutVertical];
    }
    else
    {
	*widthp = 0;
	*heightp = 0;
    }
    DBUG_VOID_RETURN;
}

static void
LayoutLayout (LayoutWidget l, Bool attemptResize)
{
    BoxPtr		box;
    Dimension		width, height;
    Dimension		prefered_width, prefered_height;

    DBUG_ENTER("LayoutLayout");
    box = l->layout.layout;
    if (!box)
	return;
    LayoutGetNaturalSize (l, &prefered_width, &prefered_height);
    if (l->core.width == 0 || l->core.height == 0)
    {
	l->core.width = prefered_width;
	l->core.height = prefered_height;
    }
    box->size[LayoutHorizontal] = l->core.width;
    box->size[LayoutVertical] = l->core.height;
    if (!ComputeSizes (box) && attemptResize)
    {
	XtMakeResizeRequest ((Widget) l,
			    prefered_width, prefered_height,
			    &width, &height);
	if (width != box->size[LayoutHorizontal] ||
	    height != box->size[LayoutVertical])
	{
	    box->size[LayoutHorizontal] = width;
	    box->size[LayoutVertical] = height;
	    ComputeSizes (box);
	}
    }
    if (l->layout.debug)
    {
	PrintBox (box, 0);
	fflush (stdout);
    }
    SetSizes (box, 0, 0);
    DBUG_VOID_RETURN;
}

