/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

*/ 

/* 

 * HISTORY

*/ 

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: Form.c /main/19 1998/03/25 12:24:56 csn $"

#endif

#endif

/* (c) Copyright 1989, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/* (c) Copyright 1987, 1988, 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>		/* for abs, float operation... */

#endif

#include <Xm/DrawP.h>

#include <Xm/FormP.h>

#include <Xm/DialogS.h>

#include <Xm/VaSimpleP.h>

#include "XmI.h"

#include "MessagesI.h"

#include "RepTypeI.h"

#include "GeoUtilsI.h"

#include "GMUtilsI.h"

#define FIX_1299

#define MESSAGE1	_XmMMsgForm_0000

#define MESSAGE5	_XmMMsgForm_0002

#define MESSAGE7 	_XmMMsgForm_0003

/*  Useful macros  */

#define Value(a) (really ? (a)->value : (a)->tempValue)

#define AssignValue(a, v)  (really ? (a->value = (int) (v))\

			           : (a->tempValue = (int) (v)))

#define GetFormConstraint(w) \

	(&((XmFormConstraintPtr) (w)->core.constraints)->form)

#define NE(x) (oldc->x != newc->x)

#define ANY(x) (NE(att[LEFT].x) || NE(att[RIGHT].x) || \

		NE(att[TOP].x)  || NE(att[BOTTOM].x))

#define SIBLINGS(w,s)	(((w != NULL) && (s != NULL)) &&\

			 (XtParent(w) == XtParent(s)))

#ifdef FIX_1299

#define ATTACHED_WIDGET(cons, j) \

  (cons->att[j].w)

#define IS_ATTACHED_WIDGET(cons, j) \

  ((cons->att[j].type == XmATTACH_WIDGET || cons->att[j].type == XmATTACH_OPPOSITE_WIDGET) \

  && cons->att[j].w != (Widget) NULL)

#endif /* FIX_1299 */

/* convenient magic numbers */

#define MAX_LOOP 10000

#define LEFT	_XmFORM_LEFT

#define RIGHT	_XmFORM_RIGHT

#define TOP	_XmFORM_TOP

#define BOTTOM	_XmFORM_BOTTOM

#define FIRST_ATTACHMENT  LEFT

#define LAST_ATTACHMENT   BOTTOM	

/********    Static Function Declarations    ********/

static void FromTopOffset( 

                        Widget w,

                        int offset,

                        XtArgVal *value) ;

static void FromBottomOffset( 

                        Widget w,

                        int offset,

                        XtArgVal *value) ;

static void FromLeftOffset( 

                        Widget w,

                        int offset,

                        XtArgVal *value) ;

static void FromRightOffset( 

                        Widget w,

                        int offset,

                        XtArgVal *value) ;

static void MarginWidthOut( 

                        Widget wid,

                        int offset,

                        XtArgVal *value) ;

static void MarginHeightOut( 

                        Widget wid,

                        int offset,

                        XtArgVal *value) ;

static void ClassPartInitialize( 

                        WidgetClass wc) ;

static Boolean SyncEdges( 

                        XmFormWidget fw,

                        Widget last_child,

                        Dimension *form_width,

                        Dimension *form_height,

                        Widget instigator,

                        XtWidgetGeometry *geometry) ;

static Boolean CalcFormSizeWithChange( 

                        XmFormWidget fw,

                        Dimension *w,

                        Dimension *h,

                        Widget c,

                        XtWidgetGeometry *g) ;

static void CalcFormSize( 

                        XmFormWidget fw,

                        Dimension *w,

                        Dimension *h) ;

static XtGeometryResult GeometryManager( 

                        Widget w,

                        XtWidgetGeometry *desired,

                        XtWidgetGeometry *allowed) ;

static XtGeometryResult QueryGeometry( 

                        Widget wid,

                        XtWidgetGeometry *req,

                        XtWidgetGeometry *ret) ;

static void Resize( 

                        Widget wid) ;

static void Redisplay( 

                        Widget fw,

                        XEvent *event,

                        Region region) ;

#ifdef FIX_1299

static void UpdateAttachments(

                        XmFormWidget fw,

                        Widget wid,

                        Widget instigator,

                        XtWidgetGeometry* inst_geometry);

static void PlaceChild(

                        XmFormWidget fw,

                        Widget child,

                        Widget instigator,

                        XtWidgetGeometry* inst_geometry);

#endif /* FIX_1299 */

static void PlaceChildren( 

                        XmFormWidget fw,

                        Widget instigator,

                        XtWidgetGeometry *inst_geometry) ;

static void ChangeManaged( 

                        Widget wid) ;

static void GetSize( 

                        XmFormWidget fw,

		        XtWidgetGeometry *g,

                        Widget w,

                        XtWidgetGeometry *desired) ;

static void ChangeIfNeeded( 

                        XmFormWidget fw,

                        Widget w,

                        XtWidgetGeometry *desired) ;

static void DeleteChild( 

                        Widget child) ;

static Boolean SetValues( 

                        Widget cw,

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void SetValuesAlmost( 

                        Widget cw,

                        Widget nw,

                        XtWidgetGeometry *req,

                        XtWidgetGeometry *rep) ;

static Boolean ConstraintSetValues( 

                        register Widget old,

                        register Widget ref,

                        register Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void Initialize( 

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void ConstraintInitialize( 

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void CheckConstraints( 

                        Widget w) ;

static void SortChildren( 

                        register XmFormWidget fw) ;

static void CalcEdgeValues( 

                        Widget w,

#if NeedWidePrototypes

                        int really,

#else

                        Boolean really,

#endif /* NeedWidePrototypes */

                        Widget instigator,

                        XtWidgetGeometry *inst_geometry,

                        Dimension *form_width,

                        Dimension *form_height) ;

static float CheckBottomBase( 

                        Widget sibling,

#if NeedWidePrototypes

                        int opposite) ;

#else

                        Boolean opposite) ;

#endif /* NeedWidePrototypes */

static float CheckRightBase( 

                        Widget sibling,

#if NeedWidePrototypes

                        int opposite) ;

#else

                        Boolean opposite) ;

#endif /* NeedWidePrototypes */

static float CheckLeftBase( 

                        Widget sibling,

#if NeedWidePrototypes

                        int opposite) ;

#else

                        Boolean opposite) ;

#endif /* NeedWidePrototypes */

static void CalcEdgeValue( 

                        XmFormWidget fw,

                        Widget w,

#if NeedWidePrototypes

                        int size,

                        int border_width,

#else

                        Dimension size,

                        Dimension border_width,

#endif /* NeedWidePrototypes */

                        int which,

#if NeedWidePrototypes

                        int really,

#else

                        Boolean really,

#endif /* NeedWidePrototypes */

                        Dimension *fwidth,

                        Dimension *fheight) ;

static void ComputeAttachment( 

			XmFormWidget fw,

                        Widget w,

#if NeedWidePrototypes

                        int size,

                        int border_width,

#else

                        Dimension size,

                        Dimension border_width,

#endif /* NeedWidePrototypes */

                        int which,

#if NeedWidePrototypes

                        int really,

#else

                        Boolean really,

#endif /* NeedWidePrototypes */

                        Dimension *fwidth,

                        Dimension *fheight) ;

static int GetFormOffset( 

                        XmFormWidget fw,

                        int which,

                        XmFormAttachment a) ;

/********    End Static Function Declarations    ********/

static XtResource resources[] = 

{

   {

       XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension,

       sizeof(Dimension),

       XtOffsetOf( struct _XmFormRec, bulletin_board.margin_width),

       XmRImmediate, (XtPointer) XmINVALID_DIMENSION

   },

   {

       XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension,

       sizeof(Dimension),

       XtOffsetOf( struct _XmFormRec, bulletin_board.margin_height),

       XmRImmediate, (XtPointer) XmINVALID_DIMENSION

   },

   {

       XmNhorizontalSpacing, XmCSpacing, XmRHorizontalDimension,

       sizeof(Dimension),

       XtOffsetOf( struct _XmFormRec, form.horizontal_spacing), 

       XmRImmediate, (XtPointer) 0

   },

   {

       XmNverticalSpacing, XmCSpacing, XmRVerticalDimension,

       sizeof(Dimension),

       XtOffsetOf( struct _XmFormRec, form.vertical_spacing), 

       XmRImmediate, (XtPointer) 0

   },

   {

       XmNfractionBase, XmCMaxValue, XmRInt, sizeof(int),

       XtOffsetOf( struct _XmFormRec, form.fraction_base), 

       XmRImmediate, (XtPointer) 100

   },

   {

       XmNrubberPositioning, XmCRubberPositioning, XmRBoolean, 

       sizeof(Boolean),

       XtOffsetOf( struct _XmFormRec, form.rubber_positioning), 

       XmRImmediate, (XtPointer) False

   },

};

/*  Definition for resources that need special processing in get values  */

static XmSyntheticResource syn_resources[] =

{

   { XmNmarginWidth,

     sizeof (Dimension),

     XtOffsetOf( struct _XmFormRec, bulletin_board.margin_width), 

	 MarginWidthOut,

	 XmeToHorizontalPixels },

   { XmNmarginHeight,

     sizeof (Dimension),

     XtOffsetOf( struct _XmFormRec, bulletin_board.margin_height), 

	 MarginHeightOut,

	 XmeToVerticalPixels },

   { XmNhorizontalSpacing,

     sizeof (Dimension),

     XtOffsetOf( struct _XmFormRec, form.horizontal_spacing), 

     XmeFromHorizontalPixels,

	 XmeToHorizontalPixels },

   { XmNverticalSpacing,

     sizeof (Dimension),

     XtOffsetOf( struct _XmFormRec, form.vertical_spacing), 

     XmeFromVerticalPixels,

	 XmeToVerticalPixels },

};

/*  The constraint resource list  */

static XtResource constraints[] =

{

   {

      XmNtopAttachment, XmCAttachment, XmRAttachment, sizeof(unsigned char),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[TOP].type),

      XmRImmediate, (XtPointer) XmATTACH_NONE

   },

   {

      XmNbottomAttachment, XmCAttachment, XmRAttachment,

      sizeof(unsigned char),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[BOTTOM].type),

      XmRImmediate, (XtPointer) XmATTACH_NONE

   },

   {

      XmNleftAttachment, XmCAttachment, XmRAttachment,

      sizeof(unsigned char),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[LEFT].type),

      XmRImmediate, (XtPointer) XmATTACH_NONE

   },

   {

      XmNrightAttachment, XmCAttachment, XmRAttachment,

      sizeof(unsigned char),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[RIGHT].type),

      XmRImmediate, (XtPointer) XmATTACH_NONE

   },

   {

      XmNtopWidget, XmCWidget, XmRWidget, sizeof(Widget),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[TOP].w),

      XmRImmediate, (XtPointer) NULL

   },

   {

      XmNbottomWidget, XmCWidget, XmRWidget, sizeof(Widget),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[BOTTOM].w),

      XmRImmediate, (XtPointer) NULL

   },

   {

      XmNleftWidget, XmCWidget, XmRWidget, sizeof(Widget),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[LEFT].w),

      XmRImmediate, (XtPointer) NULL

   },

   {

      XmNrightWidget, XmCWidget, XmRWidget, sizeof(Widget),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[RIGHT].w),

      XmRImmediate, (XtPointer) NULL

   },

   {

      XmNtopPosition, XmCPosition, XmRInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[TOP].percent),

      XmRImmediate, (XtPointer) 0

   },

   {

      XmNbottomPosition, XmCPosition, XmRInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[BOTTOM].percent),

      XmRImmediate, (XtPointer) 0

   },

   {

      XmNleftPosition, XmCPosition, XmRInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[LEFT].percent),

      XmRImmediate, (XtPointer) 0

   },

   {

      XmNrightPosition, XmCPosition, XmRInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[RIGHT].percent),

      XmRImmediate, (XtPointer) 0

   },

   {

      XmNtopOffset, XmCOffset, XmRVerticalInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[TOP].offset),

      XmRImmediate, (XtPointer) XmINVALID_DIMENSION

   },

   {

      XmNbottomOffset, XmCOffset, XmRVerticalInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[BOTTOM].offset),

      XmRImmediate, (XtPointer) XmINVALID_DIMENSION

   },

   {

      XmNleftOffset, XmCOffset, XmRHorizontalInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[LEFT].offset),

      XmRImmediate, (XtPointer) XmINVALID_DIMENSION

   },

   {

      XmNrightOffset, XmCOffset, XmRHorizontalInt, sizeof(int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[RIGHT].offset),

      XmRImmediate, (XtPointer) XmINVALID_DIMENSION

   },

   {

      XmNresizable, XmCBoolean, XmRBoolean, sizeof(Boolean),

      XtOffsetOf( struct _XmFormConstraintRec, form.resizable),

      XmRImmediate, (XtPointer) True

   }

};

/*  Definition for constraint resources that need special  */

/*  processing in get values                               */

static XmSyntheticResource syn_constraint_resources[] =

{

   { XmNtopOffset,

     sizeof (int),

     XtOffsetOf( struct _XmFormConstraintRec, form.att[TOP].offset),

     FromTopOffset,

	 XmeToVerticalPixels },

   {  XmNbottomOffset,

      sizeof (int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[BOTTOM].offset),

     FromBottomOffset,

	 XmeToVerticalPixels },

   {  XmNleftOffset,

      sizeof (int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[LEFT].offset),

     FromLeftOffset,

	 XmeToHorizontalPixels },

   {  XmNrightOffset,

      sizeof (int),

      XtOffsetOf( struct _XmFormConstraintRec, form.att[RIGHT].offset),

     FromRightOffset,

	 XmeToHorizontalPixels },

};

/*  Static initialization of the attached dialog box widget class record.  */

externaldef(xmformclassrec) XmFormClassRec xmFormClassRec =

{

   {                    /* core_class fields    */

      (WidgetClass) &xmBulletinBoardClassRec,   /* superclass   */

      "XmForm",                 /* class_name           */

      sizeof(XmFormRec),        /* widget_size          */

      (XtProc)NULL,             /* class_initialize */

      ClassPartInitialize,      /* class init part proc */

      False,                    /* class_inited         */

      Initialize,               /* initialize           */

      (XtArgsProc)NULL,         /* initialize_notify    */

      XtInheritRealize,         /* realize              */

      NULL,                     /* actions              */

      0,                        /* num_actions          */

      resources,                /* resources            */

      XtNumber(resources),      /* num_resources        */

      NULLQUARK,                /* xrm_class            */

      True,                     /* compress_motion  */

      XtExposeCompressMaximal,  /* compress_exposure    */

      False,                    /* compress_enterleave  */

      False,                    /* visible_interest     */

      (XtWidgetProc)NULL,       /* destroy              */

      Resize,                   /* resize               */

      Redisplay,                /* expose               */

      SetValues,                /* set_values           */

      (XtArgsFunc)NULL,         /* set_values_hook      */

      SetValuesAlmost,          /* set_values_almost    */

      (XtArgsProc)NULL,         /* get_values_hook      */

      (XtAcceptFocusProc)NULL,  /* accept_focus         */

      XtVersion,                /* version      */

      NULL,                     /* callback_private */

      XtInheritTranslations,    /* tm_table             */

      QueryGeometry,            /* Query Geometry proc  */

      (XtStringProc)NULL,       /* disp accelerator     */

      NULL,                     /* extension            */    

   },

   {                    /* composite_class fields */

      GeometryManager,      /* geometry_manager       */

      ChangeManaged,        /* change_managed         */

      XtInheritInsertChild, /* insert_child           */

      DeleteChild,          /* delete_child           */

      NULL,                 /* extension              */

   },

   {                    /* constraint_class fields */

      constraints,                  /* constraint resource     */

      XtNumber(constraints),        /* number of constraints   */

      sizeof(XmFormConstraintRec),  /* size of constraint      */

      ConstraintInitialize,         /* initialization          */

      (XtWidgetProc)NULL,           /* destroy proc            */

      ConstraintSetValues,          /* set_values proc         */

      NULL,                         /* extension               */

   },

   {                        /* manager_class fields   */

      XtInheritTranslations,                /* translations           */

      syn_resources,                        /* syn_resources          */

      XtNumber(syn_resources),              /* num_syn_resources      */

      syn_constraint_resources,             /* syn_cont_resources     */

      XtNumber(syn_constraint_resources),   /* num_syn_cont_resources */

      XmInheritParentProcess,               /* parent_process         */

      NULL,                                 /* extension              */

   },

   {                        /* bulletin_board_class fields */

      FALSE,                                /* always_install_accelerators */

      (XmGeoCreateProc)NULL,                /* geo_matrix_create  */

      XmInheritFocusMovedProc,              /* focus_moved_proc   */

      NULL,                                 /* extension          */

   },

   {                        /* form_class fields  */

      (XtPointer) NULL,                     /* extension          */

   }

};

externaldef(xmformwidgetclass) WidgetClass 

	xmFormWidgetClass = (WidgetClass) &xmFormClassRec;

static void

FromTopOffset(

	Widget w,

	int offset,

	XtArgVal *value)

{

    XmFormWidget fw = (XmFormWidget) w->core.parent;

    XmFormConstraint fc = GetFormConstraint(w);

    *value = (XtArgVal) GetFormOffset(fw, TOP, fc->att);

    XmeFromVerticalPixels(w, offset, value);

}

static void

FromBottomOffset(

	Widget w,

	int offset,

	XtArgVal *value)

{

    XmFormWidget fw = (XmFormWidget) w->core.parent;

    XmFormConstraint fc = GetFormConstraint(w);

    *value = (XtArgVal) GetFormOffset(fw, BOTTOM, fc->att);

    XmeFromVerticalPixels(w, offset, value);

}

static void

FromLeftOffset(

	Widget w,

	int offset,

	XtArgVal *value)

{

    XmFormWidget fw = (XmFormWidget) w->core.parent;

    XmFormConstraint fc = GetFormConstraint(w);

    *value = (XtArgVal) GetFormOffset(fw, LEFT, fc->att);

    XmeFromHorizontalPixels(w, offset, value);

}

static void

FromRightOffset(

	Widget w,

	int offset,

	XtArgVal *value)

{

    XmFormWidget fw = (XmFormWidget) w->core.parent;

    XmFormConstraint fc = GetFormConstraint(w);

    *value = (XtArgVal) GetFormOffset(fw, RIGHT, fc->att);

    XmeFromHorizontalPixels(w, offset, value);

}

static void 

MarginWidthOut(

        Widget wid,

        int offset,

        XtArgVal *value )

{

        XmFormWidget fw = (XmFormWidget) wid ;

	if (fw->bulletin_board.margin_width == XmINVALID_DIMENSION)

		*value = 0;

	else

		XmeFromHorizontalPixels((Widget) fw, offset, value);

}

static void 

MarginHeightOut(

        Widget wid,

        int offset,

        XtArgVal *value )

{

        XmFormWidget fw = (XmFormWidget) wid ;

	if (fw->bulletin_board.margin_height == XmINVALID_DIMENSION)

		*value = 0;

	else

		XmeFromVerticalPixels((Widget) fw, offset, value);

}

/************************************************************************

 *

 *  ClassPartInitialize

 *	Set up the fast subclassing.

 *

 ************************************************************************/

static void 

ClassPartInitialize(

        WidgetClass wc )

{

   _XmFastSubclassInit (wc, XmFORM_BIT);

}

/************************************************************************

 *

 *  CalcFormSizeWithChange

 *	Find size of a bounding box which will include all of the 

 *	children, including the child which may change

 *

 ************************************************************************/

static Boolean 

SyncEdges(

        XmFormWidget fw,

        Widget last_child,

        Dimension *form_width,

        Dimension *form_height,

        Widget instigator,

        XtWidgetGeometry *geometry )

{

	register Widget child;

	register XmFormConstraint c;

	long int loop_count;

	Dimension tmp_w = *form_width, tmp_h = *form_height;

	Dimension sav_w, sav_h;

	Boolean settled = FALSE;

	Boolean finished = TRUE;

	sav_w = tmp_w;

	sav_h = tmp_h;

	loop_count = 0;

	while (!settled)

	{

		/*

		 * Contradictory constraints can cause the constraint

		 * processing to go into endless oscillation.  This means that

		 * proper exit condition for this loop is never satisfied.

		 * But, infinite loops are a bad thing, even if is the result

		 * of a careless user.  We therefore have added a loop counter

		 * to ensure that this loop will terminate.

		 *

		 * There are problems with this however.  In the worst case

		 * this procedure could need to loop fw->composite.num_children!

		 * times.  Unfortunately, numbers like 100! don't fit integer

		 * space well; neither will current architectures complete that

		 * many loops before the sun burns out.

		 *

		 * Soooo, we will wait for an arbitrarily large number of

		 * iterations to go by before we give up.  This allows us to

		 * claim that the procedure will always complete, and the number

		 * is large enough to accomodate all but the very large and

		 * very pathological Form widget configurations.

		 *

		 * This is gross, but it's either do this or risk truly

		 * infinite loops.

		 */

		if (loop_count++ > MAX_LOOP)

			break;

		for (child = fw->form.first_child;

			child != NULL;

			child = c->next_sibling) 

		{

			if (!XtIsManaged (child))

				break;

			c = GetFormConstraint(child);

			CalcEdgeValues(child, FALSE, instigator, geometry, 

				&tmp_w, &tmp_h);

			if (child == last_child)

				break;

		}

		if ((sav_w == tmp_w) && (sav_h == tmp_h))

			settled = TRUE;

		else

		{

			sav_w = tmp_w;

			sav_h = tmp_h;

		}

	}

	if (loop_count > MAX_LOOP)

	{

		XmeWarning( (Widget) fw, MESSAGE7);

		finished = FALSE;

	}

	*form_width = sav_w;

	*form_height = sav_h;

	return(finished);

}

static Boolean 

CalcFormSizeWithChange(

        XmFormWidget fw,

        Dimension *w,

        Dimension *h,

        Widget c,

        XtWidgetGeometry *g )

{

	Dimension junkh = fw->core.height;

	Dimension junkw = fw->core.width;

	Widget child;

	XmFormConstraint fc;

	int tmp;

	if (h == NULL) h = &junkh;

	if (w == NULL) w = &junkw;

	/* Place children, but don't do it for real--just get new size */

	for(child = fw->form.first_child; 

		child != NULL;

		child = fc->next_sibling)

	{

		if (!XtIsManaged (child))

			break;

		fc = GetFormConstraint(child);

		CalcEdgeValues(child, False, c, g, w, h);

		if (!SyncEdges(fw, child, w, h, c, g))

			return(False);

	}

	for(child = fw->form.first_child; 

		child != NULL;

		child = fc->next_sibling)

	{

		if (!XtIsManaged (child)) 

			break;

		fc = GetFormConstraint(child);

		tmp = fc->att[RIGHT].tempValue;

		if (fc->att[RIGHT].type == XmATTACH_FORM)

			tmp += GetFormOffset(fw, RIGHT, fc->att);

		if (tmp > 0) 

			ASSIGN_MAX(*w, tmp);

		tmp = fc->att[BOTTOM].tempValue ;

		if (fc->att[BOTTOM].type == XmATTACH_FORM)

			tmp += GetFormOffset(fw, BOTTOM, fc->att);

		if (tmp > 0) 

			ASSIGN_MAX (*h, tmp);

	}

	if (!(*w))

		*w = 1;

	if (!(*h))

		*h = 1;

	if (*w != XtWidth(fw) || *h != XtHeight(fw)) 

		return True;

	else

		return False;

}

/************************************************************************

 *

 *  CalcFormSize

 *	Find size of a bounding box which will include all of the children.

 *

 ************************************************************************/

static void 

CalcFormSize(

        XmFormWidget fw,

        Dimension *w,

        Dimension *h )

{

	Widget child;

	Dimension junkh = fw->core.height;

	Dimension junkw = fw->core.width;

	XmFormConstraint fc;

	int tmp;

	if (h == NULL) h = &junkh;

	if (w == NULL) w = &junkw;

	for (child = fw->form.first_child;

		child != NULL;

		child = fc->next_sibling)

	{

		if (!XtIsManaged (child))

			break;