lib/Exm/Grid.c

/* $XConsortium: Grid.c /main/5 1995/07/15 20:40:45 drk $ */
/*
 * 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
 */
/********************************** WARNING **********************************
 *
 * ExmGrid is a demonstration widget.  OSF provides this widget
 * solely to teach programmers how to write their own Motif widgets.
 * OSF does not support this widget in any way
 *********************************** WARNING *********************************/


/******************************************************************************
 *
 * Grid.c - ExmGrid widget.  This widget manages its children as an MxN matrix.
 *          The ExmGrid widget demonstrates how to
 *             * create a relatively easy Motif manager widget.
 *             * install and use the XmQTspecifyRenderTable trait.
 *             * install and use the XmQTdialogShellSavvy trait.
 *          See the "OSF/Motif Widget Writer's Guide" for details.
 *
******************************************************************************/

/* Include appropriate header files. */
#include <Exm/GridP.h>  /* private header file for the ExmGrid widget */
#include <Xm/GadgetP.h> /* for gadget management functions */
#include <Xm/TraitP.h>  /* for trait access functions */
#include <Xm/DialogSavvyT.h> /* for XmQTdialogSavvy trait */
#include <Xm/SpecRenderT.h> /* for XmQTspecifyRenderTable trait */


/* Define macros. */
#define Max(x, y) (((x) > (y)) ? (x) : (y))
#define WARNING_TOO_MANY_ROWS "Too many rows specified for ExmGrid.\n"
#define WARNING_TOO_MANY_COLUMNS "Too many columns specified for ExmGrid.\n"


/* Declare static functions. */
static void GetDialogTitle(
                        Widget bb,
                        int resource,
                        XtArgVal *value) ;
static void ClassPartInitialize(
                        WidgetClass widgetClass);
static void Initialize(
                        Widget request_w,
                        Widget new_w,
                        ArgList args,
                        Cardinal *num_args );
static void Destroy(
                        Widget wid) ;
static void Resize (
                        Widget w );
static void Redisplay (
                        Widget w,
                        XEvent *event,
                        Region region);
static Boolean SetValues (
                        Widget old_w,
                        Widget request_w,
                        Widget new_w,
                        ArgList args,
                        Cardinal *num_args );
static void SetValuesAlmost(
                        Widget cw,
                        Widget nw,
                        XtWidgetGeometry *request,
                        XtWidgetGeometry *reply) ;
static XtGeometryResult QueryGeometry (
                        Widget w,
                        XtWidgetGeometry *request,
                        XtWidgetGeometry *reply);
static XtGeometryResult GeometryManager (
                        Widget w,
                        XtWidgetGeometry *request,
                        XtWidgetGeometry *reply);
static void ChangeManaged (
                        Widget w);
static Boolean ConstraintSetValues (
                        Widget cw,
                        Widget rw,
                        Widget nw,
                        ArgList args,
                        Cardinal *num_args);
static void Layout (
                        Widget wid,
                        Widget instigator);
static void CalcSize (
                        Widget wid,
                        Widget instigator,
                        Dimension *gridWidth,
                        Dimension *gridHeight);
static Boolean NeedRelayout (
                        Widget new,
                        Widget cur);
static void CallMapUnmap(Widget wid,
			 Boolean map_unmap) ;
static XmRenderTable GetTable(Widget wid,
			   XtEnum type);


/* No translations and no actions. */


/* Define the resources for the ExmGrid widget. */
static XtResource resources[] =
{
    {
	XmNrows,
	XmCRows,
	XmRShort,
	sizeof (short),
	XtOffsetOf( ExmGridRec, grid.rows),
	XmRImmediate,
        (XtPointer) 4
    },
    {
	XmNcolumns,
	XmCColumns,
	XmRShort,
	sizeof (short),
	XtOffsetOf( ExmGridRec, grid.columns),
	XmRImmediate,
        (XtPointer) 4
    },
    {
	XmNmarginWidth,
	XmCMarginWidth,
	XmRHorizontalDimension,
	sizeof (Dimension),
	XtOffsetOf( ExmGridRec, grid.margin_width),
	XmRImmediate,
        (XtPointer) 10
    },
    {
	XmNmarginHeight,
	XmCMarginHeight,
	XmRVerticalDimension,
	sizeof (Dimension),
	XtOffsetOf(ExmGridRec, grid.margin_height),
	XmRImmediate,
        (XtPointer) 10
    },
    {
	XmNmapCallback,
	XmCCallback,
	XmRCallback,
	sizeof (XtCallbackList),
	XtOffsetOf(ExmGridRec, grid.map_callback),
	XmRImmediate,
	(XtPointer) NULL
    },
    {
	XmNunmapCallback,
	XmCCallback,
	XmRCallback,
	sizeof (XtCallbackList),
	XtOffsetOf(ExmGridRec, grid.unmap_callback),
	XmRImmediate,
	(XtPointer) NULL
    },
    {
	XmNdefaultPosition,
	XmCDefaultPosition,
	XmRBoolean, sizeof (Boolean),
	XtOffsetOf(ExmGridRec, grid.default_position),
	XmRImmediate,
	(XtPointer) True
    },
    {
	XmNbuttonRenderTable,
	XmCButtonRenderTable,
	XmRButtonRenderTable,
	sizeof (XmRenderTable),
	XtOffsetOf(ExmGridRec, grid.button_render_table),
	XmRCallProc, (XtPointer) NULL
    },
    {
	XmNlabelRenderTable,
	XmCLabelRenderTable,
	XmRLabelRenderTable,
	sizeof (XmRenderTable),
	XtOffsetOf(ExmGridRec, grid.label_render_table),
	XmRCallProc, (XtPointer) NULL
    },
    {
	XmNtextRenderTable,
	XmCTextRenderTable,
	XmRTextRenderTable,
	sizeof (XmRenderTable),
	XtOffsetOf(ExmGridRec, grid.text_render_table),
	XmRCallProc, (XtPointer) NULL
    },
    {
	XmNdialogTitle,
	XmCDialogTitle,
	XmRXmString,
	sizeof (XmString),
	XtOffsetOf(ExmGridRec, grid.dialog_title),
	XmRImmediate, (XtPointer) NULL
    },

};

/* Three of the preceding resources will be handled as synthetic
   resources. */
static XmSyntheticResource syn_resources[] =
{
    {
	XmNmarginWidth,
	sizeof (Dimension),
	XtOffsetOf( ExmGridRec, grid.margin_width),
	XmeFromHorizontalPixels,
	XmeToHorizontalPixels
    },
    {
	XmNmarginHeight,
	sizeof (Dimension),
	XtOffsetOf( ExmGridRec, grid.margin_height),
	XmeFromVerticalPixels,
	XmeToVerticalPixels
    },
    {
	XmNdialogTitle,
	sizeof (XmString),
	XtOffsetOf( ExmGridRec, grid.dialog_title),
	GetDialogTitle,
	NULL
     }
};


/* Define the two constraints of ExmGrid. */
static XtResource constraints[] =
{
    {
        ExmNgridMarginWidthWithinCell,
        ExmCGridMarginWidthWithinCell,
        XmRHorizontalDimension,
        sizeof (Dimension),
        XtOffsetOf( ExmGridConstraintRec, grid.grid_margin_width_within_cell),
        XmRImmediate,
        (XtPointer) 0
    },
    {
        ExmNgridMarginHeightWithinCell,
        ExmCGridMarginHeightWithinCell,
        XmRVerticalDimension,
        sizeof (Dimension),
        XtOffsetOf( ExmGridConstraintRec, grid.grid_margin_height_within_cell),
        XmRImmediate,
        (XtPointer) 0
    },
};


/* Both of the preceding constraints will be handled as synthetic
   constraints. */
static XmSyntheticResource syn_constraints[] =
{
    {
        ExmNgridMarginWidthWithinCell,
        sizeof (Dimension),
        XtOffsetOf( ExmGridConstraintRec, grid.grid_margin_width_within_cell),
        XmeFromHorizontalPixels,
        XmeToHorizontalPixels
    },
    {
        ExmNgridMarginHeightWithinCell,
        sizeof (Dimension),
        XtOffsetOf( ExmGridConstraintRec, grid.grid_margin_height_within_cell),
        XmeFromVerticalPixels,
        XmeToVerticalPixels
    },
};


/* Define the widget class record.  See Chapter 4 of the
   "OSF/Motif Widget Writer's Guide" for details. */
externaldef(exmgridclassrec) ExmGridClassRec exmGridClassRec =
{
  { /* Here is the Core class record. */
    /* superclass */                 (WidgetClass) &xmManagerClassRec,
    /* class_name */                 "ExmGrid",
    /* widget_size */                sizeof(ExmGridRec),
    /* class_initialize */           NULL,
    /* class_part_initialize */      ClassPartInitialize,
    /* class_inited */               FALSE,
    /* initialize */                 Initialize,
    /* initialize_hook */            NULL,
    /* realize */                    XtInheritRealize,
    /* actions */                    NULL,
    /* num_actions */                0,
    /* resources */                  resources,
    /* num_resources */              XtNumber(resources),
    /* xrm_class */                  NULLQUARK,
    /* compress_motion */            TRUE,
    /* compress_exposure */          XtExposeCompressMaximal,
    /* compress_enterleave */        TRUE,
    /* visible_interest */           FALSE,
    /* destroy */                    Destroy,
    /* resize */                     Resize,
    /* expose */                     Redisplay,
    /* set_values */                 SetValues,
    /* set_values_hook */            NULL,
    /* set_values_almost */          SetValuesAlmost,
    /* get_values_hook */            NULL,
    /* accept_focus */               NULL,
    /* version */                    XtVersion,
    /* callback_private */           NULL,
    /* tm_table */                   XtInheritTranslations,
    /* query_geometry */             QueryGeometry,
    /* display_accelerator */        NULL,
    /* extension */                  NULL,
  },
  { /* Here is the Composite class record. */
    /* geometry_manager */           GeometryManager,
    /* change_managed */             ChangeManaged,
    /* insert_child */               XtInheritInsertChild,
    /* delete_child */               XtInheritDeleteChild,
    /* extension */                  NULL,
  },
  { /* Here is the Constaint class record. */
    /* constraint_resources */       constraints,
    /* constraint_num_resources */   XtNumber(constraints),
    /* constraint_size */            sizeof(ExmGridConstraintRec),
    /* constraint_initialize */      NULL,
    /* constraint_destroy */         NULL,
    /* constraint_set_values */      ConstraintSetValues,
    /* extension */                  NULL,
  },
  { /* Here is the XmManager class record. */
    /* translations */               XtInheritTranslations,
    /* syn_resources */              syn_resources,
    /* num_syn_resources */          XtNumber(syn_resources),
    /* syn_constraint_resources */   syn_constraints,
    /* num_syn_constraint_resources */ XtNumber(syn_constraints),
    /* parent_process */             XmInheritParentProcess,
    /* extension */                  NULL,
  },
  { /* Here is the ExmGrid class record. */
    /* layout */                     Layout,
    /* calc_size */                  CalcSize,
    /* need_relayout */              NeedRelayout,
    /* extension */                  NULL,
  }
};

/* Establish the widget class name as an externally accessible symbol.
   Use the "externaldef" macro rather than the "extern" keyword. */
externaldef(exmgridwidgetclass) WidgetClass exmGridWidgetClass =
    (WidgetClass) &exmGridClassRec;


             /* Define trait record variables. */

/* Here is the trait record variable for the XmQTdialogSavvy trait. */
static XmConst XmDialogSavvyTraitRec gridDST = {
  0,            /* version */
  CallMapUnmap, /* trait method */
};


/* Here is the trait record variable for the XmQTspecifyRenderTable trait. */
static XmConst XmSpecRenderTraitRec gridSRTT = {
  0,		/* version */
  GetTable,     /* trait method */
};


/****************************************************************************
 *
 *  GetDialogTitle
 *      Copy the XmString in XmNdialogTitle before returning it to the user.
 *
 ****************************************************************************/
static void
GetDialogTitle(
        Widget wid,
        int resource,
        XtArgVal *value)
{
   *value = (XtArgVal)XmStringCopy(((ExmGridWidget) wid)->grid.dialog_title);
}


/****************************************************************************
 *
 *  ClassPartInitialize:
 *      Called when this widget or a subclass of this widget is instantiated.
 *
 ****************************************************************************/
static void
ClassPartInitialize (
        WidgetClass widgetClass
                    )
{
 ExmGridWidgetClass wc = (ExmGridWidgetClass)widgetClass;
 ExmGridWidgetClass sc = (ExmGridWidgetClass)wc->core_class.superclass;

  /* The following code allows subclasses of ExmGrid to inherit three of
     ExmGrid's methods. */
    if (wc->grid_class.layout == ExmInheritLayout)
	wc->grid_class.layout = sc->grid_class.layout;
    if (wc->grid_class.calc_size == ExmInheritCalcSize)
	wc->grid_class.calc_size = sc->grid_class.calc_size;
    if (wc->grid_class.need_relayout == ExmInheritNeedRelayout)
	wc->grid_class.need_relayout = sc->grid_class.need_relayout;

  /* Install the XmQTdialogShellSavyy trait on this class and on
     all its future subclasses. */
    XmeTraitSet(widgetClass, XmQTdialogShellSavvy, (XtPointer) &gridDST);

  /* Install the XmQTspecifyRenderTable trait on this class and on
     all its future subclasses. */
    XmeTraitSet(widgetClass, XmQTspecifyRenderTable, (XtPointer) &gridSRTT);
}


/**************************************************************************
 *
 *  Initialize:
 *      Called when this widget is first instantiated.
 *
 ***************************************************************************/
static void
Initialize (
        Widget request_w,
        Widget new_w,
        ArgList args,
        Cardinal *num_args
           )
{
 ExmGridWidget rw = (ExmGridWidget)request_w;
 ExmGridWidget nw = (ExmGridWidget)new_w;

  /* Initialize one of the internal fields of the ExmGrid widget. */
    nw->grid.processing_constraints = False;

  /* Ensure that user doesn't specify too many rows. */
    if (rw->grid.rows > EXM_GRID_MAX_NUMBER_OF_ROWS) {
      XmeWarning((Widget)rw, WARNING_TOO_MANY_ROWS);
      nw->grid.rows = EXM_GRID_MAX_NUMBER_OF_ROWS;
    }

  /* Ensure that user doesn't specify too many columns. */
    if (rw->grid.columns > EXM_GRID_MAX_NUMBER_OF_COLUMNS) {
      XmeWarning((Widget)rw, WARNING_TOO_MANY_COLUMNS);
      nw->grid.columns = EXM_GRID_MAX_NUMBER_OF_COLUMNS;
    }

  /* Copy in the dialog title XmString and update our shell */
    if (nw->grid.dialog_title) {
      nw->grid.dialog_title = XmStringCopy(rw->grid.dialog_title) ;
      XmeSetWMShellTitle(nw->grid.dialog_title, XtParent(new_w)) ;
    }
}


/****************************************************************************
 *
 *  Destroy:
 *      Called when the widget is destroyed.
 *
 ****************************************************************************/
static void
Destroy(
        Widget wid )
{
 ExmGridWidget grid = (ExmGridWidget)wid;

  /* Deallocate the dynamic memory that holds the dialog_title. */
    XmStringFree(grid->grid.dialog_title) ;
}


/****************************************************************************
 *
 *  Resize:
 *
 ****************************************************************************/
static void
Resize (
        Widget w
       )
{
 ExmGridWidgetClass gwc = (ExmGridWidgetClass) XtClass(w);

  /* Configure the children by calling Layout. */
    if (gwc->grid_class.layout)
      (*(gwc->grid_class.layout))(w, NULL);
    else
      Layout (w, NULL);
}


/****************************************************************************
 *
 *  Redisplay:
 *      Called by the Intrinsics in response to an exposure event.
 *
 ***************************************************************************/
static void
Redisplay (
        Widget w,
        XEvent *event,
        Region region
          )
{
  /* Pass exposure event down to gadget children. */
    XmeRedisplayGadgets (w, event, region);
}


/*****************************************************************************
 *
 *  SetValues:
 *      Called by the Intrinsics whenever any of the resource values change.
 *
 ****************************************************************************/
static Boolean
SetValues (
        Widget old_w,
        Widget request_w,
        Widget new_w,
        ArgList args,
        Cardinal *num_args
          )
{
 ExmGridWidget cw = (ExmGridWidget)old_w;
 ExmGridWidget rw = (ExmGridWidget)request_w;
 ExmGridWidget nw = (ExmGridWidget)new_w;
 Boolean redisplay = False;
 Boolean need_relayout;
 ExmGridWidgetClass gwc = (ExmGridWidgetClass) XtClass(new_w);

  /* Ensure that user doesn't specify too many rows. */
    if (rw->grid.rows > EXM_GRID_MAX_NUMBER_OF_ROWS) {
      XmeWarning((Widget)rw, WARNING_TOO_MANY_ROWS);
      nw->grid.rows = EXM_GRID_MAX_NUMBER_OF_ROWS;
    }

  /* Ensure that user doesn't specify too many rows. */
    if (rw->grid.columns > EXM_GRID_MAX_NUMBER_OF_COLUMNS) {
      XmeWarning((Widget)rw, WARNING_TOO_MANY_COLUMNS);
      nw->grid.columns = EXM_GRID_MAX_NUMBER_OF_COLUMNS;
    }

  /* See if any class or subclass resources have changed. */
    if (gwc->grid_class.need_relayout)
      need_relayout = (*(gwc->grid_class.need_relayout))(old_w, new_w);
    else
      need_relayout = NeedRelayout (old_w, new_w);

  /* If any geometry resources changed and a new size wasn't specified,
     recalculate a new ideal size. */
    if (need_relayout) {
      /* Reset the widget size so that CalcSize can affect them. */
	if (nw->core.width == cw->core.width)
          nw->core.width = 0;
	if (nw->core.height == cw->core.height)
          nw->core.height = 0;

      /* Call CalcSize. */
        if (gwc->grid_class.calc_size)
          (*(gwc->grid_class.calc_size))(new_w, NULL,
                                         &nw->core.width, &nw->core.height);
        else
          CalcSize (new_w, NULL, &nw->core.width, &nw->core.height);


      /* If the geometry resources have changed but the size hasn't,
	 we need to relayout manually, because Xt won't generate a
	 Resize at this point. */
	if ((nw->core.width == cw->core.width) &&
          (nw->core.height == cw->core.height)) {

         /* Call Layout to configure the children. */
           if (gwc->grid_class.layout)
             (*(gwc->grid_class.layout))(new_w, NULL);
           else
             Layout(new_w, NULL);
           redisplay = True ;
	}
    }

 /* ExmGrid installs the XmQTdialogShellSavvy trait.  Therefore, ExmGrid
    has to process the Xm_DIALOG_SAVVY_FORCE_ORIGIN case, which is as
    follows.  A DialogShell always mimics the child position on itself.
    That is, the "current" position of an ExmGrid within a DialogShell is
    always 0.  Therefore, if an application tries to set ExmGrid's x or
    y position to 0, the Intrinsics will not detect a position change and
    wll not trigger a geometry request.  ExmGrid has to detect this special
    request and set core.x and core.y to the special value,
    XmDIALOG_SAVVY_FORCE_ORIGIN.  That is, XmDIALOG_SAVVY_FORCE_ORIGIN
    tells DialogShell that ExmGrid really does want to move to an x or y
    position of 0. */

   if (XmIsDialogShell(XtParent(new_w)))  {   /* Is parent a DialogShell? */
     Cardinal i ;

    /* We have to look in the arglist since old_w->core.x is always 0, and
       if new_w->core.x is also set to 0, we see no change. */
      for (i=0; i<*num_args; i++) {
         if (strcmp (args[i].name, XmNx) == 0) {
	   if ((args[i].value == 0) && (new_w->core.x == 0))
             new_w->core.x = XmDIALOG_SAVVY_FORCE_ORIGIN;
	 }
	 if (strcmp (args[i].name, XmNy) == 0) {
           if ((args[i].value == 0) && (new_w->core.y == 0))
             new_w->core.y = XmDIALOG_SAVVY_FORCE_ORIGIN;
         }
      } /* end for */
   } /* end of if */

   /* Update wm shell title if it has changed */
   if(nw->grid.dialog_title != cw->grid.dialog_title ) {
        XmStringFree(cw->grid.dialog_title) ;
        nw->grid.dialog_title = XmStringCopy(rw->grid.dialog_title) ;
        XmeSetWMShellTitle(nw->grid.dialog_title, XtParent(new_w)) ;
   }

   return (redisplay);
}


/*************************************************************************
 *
 *  SetValuesAlmost:
 *       Called by the Intrinsics when an XtMakeGeometryRequest call
 *       returns either XmGeometryAlmost or XtGeometryNo.
 *
 ***************************************************************************/
static void
SetValuesAlmost(
        Widget cw,		/* unused */
        Widget nw,
        XtWidgetGeometry *request,
        XtWidgetGeometry *reply )
{
 ExmGridWidgetClass gwc = (ExmGridWidgetClass) XtClass(nw);

  /* ExmGrid's parent said XtGeometryNo to ExmGrid's geometry request.
     Therefore, we need to relayout because this request
     was due to a change in internal geometry resource of the ExmGrid */
    if (!reply->request_mode) {
	if (gwc->grid_class.layout)
	    (*(gwc->grid_class.layout))(nw, NULL);
	else
	    Layout(nw, NULL);
    }

    *request = *reply;
}


/*************************************************************************
 *
 *  QueryGeometry:
 *       Called by a parent of Grid when the parent needs to find out Grid's
 *       preferred size.  QueryGeometry calls CalcSize to do find the
 *       preferred size.
 *
 ***************************************************************************/
static XtGeometryResult
QueryGeometry (
        Widget w,
        XtWidgetGeometry *request,
        XtWidgetGeometry *reply
              )
{
 ExmGridWidgetClass gwc = (ExmGridWidgetClass) XtClass(w);

  /* If ExmGrid's parent calls XtQueryGeometry before ExmGrid has been
     realized, use the current size of ExmGrid as the preferred size. */
  /* Deal with user initial size setting */
    if (!XtIsRealized(w))  {  /* Widget is not yet realized. */
	reply->width = XtWidth(w) ;    /* might be 0 */
	reply->height = XtHeight(w) ;  /* might be 0 */
    } else {	    /* Widget is realized. */
	/* always computes natural size afterwards */
	reply->width = 0;
	reply->height = 0;
    }

  /* Call CalcSize to figure out what the preferred size really is. */
    if (gwc->grid_class.calc_size)
      (*(gwc->grid_class.calc_size))(w, NULL, &reply->width, &reply->height);
    else
      CalcSize (w, NULL, &reply->width, &reply->height);

  /* This function handles CWidth and CHeight */
    return XmeReplyToQueryGeometry(w, request, reply) ;
}


/****************************************************************************
 *
 *  GeometryManager:
 *       Called by Intrinsics in response to a geometry change request from
 *       one of the children of ExmGrid.
 *
 ***************************************************************************/
static XtGeometryResult
GeometryManager (
        Widget w,  /* instigator */
        XtWidgetGeometry *request,
        XtWidgetGeometry *reply
                )
{
 ExmGridWidget gw = (ExmGridWidget) XtParent(w);
 XtWidgetGeometry parentRequest;
 XtGeometryResult result;
 Dimension curWidth, curHeight, curBW;
 ExmGridWidgetClass gwc = (ExmGridWidgetClass) XtClass((Widget)gw);

  /* If the request was caused by ConstraintSetValues reset the flag */
    if (gw->grid.processing_constraints) {
      gw->grid.processing_constraints = False;
	/* The ConstraintSetValues added one to border_width;
	   This is the Xt trick used to fire the GM when a non core
	   geometry resource (like a constraint) changes.
	   now take it away. */
	request->border_width -= 1;
    }

  /* Save the original child resources. */
    curWidth = w->core.width;
    curHeight = w->core.height;
    curBW = w->core.border_width;

  /* Deny any requests for a new position. */
    if ((request->request_mode & CWX) || (request->request_mode & CWY))
	return XtGeometryNo ;

   if (request->request_mode & CWWidth)
     w->core.width = request->width;
   if (request->request_mode & CWHeight)
     w->core.height = request->height;
   if (request->request_mode & CWBorderWidth)
     w->core.border_width = request->border_width;

  /* Calculate a new ideal size based on these requests. */
  /* Setting width and height to 0 tells CalcSize to override these
     fields with the calculated width and height. */
    parentRequest.width = 0;
    parentRequest.height = 0;
    if (gwc->grid_class.calc_size)
	(*(gwc->grid_class.calc_size))((Widget)gw, w,
				       &parentRequest.width,
				       &parentRequest.height);
    else
	CalcSize ((Widget)gw, w, &parentRequest.width, &parentRequest.height);


  /* Ask the Grid's parent if new calculated size is acceptable. */
    parentRequest.request_mode = CWWidth | CWHeight;
    if (request->request_mode & XtCWQueryOnly)
	parentRequest.request_mode |= XtCWQueryOnly;
    result = XtMakeGeometryRequest ((Widget)gw, &parentRequest, NULL);

  /*  Turn XtGeometryAlmost into XtGeometryNo. */
    if (result == XtGeometryAlmost)
      result = XtGeometryNo;

    if (result == XtGeometryNo ||
	request->request_mode & XtCWQueryOnly) {
	/* Restore original geometry. */
	w->core.width = curWidth;
	w->core.height = curHeight;
	w->core.border_width = curBW;
   } else {
       /* result == XtGeometryYes and this wasn't just a query */
       if (gwc->grid_class.layout)
	   (*(gwc->grid_class.layout))((Widget)gw, w);
       else
	   Layout ((Widget)gw, w); /* Layout with this child as the instigator,
			              so that we don't resize this child. */
   }

   return (result);
}


/**************************************************************************
 *
 *  ChangeManaged:
 *      Called by the Intrinsics whenever either of the following happens:
 *           * a managed child becomes unmanaged.
 *           * an unmanaged child becomes managed.
 *
 *************************************************************************/
static void
ChangeManaged(
        Widget w
             )
{
 Dimension gridWidth, gridHeight;
 ExmGridWidgetClass gwc = (ExmGridWidgetClass) XtClass(w);

  /* If you get an initial (C) size from the user or application, keep it.
     Otherwise, just force width and height to 0 so that CalcSize will
     overwrite the appropriate fields. */
    if (!XtIsRealized(w))  {
	/* The first time, only attempts to change non specified sizes */
	gridWidth = XtWidth(w) ;   /* might be 0 */
	gridHeight = XtHeight(w) ; /* might be 0 */
    } else {
	gridWidth = 0 ;
	gridHeight = 0 ;
    }

  /* Determine the ideal size of Grid. */
    if (gwc->grid_class.calc_size)
	(*(gwc->grid_class.calc_size))(w, NULL, &gridWidth, &gridHeight);
    else
	CalcSize (w, NULL, &gridWidth, &gridHeight);

 /* Ask parent of Grid if Grid's new size is acceptable.  Keep asking until
    parent returns either XtGeometryYes or XtGeometryNo. */
    while (XtMakeResizeRequest (w, gridWidth, gridHeight,
   		                &gridWidth, &gridHeight) == XtGeometryAlmost);

    /* Now that we have a size for the Grid, we can layout the children
       of the grid. */
    if (gwc->grid_class.layout)
	(*(gwc->grid_class.layout))(w, NULL);
    else
	Layout (w, NULL);

    /* Update keyboard traversal */
    XmeNavigChangeManaged (w);
}


/**************************************************************************
 *
 *  ConstraintSetValues:
 *      Called by Intrinsics if there is any change in any of the constraint
 *      resources.
 *
 **************************************************************************/
static Boolean
ConstraintSetValues (
    Widget cw,
    Widget rw,
    Widget nw,
    ArgList args,
    Cardinal *num_args
                    )
{
 ExmGridConstraint nc;
 ExmGridConstraint cc;
 ExmGridWidget gw;

    if (!XtIsRectObj (nw))
	return (False);

    gw = (ExmGridWidget)XtParent(nw);
    nc = ExmGridCPart(nw);
    cc = ExmGridCPart(cw);

    /* Check for change in ExmNgridMarginWidth or ExmNgridMarginHeight */
    if ((nc->grid_margin_width_within_cell !=
	 cc->grid_margin_width_within_cell ||
	 nc->grid_margin_height_within_cell !=
	 cc->grid_margin_height_within_cell) &&
	XtIsManaged (nw)) {
	/* Tell the Intrinsics and the GeometryManager method that a
	   reconfigure is needed. */
	gw->grid.processing_constraints = True;
     /* A trick: by altering one of the core geometry fields, Xt will
        call the parent's geometry_manager method. */
	nw->core.border_width += 1;
    }

    return (False);
}


/***************************************************************************
 *
 *  Layout:
 *     Does all the placement of children.
 *     Instigator tells whether or not to resize all children.
 *
 *************************************************************************/
static void
Layout (
        Widget wid,
        Widget instigator
       )
{
 ExmGridWidget gw = (ExmGridWidget) wid ;
 Dimension mw = gw->grid.margin_width;
 Dimension mh = gw->grid.margin_height;
 Dimension TotalWidthOfGridWidget  = gw->core.width;
 Dimension TotalWidthOfGridMargins, TotalHeightOfGridMargins;
 Dimension TotalHeightOfGridWidget = gw->core.height;
 Dimension AvailWidthForChildren = 1, AvailHeightForChildren = 1;
 Dimension WidthAllottedEachChild, HeightAllottedEachChild;
 int i, row, column;

    /* Lay out the children that ExmGrid is currently managing.
       Each child will be placed somewhere on the rowxcolumn grid. */
    TotalWidthOfGridMargins = 2 * mw;
    if (TotalWidthOfGridWidget > TotalWidthOfGridMargins)
	AvailWidthForChildren = TotalWidthOfGridWidget -
	    TotalWidthOfGridMargins;

    WidthAllottedEachChild = AvailWidthForChildren / gw->grid.columns;

    TotalHeightOfGridMargins = 2 * mh;
    if (TotalHeightOfGridWidget > TotalHeightOfGridMargins)
	AvailHeightForChildren = TotalHeightOfGridWidget -
	    TotalHeightOfGridMargins;
    HeightAllottedEachChild = AvailHeightForChildren / gw->grid.rows;

    /* Now that we know how much space is allotted for each child, we
       can lay them all out. */
    row = 0;
    column = 0;
    for (i = 0; i < gw->composite.num_children; i++) {
	Widget ic = gw->composite.children[i];
	ExmGridConstraint glc = ExmGridCPart (ic);
	Dimension gmw = glc->grid_margin_width_within_cell;
	Dimension gmh = glc->grid_margin_height_within_cell;
	Position ChildsStartingX, ChildsStartingY;
	Dimension ChildsActualWidth, ChildsActualHeight, cb;

	if (!XtIsManaged(ic))
	    continue;  /* ignored unmanaged children */

	cb = ic->core.border_width;

	/* Calculate the position and the size of the child.
	   During the layout, the children are all resized
	   to exactly fit the cell size minus the cell margin */

	ChildsActualWidth = WidthAllottedEachChild - (2 * (gmw + cb));
	ChildsStartingX = mw + (column * WidthAllottedEachChild) + gmw;
	ChildsStartingY = mh + (row * HeightAllottedEachChild) + gmh;
	ChildsActualHeight = HeightAllottedEachChild - 2 * (gmh + cb);

	/* If layout is instigated by the GeometryManager don't
	   configure the requesting child, just set its geometry and
	   let Xt configure it.   */
	if (ic != instigator) {
	    XmeConfigureObject (ic, ChildsStartingX, ChildsStartingY,
				ChildsActualWidth, ChildsActualHeight, cb);
	}
	else {
	    ic->core.x = ChildsStartingX;
	    ic->core.y = ChildsStartingY;
	    ic->core.width = ChildsActualWidth;
	    ic->core.height = ChildsActualHeight;
	    ic->core.border_width = cb;
	}

	/* Advance the column counter until we reach the right edge.
	   When we reach the right edge, reset the column
	   counter back to 0 (left edge) and advance the row counter. */
	column += 1;

	if (column == gw->grid.columns) {
	    column = 0;
	    row += 1;
	}
    }
}


/******************************************************************************
 *
 *  CalcSize:
 *     Called by QueryGeometry, SetValues, GeometryManager, and ChangeManaged.
 *     Calculate the ideal size of the ExmGrid widget.
 *     Only affects the returned size if it is 0.
 *
 ****************************************************************************/
static void
CalcSize (
        Widget wid,
        Widget instigator,
        Dimension *TotalWidthOfGridWidget,
        Dimension *TotalHeightOfGridWidget
         )
{
 ExmGridWidget gw = (ExmGridWidget) wid ;
 Dimension maxWidth = 1;
 Dimension maxHeight = 1;
 int i;

  /* Examine each of Grid's children.  Find the biggest child.  The
     ideal size of the Grid will be large enough to accomodate the
     largest child. */
    for (i = 0; i < gw->composite.num_children; i++) {
	Widget ic = gw->composite.children[i];
	ExmGridConstraint glc = ExmGridCPart (ic);
	Dimension width, height;
	Dimension cw, ch, cb;
	XtWidgetGeometry reply;

	if (!XtIsManaged(ic))
            continue ;

	/* Get child's preferred geometry if not the instigator. */
        if (ic != instigator) {
	    XtQueryGeometry (ic, NULL, &reply);
	    cw = (reply.request_mode & CWWidth) ? reply.width :
		ic->core.width;
	    ch = (reply.request_mode & CWHeight) ? reply.height :
		ic->core.height;
	} else {
	    cw = ic->core.width;
	    ch = ic->core.height;
	}
	cb = ic->core.border_width;

	width = cw + 2 * (cb + glc->grid_margin_width_within_cell);
	height = ch + 2 * (cb + glc->grid_margin_height_within_cell);

	maxWidth  = Max (width, maxWidth);
        maxHeight = Max (height, maxHeight);
    }


 /* The total width of the grid widget should be set to the width of
    the largest child widget times the number of columns. */
   if (!*TotalWidthOfGridWidget) {
       *TotalWidthOfGridWidget = maxWidth * gw->grid.columns +
   			         (2 * (gw->grid.margin_width));
   }

 /* The total height of the grid widget should be set to the height of
    the largest child widget times the number of columns. */
   if (!*TotalHeightOfGridWidget) {
       *TotalHeightOfGridWidget = maxHeight * gw->grid.rows +
   			          (2 * (gw->grid.margin_height));
   }
}


/****************************************************************************
 *
 *  NeedRelayout:
 *     Called by SetValues.
 *     Returns True if a relayout is needed.
 *     based on this class and all superclass resources' changes.
 *
 ***************************************************************************/
static Boolean
NeedRelayout (
        Widget old_w,
        Widget new_w
         )
{
 ExmGridWidget cw = (ExmGridWidget)old_w;
 ExmGridWidget nw = (ExmGridWidget)new_w;

    if (nw->grid.margin_width != cw->grid.margin_width ||
	nw->grid.margin_height != cw->grid.margin_height ||
	nw->grid.rows != cw->grid.rows ||
	nw->grid.columns != cw->grid.columns) {
	return True ;
    } else
	return False ;
}


/*-- Trait methods --*/


/****************************************************************
 *
 * Trait method for XmQTdialogShellSavvy trait.
 *
 **************************************************************/
static void
CallMapUnmap(
	 Widget wid,
	 Boolean map_unmap)
{
    ExmGridWidget grid = (ExmGridWidget) wid ;
    XmAnyCallbackStruct call_data;

    call_data.reason = (map_unmap)? XmCR_MAP : XmCR_UNMAP;
    call_data.event  = NULL;

    if (map_unmap) {
	XtCallCallbackList (wid, grid->grid.map_callback,
			    &call_data);
    } else {
	XtCallCallbackList (wid, grid->grid.unmap_callback,
			    &call_data);
    }
}

/*****************************************************************
 *
 * Trait method for XmQTspecifyRenderTable.
 *
*****************************************************************/

static XmRenderTable
GetTable(
	 Widget wid,
	 XtEnum type)
{
    ExmGridWidget grid = (ExmGridWidget) wid ;

    switch(type) {
    case XmLABEL_RENDER_TABLE : return grid->grid.label_render_table ;
    case XmBUTTON_RENDER_TABLE : return grid->grid.button_render_table ;
    case XmTEXT_RENDER_TABLE : return grid->grid.text_render_table ;
    }

    return NULL ;
}


/*******************************************************************************
 *
 *  ExmCreateGrid:
 *      Called by an application.
 *
 ******************************************************************************/
Widget
ExmCreateGrid (
        Widget parent,
        char *name,
        ArgList arglist,
        Cardinal argcount
              )
{
 /* This is a convenience function to instantiate an ExmGrid widget. */
   return (XtCreateWidget (name, exmGridWidgetClass, parent,
                           arglist, argcount));
}


/*******************************************************************************
 *
 *  ExmCreateGridDialog
 *      Called by an application to create an ExmGrid managed by a
 *      DialogShell.
 *
 ******************************************************************************/
Widget
ExmCreateGridDialog (
        Widget parent,
        char *name,
        ArgList arglist,
        Cardinal argcount
              )
{
   return XmeCreateClassDialog (exmGridWidgetClass,
                                parent, name, arglist, argcount) ;

}