/* 

 * 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[] = "$XConsortium: Frame.c /main/18 1996/10/15 15:01:45 cde-osf $"

#endif

#endif

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

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <Xm/DrawP.h>

#include <Xm/FrameP.h>

#include <Xm/GadgetP.h>

#include <Xm/VaSimpleP.h>

#include "GMUtilsI.h"

#include "RepTypeI.h"

#include "XmI.h"

#define GetFrameConstraint(w) \

        (&((XmFrameConstraintPtr) (w)->core.constraints)->frame)

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

static void CheckSetChildType(Widget wid, 

			      int offset, 

			      XrmValue *value); 

static void DrawShadow(

                        XmFrameWidget fw) ;

static void ClearShadow(

                        XmFrameWidget fw) ;

static void ConfigureChildren(

                        XmFrameWidget fw,

			Widget instigator,

			XtWidgetGeometry *inst_desired) ;

static void ClassPartInitialize( 

                        WidgetClass wc) ;

static void Initialize( 

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void Resize( 

                        Widget wid) ;

static void Redisplay( 

                        Widget wid,

                        XEvent *event,

                        Region region) ;

static XtGeometryResult GeometryManager( 

                        Widget w,

                        XtWidgetGeometry *request,

                        XtWidgetGeometry *reply) ;

static void ChangeManaged( 

                        Widget wid) ;

static Boolean SetValues( 

                        Widget cw,

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static XtGeometryResult QueryGeometry( 

                        Widget wid,

                        XtWidgetGeometry *request,

                        XtWidgetGeometry *ret) ;

static void CalcFrameSize( 

                        XmFrameWidget fw,

#if NeedWidePrototypes

                        int titleWidth,

                        int titleHeight,

                        int titleBorder,

                        int workWidth,

                        int workHeight,

                        int workBorder,

#else

                        Dimension titleWidth,

                        Dimension titleHeight,

                        Dimension titleBorder,

                        Dimension workWidth,

                        Dimension workHeight,

                        Dimension workBorder,

#endif /* NeedWidePrototypes */

                        Dimension *fwWidth,

                        Dimension *fwHeight) ;

static void CalcWorkAreaSize( 

                        XmFrameWidget fw,

                        Dimension *workWidth,

                        Dimension *workHeight,

#if NeedWidePrototypes

                        int workBorder,

                        int fwWidth,

                        int fwHeight) ;

#else

                        Dimension workBorder,

                        Dimension fwWidth,

                        Dimension fwHeight) ;

#endif /* NeedWidePrototypes */

static void CalcTitleExtent(

                        XmFrameWidget fw,

#if NeedWidePrototypes

                        int titleHeight,

                        int titleBorder,

#else

                        Dimension titleHeight,

                        Dimension titleBorder,

#endif /* NeedWidePrototypes */

			Dimension *titleExtent,

			Position *titleY,

			Dimension *shadowWidth,

			Position *shadowY) ;

static void ConstraintInitialize(

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static Boolean ConstraintSetValues(

                        Widget cw,

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void ConstraintDestroy(

			Widget w) ;

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

static XmSyntheticResource syn_resources[] = 

{

   {  XmNmarginWidth, 

      sizeof (Dimension),

      XtOffsetOf( struct _XmFrameRec, frame.margin_width),

      XmeFromHorizontalPixels,

      XmeToHorizontalPixels },

   {  XmNmarginHeight, 

      sizeof (Dimension),

      XtOffsetOf( struct _XmFrameRec, frame.margin_height),

      XmeFromVerticalPixels,

      XmeToVerticalPixels, }

};

static XtResource resources[] =

{

   {  XmNmarginWidth, 

      XmCMarginWidth, 

      XmRHorizontalDimension, 

      sizeof (Dimension),

      XtOffsetOf( struct _XmFrameRec, frame.margin_width),

      XmRImmediate, (XtPointer) 0 },

   {  XmNmarginHeight, 

      XmCMarginHeight, 

      XmRVerticalDimension,

      sizeof (Dimension),

      XtOffsetOf( struct _XmFrameRec, frame.margin_height),

      XmRImmediate, (XtPointer) 0 },

   {  XmNshadowType,

      XmCShadowType,

      XmRShadowType,

      sizeof (unsigned char),

      XtOffsetOf( struct _XmFrameRec, frame.shadow_type),

      XmRImmediate, (XtPointer) XmINVALID_DIMENSION },

   {  XmNshadowThickness,

      XmCShadowThickness,

      XmRHorizontalDimension,

      sizeof (Dimension),

      XtOffsetOf( struct _XmFrameRec, manager.shadow_thickness),

      XmRImmediate, (XtPointer) XmINVALID_DIMENSION }

};

static XmSyntheticResource syn_constraints[] =

{

   {  XmNchildHorizontalSpacing, sizeof (Dimension),

      XtOffsetOf( struct _XmFrameConstraintRec, frame.child_h_spacing),

      XmeFromHorizontalPixels, XmeToHorizontalPixels }

};

static XtResource constraints[] =

{

   {  "pri.vate", "Pri.vate", XmRInt,

      sizeof (int),

      XtOffsetOf( struct _XmFrameConstraintRec, frame.unused),

      XmRImmediate, (XtPointer) 0 },

   {  XmNchildType, XmCChildType, XmRChildType,

      sizeof (unsigned char),

      XtOffsetOf( struct _XmFrameConstraintRec, frame.child_type),

      XmRCallProc, (XtPointer) CheckSetChildType },

   /* add a dup in 2.0 with new local names */

   {  XmNframeChildType, XmCFrameChildType, XmRChildType,

      sizeof (unsigned char),

      XtOffsetOf( struct _XmFrameConstraintRec, frame.child_type),

      XmRCallProc, (XtPointer) CheckSetChildType },

   {  XmNchildHorizontalAlignment, XmCChildHorizontalAlignment,

      XmRChildHorizontalAlignment,

      sizeof (unsigned char),

      XtOffsetOf( struct _XmFrameConstraintRec, frame.child_h_alignment),

      XmRImmediate, (XtPointer) XmALIGNMENT_BEGINNING },

   {  XmNchildVerticalAlignment, XmCChildVerticalAlignment,

      XmRChildVerticalAlignment,

      sizeof (unsigned char),

      XtOffsetOf( struct _XmFrameConstraintRec, frame.child_v_alignment),

      XmRImmediate, (XtPointer) XmALIGNMENT_CENTER   },

   {  XmNchildHorizontalSpacing, XmCChildHorizontalSpacing,

      XmRHorizontalDimension, sizeof (Dimension),

      XtOffsetOf( struct _XmFrameConstraintRec, frame.child_h_spacing),

      XmRImmediate, (XtPointer) XmINVALID_DIMENSION}

};

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

 *

 * Full class record constant

 *

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

externaldef(xmframeclassrec) XmFrameClassRec xmFrameClassRec = 

{

   {			/* core_class fields      */

      (WidgetClass) &xmManagerClassRec,		/* superclass         */

      "XmFrame",				/* class_name         */

      sizeof(XmFrameRec),			/* widget_size        */

      NULL,					/* class_initialize   */

      ClassPartInitialize,			/* class_part_init    */

      FALSE,					/* class_inited       */

      Initialize,       			/* initialize         */

      NULL,					/* initialize_hook    */

      XtInheritRealize,				/* realize            */

      NULL,					/* actions	      */

      0,					/* num_actions	      */

      resources,				/* resources          */

      XtNumber(resources),			/* num_resources      */

      NULLQUARK,				/* xrm_class          */

      TRUE,					/* compress_motion    */

      XtExposeCompressMaximal,	                /* compress_exposure  */

      TRUE,					/* compress_enterlv   */

      FALSE,					/* visible_interest   */

      NULL,					/* destroy            */

      Resize,			                /* resize             */

      Redisplay,		    	        /* expose             */

      SetValues,                		/* set_values         */

      NULL,					/* set_values_hook    */

      XtInheritSetValuesAlmost,			/* set_values_almost  */

      NULL,					/* get_values_hook    */

      NULL,					/* accept_focus       */

      XtVersion,				/* version            */

      NULL,					/* callback_private   */

      XtInheritTranslations,			/* tm_table           */

      QueryGeometry,	                        /* query_geometry     */

      NULL,                                     /* display_accelerator   */

      NULL,                                     /* extension             */

   },

   {		/* composite_class fields */

      GeometryManager,    	                /* geometry_manager   */

      ChangeManaged,		                /* change_managed     */

      XtInheritInsertChild,		        /* insert_child       */

      XtInheritDeleteChild,			/* delete_child       */

      NULL,                                     /* extension          */

   },

   {		/* constraint_class fields */

      constraints,				/* resource list        */   

      XtNumber(constraints),			/* num resources        */   

      sizeof (XmFrameConstraintRec),            /* constraint size      */   

      ConstraintInitialize,			/* init proc            */   

      ConstraintDestroy,			/* destroy proc         */   

      ConstraintSetValues,			/* set values proc      */   

      NULL,                                     /* extension            */

   },

   {						/* manager class     */

      XtInheritTranslations,			/* translations      */

      syn_resources,				/* syn resources      	  */

      XtNumber(syn_resources),			/* num syn_resources 	  */

      syn_constraints,				/* get_cont_resources     */

      XtNumber(syn_constraints),		/* num_get_cont_resources */

      XmInheritParentProcess,                   /* parent_process         */

      NULL,					/* extension         */    

   },

   {						/* frame class       */

      NULL,					/* extension         */    

   }	

};

externaldef(xmframewidgetclass) WidgetClass xmFrameWidgetClass =

			                        (WidgetClass) &xmFrameClassRec;

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

 *

 *  CheckSetChildType

 *	default proc for the new childType resource.

 *      if this is called and child_type is INVALID, childType was

 *      not set, so default it, otherwise child_type was set and this

 *      one is not, so don't change it.

 *

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

/*ARGSUSED*/

static void 

CheckSetChildType(Widget wid,

		    int offset,

		    XrmValue *value)

{

    XmFrameConstraint fc = GetFrameConstraint(wid);

    static unsigned char child_type = XmFRAME_WORKAREA_CHILD ;

    if (fc->unused) /* Been here already, so default it .. */

	value->addr = (XPointer) &child_type;

    else {

	value->addr = (XPointer) &(fc->child_type);

	fc->unused = 1;

    }

}

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

 *

 *  DrawShadow

 *	Draw the Frame shadow

 *

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

static void

DrawShadow(

        XmFrameWidget fw )

{

   if (XtIsRealized((Widget)fw)) {

       XmeDrawShadows(XtDisplay (fw), XtWindow (fw),

		fw->manager.top_shadow_GC, fw->manager.bottom_shadow_GC,

		fw->frame.old_shadow_x, fw->frame.old_shadow_y,

		fw->frame.old_width, fw->frame.old_height,

		fw->frame.old_shadow_thickness, fw->frame.shadow_type);

   }

}

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

 *

 *  ClearShadow

 *	Erase the Frame shadow

 *

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

static void

ClearShadow(

        XmFrameWidget fw )

{

   if (XtIsRealized((Widget)fw)) {

	XmeClearBorder (XtDisplay(fw), XtWindow(fw),

		      fw->frame.old_shadow_x,

		      fw->frame.old_shadow_y, 

		      fw->frame.old_width, 

		      fw->frame.old_height,

		      fw->frame.old_shadow_thickness);

    }

}

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

 *

 *  ConfigureChildren

 *	Configure the title and work area if they aren't instigaror

 *      of the request (Yes policy). Compute the shadow location.

 *

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

static void 

ConfigureChildren(

	XmFrameWidget fw,

	Widget instigator,

	XtWidgetGeometry * inst_geometry)

{

    Widget child;

    XmFrameConstraint fc;

    Position childX = 0;

    Position childY;

    Dimension childWidth;

    Dimension childHeight;

    Dimension childBW;

    Dimension shadowThickness = fw->manager.shadow_thickness;

    Dimension titleExtent = shadowThickness;

    Dimension shadowHeight = fw->core.height;

    Position shadowY = 0;

    XtWidgetGeometry title_reply;

    Dimension spacing;

    if (fw->frame.title_area && XtIsManaged(fw->frame.title_area)) {

	child = fw->frame.title_area;

	fc = GetFrameConstraint(child);

	spacing = shadowThickness + fc->child_h_spacing;

	/* asking the preferred geometry without constraint */

	XtQueryGeometry (child, NULL, &title_reply);

	childWidth = (title_reply.request_mode & CWWidth) ?

			title_reply.width : child->core.width;

	childHeight = (title_reply.request_mode & CWHeight) ?

			title_reply.height : child->core.height;

	childBW = child->core.border_width;

	if (child == instigator) {

	    childWidth = (inst_geometry->request_mode & CWWidth) ?

			inst_geometry->width : childWidth;

	    childHeight = (inst_geometry->request_mode & CWHeight) ?

			inst_geometry->height : childHeight;

	    childBW = (inst_geometry->request_mode & CWBorderWidth) ?

			inst_geometry->border_width : childBW;

	}

	if (childWidth + 2 * (spacing + childBW) > fw->core.width) {

	    if (fw->core.width > 2 * (spacing + childBW))

		childWidth = fw->core.width - 2 * (spacing + childBW);

	    else

		childWidth = 1;

	}

	switch (fc->child_h_alignment) {

	    case(XmALIGNMENT_BEGINNING):

		if (LayoutIsRtoLM(fw))

		    childX = fw->core.width - spacing -

				childWidth - 2 * childBW;

		else

		    childX = spacing;

		break;

	    case(XmALIGNMENT_CENTER):

		childX = fw->core.width/2 - childWidth/2 - childBW;

	        break;

	    case(XmALIGNMENT_END):

	    default:

		if (LayoutIsRtoLM(fw))

		    childX = spacing;

		else

		    childX = fw->core.width - spacing -

				childWidth - 2 * childBW;

		break;

	}

	CalcTitleExtent (fw, childHeight, childBW,

				&titleExtent, &childY, &shadowHeight, &shadowY);

	if (child != instigator) {

	    XmeConfigureObject (child, childX, childY, childWidth,

				childHeight, childBW);

	}

	else {

	    /* Do not resize the instigator, just return GeometryYes */

	    inst_geometry->request_mode = CWX | CWY | CWWidth | CWHeight |

						CWBorderWidth;

	    child->core.x = childX; 

	    child->core.y = childY; 

	    child->core.width = childWidth; 

	    child->core.height = childHeight; 

	    child->core.border_width = childBW;

	}

    }

    if (fw->frame.work_area  && XtIsManaged(fw->frame.work_area)) {

	child = fw -> frame.work_area;

	if (child != instigator)

	    childBW = child->core.border_width;

	else

	    childBW = (inst_geometry->request_mode & CWBorderWidth) ?

		    inst_geometry->border_width : child->core.border_width;

	CalcWorkAreaSize (fw, &childWidth, &childHeight, childBW,

			      fw->core.width, fw->core.height);

	childX = shadowThickness + fw->frame.margin_width;

	childY = titleExtent + fw->frame.margin_height;

	if (child != instigator) {

	    XmeConfigureObject (child, childX, childY, childWidth, childHeight,

				childBW);

	}

	else {

	    /* Do not resize the instigator, just return GeometryYes */

	    inst_geometry->request_mode = CWX | CWY | CWWidth | CWHeight |

						CWBorderWidth;

	    child->core.x = childX; 

	    child->core.y = childY; 

	    child->core.width = childWidth; 

	    child->core.height = childHeight; 

	    child->core.border_width = childBW;

	}   

    }

    fw->frame.old_shadow_x = 0;

    fw->frame.old_shadow_y = shadowY;

    fw->frame.old_width = fw->core.width;

    fw->frame.old_height = shadowHeight;

    fw->frame.old_shadow_thickness = shadowThickness;

}

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

 *

 *  ClassPartInitialize

 *     Set up the fast subclassing for the widget

 *

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

static void 

ClassPartInitialize(

        WidgetClass wc )

{

   _XmFastSubclassInit (wc, XmFRAME_BIT);

}

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

 *

 *  Initialize

 *	Ensure that the width and height are not 0.

 *

 *************************************<->***********************************/

/*ARGSUSED*/

static void 

Initialize(

        Widget rw,

        Widget nw,

        ArgList args,		/* unused */

        Cardinal *num_args )	/* unused */

{

   XmFrameWidget request = (XmFrameWidget) rw ;

   XmFrameWidget new_w = (XmFrameWidget) nw;

   new_w->frame.title_area = NULL;

   new_w->frame.work_area = NULL;

   new_w->frame.processing_constraints = False;

   if (new_w->frame.shadow_type == (unsigned char) XmINVALID_DIMENSION)

   {

      if (XtIsShell (XtParent(new_w)))

      {

         new_w->frame.shadow_type = XmSHADOW_OUT;

      }

      else

      {

         new_w->frame.shadow_type = XmSHADOW_ETCHED_IN;

      }

  }

   if (!XmRepTypeValidValue( XmRID_SHADOW_TYPE, new_w->frame.shadow_type,

			(Widget) new_w))

   {

      new_w->frame.shadow_type = XmSHADOW_ETCHED_IN;

   }

   if (request->manager.shadow_thickness == XmINVALID_DIMENSION)

   {

      if (XtIsShell (XtParent(new_w)))

      {

         new_w->manager.shadow_thickness = 1;

     }

      else

      {

         new_w->manager.shadow_thickness = 2;

     }

  }

   new_w->frame.old_shadow_x = 0;

   new_w->frame.old_shadow_y = 0;

   new_w->frame.old_width = new_w->core.width;

   new_w->frame.old_height = new_w->core.height;

   new_w->frame.old_shadow_thickness = new_w->manager.shadow_thickness;

}

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

 *

 *  Resize 

 *  	Calculate the size of the children and resize.

 *

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

static void 

Resize(

        Widget wid )

{

   XmFrameWidget fw = (XmFrameWidget) wid ;

   ClearShadow(fw);

   ConfigureChildren(fw, NULL, NULL);

   DrawShadow(fw);

}

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

 *

 *  Redisplay

 *     General redisplay function called on exposure events.

 *

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

static void 

Redisplay(

        Widget wid,

        XEvent *event,

        Region region )

{

   XmFrameWidget fw = (XmFrameWidget) wid;

   Widget title_area = fw->frame.title_area;

   DrawShadow(fw);

   /* since the shadow may have screw up the gadget title, while this

      one won't get refresh, we have to redraw it manually */

   if (title_area && XmIsGadget(title_area) && XtIsManaged(title_area))

   {

      XClearArea (XtDisplay(fw), XtWindow(fw),

		  title_area->core.x, title_area->core.y,

		  title_area->core.width, title_area->core.height,

		  False);

      if (region && !XRectInRegion (region, title_area->core.x,

	title_area->core.y, title_area->core.width, title_area->core.height))

      {

	 XtExposeProc expose;

	 _XmProcessLock();

	 expose = title_area->core.widget_class->core_class.expose;

	 _XmProcessUnlock();

         if (expose)

	    (*expose)(title_area, event, NULL);

      }

   }

   XmeRedisplayGadgets( (Widget) fw, event, region);

}

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

 *

 *  Geometry Manager

 *	Take the requested geometry, calculate the needed size for

 *	the frame and make a request to the frames parent.

 *      Requests to change x, y position are always denied.

 *

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

static XtGeometryResult 

GeometryManager(

        Widget w,

        XtWidgetGeometry *request,

        XtWidgetGeometry *reply )

{

   XmFrameWidget fw = (XmFrameWidget) XtParent(w);

   Widget title_area = fw->frame.title_area;

   Widget work_area = fw->frame.work_area;

   Dimension req_width, req_height, req_bw;

   Boolean query_only = False;

   Boolean almost = False;

   Dimension title_width = (title_area)?title_area->core.width:0;

   Dimension title_height = (title_area)?title_area->core.height:0;

   Dimension title_bw = (title_area)?title_area->core.border_width:0;

   Dimension work_width = (work_area)?work_area->core.width:0;

   Dimension work_height = (work_area)?work_area->core.height:0;

   Dimension work_bw = (work_area)?work_area->core.border_width:0;

   Dimension frame_width, frame_height;

   XtWidgetGeometry parent_request;

   XtWidgetGeometry parent_reply;

   Dimension almost_width;

   Dimension almost_height;

   if (fw->frame.processing_constraints)

   {

      fw->frame.processing_constraints = False;

      request -> border_width -= 1;

   }

   /*  Set up the calculation variables according to the  */

   /*  contents of the requested geometry.                */

   if (request -> request_mode & XtCWQueryOnly)

      query_only = True;

   if ((request -> request_mode & CWX) || (request -> request_mode & CWY))

      almost = True;

   if (request -> request_mode & CWWidth) req_width = request -> width;

   else req_width = w -> core.width;

   if (request -> request_mode & CWHeight) req_height = request -> height;

   else req_height = w -> core.height;

   if (request -> request_mode & CWBorderWidth)

       req_bw = request -> border_width;

   else req_bw = w -> core.border_width;

   if (w == title_area)

   {

      title_width = req_width;

      title_height = req_height;

      title_bw = req_bw;

   }

   if (w == work_area)

   {

      work_width = req_width;

      work_height = req_height;

      work_bw = req_bw;

   }

   /* find the frame size based on the children preferred geometry */

   CalcFrameSize (fw, title_width, title_height, title_bw,

		  work_width, work_height, work_bw,

		  &frame_width, &frame_height);

   parent_request.request_mode = CWWidth | CWHeight;

   if (almost || query_only) parent_request.request_mode |= XtCWQueryOnly;

   parent_request.width = frame_width;

   parent_request.height = frame_height;

   switch (XtMakeGeometryRequest ((Widget)fw, 

				  &parent_request, &parent_reply)) {

   case XtGeometryYes:

       if (!almost) {

	   if (!query_only) {

	       ClearShadow(fw);

	       ConfigureChildren(fw, w, request);

	       DrawShadow(fw);

	   }

	   return (XtGeometryYes);

         } else {

	     almost_width = request->width;

	     almost_height = request->height;

	 }

       break;

   case XtGeometryNo:

	 if (w == title_area) { 

	     /* we got a No, try to honor the title request anyway,

	        by resizing the work_area child */

	     if (!almost) {

		 if (!query_only) {

		     ClearShadow(fw);

		     ConfigureChildren(fw, w, request);

		     DrawShadow(fw);

		 }

		 return (XtGeometryYes);

	     } else {

		 almost_width = request->width;

		 almost_height = request->height;

	     }

	 } else return (XtGeometryNo);

         break;

   case XtGeometryAlmost:

	 if (w == title_area) {

	     /* we got an Almost, try to honor the title request anyway,

	        by accepting the deal and resizing the work_area child */

	     if (!almost) {

		 if (!query_only) {

		     ClearShadow(fw);

		     XtMakeResizeRequest((Widget)fw, parent_reply.width,

					 parent_reply.height, NULL, NULL); 

		     ConfigureChildren(fw, w, request);

		 }

		 return (XtGeometryYes);

	     } else {

		 almost_width = request->width;

		 almost_height = request->height;

	     }

	 } else {

	     /* we got an Almost, accept the deal and 

		compute the work_area size */

	     CalcWorkAreaSize (fw, &almost_width, &almost_height,

			       req_bw, parent_reply.width, 

			       parent_reply.height);

	 }

         break;

   default:

         return (XtGeometryNo);

	 break;

   }

   /*  Fallen through to an almost condition.  Clear the x and y  */

   /*  and set the width, height, and border.                     */

   if (reply != NULL) {

      reply -> request_mode = request -> request_mode & ~(CWX | CWY);

      reply -> width = almost_width;

      reply -> height = almost_height;

      reply -> border_width = req_bw;

      if (request -> request_mode & CWSibling)

               reply -> sibling = request -> sibling;

      if (request -> request_mode & CWStackMode)

               reply -> stack_mode = request -> stack_mode;

      return (XtGeometryAlmost);

   }

   return (XtGeometryNo);

}

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

 *

 *  ChangeManaged

 *	Process a changed in managed state of the child.  If its

 *	size is out of sync with the frame, make a resize request

 *	to change the size of the frame.

 *	Note: called before ConstraintDestroy.

 *

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

static void 

ChangeManaged(

        Widget wid )

{

   XmFrameWidget fw = (XmFrameWidget) wid ;

   Widget title_area = (fw->frame.title_area &&

			XtIsManaged(fw->frame.title_area)) ?

			fw->frame.title_area : (Widget) NULL;

   Dimension t_w = 0;

   Dimension t_h = 0;

   Dimension t_bw = (title_area) ? title_area->core.border_width : 0;

   Widget work_area = (fw->frame.work_area &&

			XtIsManaged(fw->frame.work_area)) ?

			fw->frame.work_area : (Widget) NULL;

   Dimension w_w = (work_area) ? work_area->core.width : 0;

   Dimension w_h = (work_area) ? work_area->core.height : 0;

   Dimension w_bw = (work_area) ? work_area->core.border_width : 0;

   Dimension fwWidth, fwHeight;

   if (title_area) 

   {                                          

	/* We don't want the current size of the title object -- width/height

	** may have been set on it. Because we'll be forcing it to the size we

	** want (see ConfigureChildren), we must use the "natural" size here,

	** so query its value now. (Use current border_width.)

        */

	XtWidgetGeometry title_reply;                           

	XtQueryGeometry (title_area, NULL, &title_reply);