/*

 * 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

 * 

 */

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

*	INCLUDE FILES

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

#include <stdio.h>

#include "XmI.h"

#include <Xm/IconBoxP.h>

#include <Xm/ExtP.h>

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

*	TYPEDEFS AND DEFINES

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

#define SUPERCLASS ((WidgetClass) &xmManagerClassRec)

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

*	MACROS

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

#define GetIconInfo(w) ((IconInfo*) \

           &(((XmIconBoxConstraintsRec*)((char*)((w)->core.constraints)))->icon))

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

*	GLOBAL DECLARATIONS

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

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

*	STATIC FUNCTION DECLARATIONS

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

static void ClassInitialize();

static void ClassPartInitialize(WidgetClass w_class);

static void Realize(Widget, Mask *, XSetWindowAttributes *);

static void Resize(Widget), ChangeManaged(Widget), InsertChild(Widget);

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

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

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

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

static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry *,

					XtWidgetGeometry *);

static XtGeometryResult QueryGeometry(Widget,

				      XtWidgetGeometry *, XtWidgetGeometry *);

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

 * Actions and callbacks.

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

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

 * Internal Routines.

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

static void FindNearestCellLocation(Widget, Position *, Position *);

static void GetMinCells(Widget, Cardinal *, Cardinal *);

static void PlaceChildren(Widget, Widget);

static void GetMaxCellSize(Widget, Widget, Dimension *, Dimension *);

static void GetCellFromXY(Widget, Position, Position, Position *, Position *);

static void GetXYFromCell(Widget, IconInfo *, Position *, Position *);

static void CalcCellSizes(Widget, Widget,

			  Boolean, Boolean, Dimension *, Dimension *);

static Boolean SetToEmptyCell(Widget);

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

*	STATIC DECLARATIONS

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

static XtResource resources[] =

{

  {

    XmNminimumVerticalCells, XmCDefaultCells, XmRDimension,

    sizeof(Dimension), XtOffsetOf(XmIconBoxRec, box.min_v_cells),

    XmRImmediate, (XtPointer) 2

  },

  {

    XmNminimumHorizontalCells, XmCDefaultCells, XmRHorizontalDimension, 

    sizeof(Dimension), XtOffsetOf(XmIconBoxRec, box.min_h_cells),

    XmRImmediate, (XtPointer) 2

  },

  {

    XmNminimumCellWidth, XmCMinimumCellSize, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmIconBoxRec, box.min_cell_width),

    XmRImmediate, (XtPointer) 20

  },

  {

    XmNminimumCellHeight, XmCMinimumCellSize, XmRDimension,

    sizeof(Dimension), XtOffsetOf(XmIconBoxRec, box.min_cell_height),

    XmRImmediate, (XtPointer) 10

  },

  {

    XmNverticalMargin, XmCMargin, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmIconBoxRec, box.v_margin),

    XmRImmediate, (XtPointer) 4

  },

  {

    XmNhorizontalMargin, XmCMargin, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmIconBoxRec, box.h_margin),

    XmRImmediate, (XtPointer) 4

  }

};

static XmSyntheticResource get_resources[] =

{

  {

    XmNhorizontalMargin, sizeof(Dimension),

    XtOffsetOf(XmIconBoxRec, box.h_margin),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  },

  {

    XmNverticalMargin, sizeof(Dimension),

    XtOffsetOf(XmIconBoxRec, box.v_margin),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  },

  {

    XmNminimumCellWidth, sizeof(Dimension),

    XtOffsetOf(XmIconBoxRec, box.min_cell_width),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  },

  {

    XmNminimumCellHeight, sizeof(Dimension),

    XtOffsetOf(XmIconBoxRec, box.min_cell_height),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  }

};

static short G_any_cell = XmIconBoxAnyCell;

static XtResource constraints[] =

{

  {

    XmNcellX, XmCCellX, XmRShort,

    sizeof(short), XtOffsetOf(XmIconBoxConstraintsRec, icon.cell_x),

    XmRShort, (XtPointer) &G_any_cell

  },

  {

    XmNcellY, XmCCellY, XmRShort,

    sizeof(short), XtOffsetOf(XmIconBoxConstraintsRec, icon.cell_y),

    XmRShort, (XtPointer) &G_any_cell

  }

};

XmIconBoxClassRec xmIconBoxClassRec = {

  { /* core fields */

    /* superclass		*/	SUPERCLASS,

    /* class_name		*/	"XmIconBox",

    /* widget_size		*/	sizeof(XmIconBoxRec),

    /* class_initialize		*/	ClassInitialize,

    /* class_part_initialize	*/	ClassPartInitialize,

    /* class_inited		*/	FALSE,

    /* initialize		*/	Initialize,

    /* initialize_hook		*/	NULL,

    /* realize			*/	Realize,

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

    /* resize			*/	Resize,

    /* expose			*/	NULL,

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

    /* extension		*/	NULL

  },

   {		/* composite_class fields */

    /* geometry_manager   */      GeometryManager,

    /* change_managed     */      ChangeManaged,

    /* insert_child       */      InsertChild,			

    /* delete_child       */      XtInheritDeleteChild,			

    /* extension          */      NULL,                                     

   },

   {		/* constraint_class fields */

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

    /* num resources        */         XtNumber(constraints),	

    /* constraint size      */         sizeof(XmIconBoxConstraintsRec),

    /* init proc            */         ConstraintInitialize,

    /* destroy proc         */         NULL,

    /* set values proc      */         ConstraintSetValues,

    /* extension            */         NULL, 

   },

   {		/* manager_class fields */

    /* default translations   */      XtInheritTranslations,	

    /* syn_resources          */      get_resources,

    /* num_syn_resources      */      XtNumber(get_resources),

    /* syn_cont_resources     */      NULL,

    /* num_syn_cont_resources */      0,

    /* parent_process         */      XmInheritParentProcess,

    /* extension	      */      NULL,	

   },

  { /* Icon Box fields */

      NULL                      /* extension          */

  }

};

WidgetClass xmIconBoxWidgetClass = (WidgetClass)&xmIconBoxClassRec;

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

*	STATIC CODE

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

/*	Function Name: Initialize

 *	Description:   Called to initialize information specific

 *                     to this widget.

 *	Arguments:     req - what was originally requested.

 *                     set - what will be created (our superclassed have

 *                           already mucked with this)

 *                     args, num_args - The arguments passed to 

 *                                      the creation call.

 *	Returns:       none.

 */

static void

ClassInitialize()

{

  /* do nothing */

}

/*ARGSUSED*/

static void 

Initialize(Widget req, Widget set, ArgList args, Cardinal * num_args)

{

    XmIconBoxWidget ibw = (XmIconBoxWidget) set;

    /*

     * This is needed so that the right thing happens if an icon box is 

     * created w/o any children.

     */

    CalcCellSizes(set, NULL, FALSE, FALSE, 

		  &(XmIconBox_cell_width(ibw)), &(XmIconBox_cell_height(ibw)));

}

/*	Function Name: Realize

 *	Description:   Called to realize this widget.

 *	Arguments:     w - Widget to realize.

 *                     valueMask, attributes - attributes to use when creating

 *                     this widget's window.

 *	Returns:       none.

 *

 * This overrides the Manager's frobbing with various values.

 */

static void 

Realize(Widget w, Mask *valueMask, XSetWindowAttributes *attributes)

{

    XtCreateWindow (w, InputOutput, CopyFromParent, *valueMask, attributes);

}

/*	Function Name: Resize

 *	Description:   Called when this widget has been resized.

 *	Arguments:     w - the widget to resize. 

 *	Returns:       none.

 */

static void 

Resize(Widget w)

{

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    CalcCellSizes(w, NULL, TRUE, FALSE, 

		  &(XmIconBox_cell_width(ibw)), &(XmIconBox_cell_height(ibw)));

    PlaceChildren(w, NULL);

}

/*	Function Name: SetValues

 *	Description:   Called when some widget data needs to be modified on-

 *                     the-fly.

 *	Arguments:     current - the current (old) widget values.

 *                     request - before superclassed have changed things.

 *                     set - what will acutally be the set values. 

 *                     args, num_args - the arguments in the list.

 *	Returns:       none

 */

/*ARGSUSED*/

static Boolean 

SetValues(Widget current, Widget request, Widget set,

	  ArgList args, Cardinal * num_args)

{

    XmIconBoxWidget old_ibw = (XmIconBoxWidget) current;

    XmIconBoxWidget set_ibw = (XmIconBoxWidget) set;

    if ((XmIconBox_min_v_cells(old_ibw) != XmIconBox_min_v_cells(set_ibw))           ||

	(XmIconBox_min_h_cells(old_ibw) != XmIconBox_min_h_cells(set_ibw))           ||

	(XmIconBox_min_cell_width(old_ibw) != XmIconBox_min_cell_width(set_ibw))     ||

	(XmIconBox_min_cell_height(old_ibw) != XmIconBox_min_cell_height(set_ibw))   ||

	(XmIconBox_v_margin(old_ibw) != XmIconBox_v_margin(set_ibw))                 ||

	(XmIconBox_h_margin(old_ibw) != XmIconBox_h_margin(set_ibw)) ) 

    {

	CalcCellSizes(set, NULL, FALSE, FALSE, 

		      &(XmIconBox_cell_width(set_ibw)), &(XmIconBox_cell_height(set_ibw)));

	PlaceChildren(set, NULL);

    }

    return(FALSE);

}

/*	Function Name: QueryGeometry

 *	Description:   Called when my parent wants to know what size

 *                     I would like to be.

 *	Arguments:     w - the widget to check.

 *                     indended - constriants imposed by the parent.

 *                     preferred - what I would like.

 *	Returns:       See Xt Manual.

 */

static XtGeometryResult 

QueryGeometry(Widget w,XtWidgetGeometry *intended, XtWidgetGeometry *preferred)

{

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    Cardinal min_x, min_y;

    Dimension max_w, max_h;

    GetMinCells(w, &min_x, &min_y);

    GetMaxCellSize(w, NULL, &max_w, &max_h);

    min_x++;

    min_y++;

    preferred->width = XmIconBox_h_margin(ibw) + min_x * (max_w + XmIconBox_h_margin(ibw));

    preferred->height= XmIconBox_v_margin(ibw) + min_y * (max_h + XmIconBox_v_margin(ibw));

    return(_XmHWQuery(w, intended, preferred));

}

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

 *

 * Composite and Constraint Information.

 *

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

/*	Function Name: GeometryManager

 *	Description:   handles requests from children for a size change.

 *	Arguments:     child - the child to change.

 *                     request - the geometry that the child wants.

 *                     return - what we will allow if this is an almost.

 *	Returns:       status.

 */

/*ARGSUSED*/

static XtGeometryResult

GeometryManager(Widget w, XtWidgetGeometry * request, 

		XtWidgetGeometry * result)

{

    Dimension cwidth, cheight;

    XmIconBoxWidget ibw = (XmIconBoxWidget) XtParent(w);

    IconInfo * info = GetIconInfo(w);

    Boolean w_req = (request->request_mode & CWWidth);

    Boolean h_req = (request->request_mode & CWHeight);

    Boolean x_req = (request->request_mode & CWX);

    Boolean y_req = (request->request_mode & CWY);

    if (!(request->request_mode & (CWWidth | CWHeight | CWX | CWY)))

	return(XtGeometryNo);

    result->request_mode = 0;

    if (w_req || h_req) {

	CalcCellSizes((Widget) ibw, w, FALSE, TRUE, &cwidth, &cheight);

	if(w_req)

	    ASSIGN_MAX(cwidth, request->width);

	else

	    ASSIGN_MAX(cwidth, w->core.width);

	if(h_req)

	    ASSIGN_MAX(cheight, request->height);

	else

	    ASSIGN_MAX(cheight, w->core.height);

	/*

	 * Do not allow an x, y width and height request at the same time.

	 * since it is unclear what this would mean.  I want to place the

	 * widget in the cell the center of it is over.  With a multiple

	 * request like this is it tough to find out which cell to use

	 * since there are two reasonable values for height and width.

	 */

	result->x = w->core.x;

	result->y = w->core.y;

	result->width  = cwidth;

	result->height = cheight;

	result->request_mode |= CWX | CWY | CWHeight | CWWidth;

    }

    else if ( x_req || y_req ) {

	Position x, y;

	short cell_x, cell_y;

	if (x_req) 

	    x = request->x;

	else

	    x = w->core.x;

	if (y_req)

	    y = request->y;

	else

	    y = w->core.y;

	FindNearestCellLocation((Widget) ibw, &x, &y);

	GetCellFromXY((Widget) ibw, x, y, &cell_x, &cell_y);

	if (XmIconBoxIsCellEmpty((Widget) ibw, cell_x, cell_y, w)) {

	    result->x = x;

	    result->y = y;

	    result->request_mode |= CWX | CWY;

	}

	else			/* Cell is full, return NO. */

	    return(XtGeometryNo);

    }

    if (((request->x == result->x) || !x_req) &&

	((request->y == result->y) || !y_req) &&

	((request->width == result->width) || !w_req) &&

	((request->height == result->height) || !h_req))

    {

	if (request->request_mode & 

	    (CWBorderWidth | CWStackMode | CWSibling)) 

	{

	    return(XtGeometryAlmost);

	}

	if (request->request_mode & XtCWQueryOnly) 

	    return(XtGeometryYes);

	if (w_req || h_req) {

	    if (w_req) 

		info->pref_width = w->core.width = request->width;

	    if (h_req)

		info->pref_height = w->core.height = request->height;

	}

	else {

	    /*

	     * NOTE: We are assuming here that the cell height/width

	     * did not change.  This is valid because this code is

	     * only executed if w_req and h_req are false.

	     */

	    GetCellFromXY((Widget) ibw, result->x, result->y, 

			  &(info->cell_x), &(info->cell_y));

	}

	CalcCellSizes((Widget) ibw, NULL, FALSE, FALSE, 

		      &(XmIconBox_cell_width(ibw)), &(XmIconBox_cell_height(ibw)));

	PlaceChildren((Widget) ibw, w);

	return(XtGeometryYes);

    }

    info->pref_width = info->pref_height = 0; /* invalidate cache. */

    if (((request->x == result->x) || !x_req)         ||

	((request->y == result->y) || !y_req)         ||

	((request->width == result->width) || !w_req) ||

	((request->height == result->height) || !h_req))

    {

	return(XtGeometryAlmost);

    }

    else 

	return(XtGeometryNo);

}

/*	Function Name: InsertChild

 *	Description: called when a new child is to be added.

 *	Arguments: w - the new child.

 *	Returns: none.

 *

 * This routine simply makes sure that no gadgets are added.

 */

static void 

InsertChild(Widget w)

{

   if (_XmGadgetWarning(w))

       return;

   {

      XtWidgetProc insert_child;

      _XmProcessLock();

      insert_child = ( (CompositeWidgetClass) SUPERCLASS)->composite_class.insert_child;

      _XmProcessUnlock();

      (*insert_child)(w);

   }

}

/*	Function Name: ChangeManaged

 *	Description:   When a management change has occured...

 *	Arguments:     w - the icon box widget.

 *	Returns:       none.

 */

static void

ChangeManaged(Widget w)

{

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    Widget * childp;

    CalcCellSizes(w, NULL, FALSE, TRUE, 

		  &(XmIconBox_cell_width(ibw)), &(XmIconBox_cell_height(ibw)));

    ForAllChildren(ibw, childp) {   

	IconInfo * info = GetIconInfo(*childp);

	if ((info->cell_x != XmIconBoxAnyCell) && 

	    (info->cell_y != XmIconBoxAnyCell) &&

	    !XmIconBoxIsCellEmpty((Widget) ibw, 

				  info->cell_x, info->cell_y, *childp))

	{

	    static String params[1];

	    Cardinal num = 1;

	    char buf[BUFSIZ];

	    params[0] = buf;

	    snprintf(buf, BUFSIZ, "(%d, %d)", info->cell_x, info->cell_y);

	    _XmWarningMsg(w, XmNcellNotEmpty,

		    XmNcellNotEmptyMsg, params, num);

	    /*

	     * tell it to reset this to an empty cell.

	     */

	    info->cell_y = XmIconBoxAnyCell; 

	}

	if ((info->cell_x == XmIconBoxAnyCell) || 

	    (info->cell_y == XmIconBoxAnyCell))

	{

	    Position x = (*childp)->core.x;

	    Position y = (*childp)->core.y;

	    Position cell_x, cell_y;

	    /*

	     * If the cell location is not specified try to find the

	     * cell nearest the X and Y coords specified.

	     */

	    FindNearestCellLocation((Widget) ibw, &x, &y);

	    GetCellFromXY((Widget) ibw, x, y, &cell_x, &cell_y);

	    if (XmIconBoxIsCellEmpty((Widget) ibw, cell_x, cell_y, w))

	    {

		info->cell_x = cell_x;

		info->cell_y = cell_y;

	    }

	    /*

	     * If this cell is full the just find any empty cell.

	     */

	    else if (!SetToEmptyCell(*childp)) {

		XmeWarning(w, XmNnoEmptyCellsMsg);

	    }

	}

    }

    CalcCellSizes(w, NULL, FALSE, FALSE, 

		  &(XmIconBox_cell_width(ibw)), &(XmIconBox_cell_height(ibw)));

    PlaceChildren(w, NULL);

   XmeNavigChangeManaged(w);	/* For Motif navigation */

}

/*

 * 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, XmICONBOX_BIT);

}

/*	Function Name: ConstraintInitialize

 *	Description:   Called when a childs constriaints need initializing.

 *	Arguments:     req - the widget being requested.

 *                     set - what this will become.

 *                     args, num_args - the argument list.

 *	Returns:       none.

 */

/*ARGSUSED*/

static void

ConstraintInitialize(Widget req, Widget set, ArgList args, Cardinal * num_args)

{

    IconInfo * info = GetIconInfo(set);

    info->pref_width = req->core.width;

    info->pref_height = req->core.height;

}

/*	Function Name: ConstraintSetValues

 *	Description:   Called when some constraint data needs to be modified 

 *                     on-the-fly.

 *	Arguments:     current - the current (old) widget values.

 *                     request - before superclassed have changed things.

 *                     set - what will acutally be the new values. 

 *                     args, num_args - the arguments in the list.

 *	Returns:       none

 */

/*ARGSUSED*/

static Boolean 

ConstraintSetValues(Widget current, Widget request, Widget set,

		    ArgList args, Cardinal * num_args)

{

    IconInfo * set_info = GetIconInfo(set);

    IconInfo * old_info = GetIconInfo(current);

    if (set->core.width != set_info->pref_width)

	set_info->pref_width = 0;

    if (set->core.height != set_info->pref_height)

	set_info->pref_height = 0;

    if ((set_info->cell_x != old_info->cell_x) ||

	(set_info->cell_y != old_info->cell_y)) 

    {

	if ( XmIconBoxIsCellEmpty(XtParent(set), 

				  set_info->cell_x, set_info->cell_y, set)) 

	{

	    GetXYFromCell(XtParent(set), 

			  set_info, &(set->core.x), &(set->core.y));

	}

	else {

	    static String params[1];

	    Cardinal num = 1;

	    char buf[BUFSIZ];

	    params[0] = buf;

	    snprintf(buf, BUFSIZ, "(%d, %d)", set_info->cell_x, set_info->cell_y);

	    _XmWarningMsg(set, XmNcellNotEmpty,

		    XmNcellNotEmptyMsg, params, num);

	    set_info->cell_x = old_info->cell_x;

	    set_info->cell_y = old_info->cell_y;

	}			 

    }

    return(False);

}

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

 *

 * Actions and Callbacks.

 *

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

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

 *

 * Internal routines.

 *

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

/*	Function Name: GetCellFromXY

 *	Description:   Gets the cell located at this location.

 *	Arguments:     w - the icon box.

 *                     x, y - the coordinates in X space.

 * RETURNED            cell_x, cell_y - the corrdinates in cell space.

 *	Returns:       none.

 */

static void

GetCellFromXY(Widget w, 

	      Position x, Position y, Position * cell_x, Position * cell_y)

{

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    *cell_x = (int)x / (int)(XmIconBox_cell_width(ibw) + XmIconBox_h_margin(ibw));

    *cell_y = (int)y / (int)(XmIconBox_cell_height(ibw) + XmIconBox_v_margin(ibw));

}

/*	Function Name: Find Nearest Cell Location

 *	Description: Finds the nearest cell

 *	Arguments: ibw - the icon box widget.

 * IN/OUT          x, y - Used as an input for the current location

 *                        is output with the new location.

 *	Returns: none

 */

static void

FindNearestCellLocation(Widget w, Position *x, Position *y)

{

    IconInfo temp;

    Dimension width, height;

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    width = XmIconBox_cell_width(ibw);

    height = XmIconBox_cell_height(ibw);

    GetCellFromXY(w, *x + width/2, 

		  *y + height/2, &(temp.cell_x), &(temp.cell_y));

    GetXYFromCell(w, &temp, x, y);

}

/*	Function Name: GetXYFromCell

 *	Description:   Gets the X and Y position for this cell.

 *	Arguments:     info - the cell info.

 * RETURNED            x, y - the coordinates in X space.

 *	Returns:       none.

 */

static void

GetXYFromCell(Widget w, IconInfo * info, Position * x, Position * y)

{

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    Position x_temp = (info->cell_x < 0) ? 0 : info->cell_x;

    Position y_temp = (info->cell_y < 0) ? 0 : info->cell_y;

    *x = XmIconBox_h_margin(ibw) + 

	 x_temp * (XmIconBox_cell_width(ibw) + XmIconBox_h_margin(ibw));

    *y = XmIconBox_v_margin(ibw) + 

	 y_temp * (XmIconBox_cell_height(ibw) + XmIconBox_v_margin(ibw));

}

/*	Function Name: PlaceChildren

 *	Description:   Places all managed children correctly.

 *	Arguments:     w - the icon box widget.

 *                     child - set attributes rather than configure this child.

 *	Returns:       none.

 */

static void 

PlaceChildren(Widget w, Widget child)

{

    Widget * childp;

    Position x, y;

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    ForAllChildren(ibw, childp) {

	if (!XtIsManaged(*childp))

	    continue;

	GetXYFromCell(w, GetIconInfo(*childp), &x, &y);

	if (*childp == child) {

	    child->core.x = x;

	    child->core.y = y;

	    child->core.width = XmIconBox_cell_width(ibw);

	    child->core.height = XmIconBox_cell_height(ibw);

	}

	else {

	    _XmConfigureWidget(*childp, x, y, 

			       XmIconBox_cell_width(ibw), XmIconBox_cell_height(ibw),

			       (*childp)->core.border_width);

	}	

    }

}

/*	Function Name: CalcCellSizes

 *	Description:   Calculates the height and width of each cell.

 *	Arguments:     w - the icon box widget.

 *                     ignore - ignore this child when calculating cell sizes.

 *                     noresize - If true then never attempt a resize.

 *                     query_only - only ask, don't change anything.

 *                     cell_width, cell_height - new size of each cell.

 *	Returns:       none.

 */

static void

CalcCellSizes(Widget w, Widget ignore, Boolean noresize, Boolean query_only, 

	      Dimension * cell_width, Dimension * cell_height)

{

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    Cardinal min_x, min_y;

    Dimension max_w, max_h, d_width, d_height, width, height;

    GetMinCells(w, &min_x, &min_y);

    GetMaxCellSize(w, ignore, &max_w, &max_h);

    min_x++;

    min_y++;

    d_width = XmIconBox_h_margin(ibw) + min_x * (max_w + XmIconBox_h_margin(ibw));

    d_height = XmIconBox_v_margin(ibw) + min_y * (max_h + XmIconBox_v_margin(ibw));

    if (noresize ||

	(_XmRequestNewSize(w, query_only, d_width, d_height, 

			   &width, &height) != XtGeometryYes))

    {

	if (noresize) {

	    width = w->core.width;

	    height = w->core.height;

	}

	/*

	 * We may need to adjust the cell size.

	 */

	if (width < d_width)

	    max_w = (width - XmIconBox_h_margin(ibw))/ min_x - XmIconBox_h_margin(ibw); 

	if (height < d_height)

	    max_h = (height - XmIconBox_v_margin(ibw))/ min_y - XmIconBox_v_margin(ibw); 

    }

    *cell_width = max_w;

    *cell_height = max_h;

}

/*	Function Name: GetMinCells

 *	Description:   Returns the minimum number of cells that should

 *                     be displayed in each direction.

 *	Arguments:     w - the Icon Box widget.

 * RETURN              min_x, min_y - minimum number of cells needed

 *                                    in each direction.

 *                     

 *	Returns:       

 */

static void

GetMinCells(Widget w, Cardinal * min_x, Cardinal * min_y)

{

    Widget * childp;

    XmIconBoxWidget ibw = (XmIconBoxWidget) w;

    *min_x = XmIconBox_min_h_cells(ibw) - 1;

    *min_y = XmIconBox_min_v_cells(ibw) - 1;

    ForAllChildren(ibw, childp) {

	Position x, y;

	IconInfo * info;

	if (!XtIsManaged(*childp))

	    continue;