/*

 * 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

 * 

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <Xm/ColumnP.h>

#include <Xm/RowColumn.h>

#include <Xm/Label.h>

#include <Xm/VaSimpleP.h>

#include "XmI.h"

#define XK_LATIN1

#include <X11/keysymdef.h>

static void ClassInitialize(void);

static void Initialize(Widget, Widget, ArgList, Cardinal*);

static void ClassPartInitialize(WidgetClass w_class);

static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal*);

static void Destroy(Widget);

static void Resize(Widget);

static XtGeometryResult QueryGeometry(Widget, 

        XtWidgetGeometry*, XtWidgetGeometry*);

static XtGeometryResult GeometryManager(Widget, 

        XtWidgetGeometry*, XtWidgetGeometry*);

static void ChangeManaged(Widget);

static void ConstraintInitialize(Widget, Widget, ArgList, Cardinal*);

static Boolean ConstraintSetValues(Widget, Widget, Widget, ArgList, Cardinal*);

static void ConstraintDestroy(Widget);

static void ConstraintGetValues(Widget, ArgList, Cardinal*);

static Boolean CvtStringToXiAlignment(

	Display*, XrmValue*, Cardinal*, XrmValue*, XrmValue*, XtPointer

);

static Boolean CvtStringToFillStyle(

	Display*, XrmValue*, Cardinal*, XrmValue*, XrmValue*, XtPointer

);

static Boolean CvtStringToDistribution(

	Display*, XrmValue*, Cardinal*, XrmValue*, XrmValue*, XtPointer

);

static void Layout(

	XmColumnWidget, Widget, XtWidgetGeometry*, int, int

);

static void HorizontalLayout(

	XmColumnWidget, Widget, XtWidgetGeometry*, int, int

);

static void VerticalLayout(

	XmColumnWidget, Widget, XtWidgetGeometry*, int, int

);

static void VerifyResources(

	XmColumnWidget, XmColumnWidget, XmColumnWidget

);

static void VerifyConstraints(

	Widget, Widget, Widget

);

static void CalcSize(

	XmColumnWidget, Widget, XtWidgetGeometry*, Boolean, Dimension*, Dimension*

);

static Boolean CompareGeometry(

	XtWidgetGeometry*, XtWidgetGeometry*

);

static Boolean CompareGeometryToWidget(

	XtWidgetGeometry*, Widget

);

static void CheckSetEntryLabelRenderTable(Widget wid, int offs, XrmValue *value); 

static void CheckSetDefaultEntryLabelRenderTable(Widget wid, int offs, XrmValue *value); 

static void XmColumnLabelDestroyedCallback(

	Widget, XtPointer, XtPointer

);

#if 0	/* POSITION HANDLING */

	Note: this code was never finished and has been pulled out. The

	public and semi-public traces have been pulled out of the header files.

	Everything is marked with the #if used above.

#endif

#define BBPart(w) ((XmBulletinBoardPart*)(&(((XmBulletinBoardWidget)(w))->bulletin_board)))

#define XiC(w) ((XmColumnConstraintPart*)(&((XmColumnConstraintPtr)((w)->core.constraints))->column))

#define XiValidChild(c) (((c)) != NULL && XtIsManaged((c)) && \

			 !(c)->core.being_destroyed && \

			 XiC(c)->label_widget != NULL)

#define XmColumn(c) ((XmColumnWidget) XtParent((c)))

#define XiAlignment(c) ((XiC((c))->label_alignment == XmALIGNMENT_UNSPECIFIED) \

			? XmColumn_default_label_alignment(XmColumn((c))) \

			: XiC(c)->label_alignment)

#if 0	/* POSITION HANDLING */

#define XiPosition(c) ((XiC(c)->label_position == XiLABEL_POSITION_UNSPECIFIED)\

		       ? XmColumn_default_label_position(XmColumn(c)) \

		       : XiC(c)->label_position)

#endif

#define XiFill(c) ((XiC(c)->fill_style == XmFILL_UNSPECIFIED)\

		   ? XmColumn_default_fill_style(XmColumn(c)) \

		   : XiC(c)->fill_style)

#define XiWidth(c) (XtWidth(c) + 2 * XtBorderWidth(c))

#define XiHeight(c) (XtHeight(c) + 2 * XtBorderWidth(c))

#if 0	/* POSITION HANDLING */

/* from public .h file */

#define XiLABEL_POSITION_UNSPECIFIED	0

#define XiLABEL_POSITION_CENTER 	(1L<<0)

#define XiLABEL_POSITION_LEFT		(1L<<1)

#define XiLABEL_POSITION_RIGHT		(1L<<2)

#define XiLABEL_POSITION_TOP		(1L<<3)

#define XiLABEL_POSITION_BOTTOM		(1L<<4)

/* structure member elements from private P.h file */

    unsigned char default_label_position;

    unsigned char       label_position;

#define XmColumnC_label_position(w) XmColCField(w, label_position, unsigned char)

#define XmColumn_default_label_position(w) XmColField(w, default_label_position, unsigned char)

#endif

#define DEFAULT_ALIGNMENT XmALIGNMENT_BEGINNING

#if 0	/* POSITION HANDLING */

#define DEFAULT_POSITION XiLABEL_POSITION_LEFT

#endif

#define DEFAULT_ORIENTATION XmVERTICAL

#define DEFAULT_FILL_STYLE XmFILL_RAGGED

static XtResource resources[] =

{

  {

    "pri.vate", "Pri.vate", XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmColumnRec, column.check_set_render_table),

    XmRImmediate, (XtPointer) False

  },

  {

    XmNdefaultEntryLabelFontList, XmCFontList, XmRFontList,

    sizeof(XmFontList), XtOffsetOf(XmBulletinBoardRec, bulletin_board.label_font_list),

    XmRCallProc, (XtPointer) CheckSetDefaultEntryLabelRenderTable

  },

  {

    XmNdefaultEntryLabelRenderTable, XmCRenderTable, XmRRenderTable,

    sizeof(XmRenderTable), XtOffsetOf(XmBulletinBoardRec, bulletin_board.label_font_list),

    XmRCallProc, (XtPointer) CheckSetDefaultEntryLabelRenderTable

  },

  {

    XmNdefaultEntryLabelAlignment, XmCAlignment, XmRXmAlignment,

    sizeof(unsigned char), XtOffsetOf(XmColumnRec, column.default_label_alignment),

    XmRImmediate, (XtPointer) DEFAULT_ALIGNMENT

  },

#if 0	/* POSITION HANDLING */

  {

    XmNdefaultEntryLabelPosition, XmCEntryLabelPosition, XmRLabelPosition,

    sizeof(unsigned char), XtOffsetOf(XmColumnRec, column.default_label_position),

    XmRImmediate, (XtPointer) DEFAULT_POSITION

  },

#endif

  {

    XmNdefaultFillStyle, XmCFillStyle, XmRFillStyle,

    sizeof(unsigned char), XtOffsetOf(XmColumnRec, column.default_fill_style),

    XmRImmediate, (XtPointer) DEFAULT_FILL_STYLE

  },

  {

    XmNitemSpacing, XmCItemSpacing, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmColumnRec, column.item_spacing),

    XmRImmediate, (XtPointer) 2

  },

  {

    XmNlabelSpacing, XmCLabelSpacing, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmColumnRec, column.label_spacing),

    XmRImmediate, (XtPointer) 10

  },

  {

    XmNorientation, XmCOrientation, XmROrientation,

    sizeof(unsigned char), XtOffsetOf(XmColumnRec, column.orientation),

    XmRImmediate, (XtPointer) DEFAULT_ORIENTATION

  },

  {

    XmNdistribution, XmCDistribution, XmRDistribution,

    sizeof(unsigned char), XtOffsetOf(XmColumnRec, column.distribution),

    XmRImmediate, (XtPointer) XmDISTRIBUTE_TIGHT

  }

};

static XmSyntheticResource get_resources[] =

{

  {

    XmNlabelSpacing, sizeof(Dimension),

    XtOffsetOf(XmColumnRec, column.label_spacing),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  },

  {

    XmNitemSpacing, sizeof(Dimension),

    XtOffsetOf(XmColumnRec, column.item_spacing),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  }

};

static XtResource constraint_resources[] =

{

  {

    "pri.vate", "Pri.vate", XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmColumnConstraintRec, column.check_set_render_table),

    XmRImmediate, (XtPointer) False

  },

  {

    XmNentryLabelFontList, XmCFontList, XmRFontList,

    sizeof(XmFontList), XtOffsetOf(XmColumnConstraintRec, column.label_font_list),

    XmRCallProc, (XtPointer) CheckSetEntryLabelRenderTable

  },

  {

    XmNentryLabelRenderTable, XmCRenderTable, XmRRenderTable,

    sizeof(XmRenderTable), XtOffsetOf(XmColumnConstraintRec, column.label_font_list),

    XmRCallProc, (XtPointer) CheckSetEntryLabelRenderTable

  },

  {

    XmNentryLabelAlignment, XmCAlignment, XmRXmAlignment,

    sizeof(unsigned char), XtOffsetOf(XmColumnConstraintRec, column.label_alignment),

    XmRImmediate, (XtPointer) XmALIGNMENT_UNSPECIFIED

  },

#if 0	/* POSITION HANDLING */

  {

    XmNentryLabelPosition, XmCEntryLabelPosition, XmRLabelPosition,

    sizeof(unsigned char), XtOffsetOf(XmColumnConstraintRec, column.label_position),

    XmRImmediate, (XtPointer) XiLABEL_POSITION_UNSPECIFIED

  },

#endif

  {

    XmNfillStyle, XmCFillStyle, XmRFillStyle,

    sizeof(unsigned char), XtOffsetOf(XmColumnConstraintRec, column.fill_style),

    XmRImmediate, (XtPointer) XmFILL_UNSPECIFIED

  },

  { 

    XmNentryLabelType, XmCLabelType, XmRLabelType,

    sizeof(unsigned char), XtOffsetOf(XmColumnConstraintRec, column.label_type),

    XmRImmediate, (XtPointer) XmSTRING

  },

  {

      XmNentryLabelString, XmCLabelString, XmRXmString,

      sizeof(XmString), XtOffsetOf(XmColumnConstraintRec, column.label_string),

      XmRImmediate, (XtPointer) NULL

  },

  {

      XmNentryLabelPixmap, XmCLabelPixmap, XmRPrimForegroundPixmap,

      sizeof(Pixmap), XtOffsetOf(XmColumnConstraintRec, column.label_pixmap),

      XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

  },

  {

      XmNshowEntryLabel, XmCShowLabel, XmRBoolean,

      sizeof(Boolean), XtOffsetOf(XmColumnConstraintRec, column.show_label),

      XmRImmediate, (XtPointer) True

  },

  {

      XmNstretchable, XmCStretchable, XmRBoolean,

      sizeof(Boolean), XtOffsetOf(XmColumnConstraintRec, column.stretchable),

      XmRImmediate, (XtPointer) False

  }

};

/*

 * Synthetic constraints.  Note that these are NOT currently used,

 * as the constraint get_values_hook method below seems to work where

 * synthetic resources don't.  Dunno.

 */

static void Get_entryLabelString(Widget, int, XtArgVal *);

static XmSyntheticResource cont_get_resources[] =

{

  {

    XmNentryLabelString, sizeof(XmString),

    XtOffsetOf(XmColumnConstraintRec, column.label_string),

    Get_entryLabelString, (XmImportProc) NULL

  }

};

ConstraintClassExtensionRec xiColumnConstraintExtension = {

    NULL,			         /* next_extension  */

    NULLQUARK,			         /* record_type     */

    XtConstraintExtensionVersion,        /* version         */

    sizeof(ConstraintClassExtensionRec), /* record_size     */

    ConstraintGetValues		         /* get_values_hook */

};

XmColumnClassRec xmColumnClassRec = {

  {

    /* core_class members      */

    /* superclass         */	(WidgetClass) &xmBulletinBoardClassRec,

    /* class_name         */	"XmColumn",                            

    /* widget_size        */	sizeof(XmColumnRec),

    /* class_initialize   */	ClassInitialize,

    /* class_part_init    */	ClassPartInitialize,

    /* class_inited       */	False,                            	

    /* initialize         */	Initialize, 

    /* initialize_hook    */	NULL,                             	

    /* realize            */	XtInheritRealize,

    /* actions            */	NULL,

    /* num_actions        */	0,

    /* resources          */	(XtResource*)resources,

    /* num_resources      */	XtNumber(resources), 

    /* xrm_class          */	NULLQUARK,                        

    /* compress_motion    */	True,                             	

    /* compress_exposure  */	True,                             	

    /* compress_enterleave*/	True,                             	

    /* visible_interest   */	False,                            

    /* destroy            */	Destroy,

    /* resize             */	Resize,                           

    /* expose             */	XtInheritExpose,

    /* 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           */	XtInheritTranslations,

    /* query_geometry     */	(XtGeometryHandler) QueryGeometry, 

    /* display_accelerator*/	NULL,                             

    /* extension          */	NULL,                             

  },

  {

    /* composite_class members */

    /* geometry_manager   */	GeometryManager,

    /* change_managed     */	ChangeManaged,                    

    /* insert_child       */	XtInheritInsertChild,

    /* delete_child       */	XtInheritDeleteChild,

    /* extension          */	NULL,                             

  },

  { /* constraint_class fields */

    /* resource list      */    (XtResource*)constraint_resources,

    /* num resources      */ 	XtNumber(constraint_resources),

    /* constraint size    */ 	sizeof(XmColumnConstraintRec),

    /* init proc          */ 	ConstraintInitialize,

    /* destroy proc       */ 	ConstraintDestroy,

    /* set values proc    */ 	ConstraintSetValues,

    /* extension          */ 	&xiColumnConstraintExtension,

  },

  { /* manager_class fields */

    /* default translations */ 	XtInheritTranslations,

    /* syn_resources        */ 	get_resources,

    /* num_syn_resources    */ 	XtNumber(get_resources),

    /* syn_cont_resources   */ 	NULL, /* cont_get_resources, */

    /* num_syn_cont_resources */ 0, /* XtNumber(cont_get_resources),*/

    /* parent_process       */ 	XmInheritParentProcess,

    /* extension            */ 	NULL,

  },

  { /* bulletin board members */

    /* always_install_accel */  False,

    /* geo_matrix_create    */  NULL,

    /* focus_moved_proc     */  XmInheritFocusMovedProc,

    /* extension            */  NULL,

  },

  {

    /* column class members */

    /* extension            */	NULL,                                

  }

};

WidgetClass xmColumnWidgetClass = (WidgetClass) &xmColumnClassRec;

/*

 * Function:

 *	ClassInitialize(void)

 * Description:

 *	This function is called the first time XmColumn or subclass is

 *	created.  This function is used to install all need type

 *	converters for this widget class.

 * Input:

 *	None.

 * Output:

 *	None.

 */

static void

ClassInitialize(void)

{

    XmColumnClassRec* wc = &xmColumnClassRec;

#if 0	/* POSITION HANDLING */

    XtSetTypeConverter(XmRString, XmRLabelPosition,

		       (XtTypeConverter) CvtStringToLabelPosition,

		       NULL, 0, XtCacheAll, NULL);

#endif

    XtSetTypeConverter(XmRString, XmRXmAlignment,

		       (XtTypeConverter) CvtStringToXiAlignment,

		       NULL, 0, XtCacheAll, NULL);

    XtSetTypeConverter(XmRString, XmRFillStyle,

		       (XtTypeConverter) CvtStringToFillStyle,

		       NULL, 0, XtCacheAll, NULL);

    XtSetTypeConverter(XmRString, XmRDistribution,

		       (XtTypeConverter) CvtStringToDistribution,

		       NULL, 0, XtCacheAll, NULL);

}

/*

 * ClassPartInitialize sets up the fast subclassing for the widget.

 */

static void 

#ifdef _NO_PROTO

ClassPartInitialize(w_class)

        WidgetClass w_class ;

#else

ClassPartInitialize(WidgetClass w_class)

#endif /* _NO_PROTO */

{

    _XmFastSubclassInit (w_class, XmCOLUMN_BIT);

}

/*

 * Function:

 *	Initialize(request, set, arg_list, arg_cnt)

 * Description:

 *	This function is called to initialize the resource values for each

 *	new widget instance.  This function verifies the resource values

 *	and takes the needed actions to initialize the new instance.

 * Input:

 *	request  : Widget   - user resource requests

 *	set      : Widget   - the resource values for the new widget

 *	arg_list : ArgList  - the argument list used to set the resource

 *	ang_cnt  : Cardinal - the number of arguments in the list

 * Output:

 *	None.

 */

/* ARGSUSED */

static void

Initialize(Widget request, Widget set, ArgList arg_list, Cardinal *arg_cnt)

{

    XmColumnWidget rc = (XmColumnWidget) request,

                   sc = (XmColumnWidget) set;

    VerifyResources(rc, (XmColumnWidget) NULL, sc);

    if( rc->core.width == 0 )

    {

	sc->core.width = 2 * (rc->manager.shadow_thickness +

			      BBPart(rc)->margin_width);

    }

    if( rc->core.height == 0 )

    {

	sc->core.height = 2 * (rc->manager.shadow_thickness +

			       BBPart(rc)->margin_height);

    }

}

/*

 * Function:

 *	Destroy(widget)

 * Description:

 *	This function is called when an instance of the Column is being

 *	destroyed.  This function deallocates any memory allocated by the

 *	instance.

 * Input:

 *	widget : Widget - the widget being destroyed

 * Output:

 *	None.

 */

/* ARGSUSED */

static void

Destroy(Widget widget)

{

    /* This space intentionally left blank */

}

/*

 * Function:

 *	Resize(widget)

 * Description:

 *	This function is called when an instance changes size.  This 

 *	function needs to adjust the childrens sizes and positions

 *	appropriately for the new size.

 * Input:

 *	widget : Widget - the widget that changed size.

 * Output:

 *	None.

 */

static void

Resize(Widget widget)

{

    WidgetClass    sc = XtSuperclass(widget);

    XmColumnWidget cw = (XmColumnWidget) widget;

    XtWidgetProc resize;

    _XmProcessLock(); 

    resize = *sc->core_class.resize;

    _XmProcessUnlock();

    (* resize) (widget);

    Layout(cw, NULL, NULL, -1, -1);

    XmColumn_resize_done(cw) = True;

}

/*

 * Function:

 *	SetValues(current, request, set, arg_list, arg_cnt)

 * Description:

 *	This function is called when the user changes the resource

 *	values for the column.  This function adjusts the columns

 *	appearance and behavior based on the new resource settings.

 * Input:

 *	current  : Widget  - the current resource values for the widget

 *	request  : Widget  - the requested resource values for the widget

 *	set      : Widget  - the new resource values for the widget

 *	arg_list : ArgList - the argument list used to change the resource

 *			     values

 *	arg_cnt  :Cardinal - the number of arguments

 * Output:

 *	Boolean - True if the Column needs redisplayed, else False.

 */

/* ARGSUSED */

static Boolean

SetValues(Widget current, Widget request, Widget set, ArgList arg_list,

	  Cardinal *arg_cnt)

{

    XmColumnWidget cc = (XmColumnWidget) current,

                   cs = (XmColumnWidget) set;

    Boolean        request_size = False,

                   relayout = False;

    WidgetList     kid, kids = cs->composite.children;

    Cardinal       n, i, kidCnt = cs->composite.num_children;

    Arg            args[10];

    VerifyResources((XmColumnWidget) request, cc, cs);

    if( XmColumn_item_spacing(cc) != XmColumn_item_spacing(cs) ||

        XmColumn_label_spacing(cc) != XmColumn_label_spacing(cs) ||

        XmColumn_distribution(cc) != XmColumn_distribution(cs) ||

        XmColumn_orientation(cc) != XmColumn_orientation(cs) ||

        cc->manager.shadow_thickness != cs->manager.shadow_thickness ||

        BBPart(cc)->margin_width != BBPart(cs)->margin_width ||

        BBPart(cc)->margin_height != BBPart(cs)->margin_height)

    {

	request_size = True;

    }

    if( XmColumn_default_fill_style(cc) != XmColumn_default_fill_style(cs) 

#if 0	/* POSITION HANDLING */

	|| XmColumn_default_label_position(cc) != XmColumn_default_label_position(cs) 

#endif

	)

    {

	relayout = True;

    }

    n = 0;

    if( cc->core.background_pixel != cs->core.background_pixel )

    {

	XtSetArg(args[n], XmNbackground, cs->core.background_pixel); n++;

    }

    if( cc->manager.foreground != cs->manager.foreground )

    {

	XtSetArg(args[n], XmNforeground, cs->manager.foreground); n++;

    }

    for( i = 0, kid = kids; i < kidCnt; ++i, ++kid )

    {

	if( (*kid) == NULL || (*kid)->core.being_destroyed ||

	    XiC(*kid)->label_widget == NULL ) continue;

	XtSetValues(XiC(*kid)->label_widget, args, n);

    }

    if( BBPart(cc)->label_font_list !=

            BBPart(cs)->label_font_list )

    {

	for( i = 0, kid = kids; i < kidCnt; ++i, ++kid )

	{

	    if( (*kid) == NULL || (*kid)->core.being_destroyed ||

	       XiC(*kid)->label_widget == NULL ) continue;

	    if( XiC(*kid)->label_font_list == NULL )

	    {

		XtVaSetValues(XiC(*kid)->label_widget,

			      XmNrenderTable,

			      BBPart(cs)->label_font_list,

			      NULL);

	    }

	}

    }

    if( XmColumn_default_label_alignment(cc) !=

            XmColumn_default_label_alignment(cs) )

    {

	for( i = 0, kid = kids; i < kidCnt; ++i, ++kid )

	{

	    if( (*kid) == NULL || (*kid)->core.being_destroyed ||

	       XiC(*kid)->label_widget == NULL ) continue;

	    if( XiC(*kid)->label_alignment == XmALIGNMENT_UNSPECIFIED )

	    {

		XtVaSetValues(XiC(*kid)->label_widget,

			      XmNalignment,

			      XmColumn_default_label_alignment(cs),

			      NULL);

	    }

	}

    }

    if( request_size )

    {

	Dimension width, height;

	XmColumn_resize_done(cs) = False;

	CalcSize(cs, NULL, NULL, False, &width, &height);

	if( XtMakeResizeRequest((Widget) cs, width, height, &width,

			&height) == XtGeometryAlmost )

	{

	    XmColumn_resize_done(cs) = False;

	    XtMakeResizeRequest((Widget) cs, width, height, NULL, NULL);

	}

	relayout = !XmColumn_resize_done(cs);

    }

    if( relayout )

    {

	Resize((Widget) cs);

    }

    return( False );

}

/*

 * Function:

 *	QueryGeometry(widget, request, allowed)

 * Description:

 *	This function is called when someone wants to know how the Column

 *	would react to a specific geometry or when someone wants to know

 *	what size the Column wants to be.

 * Input:

 *	widget  : Widget            - the column widget

 *	request : XtWidgetGeometry* - the requested widget geometry

 *	allowed : XtWidgetGeometry* - the geometry column is will to accept

 * Output:

 *	XtWidgetResult - the columns response to the geometry request

 */

static XtGeometryResult

QueryGeometry(Widget widget, XtWidgetGeometry *request,

	      XtWidgetGeometry *wanted)

{

    XmColumnWidget   cw = (XmColumnWidget) widget;

    XtGeometryResult result;

    Dimension        width, height;

    /*

     * Lets start by calling this handly dandy function to calculate

     * the geometry we want to be.

     */

    CalcSize(cw, NULL, NULL, False, &width, &height);

    /*

     * Now lets see if the caller requested anything and if not

     * lets give him our prefered geometry.

     */

    if( request->request_mode == 0 )

    {

	wanted->request_mode = CWWidth | CWHeight;

	wanted->width = width;

	wanted->height = height;

	if( width == XtWidth(cw) && height == XtHeight(cw) )

	{

	    return( XtGeometryNo );

	}

	return( XtGeometryAlmost );

    }

    *wanted = *request;

    if( request->request_mode & CWWidth )

    {

	if( request->width < width )

	{

	    wanted->width = width;

	}

    }

    if( request->request_mode & CWHeight )

    {

	if( request->height < height )

	{

	    wanted->height = height;

	}

    }

    /*

     * Now we have set everything in our return structure to what we

     * want it to be.  Now all that is left is to come up with the

     * correct return result.  The return result is something like.

     *

     * o request == wanted and wanted != real	-> XtGeometryYes

     * o request == wanted and wanted == real	-> XtGeometryNo

     * o request != wanted and wanted != real	-> XtGeometryAlmost

     * o request != wanted and wanted == real   -> XtGeometryNo

     */

    /*

     * Lets first see if request == wanted

     */

    if( CompareGeometryToWidget(wanted, (Widget) cw) )

    {

	result = XtGeometryNo;

    }

    else

    {

	if( CompareGeometry(request, wanted) )

	{

	    result = XtGeometryYes;

	}

	else

	{

	    result = XtGeometryNo;

	}

    }

    return( result );

}

/*

 * Function:

 *	GeometryManager(widget, request, allowed)

 * Description:

 *	This function is called when a child of the Column would like

 *	to change size.  This function reacts to the child's request.

 * Input:

 *	widget  : Widget            - the child requesting the change

 *	request : XtWidgetGeometry* - the requested widget geometry

 *	allowed : XtWidgetGeometry* - the geometry column is will to accept

 * Output:

 *	XtWidgetResult - the columns response to the geometry request

 */

static XtGeometryResult

GeometryManager(Widget widget, XtWidgetGeometry *request,

		XtWidgetGeometry *allowed)

{

    XmColumnWidget   cw = (XmColumnWidget) XtParent(widget);

    Dimension        width, height, width_return, height_return;

    XtGeometryResult result;

    Boolean          equal;

    /*

     * Now being the mean manager that we are, we are only going to 

     * allow our children to change geometry parts the affect their

     * size.  i.e. we will not even discuss with them their position,

     * this is mainly because we do not want to deal with it.

     */

    *allowed = *request;

    allowed->request_mode = request->request_mode =

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

    /*

     * Now lets see what this child wants to change.

     */

    if( request->request_mode & CWWidth )

    {

	allowed->width = request->width;

    }

    else

    {

	allowed->width = XiC(widget)->request_width;

    }

    if( request->request_mode & CWHeight )

    {

	allowed->height = request->height;

    }

    else

    {

	allowed->height = XiC(widget)->request_height;

    }

    if( request->request_mode & CWBorderWidth )

    {

	allowed->border_width = request->border_width;

    }

    else

    {

	allowed->border_width = XtBorderWidth(widget);

    }

    /*

     * Now that we know what size our child want to be lets see

     * how that effects the geometry we want to be.

     */

    CalcSize(cw, widget, allowed, False, &width, &height);

    /*

     * Now that we know that size that we want to be, lets ask our

     * parent and see what they have to say.

     */

    if( request->request_mode & XtCWQueryOnly )

    {

	XtWidgetGeometry req, alw;

	req.request_mode = CWWidth | CWHeight | XtCWQueryOnly;

	req.width = width;

	req.height = height;

	width = XtWidth(cw);

	height = XtHeight(cw);

	switch( XtMakeGeometryRequest((Widget) cw, &req, &alw) )

	{

	case XtGeometryYes:

	    return( XtGeometryYes );

	    break;

	case XtGeometryAlmost:

	    if( alw.request_mode & CWWidth ) width = alw.width;

	    if( alw.request_mode & CWHeight ) height = alw.height;

	case XtGeometryNo:

	default:

	    Layout(cw, widget, allowed, width, height);

	    allowed->width = XiC(widget)->position.width;

	    allowed->height = XiC(widget)->position.height;

	    break;

	}

    }

    else

    {

	Dimension cur_width, cur_height;

	XiC(widget)->request_width = allowed->width;

	XiC(widget)->request_height = allowed->height;

	XmColumn_resize_done(cw) = False;

	cur_width = XtWidth(cw);

	cur_height = XtHeight(cw);

	switch( XtMakeResizeRequest((Widget) cw, width, height,

				    &width_return, &height_return) )

	{

	case XtGeometryYes:

	    /*

	     * It appears that our parent will has let us change to 

	     * the size that we want to be, so lets see if we need to

	     * call our resize procedure.

	     */

	    if( !XmColumn_resize_done(cw) ) Resize((Widget) cw);

	    Layout(cw, widget, allowed, width, height);

	    allowed->width = XiC(widget)->position.width;

	    allowed->height = XiC(widget)->position.height;