/* 

 * 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: GeoUtils.c /main/13 1996/08/15 17:11:25 pascale $"

#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>

#endif

#include "XmI.h"

#include "GeoUtilsI.h"

#include "GMUtilsI.h"

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

static XtGeometryResult QueryAnyPolicy( 

                        XmGeoMatrix geoSpec,

                        XtWidgetGeometry *parentRequestRtn) ;

static XtGeometryResult QueryGrowPolicy( 

                        XmGeoMatrix geoSpec,

                        XtWidgetGeometry *parentRequestRtn) ;

static XtGeometryResult QueryNonePolicy( 

                        XmGeoMatrix geoSpec,

                        XtWidgetGeometry *parentRequestRtn) ;

static Dimension _XmGeoStretchVertical( 

                        XmGeoMatrix geoSpec,

#if NeedWidePrototypes

                        int actualH,

                        int desiredH) ;

#else

                        Dimension actualH,

                        Dimension desiredH) ;

#endif /* NeedWidePrototypes */

static Dimension _XmGeoFillVertical( 

                        XmGeoMatrix geoSpec,

#if NeedWidePrototypes

                        int actualH,

                        int desiredH) ;

#else

                        Dimension actualH,

                        Dimension desiredH) ;

#endif /* NeedWidePrototypes */

static void _XmGeoCalcFill( 

#if NeedWidePrototypes

                        int fillSpace,

                        int margin,

#else

                        Dimension fillSpace,

                        Dimension margin,

#endif /* NeedWidePrototypes */

                        unsigned int numBoxes,

#if NeedWidePrototypes

                        int endSpec,

                        int betweenSpec,

#else

                        Dimension endSpec,

                        Dimension betweenSpec,

#endif /* NeedWidePrototypes */

                        Dimension *pEndSpace,

                        Dimension *pBetweenSpace) ;

static int boxWidthCompare( 

                        XmConst void *boxPtr1,

                        XmConst void *boxPtr2) ;

static void FitBoxesAveraging( 

                        XmKidGeometry rowPtr,

                        unsigned int numBoxes,

#if NeedWidePrototypes

                        int boxWidth,

#else

                        Dimension boxWidth,

#endif /* NeedWidePrototypes */

                        int amtOffset) ;

static void FitBoxesProportional( 

                        XmKidGeometry rowPtr,

                        unsigned int numBoxes,

#if NeedWidePrototypes

                        int boxWidth,

#else

                        Dimension boxWidth,

#endif /* NeedWidePrototypes */

                        int amtOffset) ;

static void SegmentFill( 

                        XmKidGeometry rowBoxes,

                        unsigned int numBoxes,

                        XmGeoRowLayout layoutPtr,

#if NeedWidePrototypes

                        int x,

                        int width,

                        int marginW,

                        int endX,

                        int maxX,

                        int endSpace,

                        int betweenSpace) ;

#else

                        Position x,

                        Dimension width,

                        Dimension marginW,

                        Position endX,

                        Position maxX,

                        Dimension endSpace,

                        Dimension betweenSpace) ;

#endif /* NeedWidePrototypes */

static Position _XmGeoLayoutWrap( 

                        XmKidGeometry rowPtr,

                        XmGeoRowLayout layoutPtr,

#if NeedWidePrototypes

                        int x,

                        int y,

                        int endSpace,

                        int betweenSpace,

                        int maxX,

                        int width,

                        int marginW) ;

#else

                        Position x,

                        Position y,

                        Dimension endSpace,

                        Dimension betweenSpace,

                        Position maxX,

                        Dimension width,

                        Dimension marginW) ;

#endif /* NeedWidePrototypes */

static Position _XmGeoLayoutSimple( 

                        XmKidGeometry rowPtr,

                        XmGeoRowLayout layoutPtr,

#if NeedWidePrototypes

                        int x,

                        int y,

                        int maxX,

                        int endSpace,

                        int betweenSpace) ;

#else

                        Position x,

                        Position y,

                        Position maxX,

                        Dimension endSpace,

                        Dimension betweenSpace) ;

#endif /* NeedWidePrototypes */

static Position _XmGeoArrangeList( 

                        XmKidGeometry rowBoxes,

                        XmGeoRowLayout layoutPtr,

#if NeedWidePrototypes

                        int x,

                        int y,

                        int width,

                        int marginW,

                        int marginH) ;

#else

                        Position x,

                        Position y,

                        Dimension width,

                        Dimension marginW,

                        Dimension marginH) ;

#endif /* NeedWidePrototypes */

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

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

#ifdef DEBUG_GEOUTILS

void PrintBox( char * hdr, XmKidGeometry box) ;

void PrintList( char * hdr, XmKidGeometry listPtr) ;

void PrintMatrix( char * hdr, XmGeoMatrix spec) ;

#endif /* DEBUG_GEOUTILS */

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

XtGeometryResult 

_XmHandleQueryGeometry(

        Widget widget,

        XtWidgetGeometry *intended,

        XtWidgetGeometry *desired,

#if NeedWidePrototypes

        unsigned int resize_policy,

#else

        unsigned char resize_policy,

#endif /* NeedWidePrototypes */

        XmGeoCreateProc createMatrix)

{

    Dimension       width = 0 ;

    Dimension       height = 0 ;

    XmGeoMatrix     geoSpec ;

    /* first determine what is the desired size, using the resize_policy. */

    if (resize_policy == XmRESIZE_NONE) {

	desired->width = XtWidth(widget) ;

	desired->height = XtHeight(widget) ;

    } else {

	if (GMode( intended) & CWWidth) width = intended->width;

	if (GMode( intended) & CWHeight) height = intended->height;

	geoSpec = (*createMatrix)( widget, NULL, NULL) ;

	_XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

	_XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0, 

			   &width, &height) ;

	_XmGeoMatrixFree( geoSpec) ;

	if ((resize_policy == XmRESIZE_GROW) &&

	    ((width < XtWidth(widget)) ||

	     (height < XtHeight(widget)))) {

	    desired->width = XtWidth(widget) ;

	    desired->height = XtHeight(widget) ;

	} else {

	    desired->width = width ;

	    desired->height = height ;

	}

    }

    /* deal with user initial size setting */

    if (!XtIsRealized(widget))  {

	if (XtWidth(widget) != 0) desired->width = XtWidth(widget) ;

	if (XtHeight(widget) != 0) desired->height = XtHeight(widget) ;

    }	    

    return XmeReplyToQueryGeometry(widget, intended, desired) ;

}

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

XtGeometryResult 

_XmHandleGeometryManager(

        Widget wid,

        Widget instigator,

        XtWidgetGeometry *desired,

        XtWidgetGeometry *allowed,

#if NeedWidePrototypes

        unsigned int policy,

#else

        unsigned char policy,

#endif /* NeedWidePrototypes */

        XmGeoMatrix *cachePtr,

        XmGeoCreateProc createMatrix)

{

            XmGeoMatrix     geoSpec ;

            XtWidgetGeometry parentRequest ;

            XtGeometryResult queryResult ;

            XtGeometryResult result ;

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

    if(    !cachePtr    )

    {   

        /* Almost replies are not entertained unless caching is supported.

        */

        allowed = NULL ; 

        } 

    else

    {   geoSpec = *cachePtr ;

        if(    geoSpec    )

        {   

            if(    (geoSpec->composite == wid)

                && (geoSpec->instigator == instigator)

                && _XmGeometryEqual( instigator, geoSpec->in_layout, desired)    )

            {   

                /* This is a successive geometry request which matches the

                *   cached geometry record.

                */

                if(    GMode( desired) & XtCWQueryOnly    )

                {   return( XtGeometryYes) ;

                    }

                else

                {   /* If we get here, we should have already verified that

                    *   the current layout is acceptable to the parent, so 

                    *   we will ignore the result of the request.

                    */

                    if(    geoSpec->parent_request.request_mode    )

                    {   

                        geoSpec->parent_request.request_mode &= ~XtCWQueryOnly ;

                        XtMakeGeometryRequest( wid, &geoSpec->parent_request,

                                                                            NULL) ;

                        } 

                    _XmGeoMatrixSet( geoSpec) ;

                    _XmGeoMatrixFree( geoSpec) ;

                    *cachePtr = NULL ;

                    return( XtGeometryYes) ;

                    } 

                } 

            else

            {   /* Cached geometry is different than current request, so clear

                *   existing cache record and allow request to be processed.

                */

                _XmGeoMatrixFree( geoSpec) ;

                *cachePtr = NULL ;

                } 

            }

        }

    /*	Get box list and arrange boxes according to policy.

    */

    geoSpec = (*createMatrix)( wid, instigator, desired) ;

    if(    geoSpec->no_geo_request

        && (*geoSpec->no_geo_request)( geoSpec)    )

    {   

        _XmGeoMatrixFree( geoSpec) ;

        return( XtGeometryNo) ;

        } 

    /* The following Query routines only respond with XtGeometryYes or

    *    XtGeometryNo.  All requests made to the parent are strictly

    *    queries.

    *  A return value (from these routines!) of XtGeometryNo means that

    *    the composite widget would need to change size in order to

    *    entertain the child's request, and that the parent said "no"

    *    to the request.  A XtGeometryNo leaves no alternatives to the

    *    child's geometry request.

    *  A return value of XtGeometryYes means that either the composite

    *    widget does not need to change size to entertain the child's

    *    request, or that negotiation with the parent yielded a viable

    *    geometry layout.  If the composite widget does not need to 

    *    change size, then request_mode field of the returned geometry

    *    structure will contain zero.  Otherwise, the returned geometry

    *    structure will contain a request which is guaranteed to be 

    *    accepted by a subsequent request to the parent.

    *  A return value of XtGeometryYes always loads the return geometry

    *    structure with valid data.

    */

    switch(    policy    )

    {   

        case XmRESIZE_GROW:

        {   queryResult = QueryGrowPolicy( geoSpec, &parentRequest) ;

	    break;

            } 

	case XmRESIZE_NONE:

        {   queryResult = QueryNonePolicy( geoSpec, &parentRequest) ;

            break ;

            } 

	case XmRESIZE_ANY:

        default:

        {   queryResult = QueryAnyPolicy( geoSpec, &parentRequest) ;

            break ;

            } 

        } 

    result = XtGeometryNo ; /* Setup default response. */

    /* If parent replies XtGeometryYes, then build appropriate reply for

    *   instigator.  Otherwise, it is not reasonable to try to find a child

    *   size which would result in an acceptable overall size, so just say no.

    */

    if(    queryResult == XtGeometryYes    )

    {   

        if(    _XmGeoReplyYes( instigator, desired, geoSpec->in_layout)    )

        {   

            /* Reply Yes since desired geometry is same as the

            *   instigator geometry in this layout.

            */

            if(    GMode( desired) & XtCWQueryOnly    )

            {   

                geoSpec->parent_request = parentRequest ;

                result = XtGeometryYes ;

                } 

            else

            {   /* Don't need almost reply and this is not a query, so do it!

                */

                if(    parentRequest.request_mode    )

                {   

                    /* The geometry request in parentRequest has already

                    *   been tested by a query to the parent, so should

                    *   always be honored.

                    */

                    parentRequest.request_mode &= ~XtCWQueryOnly ;

                    XtMakeGeometryRequest( wid, &parentRequest, NULL) ;

                    } 

                _XmGeoMatrixSet( geoSpec) ;

                result = XtGeometryYes ;

                }

            } 

        else 

        {   /* If allowed and not an exception then reply Almost, since 

            *   desired geometry is different than geometry in this layout.

            */

            if(    allowed

                && (    !geoSpec->almost_except

                     || !(*(geoSpec->almost_except))(geoSpec))    )

            {   

                geoSpec->parent_request = parentRequest ;

                result = XtGeometryAlmost ;

                }

            }

        }

    switch(    result    )

    {   

        case XtGeometryAlmost:

        {   

            /* Cache "almost" replies.  Variables cachePtr and allowed are

            *   guaranteed to be non-null since almost replies are prevented

            *   if either is null.

            */

            if(geoSpec->in_layout) {

		*cachePtr = geoSpec ;

		*allowed = *(geoSpec->in_layout) ;

            } else /* For fixing OSF CR 5956 */ {

		allowed = NULL ;

		*cachePtr = NULL ;

		result = XtGeometryNo ;

	    }

            break ;

	} 

        case XtGeometryYes:

        {   

            /* This must be a query-only request, or the response would

            *   be XtGeometryYes.  Cache this reply if caching is

            *   supported.  Otherwise, drop through and free geoSpec.

            */

            if(    cachePtr    )

            {   *cachePtr = geoSpec ;

                break ;

                } 

            } 

        default:

        {   _XmGeoMatrixFree( geoSpec) ;

            break ;

            } 

        } 

    return( result) ;

    }

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

 * Handle geometry request for XmRESIZE_ANY resize policy.

 * Accept request allowed by parent.

 * Reject request to change both width and height if both

 *   are disallowed by parent, but return almost if one is

 *   allowed.

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

static XtGeometryResult 

QueryAnyPolicy(

        XmGeoMatrix geoSpec,

        XtWidgetGeometry *parentRequestRtn )

{

            Widget          wid ;

            Dimension       layoutW ;

            Dimension       layoutH ;

            XtWidgetGeometry parentResponse ;

            XtGeometryResult queryResult ;

            Dimension       almostW ;

            Dimension       almostH ;

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

    wid = geoSpec->composite ;

    _XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

    layoutW = 0 ;

    layoutH = 0 ;

    _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0, &layoutW,

                                                                    &layoutH) ;

    /*	Load request.

    */

    parentRequestRtn->request_mode = CWWidth | CWHeight ;

    parentRequestRtn->width = layoutW ;

    parentRequestRtn->height = layoutH ;

    /*	Query parent only if necessary.

    */

    if(    (layoutW == XtWidth( wid))

        && (layoutH == XtHeight( wid))    )

    {   

        parentRequestRtn->request_mode = 0 ;

        queryResult = XtGeometryYes ;

        } 

    else

    {   parentRequestRtn->request_mode |= XtCWQueryOnly ;

        queryResult = XtMakeGeometryRequest( wid, parentRequestRtn,

                                                             &parentResponse) ;

        if(    queryResult == XtGeometryAlmost    )

        {   

            if(    (parentResponse.request_mode & (CWWidth | CWHeight))

                                                   != (CWWidth | CWHeight)    )

            {   queryResult = XtGeometryNo ;

                } 

            else

            {   /* The protocol guarantees an XtGeometryYes reply for

                *   for an immediately subsequent request which is 

                *   identical to the XtGeometryAlmost reply.

                */

                *parentRequestRtn = parentResponse ;

                queryResult = XtGeometryYes ;

                almostW = parentResponse.width ;

                almostH = parentResponse.height ;

                if(    (almostW != layoutW)  ||  (almostH != layoutH)    )

                {   

                    /* Response to geometry request was different than 

                    *   requested geometry in fields that we care about. 

                    *   So, try a new arrangement with the area being 

                    *   offered by the parent.

                    */

                    _XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

                    layoutW = almostW ;

                    layoutH = almostH ;

                    _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0,

                                                          &layoutW, &layoutH) ;

                    if(    (almostW != layoutW)  ||  (almostH != layoutH)    )

                    {   

                        /* The children cannot be laid-out in the area offered

                        *   by the parent, so parent result is No.

                        */

                        queryResult = XtGeometryNo ;

                        } 

                    } 

                }

            }

        }

    return( queryResult) ;

    }

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

 * Handle geometry request for XmRESIZE_GROW resize policy.

 * Accept request which would increase or maintain current size.

 * Reject request which would decrease both preferred width

 *   and preferred height, but return almost if only one

 *   would decrease.

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

static XtGeometryResult 

QueryGrowPolicy(

        XmGeoMatrix geoSpec,

        XtWidgetGeometry *parentRequestRtn )

{

            Widget          wid ;

            Dimension       layoutW ;

            Dimension       layoutH ;

            XtWidgetGeometry parentResponse ;

            XtGeometryResult queryResult ;

            Dimension       almostW ;

            Dimension       almostH ;

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

    wid = geoSpec->composite ;

    _XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

    if(    geoSpec->instig_request.request_mode & CWWidth    )

    {   layoutW = 0 ;               /* Let the layout routine choose a width.*/

        } 

    else

    {   layoutW = XtWidth( wid) ;   /* All changes will be reflected in      */

        }                           /*   vertical dimension.                 */

    layoutH = XtHeight( wid) ;  /* Layout routine will grow vert., if needed.*/

    _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0, &layoutW,

                                                                    &layoutH) ;

    if(    layoutW < XtWidth( wid)    )

    {   

        /* Try again, this time passing the width to _XmGeoArrangeBoxes.

        */

        _XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

        layoutW = XtWidth( wid) ;

        layoutH = XtHeight( wid) ;

        _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0, &layoutW,

                                                                    &layoutH) ;

        } 

    /*	Load request.

    */

    parentRequestRtn->request_mode = CWWidth | CWHeight ;

    parentRequestRtn->width = layoutW ;

    parentRequestRtn->height = layoutH ;

    /*	Query parent only if necessary.

    */

    if(    (layoutW == XtWidth( wid))

        && (layoutH == XtHeight( wid))    )

    {   

        parentRequestRtn->request_mode = 0 ;

        queryResult = XtGeometryYes ;

        } 

    else

    {   parentRequestRtn->request_mode |= XtCWQueryOnly ;

        queryResult = XtMakeGeometryRequest( wid, parentRequestRtn,

                                                             &parentResponse) ;

        if(    queryResult == XtGeometryAlmost    )

        {   

            if(    (parentResponse.request_mode & (CWWidth | CWHeight))

                                                   != (CWWidth | CWHeight)    )

            {   queryResult = XtGeometryNo ;

                } 

            else

            {   /* The protocol guarantees an XtGeometryYes reply for

                *   for an immediately subsequent request which is 

                *   identical to the XtGeometryAlmost reply.

                */

                *parentRequestRtn = parentResponse ;

                queryResult = XtGeometryYes ;

                almostW = parentResponse.width ;

                almostH = parentResponse.height ;

                if(    (almostW < XtWidth( wid))

                    || (almostH < XtHeight( wid))    )

                {   

                    queryResult = XtGeometryNo ;

                    } 

                else

                {   if(    (almostW != layoutW)  ||  (almostH != layoutH)    )

                    {   

                        /* Response to geometry request was different than 

                        *   requested geometry in fields that we care about.

                        *   So, try a new arrangement with the area being 

                        *   offered by the parent.

                        */

                        _XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

                        layoutW = almostW ;

                        layoutH = almostH ;

                        _XmGeoArrangeBoxes( geoSpec, (Position) 0,

                                            (Position) 0, &layoutW, &layoutH) ;

                        if(    (almostW != layoutW)  ||  (almostH != layoutH) )

                        {   

                            /* The children cannot be laid-out in the area

                            *   offered by the parent, so parent result is No.

                            */

                            queryResult = XtGeometryNo ;

                            } 

                        } 

                    } 

                } 

            } 

        } 

    return( queryResult) ;

    }

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

 * Handle geometry request for XmRESIZE_NONE resize policy.

 * Accept request which would not change preferred size and

 *   allowed by parent.

 * Reject request which would change both preferred width

 *   and preferred height, but return almost if only one

 *   would change and parent allows the other.

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

static XtGeometryResult 

QueryNonePolicy(

        XmGeoMatrix geoSpec,

        XtWidgetGeometry *parentRequestRtn )

{

            Widget          wid ;

            Dimension       layoutW ;

            Dimension       layoutH ;

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

    wid = geoSpec->composite ;

    _XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

    layoutW = XtWidth( wid) ;

    layoutH = XtHeight( wid) ;

    _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0,

                                                          &layoutW, &layoutH) ;

    parentRequestRtn->request_mode = 0 ;

    if(    (layoutW != XtWidth( wid))  ||  (layoutH != XtHeight( wid))    )

    {   return( XtGeometryNo) ;

        }

    return( XtGeometryYes) ;

    }

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

void 

_XmHandleSizeUpdate(

        Widget wid,

#if NeedWidePrototypes

        unsigned int policy,

#else

        unsigned char policy,

#endif /* NeedWidePrototypes */

        XmGeoCreateProc createMatrix)

{

            XmGeoMatrix     geoSpec ;

            Dimension       w ;

            Dimension       h ;

            Dimension       r_w ;

            Dimension       r_h ;

            XtGeometryResult parentResult = XtGeometryNo ;

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

    geoSpec = (*createMatrix)( wid, NULL, NULL) ;

    _XmGeoMatrixGet( geoSpec, XmGET_PREFERRED_SIZE) ;

    switch(    policy    )

    {   

        case XmRESIZE_NONE:

        {   

            w = XtWidth( wid) ;

            h = XtHeight( wid) ;

            _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0, &w, &h) ;

            break ;

            } 

        case XmRESIZE_GROW:

        {   

            w = 0 ;

            h = XtHeight( wid) ;

            _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0, &w, &h) ;

            if(    w < XtWidth( wid)    )

            {   w = XtWidth( wid) ;

                h = XtHeight( wid) ;

                _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0,

                                                                      &w, &h) ;

                }

            break ;

            } 

        case XmRESIZE_ANY:

        default:

        {   

            w = 0 ;

            h = 0 ;

            _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0, &w, &h) ;

            break ;

            } 

        } 

    if(    ((w == XtWidth( wid))  &&  (h == XtHeight( wid)))    )

    {   parentResult = XtGeometryYes ;

        } 

    else

    {   if(    policy != XmRESIZE_NONE    )

        {   

            parentResult = XtMakeResizeRequest( wid, w, h, &r_w, &r_h) ;

            if(    parentResult == XtGeometryAlmost    )

            {   

                if(    (policy == XmRESIZE_GROW)

                    && (   (r_w < XtWidth( wid))

                        || (r_h < XtHeight( wid)))    )

                {   

                    parentResult = XtGeometryNo ;

                    } 

                else

                {   w = r_w ;

                    h = r_h ;

                    _XmGeoArrangeBoxes( geoSpec, (Position) 0, (Position) 0,

                                                                      &w, &h) ;

                    if(    (w == r_w)  &&  (h == r_h)    )

                    {   XtMakeResizeRequest( wid, w, h, NULL, NULL) ;

                        } 

                    else

                    {   parentResult = XtGeometryNo ;

                        } 

                    } 

                }

            } 

        }

    if(    parentResult != XtGeometryNo    )

    {   _XmGeoMatrixSet( geoSpec) ;

        } 

    _XmGeoMatrixFree( geoSpec) ;

    return ;

    }

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

 * This routine allocates and initializes the data structure used

 *   to describe a matrix of geometry boxes.  Supplemental initialization

 *   may be required for some of the fields of the data structure, if 

 *   the user uses these fields in its supplied co-routines.

 * Rows of the GeoMatrix are lists of kid boxes which are terminated with

 *   a NULL in the kid widget field of the box structure.  This routine

 *   automatically allocates extra boxes to use to mark the end of each

 *   row list.

 * This routine initializes all fields to NULL.

 * The pointer returned by this routine should be freed by the user

 *   using the _XmGeoMatrixFree() routine.

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

XmGeoMatrix 

_XmGeoMatrixAlloc(

        unsigned int numRows,       /* Number of rows of widgets to layout.*/

        unsigned int numBoxes,      /* Total number of widgets of matrix.*/

        unsigned int extSize )      /* Extension record size (bytes).*/

{

            XmGeoMatrix     geoSpecPtr ;

            unsigned int    matrixRecSize ;

            unsigned int    layoutRecSize ;

            unsigned int    kidGeoRecSize ;

            unsigned int    layoutSize ;

            unsigned int    boxesSize ;

            unsigned int    totalSize ;

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

    /* Get sizes of the various components of the GeoMatrix.  Round up to

    *   prevent alignment problems.

    */

    matrixRecSize = sizeof( XmGeoMatrixRec) ;

    if(    matrixRecSize & 0x03    )

    {   matrixRecSize = (matrixRecSize + 4) & ~((unsigned int) 0x03) ;

        } 

    layoutRecSize = sizeof( XmGeoRowLayoutRec) ;

    if(    layoutRecSize & 0x03    )

    {   layoutRecSize = (layoutRecSize + 4) & ~((unsigned int) 0x03) ;

        } 

    kidGeoRecSize = sizeof( XmKidGeometryRec) ;

    if(    kidGeoRecSize & 0x03    )

    {   kidGeoRecSize = (kidGeoRecSize + 4) & ~((unsigned int) 0x03) ;

        } 

    layoutSize = (numRows + 1) * layoutRecSize ;

    /* Extra boxes are used to mark the end of each row.

    */

    boxesSize = (numBoxes + numRows) * kidGeoRecSize ; 

    totalSize = matrixRecSize + layoutSize + boxesSize + extSize ;

    geoSpecPtr = (XmGeoMatrix) XtCalloc( 1, totalSize) ;   /* Must be zeroed.*/

    /* Set locations of arrays of row layout, box, and extension records.

    */

    geoSpecPtr->layouts = (XmGeoMajorLayout) (((char *) geoSpecPtr)

                                                             + matrixRecSize) ;

    geoSpecPtr->boxes = (XmKidGeometry) (((char *) geoSpecPtr)

                                                + matrixRecSize + layoutSize) ;

    if(    extSize    )

    {   geoSpecPtr->extension = (XtPointer) (((char *) geoSpecPtr)

                                    + matrixRecSize + layoutSize + boxesSize) ;

        } 

    return( geoSpecPtr) ;

    }

void

_XmGeoMatrixFree(

	XmGeoMatrix geo_spec)

{

  if(    geo_spec->ext_destructor    )

    {

      (*(geo_spec->ext_destructor))( geo_spec->extension) ;

    }

  XtFree( (char *) geo_spec) ;

}

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

 * If the widget specified by the "kidWid" parameter is non-NULL and is managed,

 *   its value is copied into the appropriate field of the kid geometry 

 *   structure provided by the "geo" parameter and TRUE is returned.

 * Otherwise, nothing is done and FALSE is returned.

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

Boolean 

_XmGeoSetupKid(

        XmKidGeometry geo,          /* Must be non-NULL.*/

        Widget kidWid )

{

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

    if(    !kidWid  ||  !XtIsManaged( kidWid)    )

    {   return( FALSE) ;