/*

 * 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 "xmlist.h"

#include <Xm/TreeP.h>

#include <X11/Xutil.h>

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

*	TYPEDEFS AND DEFINES

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

#define SUPERCLASS (&xmHierarchyClassRec)

#define INDENT_SPACE 30

typedef struct {

  int x;

  int y;

} LadderPoint;

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

*	MACROS

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

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

*	GLOBAL DECLARATIONS

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

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

*	STATIC FUNCTION DECLARATIONS

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

static void Resize(Widget), ClassInit(void);

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

static void Redisplay(Widget, XEvent *, Region);

static void ClassPartInitialize(WidgetClass w_class);

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

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

static void ConstraintDestroy(Widget);

static void TreeDestroy(Widget);

static void ToggleNodeState(Widget, XtPointer, XtPointer);

static XtGeometryResult QueryGeometry(Widget, 

				      XtWidgetGeometry *, XtWidgetGeometry *);

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

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

static XtGeometryResult GeometryManager(Widget, 

				      XtWidgetGeometry *, XtWidgetGeometry *);

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

 * Actions and callbacks.

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

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

 * Internal Routines.

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

static Boolean CvtStringToConnectStyle(Display *, XrmValuePtr, Cardinal *, 

				       XrmValuePtr, XrmValuePtr);

static Boolean CvtStringToCompressStyle(Display *, XrmValuePtr, Cardinal *, 

				       XrmValuePtr, XrmValuePtr);

static Boolean CvtStringToLineStyle(Display *, XrmValuePtr, Cardinal *, 

				       XrmValuePtr, XrmValuePtr);

static void ReleaseNodeGCs(Widget), GetNodeGCs(Widget);

static TreeConstraints GetNodeInfo(Widget);

static int GetExtraVertSpace(Widget);

static int GetExtraHorizSpace(Widget);

static void LineColorDefault(Widget, int, XrmValue *);

static void LineBackgroundColorDefault(Widget, int, XrmValue *);

static void HorizontalNodeSpaceDefault(Widget, int, XrmValue *);

static void VerticalNodeSpaceDefault(Widget, int, XrmValue *);

static void ChangeManaged(Widget), CalcMaxSize(Widget);

static void CalcLocations(Widget, Boolean);

static void LayoutChildren(Widget, Widget);

static Boolean GetNodeHeightAndWidth(Widget, TreeConstraints,

				     Cardinal *, Cardinal);

static void GetDesiredSize(Widget, Dimension *, Dimension *, Boolean);

static void _DrawLine(Widget, XRectangle *, TreeConstraints, TreeConstraints,

		      LadderPoint, LadderPoint *);

static void _PlaceNode(Widget, TreeConstraints);

static void _ResetPlacedFlag(TreeConstraints);

static void FindNodeLocations(Widget);

static void DrawTreeLine(Widget, XRectangle *, TreeConstraints);

static void RedrawTreeLines(Widget, XRectangle *);

static Boolean RequestNewSize(Widget);

static Bool CheckExpose(Display *, XEvent *, char *);

static Boolean LocInRect(XRectangle *, Widget, Position, Position);

static Boolean WidgetInRect(XRectangle *, Widget);

static Boolean CheckWidget(XRectangle *, TreeConstraints);

static void ProcessChildQueue(XmTreeWidget, XRectangle *);

static void MoveNode(XmTreeWidget, TreeConstraints, Position, Position,

		     Position, Position, Boolean);

static void ProcessNode(TreeConstraints);

static Boolean MoveNodesTimer(XtPointer);

static void UnmapNode(XmTreeWidget tw, TreeConstraints node);

static void UnmapAllExtraNodes(Widget w, HierarchyConstraints node);

static void LineStyle_confirm (Widget w, int value);

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

*	STATIC DECLARATIONS

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

static XtResource resources[] =

{

  {

    XmNconnectStyle, XmCConnectStyle, XmRXmConnectStyle,

    sizeof(XmTreeConnectStyle), XtOffsetOf(XmTreeRec, tree.connect_style),

    XmRImmediate, (XtPointer) XmTreeDirect

  },

  {

    XmNorientation, XmCOrientation, XmROrientation,

    sizeof(unsigned char), XtOffsetOf(XmTreeRec, tree.orientation),

    XmRImmediate, (XtPointer) XmHORIZONTAL

  },

  {

    XmNcompressStyle, XmCCompressStyle, XmRXmCompressStyle,

    sizeof(XmTreeCompressStyle), XtOffsetOf(XmTreeRec, tree.compress_style),

    XmRImmediate, (XtPointer) XmTreeCompressLeaves

  },

  {

    XmNverticalDelta, XmCVerticalDelta, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmTreeRec, tree.vertical_delta),

    XmRImmediate, (XtPointer) 30

  },

  {

    XmNhorizontalDelta, XmCHorizontalDelta, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmTreeRec, tree.horizontal_delta),

    XmRImmediate, (XtPointer) 25

  },

  {

    XmNhorizontalNodeSpace, XmCDimension, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmTreeRec, tree.h_node_space),

    XmRCallProc, (XtPointer) HorizontalNodeSpaceDefault

  },

  {

    XmNverticalNodeSpace, XmCDimension, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmTreeRec, tree.v_node_space),

    XmRCallProc, (XtPointer) VerticalNodeSpaceDefault

  }

};

static XmSyntheticResource get_resources[] =

{

  {

    XmNhorizontalNodeSpace, sizeof(Dimension),

    XtOffsetOf(XmTreeRec, tree.h_node_space),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  },

  {

    XmNverticalNodeSpace, sizeof(Dimension),

    XtOffsetOf(XmTreeRec, tree.v_node_space),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  },

  {

    XmNverticalDelta, sizeof(Dimension),

    XtOffsetOf(XmTreeRec, tree.vertical_delta),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  },

  {

    XmNhorizontalDelta, sizeof(Dimension),

    XtOffsetOf(XmTreeRec, tree.horizontal_delta),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  }

};

static XtResource constraints[] =

{

  {

    XmNopenClosePadding, XmCOpenClosePadding, XmRInt,

    sizeof(int), XtOffsetOf(XmTreeConstraintRec, tree.open_close_padding),

    XmRImmediate, (XtPointer) 0

  },

  {

    XmNlineColor, XmCForeground, XmRPixel,

    sizeof(Pixel), XtOffsetOf(XmTreeConstraintRec, tree.color),

    XmRCallProc, (XtPointer) LineColorDefault

  },

  {

    XmNlineBackgroundColor, XmCBackground, XmRPixel,

    sizeof(Pixel), XtOffsetOf(XmTreeConstraintRec, tree.background_color),

    XmRCallProc, (XtPointer) LineBackgroundColorDefault

  },

  {

    XmNlineWidth, XmCLineWidth, XmRInt,

    sizeof(int), XtOffsetOf(XmTreeConstraintRec, tree.line_width),

    XmRImmediate, (XtPointer) 0

  },

  {

    XmNlineStyle, XmCLineStyle, XmRXmLineStyle,

    sizeof(int), XtOffsetOf(XmTreeConstraintRec, tree.line_style),

    XmRImmediate, (XtPointer) LineSolid

  }

};

static XmSyntheticResource get_cons_resources[] =

{

  {

    XmNopenClosePadding, sizeof(int),

    XtOffsetOf(XmTreeConstraintRec, tree.open_close_padding),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  }

};

#undef offset

XmTreeClassRec xmTreeClassRec = {

  { /* core fields */

    /* superclass		*/	((WidgetClass) SUPERCLASS),

    /* class_name		*/	"XmTree",

    /* widget_size		*/	sizeof(XmTreeRec),

    /* class_initialize		*/	ClassInit,

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

    /* compress_enterleave	*/	TRUE,

    /* visible_interest		*/	FALSE,

    /* destroy			*/	TreeDestroy,

    /* resize			*/	Resize,

    /* expose			*/	Redisplay,

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

    /* delete_child       */      XtInheritDeleteChild,

    /* extension          */      NULL,                                     

   },

   {		/* constraint_class fields */

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

    /* num resources        */         XtNumber(constraints),

    /* constraint size      */         sizeof(XmTreeConstraintRec),

    /* init proc            */         ConstraintInitialize,

    /* destroy proc         */         ConstraintDestroy,

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

    /* num_syn_cont_resources */      XtNumber(get_cons_resources),

    /* parent_process         */      XmInheritParentProcess,

    /* extension	      */      NULL,	

   },

   { /* Hierarchy fields */

      XtInheritChangeNodeState,	/* The function for changing the node state. */

      XtInheritMapNode,			/* Maps a given node. */

      XtInheritUnmapNode,		/* Unmaps a given node. */

      UnmapAllExtraNodes,		/* Unmaps all extra nodes. */

      XtInheritBuildNodeTable,		/* Builds up the node table. */

      XtInheritResetOpenCloseButton, 	/* Resets the the o/c button. */

      ToggleNodeState,		/* Called to toggle the state of node. */

      NULL,			/* extension          */

   },

   { /* Tree fields */

      NULL                      /* extension    */

   }

};

WidgetClass xmTreeWidgetClass = (WidgetClass) &xmTreeClassRec;

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

*	STATIC CODE

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

/*	Function Name: ClassInit

 *	Description:   Called to initialize information specific

 *                     to this widget class.

 *	Arguments:     none.

 *	Returns:       none.

 */

/*ARGSUSED*/

static void 

ClassInit(void)

{

    XmTreeClassRec* wc = &xmTreeClassRec;

    XtSetTypeConverter(XmRString, XmRXmConnectStyle,

		       (XtTypeConverter) CvtStringToConnectStyle,

		       NULL, (Cardinal) 0, XtCacheAll, (XtDestructor) NULL);

    XtSetTypeConverter(XmRString, XmRXmCompressStyle,

		       (XtTypeConverter) CvtStringToCompressStyle,

		       NULL, (Cardinal) 0, XtCacheAll, (XtDestructor) NULL);

    XtSetTypeConverter(XmRString, XmRXmLineStyle,

		       (XtTypeConverter) CvtStringToLineStyle,

		       NULL, (Cardinal) 0, XtCacheNone, (XtDestructor) NULL);

}

/*

 * ClassPartInitialize sets up the fast subclassing for the widget.

 */

static void 

#ifdef _NO_PROTO

ClassPartInitialize(w_class)

        WidgetClass w_class ;

#else

ClassPartInitialize(WidgetClass w_class)

#endif /* _NO_PROTO */

{

    _XmFastSubclassInit (w_class, XmTREE_BIT);

}

/*	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.

 */

/* ARGSUSED */

static void 

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

{

    XmTreeWidget tw = (XmTreeWidget) set;

    TreeConstraints top_node;

    top_node = ((TreeConstraints) 

		XtRealloc((XtPointer) XmHierarchy_top_node(tw),

			  sizeof(TreeConstraintRec)));

    XmHierarchy_top_node(tw) = (HierarchyConstraints) top_node;

    XmTree_ul_point(tw).x = XmTree_ul_point(tw).y = 0;

    XmTree_lr_point(tw).x = XmTree_lr_point(tw).y = 0;

    XmTreeC_box_x(top_node) = XmTreeC_box_y(top_node) = 0;

    XmTreeC_bb_width(top_node) = XmTreeC_bb_height(top_node) = 0;

    XmTreeC_placed(top_node) = False;

    XmTree_child_op_list(tw) = _XmListInit();

    /* 

     * Set the initial values for XmTreeC_max_width(tw) and XmTreeC_max_height(tw).

     */

    CalcMaxSize(set);    

}

/*	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: Redisplay

 *	Description:   This function redraws the tree lines.

 *	Arguments:     w - the Tree widget.

 *                     event - event that caused the exposure.

 *                     region - the region containing all the exposures.

 *	Returns:       none

 */

typedef struct _RedispInfo {

    Window window;

    Boolean found;

} RedispInfo;

/* ARGSUSED */

static void

Redisplay(Widget w, XEvent * event, Region region)

{

    XmTreeWidget tw = (XmTreeWidget) w;

    XEvent junk;

    RedispInfo info;

    int lrx, lry;		/* local variables fro lower left corner. */

    XmDropSiteStartUpdate(w);

    /*

     * Make sure that there are not more expose events pending in the queue

     * since only one is required to paint the tree lines.

     */

    info.window = XtWindow(w);

    info.found = False;

    XCheckIfEvent(XtDisplay(w), &junk, CheckExpose, (char *) &info;;

    /* 

     * Compute the maximum bounding rectangle for all expose events

     * that have yet to be processed.

     */

    if (event->xexpose.x < XmTree_ul_point(tw).x) 

	XmTree_ul_point(tw).x = event->xexpose.x;

    if (event->xexpose.y < XmTree_ul_point(tw).y) 

	XmTree_ul_point(tw).y = event->xexpose.y;

    lrx = event->xexpose.x + event->xexpose.width;

    lry = event->xexpose.y + event->xexpose.height;

    if (lrx > XmTree_lr_point(tw).x) 

	XmTree_lr_point(tw).x = lrx;

    if (lry > XmTree_lr_point(tw).y) 

	XmTree_lr_point(tw).y = lry;

    if (!info.found) {	/* No more expose events waiting - process these. */

	XRectangle rect;

	rect.x = XmTree_ul_point(tw).x;

	rect.y = XmTree_ul_point(tw).y;

	rect.width = XmTree_lr_point(tw).x - XmTree_ul_point(tw).x;

	rect.height = XmTree_lr_point(tw).y - XmTree_ul_point(tw).y;

	ProcessChildQueue((XmTreeWidget) w, &rect);

	RedrawTreeLines(w, &rect);

	/*

	 * Reset upper right and lower left points.

	 */

	XmTree_ul_point(tw).x = w->core.width;

	XmTree_ul_point(tw).y = w->core.height;

	XmTree_lr_point(tw).x = XmTree_lr_point(tw).y = 0;

    }

    XmDropSiteEndUpdate(w);

}

/*	Function Name: CheckExpose

 *	Description: Checks to see if there is an expose event on the queue.

 *	Arguments: disp - the X Display.

 *                 event - the event to check for.

 *                 info_ptr - a pointer to the redispInfo.

 *	Returns: Always False.

 */

/* ARGSUSED */

static Bool

CheckExpose(Display *disp, XEvent *event, char *info_ptr)

{

    RedispInfo *info = (RedispInfo *) info_ptr;

    if (info->found || event->xany.type != Expose)

	return(False);

    if (event->xexpose.window == info->window)

	info->found = True;

    return(False);

}

/*	Function Name: Resize

 *	Description:   Called when this widget has been resized.

 *	Arguments:     w - Extended List Widget to resize.

 *	Returns:       none.

 */

static void 

Resize(Widget w)

{

    XmTreeWidget tw = (XmTreeWidget) w;

    if (XmHierarchy_refigure_mode(tw)) {

	LayoutChildren(w, NULL);

	if (XtIsRealized((Widget)tw)) {

	    XClearArea(XtDisplay(tw), XtWindow(tw),

		       0, 0, tw->core.width, tw->core.height, True);

	}

    }

}

/*	Function Name: QueryGeometry

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

 *                     I would like to be.

 *	Arguments:     w - the drt widget.

 *                     indended - constriants imposed by the parent.

 *                     preferred - what I would like.

 *	Returns:       See Xt Manual.

 */

static XtGeometryResult 

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

{

    GetDesiredSize(w, &(preferred->width), &(preferred->height), True);

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

}

/*	Function Name: SetValues

 *	Description:   Called a resources is changed.

 *	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 

SetValues(Widget current, Widget request, Widget set,

	  ArgList args, Cardinal * num_args)

{

    XmTreeWidget c_tree = (XmTreeWidget) current;

    XmTreeWidget tree = (XmTreeWidget) set;

    Boolean redisplay = False;

    Boolean layout = False;

    if ((XmHierarchy_v_margin(c_tree) != XmHierarchy_v_margin(tree)) ||

	(XmHierarchy_h_margin(c_tree) != XmHierarchy_h_margin(tree)) ||

	(XmTree_orientation(c_tree) != XmTree_orientation(tree)) ||

	((XmTree_compress_style(c_tree) != XmTree_compress_style(tree)) &&

         (XmTree_orientation(tree) == XmVERTICAL))                  ||

	(XmTree_horizontal_delta(c_tree) != XmTree_horizontal_delta(tree)) ||

	(XmTree_vertical_delta(c_tree) != XmTree_vertical_delta(tree)) ||

	(XmTree_v_node_space(c_tree) != XmTree_v_node_space(tree)) ||

	(XmTree_h_node_space(c_tree) != XmTree_h_node_space(tree)))

    {

	layout = redisplay = True;

    }

    if (XmTree_connect_style(c_tree) != XmTree_connect_style(tree))

	redisplay = True;

    if (XmHierarchy_refigure_mode(c_tree) != XmHierarchy_refigure_mode(tree))

	layout = redisplay = XmHierarchy_refigure_mode(tree);

    if (layout && XmHierarchy_refigure_mode(tree)) {

	CalcLocations(set, False);

	LayoutChildren(set, NULL);

	GetDesiredSize(set, &(set->core.width), &(set->core.height), False);

	redisplay = True;

    }

    return(redisplay);

}

/*    Function Name: Destroy

 *    Description:   Destroys all data allocated by the widget

 *    Arguments:     w - the widget.

 *    Returns:       none.

 */

static void TreeDestroy (Widget widget)

{

  XmTreeWidget tree = (XmTreeWidget) widget;

    _XmListFree(XmTree_child_op_list(tree)); 

}

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

 *

 *  Composite Widget class procedures.

 *

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

/*	Function Name: ChangeManaged

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

 *	Arguments:     w - the icon box widget.

 *	Returns:       none.

 */

static void

ChangeManaged(Widget w)

{

    XmTreeWidget tw = (XmTreeWidget) w;

    if (XmHierarchy_refigure_mode(tw)) {

	CalcLocations(w, True);

	LayoutChildren(w, NULL);

	if (XtIsRealized((Widget)tw)) {

	    XClearArea(XtDisplay(tw), XtWindow(tw),

		       0, 0, tw->core.width, tw->core.height, True);

	}

    }

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

}

/*	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)

{

    Widget tw = XtParent(w);

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

	return(XtGeometryNo);

    if (!(request->request_mode & CWWidth)) {

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

	request->request_mode |= CWWidth;

    }

    if (!(request->request_mode & CWBorderWidth)) {

	request->border_width = w->core.border_width;

	request->request_mode |= CWBorderWidth;

    }

    if (!(request->request_mode & CWHeight)) {

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

	request->request_mode |= CWHeight;

    }

    if (request->request_mode & (CWX | CWY | CWStackMode | CWSibling)) {

	*result = *request;

	result->request_mode &= ~(CWX | CWY | CWStackMode | CWSibling);

	return(XtGeometryAlmost);

    }

    /*

     * Any width or height request is allowed, but others will be disallowed

     * or result in an almost that states only the width and height can

     * change. 

     */

    if (request->request_mode & XtCWQueryOnly) 

	return(XtGeometryYes);

    /*

     * A real allowed request, make the change.

     */

    _XmResizeWidget(w, request->width, request->height, request->border_width);

    if (XmHierarchy_refigure_mode((XmTreeWidget) tw)) {

	CalcLocations(tw, True);

	LayoutChildren(tw, w);

	if (XtIsRealized(tw)) {

	    XClearArea(XtDisplay(tw), XtWindow(tw),

		       0, 0, tw->core.width, tw->core.height, True);

	}

    }

    return(XtGeometryYes);

}

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

 * 

 * Constraint widget class procedures.

 *

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

/*	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)

{

    TreeConstraints node = GetNodeInfo(set);

    XmTreeC_box_x(node) = XmTreeC_box_y(node) = 0;

    XmTreeC_bb_width(node) = XmTreeC_bb_height(node) = 0;

    XmTreeC_placed(node) = False;

    XmTreeC_is_compressed(node) = False;

    LineStyle_confirm(set, LineSolid);

    if (XmHierarchyC_state(node) != XmNotInHierarchy)

	GetNodeGCs(set);

    else

 	XmTreeC_gc(node) = None;

}

/*	Function Name: ConstraintDestroy

 *	Description:   Destroys all data allocated by the constraint 

 *                     record.

 *	Arguments:     w - the widget.

 *	Returns:       none.

 *

 * Removes the destroyed children from the list of children that still

 * need to be moved.

 */

static void

ConstraintDestroy(Widget w)

{

    TreeConstraints node = GetNodeInfo(w);

    XmListElem *elem, *next;

    XmTreeWidget tw;

    if (XmHierarchyC_state(node) == XmNotInHierarchy) 

    {

      return;

    }

    tw = (XmTreeWidget) XtParent(w);

    elem = XmListFirst(XmTree_child_op_list(tw)); 

    while(elem != NULL) {

	TreeConstraints info = (TreeConstraints) XmListElemData(elem);

	next = XmListElemNext(elem);

	if (XmHierarchyC_widget(info) == w) {

	    /*

	     * Each widget will only be in the list once.

	     */

	    _XmListRemove(XmTree_child_op_list(tw), elem);

	    break;

	}

	elem = next;

    }

    ReleaseNodeGCs(w);

}

/*	Function Name: GetNodeGCs(node)

 *	Description: Gets the gc's associated with a tree node.

 *	Arguments: w - the child who's gc we are getting.

 *	Returns: none

 */

static void

GetNodeGCs(Widget w)

{

    XtGCMask mask;

    XGCValues values;

    TreeConstraints node = GetNodeInfo(w);

    mask = GCForeground | GCLineWidth | GCLineStyle | GCBackground;

    values.foreground = XmTreeC_color(node);

    values.background = XmTreeC_background_color(node);

    values.line_width = XmTreeC_line_width(node);

    values.line_style = XmTreeC_line_style(node);

    XmTreeC_gc(node) = XtGetGC(w, mask, &values);

}

/*	Function Name: ReleaseNodeGCs(node)

 *	Description: Releases the gc's associated with a tree node.

 *	Arguments: w - the child who's gc we are releasing

 *	Returns: none

 */

static void

ReleaseNodeGCs(Widget w)

{

    TreeConstraints node = GetNodeInfo(w);

    if (XmTreeC_gc(node) != None)

	XtReleaseGC(w, XmTreeC_gc(node));

}

/*	Function Name: ConstraintSetValues

 *	Description:   Called a constraint is changed on my children.

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

{

    Widget tw = XtParent(set);

    TreeConstraints set_node = GetNodeInfo(set);

    TreeConstraints old_node = GetNodeInfo(current);

    Boolean redisplay = False;

    Boolean insert_change = False;

    int i;

    for (i = 0; i < *num_args; i++) 

	if (streq(args[i].name, XmNinsertBefore)) {

	    insert_change = True;

	    break;

	}

    if ((XmTreeC_color(set_node) != XmTreeC_color(old_node)) ||

    	(XmTreeC_background_color(set_node) != XmTreeC_background_color(old_node)) ||

    	(XmTreeC_line_width(set_node) != XmTreeC_line_width(old_node)) ||

    	(XmTreeC_line_style(set_node) != XmTreeC_line_style(old_node)))

    {

	LineStyle_confirm(set, XmTreeC_line_style(old_node));

	ReleaseNodeGCs(current);

	GetNodeGCs(set);

	redisplay = True;

    }

    /*

     * Nothing below here needs to be done before we are realized.

     */

    if (!XtIsRealized(set))

	return(False);