/*

 * 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 HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef REV_INFO

#ifndef lint

static char *rcsid = "$XConsortium: RCLayout.c /main/6 1995/10/25 20:14:15 cde-sun $";

#endif

#endif

#include <stdio.h>

#include <ctype.h>

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>

#endif

#include <Xm/CascadeBGP.h>

#include <Xm/CascadeBP.h>

#include <Xm/GadgetP.h>

#include <Xm/LabelP.h>

#include <Xm/ManagerP.h>

#include <Xm/PrimitiveP.h>

#include <Xm/RowColumnP.h>

#include <Xm/TearOffBP.h>

#include <Xm/TearOffP.h>

#include <Xm/XmosP.h>		/* for bzero */

#include "LabelGI.h"

#include "GeoUtilsI.h"

#include "RCLayoutI.h"

#include "RowColumnI.h"

#include "XmI.h"

#define RESOURCE_MIN_WIDTH	16 /* 'cuz it's the size of a hot spot... */

#define RESOURCE_MIN_HEIGHT	16

static void CalcHelp( 

                        XmRowColumnWidget m,

                        Dimension *m_width,

                        Dimension *m_height,

#if NeedWidePrototypes

                        int b,

                        int max_x,

                        int max_y,

#else

                        Dimension b,

                        Position max_x,

                        Position max_y,

#endif /* NeedWidePrototypes */

                        Position *x,

                        Position *y,

#if NeedWidePrototypes

                        int w,

                        int h) ;

#else

                        Dimension w,

                        Dimension h) ;

#endif /* NeedWidePrototypes */

static void GetMaxValues( 

                        XmRowColumnWidget m,

                        Dimension *border,

                        Dimension *w,

                        Dimension *h,

                        int *items_per,

                        Dimension *baseline,

                        Dimension *shadow,

                        Dimension *highlight,

                        Dimension *margin_top,

                        Dimension *margin_height,

                        Dimension *text_height) ;

static void AdjustLast( 

                        XmRowColumnWidget m,

                        int start_i,

#if NeedWidePrototypes

                        int w,

                        int h) ;

#else

                        Dimension w,

                        Dimension h) ;

#endif /* NeedWidePrototypes */

static void SetAsking( 

                        XmRowColumnWidget m,

                        Dimension *m_width,

                        Dimension *m_height,

#if NeedWidePrototypes

                        int b,

                        int max_x,

                        int max_y,

                        int x,

                        int y,

                        int w,

                        int h) ;

#else

                        Dimension b,

                        Position max_x,

                        Position max_y,

                        Position x,

                        Position y,

                        Dimension w,

                        Dimension h) ;

#endif /* NeedWidePrototypes */

static void FindLargestOption( 

                        XmRowColumnWidget submenu,

                        Dimension *c_width,

                        Dimension *c_height) ;

static void TopOrBottomAlignment( 

                        XmRowColumnWidget m,

#if NeedWidePrototypes

                        int h,

                        int shadow,

                        int highlight,

                        int baseline,

                        int margin_top,

                        int margin_height,

                        int text_height,

#else

                        Dimension h,

                        Dimension shadow,

                        Dimension highlight,

                        Dimension baseline,

                        Dimension margin_top,

                        Dimension margin_height,

                        Dimension text_height,

#endif /* NeedWidePrototypes */

                        Dimension *new_height,

                        int start_i,

                        int end_i) ;

static void BaselineAlignment( 

                        XmRowColumnWidget m,

#if NeedWidePrototypes

                        int h,

                        int shadow,

                        int highlight,

                        int baseline,

#else

                        Dimension h,

                        Dimension shadow,

                        Dimension highlight,

                        Dimension baseline,

#endif /* NeedWidePrototypes */

                        Dimension *new_height,

                        int start_i,

                        int end_i) ;

static void CenterAlignment( 

                        XmRowColumnWidget m,

#if NeedWidePrototypes

                        int h,

#else

                        Dimension h,

#endif /* NeedWidePrototypes */

                        int start_i,

                        int end_i) ;

static void ComputeTearOffHeight(

			XmRowColumnWidget m,

			Dimension *toc_b, 

                        Dimension *b, 

	                Dimension *toc_height,

                        int *start_i, 

                        int *child_i,

			int r);

static void LayoutColumn( 

                        XmRowColumnWidget m,

                        Dimension *m_width,

                        Dimension *m_height) ;

static void LayoutVerticalTight( 

                        XmRowColumnWidget m,

                        Dimension *m_width,

                        Dimension *m_height) ;

static void LayoutHorizontaltight( 

                        XmRowColumnWidget m,

                        Dimension *m_width,

                        Dimension *m_height) ;

static void LayoutNone( 

                        XmRowColumnWidget m,

                        Dimension *m_width,

                        Dimension *m_height) ;

static void LayoutOptionAndSize( 

                        register XmRowColumnWidget menu,

                        Dimension *width,

                        Dimension *height,

                        Widget instigator,

                        XtWidgetGeometry *request,

#if NeedWidePrototypes

                        int calcMenuDimension) ;

#else

                        Boolean calcMenuDimension) ;

#endif /* NeedWidePrototypes */

static void GetMenuKidMargins(

				 XmRowColumnWidget m,

				 Dimension *width,

				 Dimension *height,

				 Dimension *left,

				 Dimension *right,

				 Dimension *top,

				 Dimension *bottom );

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

 * 

 * This section is all the layout stuff, the whole thing has to operate 

 * in two different modes, one: a read-only mode which

 * is nice for making decisions about the size of the row column vs. the size

 * of the children.  two: a change everything mode which implements the

 * change.

 *

 * further complicated by the xtoolkit restriction that a subwidget making

 * a geo request (referred to as the 'instigator') of the row column may not 

 * have his resize proc called but all other widget children must.

 *

 * this is done by building a set of XtWidgetGeometry request blocks, one

 * for each child (widget and gadget), which holds the changes we would like  

 * to make for this child.  If needed then another pass is made over the  

 * requests to actually implement the changes.

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

/*

 * Decide where to put the help child.  He better be the last one

 * 'cuz we may trash the x, y's

 */

static void 

CalcHelp(

        XmRowColumnWidget m,

        Dimension *m_width,     /* if 0 then caller's asking */

        Dimension *m_height,    /* if 0 then caller's asking */

#if NeedWidePrototypes

        int b,

        int max_x,

        int max_y,

#else

        Dimension b,

        Position max_x,

        Position max_y,

#endif /* NeedWidePrototypes */

        Position *x,

        Position *y,

#if NeedWidePrototypes

        int w,

        int h )

#else

        Dimension w,

        Dimension h )

#endif /* NeedWidePrototypes */

{

   register Dimension subtrahend;

   if (IsVertical (m))             /* glue to bottom edge of ... */

   {

      if (Asking (*m_height))

      {

	 if (RC_NCol (m) == 1)       /* just use max_y */

	     *y = max_y;

	 else                /* go up from max_y */

	 {

	     subtrahend = RC_Spacing (m) + h + b;

	     *y = (max_y > (int)subtrahend) ? max_y - subtrahend : 0; 

	 }

      }

      else

      {   

	  subtrahend = MGR_ShadowThickness(m) + RC_MarginH (m) + h + b;

	  *y = (*m_height > (int)subtrahend) ? *m_height - subtrahend : 0;

      }

   }

   else                    /* glue to right edge of ... */

   {

      if (Asking (*m_width))

      {

	 if (RC_NCol (m) == 1)

	     *x = max_x;

	 else

	 {

	     subtrahend = RC_Spacing (m) + w + b;

	     *x = (max_x > (int)subtrahend) ? max_x - subtrahend : 0;

	 }

      }

      else

      {

	 subtrahend = MGR_ShadowThickness(m) + RC_MarginW (m) + w + b;

	 *x = (*m_width > (int)subtrahend) ? *m_width - subtrahend : 0;

      }

   }

}

/*

 * count the widest & tallest entry dimensions

 * and compute entries per row/column

 */

static void 

GetMaxValues(

        XmRowColumnWidget m,

        Dimension *border,

        Dimension *w,

        Dimension *h,

        int *items_per,

        Dimension *baseline,

        Dimension *shadow,

        Dimension *highlight,

        Dimension *margin_top,

        Dimension *margin_height,

        Dimension *text_height )

{

    XtWidgetGeometry *b;

    Widget k ;

    int i, n ;

    *border = *w = *h = *baseline = *shadow = *highlight = 

	*margin_top = *margin_height = *text_height = 0;

    /* skip the tearoff control */

    for (i = (RC_TearOffControl(m) && 

	      XtIsManaged(RC_TearOffControl(m)))? 1 : 0, n = 0; 

	 RC_Boxes (m) [i].kid != NULL; 

	 i++, n++) {

       b = &(RC_Boxes (m) [i].box);

       k = RC_Boxes (m) [i].kid ;

       ASSIGN_MAX(*w, BWidth (b));

       ASSIGN_MAX(*h, BHeight (b));

       if (XtIsWidget(k)) {

	   ASSIGN_MAX(*border, k->core.border_width);

       } else if (XmIsGadget(k)) {

	   ASSIGN_MAX(*border, ((XmGadget)k)->rectangle.border_width);

       }

       ASSIGN_MAX(*baseline, RC_Boxes (m) [i].baseline);

       if (XmIsGadget (k) || XmIsPrimitive (k) ) {

         XmBaselineMargins textMargins;

	 _XmRC_SetOrGetTextMargins(k, XmBASELINE_GET, &textMargins);

         ASSIGN_MAX(*shadow, textMargins.shadow);

         ASSIGN_MAX(*highlight, textMargins.shadow);

         ASSIGN_MAX(*margin_top, textMargins.margin_top);

         ASSIGN_MAX(*margin_height, textMargins.margin_height);

         ASSIGN_MAX(*text_height, textMargins.text_height);

       }

    }

    *items_per = n / RC_NCol (m);       /* calc column size */

    if ((n % RC_NCol (m)) != 0) (*items_per)++;  /* some left overs */

                                                 /* add another row/col */

}

/*

 * Make sure that entries in the right most column/row extend all the 

 * way to the right/bottom edge of the row column widget.  This keeps 

 * 'dead space' in the row column widget to a minimum.  For single 

 * column widgets, the only column is the right most.  

 *

 */

static void 

AdjustLast(

        XmRowColumnWidget m,

        int start_i,

#if NeedWidePrototypes

        int w,

        int h )

#else

        Dimension w,

        Dimension h )

#endif /* NeedWidePrototypes */

{

   XmRCKidGeometry kg = RC_Boxes (m);

   XtWidgetGeometry *b;

   register Dimension subtrahend;

   for ( ; kg [start_i].kid != NULL; start_i++)

   {

      b = &(kg[start_i].box);

      if (IsVertical (m))

      {

         subtrahend = MGR_ShadowThickness(m) + RC_MarginW (m) + BX (b)

	     + Double (BBorder (b));

	 /* if w (rowcol width) is greater than subtrahend (the smallest

	  * width of the child, we'll guarantee at least a width of 1.

	  */

	 if (w > subtrahend) 

	     BWidth (b) = w-subtrahend;

      }

      else

      {

         subtrahend =  MGR_ShadowThickness(m) + RC_MarginH (m) + BY (b)

	     + Double (BBorder (b));

         /* When adjusting the last line, text and label widgets or gadgets, */

         /* use the extra height that is added differently. Text just adds  */

         /* it on whereas label tries to center it in the extra space.      */

         /* In order to make the baselines align again as a result of the   */

         /* above behavior,  Text's margin top has to be adjusted. */

	 if (h > subtrahend) 

         {

             Dimension m_top;

	     /* Check for underflow */

	     /* The difference is what it grows in height */

	     m_top = ((h-subtrahend) > BHeight(b)) ?

		((h-subtrahend) - BHeight (b)) : 0 ;

	     BHeight (b) = h-subtrahend;

	     if (m_top && (XmIsText(kg [start_i].kid) || 

			   XmIsTextField(kg [start_i].kid) ||

			   XmIsCSText(kg [start_i].kid)))

             {

	       kg [start_i].margin_top += m_top/2; /* Since labels center it */

             }

         }

      }

   }

}

/*

 * decide exactly the dimensions of the row column widget we will return to 

 * an asking caller based on the accumulated layout information.

 */

static void 

SetAsking(

        XmRowColumnWidget m,

        Dimension *m_width,     /* if 0 then caller's asking */

        Dimension *m_height,    /* if 0 then caller's asking */

#if NeedWidePrototypes

        int b,

        int max_x,

        int max_y,

        int x,

        int y,

        int w,

        int h )

#else

        Dimension b,

        Position max_x,

        Position max_y,

        Position x,

        Position y,

        Dimension w,

        Dimension h )

#endif /* NeedWidePrototypes */

{

    long iheight;

    long iwidth;

    if (IsVertical (m))             /* tell caller what he wants */

    {

        if (Asking (*m_width))

            *m_width =   x + w + b      /* right edge of last child */

                   + MGR_ShadowThickness(m)

                   + RC_MarginW (m);    /* plus margin on right */

        if (Asking (*m_height))

        {

            ASSIGN_MAX (max_y, y);

            iheight = (long) max_y                /* last unused y */

                - (long) (RC_Spacing (m))         /* up by unused spacing */

                + (long) (MGR_ShadowThickness(m))

                + (long) (RC_MarginH (m)) ;       /* plus margin on bottom */

            if (iheight < 0)             /* this is a temporary fix */

                *m_height = 0;           /* to make sure we don't   */

            else                         /* compute a negative height */

                *m_height = (Dimension) iheight; /*in an unsigned short   */

        }

    }

    else

    {

        if (Asking (*m_width))

        {

            ASSIGN_MAX (max_x, x);

            iwidth = (long) max_x

                - (long) (RC_Spacing (m))

                + (long) (MGR_ShadowThickness(m))

                + (long) (RC_MarginW (m)) ;

            if (iwidth < 0)

                *m_width = 0;

            else

                *m_width = (Dimension) iwidth ;

        }

        if (Asking (*m_height))

            *m_height = y + h + b

                + MGR_ShadowThickness(m)

                + RC_MarginH (m);

    }

}

static void

FindLargestOption( 

	XmRowColumnWidget submenu, 

	Dimension *c_width, 

	Dimension *c_height )

{

    int i;

    Widget *child ;

    if (!submenu) return ;

    ForManagedChildren (submenu, i, child) {

	/* Is this recursivity wanted ? */

	if (XmIsCascadeButton(*child))	{

	    FindLargestOption((XmRowColumnWidget)

			      CB_Submenu(*child), 

			      c_width, c_height);

	}

	else if (XmIsCascadeButtonGadget(*child))	       {

	    FindLargestOption((XmRowColumnWidget)

			      CBG_Submenu(*child), 

			      c_width, c_height);

	}

	else {

	    /* The entire size of the largest menu

	     * item is used instead of only its TextRect.  This may

	     * result in large expanses of label white space when items 

	     * utilize left and right margins, shadow, or accelerator 

	     * text - but the glyph will be visible when the submenu is

	     * posted!

	     */

	    if (XmIsMenuShell(XtParent(submenu))) {

		ASSIGN_MAX(*c_width, XtWidth(*child));

		ASSIGN_MAX(*c_height, XtHeight(*child));

	    }

	    /*

	     * must be a torn pane.  Don't rely on its dimensions

	     * since it may be stretched in the tear off so that

	     * the label string fits into the titlebar

	     */

	    else {

		XtWidgetGeometry preferred;

		XtQueryGeometry (*child, NULL, &preferred);

		ASSIGN_MAX(*c_width, preferred.width);

		ASSIGN_MAX(*c_height, preferred.height);

	    }

	}

    }

}

void

_XmRC_CheckAndSetOptionCascade(

      XmRowColumnWidget menu )

{

   Dimension width = 0;

   Dimension height = 0;

   int i;

   Widget cb;

   /*

    * if its is a pulldown menu, travel up the cascades to verify the

    * option menus cascade button is sized large enough.  

    */

   if (IsPulldown(menu)) {

       for (i=0; i < menu->row_column.postFromCount; i++) {

	   _XmRC_CheckAndSetOptionCascade((XmRowColumnWidget)

				XtParent(menu->row_column.postFromList[i]));

       }

   } 

   if (!IsOption(menu)  || RC_FromResize(menu)) return ;

   if ((cb = XmOptionButtonGadget( (Widget) menu)) != NULL) {

       if (RC_OptionSubMenu(menu)) {

	   FindLargestOption

	       ((XmRowColumnWidget)RC_OptionSubMenu(menu), &width, &height );

	   if (LayoutIsRtoLG(cb))

	     width += Double(G_HighlightThickness(cb)) +

	       G_ShadowThickness(cb) + LabG_MarginLeft(cb) +

		 Double(MGR_ShadowThickness(RC_OptionSubMenu(menu))) - 2;

	   else  

	     width += Double(G_HighlightThickness(cb)) +

	       G_ShadowThickness(cb) + LabG_MarginRight(cb) +

		 Double(MGR_ShadowThickness(RC_OptionSubMenu(menu))) - 2;

	   height += Double(G_HighlightThickness(cb)) + LabG_MarginTop(cb)

	       + LabG_MarginBottom(cb);

	   /* change cb if needed */

	   if ((width != XtWidth(cb)) || (height != XtHeight(cb))) {

	       /* we have pixels, but the cascade unit type might not be 

		  pixel, so save it and restore it after the setvalues */

	       unsigned char saved_unit_type = 

		   ((XmGadget)cb)->gadget.unit_type ;

	       ((XmGadget)cb)->gadget.unit_type = XmPIXELS;

	       XtVaSetValues (cb, XmNwidth, width, XmNheight, height, NULL);

	       ((XmGadget)cb)->gadget.unit_type = saved_unit_type;

	   }

       }

   }

}

/*ARGSUSED*/

static void

TopOrBottomAlignment(

	XmRowColumnWidget m,

#if NeedWidePrototypes

	int h,

	int shadow,

	int highlight,

	int baseline,		/* unused */

	int margin_top,

	int margin_height,

	int text_height,

#else

        Dimension h,

        Dimension shadow,

        Dimension highlight,

        Dimension baseline,	/* unused */

        Dimension margin_top,

        Dimension margin_height,

        Dimension text_height,

#endif /* NeedWidePrototypes */

	Dimension *new_height,

        int start_i,

        int end_i)

{

  XmRCKidGeometry kg = RC_Boxes (m);

  while (start_i < end_i)

  {

    if (XmIsGadget(kg [start_i].kid) || XmIsPrimitive(kg [start_i].kid))

    {

      XmBaselineMargins textMargins;

      _XmRC_SetOrGetTextMargins(kg[start_i].kid, XmBASELINE_GET, &textMargins);

      kg[start_i].margin_top = textMargins.margin_top;

      kg[start_i].margin_bottom = textMargins.margin_bottom;

      if (textMargins.shadow < shadow)

      {

         kg[start_i].margin_top += shadow - textMargins.shadow;

         kg[start_i].box.height += shadow - textMargins.shadow;

      }

      if (textMargins.highlight < highlight)

      {

         kg[start_i].margin_top += highlight - textMargins.highlight;

         kg[start_i].box.height += highlight - textMargins.highlight;

      }

      if (textMargins.margin_top < margin_top)

      {

         kg[start_i].margin_top += margin_top - textMargins.margin_top;

         kg[start_i].box.height += margin_top - textMargins.margin_top;

      }

      if (textMargins.margin_height < margin_height)

      {

         kg[start_i].margin_top += margin_height - textMargins.margin_height;

         kg[start_i].box.height += margin_height - textMargins.margin_height;

      }

      if (AlignmentBottom (m))

       if (textMargins.text_height < text_height)

       {

         kg[start_i].margin_top += text_height - textMargins.text_height;

         kg[start_i].box.height += text_height - textMargins.text_height;

       }

      if (kg[start_i].box.height < h)

      {

	kg[start_i].margin_bottom += h - kg[start_i].box.height;

        kg[start_i].box.height = h;

      }

    }

    if (kg[start_i].box.height > h)

      if (kg[start_i].box.height > *new_height)

        *new_height = kg[start_i].box.height;

    start_i++;

  }

}

/*ARGSUSED*/

static void

BaselineAlignment(

	XmRowColumnWidget m,

#if NeedWidePrototypes

	int h,

	int shadow,		/* unused */

	int highlight,		/* unused */

	int baseline,

#else

        Dimension h,

        Dimension shadow,	/* unused */

        Dimension highlight,	/* unused */

        Dimension baseline,

#endif /* NeedWidePrototypes */

	Dimension *new_height,

        int start_i,

        int end_i)

{

   XmRCKidGeometry kg = RC_Boxes (m);

   XmBaselineMargins textMargins;

   while (start_i < end_i)

   {

     if (XmIsPrimitive (kg [start_i].kid) || XmIsGadget (kg [start_i].kid))

     {

      unsigned char label_type;

      _XmRC_SetOrGetTextMargins(kg [start_i].kid, XmBASELINE_GET, &textMargins);

      kg[start_i].margin_top = textMargins.margin_top;

      kg[start_i].margin_bottom = textMargins.margin_bottom;

      XtVaGetValues(kg [start_i].kid, XmNlabelType, &label_type, NULL);

      if (label_type == XmSTRING)

      {

        if (kg[start_i].baseline < baseline)

        {

          kg[start_i].margin_top += baseline - kg[start_i].baseline;

          if (kg[start_i].box.height + (baseline - kg[start_i].baseline) > h)

          {

            if (kg[start_i].box.height + (baseline - kg[start_i].baseline) > *new_height)

	      *new_height = kg[start_i].box.height + (baseline - kg[start_i].baseline);

	    kg[start_i].box.height += baseline - kg[start_i].baseline;

          }

          else

          {

	    kg[start_i].margin_bottom += h  - (kg[start_i].box.height +

					       (baseline - kg[start_i].baseline));

	    kg[start_i].box.height = h;

          }

        }

        else

        {

	  kg[start_i].margin_bottom += h  - (kg[start_i].box.height +

					     (baseline - kg[start_i].baseline));

	  kg[start_i].box.height = h;

        }

      }

      else

       kg[start_i].box.height = h;

    }

    else

      kg[start_i].box.height = h;

    start_i++;

   }

}

static void

CenterAlignment(

        XmRowColumnWidget m,

#if NeedWidePrototypes

        int h,

#else

        Dimension h,

#endif /* NeedWidePrototypes */

        int start_i,

        int end_i)

{

  XmRCKidGeometry kg = RC_Boxes (m);

  while(start_i < end_i)

  {

    if (XmIsGadget (kg [start_i].kid) || XmIsPrimitive (kg [start_i].kid))

    {

      XmBaselineMargins textMargins;

      _XmRC_SetOrGetTextMargins(kg [start_i].kid, XmBASELINE_GET, &textMargins);

      kg[start_i].margin_top = textMargins.margin_top;

      kg[start_i].margin_bottom = textMargins.margin_bottom;

    }

    kg[start_i++].box.height = h;

  }

}

static void 

ComputeTearOffHeight(

        XmRowColumnWidget m,

        Dimension *toc_b, 

        Dimension *b, 

	Dimension *toc_height,

        int *start_i, 

        int *child_i,

        int r)

{

    XmRCKidGeometry kg = RC_Boxes (m);

    *toc_b = *b = Double (RC_EntryBorder (m));

    if (RC_TearOffControl(m) && XtIsManaged(RC_TearOffControl(m))) {

	XmTearOffButtonWidget tw = (XmTearOffButtonWidget)RC_TearOffControl(m);

	if (!RC_EntryBorder(m) && kg[0].kid && XtIsWidget(kg[0].kid))

	    *toc_b = Double(kg[0].kid->core.border_width);

	*toc_height = 0;

	/* Remember!  If toc exists, it has the  first kid geo */

	for (*start_i = 1;  kg[*start_i].kid != NULL; (*start_i)++)

	    ASSIGN_MAX(*toc_height, kg[*start_i].box.height);

	*toc_height = *toc_height >> r;    /* r is 1 or 2 depending on the

					    orientation. 1 makes the tear off

					    half the highest, 2 makes 1/4 */

	ASSIGN_MAX(*toc_height, 2 + *toc_b +  2*

	       ((XmPrimitiveWidget)kg[0].kid)->primitive.shadow_thickness);

	/* Sync up the kid geo */

	/* Fix CR# 4778 */

	if (tw -> label.recompute_size == True)

	    kg[0].box.height = *toc_height;

	else

	    kg[0].box.height = *toc_height = XtHeight(tw);

	kg[0].box.width = XtWidth(m);

	*start_i = *child_i = 1;

    }

    else

	*toc_height = *toc_b = *start_i = *child_i = 0;

}

/*

 * figure out where all the children of a column style widget go.  The

 * border widths are already set.  

 *

 * In columnar mode, all heights and widths are identical.  They are the

 * size of the largest item.

 *

 * For vertical widgets the items are laid out in columns, going down the

 * first column and then down the second.  For horizonatal, think of the

 * columns as rows. 

 *

 * By convention incoming row column size can be zero, indicating a request

 * for preferred size, this means lay it out and record the needed size.

 *

 * NOTE: the layout is predicated on the help child being the last one since

 * it messes up the x, y for a following child.

 */

static void