/*

 * 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 <Xm/OutlineP.h>

#include <Xm/DropSMgr.h>

#include "XmI.h"

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

*	TYPEDEFS AND DEFINES

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

#define SUPERCLASS (&xmHierarchyClassRec)

#define DEF_INDENT_SPACE 30

#define MOVE_TIME    200

typedef struct {

  int x;

  int y;

} LadderPoint;

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

*	MACROS

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

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

*	GLOBAL DECLARATIONS

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

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

*	STATIC FUNCTION DECLARATIONS

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

static void ClassInitialize();

static void Resize(Widget), ClassPartInitialize(WidgetClass);

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

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

static void Destroy(Widget widget);

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

static void ConstraintDestroy(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 Bool CheckExpose(Display *, XEvent *, char *);

static OutlineConstraints GetNodeInfo(Widget);

static int CalcMaxWidth(Widget);

static void ChangeManaged(Widget);

static void RequestNewSize(Widget), CalcLocations(Widget, Boolean);

static void GetNodeDimensions(Widget, OutlineConstraints, 

			      Cardinal, Cardinal *);

static void GetNodeHeightAndWidth(Widget, OutlineConstraints,

				  Cardinal, Boolean, Cardinal *);

static void GetDesiredSize(Widget, Dimension*, Dimension*,

			   Dimension *, Dimension *,

			   Boolean, Boolean);

static void LayoutChildren(Widget, Widget);

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

static Boolean WidgetInRect(XRectangle *, Widget);

static Boolean CheckWidget(XRectangle *, OutlineConstraints);

static void ProcessChildQueue(XmOutlineWidget, XRectangle *);

static void MoveNode(XmOutlineWidget, OutlineConstraints, Position,

		     Position, Position, Position, Boolean);

static void ProcessNode(OutlineConstraints);

static Boolean MoveNodesTimer(XtPointer);

static void UnmapNode(XmOutlineWidget ow, OutlineConstraints node);

static void UnmapAllExtraNodes(Widget w, HierarchyConstraints node);

static void NegotiateNodeWidth(Widget w, OutlineConstraints node);

static void RedrawOutlineLines(Widget, XRectangle *);

static void DrawOutlineLine(Widget, XRectangle *, OutlineConstraints);

static void _CalcNodeMidPoint( OutlineConstraints node, Widget w, LadderPoint *ret_point );

static void _OutlineDrawLine(Widget w, XRectangle *rect, OutlineConstraints parent, 

	  OutlineConstraints child, LadderPoint from_ladder_point,

	  LadderPoint *to_ladder_point );

static void CreateGC(XmOutlineWidget ow);

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

*	STATIC DECLARATIONS

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

static XtResource resources[] =

{

  {

    XmNindentSpace, XmCIndentSpace, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmOutlineRec, outline.indent_space),

    XmRImmediate, (XtPointer)DEF_INDENT_SPACE

  },

  {

    XmNconstrainWidth, XmCConstrainWidth, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmOutlineRec, outline.constrain_width),

    XmRImmediate, (XtPointer)False

  },

  {

    XmNconnectNodes, XmCBoolean, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmOutlineRec, outline.connect_nodes),

    XmRImmediate, (XtPointer)False

  }

};

static XmSyntheticResource get_resources[] =

{

  {

    XmNindentSpace, sizeof(Dimension),

    XtOffsetOf(XmOutlineRec, outline.indent_space),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  }

};

XmOutlineClassRec xmOutlineClassRec = {

  { /* core fields */

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

    /* class_name		*/	"XmOutline",

    /* widget_size		*/	sizeof(XmOutlineRec),

    /* class_initialize		*/	ClassInitialize,

    /* class_part_initialize	*/	ClassPartInitialize,

    /* class_inited		*/	FALSE,

    /* initialize		*/	Initialize,

    /* initialize_hook		*/	NULL,

    /* realize			*/	XtInheritRealize,

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

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

    /* num resources        */         0,

    /* constraint size      */         sizeof(XmOutlineConstraintRec),	

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

    /* num_syn_cont_resources */      0,

    /* parent_process         */      NULL,

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

   },

   { /* Outline fields */

      CalcMaxWidth,		/* calculates the max width of the outline. */

      CalcLocations,		/* calculates were children will be placed. */

      NULL                      /* extension    */

   }

};

WidgetClass xmOutlineWidgetClass = (WidgetClass) &xmOutlineClassRec;

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

*	STATIC CODE

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

/*      Function Name: ClassInitialize

 *      Description:   Initializes class-specific data (offsets)

 *      Arguments:     none

 *      Returns:       nothing

 */

static void

ClassInitialize()

{

  /* do nothing */

}

/*	Function Name: ClassPartInitialize

 *	Description: handles inheritance of class functions.

 *	Arguments: class - the widget class of this widget.

 *	Returns: none.

 */

static void

ClassPartInitialize(WidgetClass class)

{

    XmOutlineWidgetClass wc = (XmOutlineWidgetClass) class;

    XmOutlineWidgetClass superC;

    _XmProcessLock();

    superC = (XmOutlineWidgetClass) wc->core_class.superclass;

/* 

 * We don't need to check for NULL super since we'll get to The functions

 * defined by the Outline class eventually.

 */

    if (wc->outline_class.calc_max_width == XtInheritCalcMaxWidth)

	wc->outline_class.calc_max_width= superC->outline_class.calc_max_width;

    if (wc->outline_class.calc_locations == XtInheritCalcLocations)

	wc->outline_class.calc_locations= superC->outline_class.calc_locations;

    _XmProcessUnlock();

}

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

{

    XmOutlineWidget ow = (XmOutlineWidget) set;

    XmHierarchy_top_node(ow) = ((HierarchyConstraints) 

			      XtRealloc((XtPointer) XmHierarchy_top_node(ow),

					sizeof(OutlineConstraintRec)));

    XmOutline_top_node_of_display(ow) = NULL;

    XmOutline_max_width(ow) = 0;	

    XmOutline_max_widget_width(ow) = 0;

    XmOutline_ul_point(ow).x = ow->core.width;

    XmOutline_ul_point(ow).y = ow->core.height;

    XmOutline_lr_point(ow).x = 0;

    XmOutline_lr_point(ow).y = 0;

    XmOutline_child_op_list(ow) = _XmListInit();

    CreateGC(ow);

}

static void CreateGC(XmOutlineWidget ow)

{

    	XGCValues values;

	values.foreground = ow->manager.foreground;

	XmOutline_draw_gc(ow) = XtGetGC((Widget)ow, GCForeground, &values);

}

/*    Function Name: Destroy

 *    Description:   Destroys all data allocated by the widget

 *    Arguments:     w - the widget.

 *    Returns:       none.

 */

static void

Destroy(Widget widget)

{

  XmOutlineWidget ow = (XmOutlineWidget) widget;

  _XmListFree(XmOutline_child_op_list(ow)); 

  XtReleaseGC(widget,XmOutline_draw_gc(ow));

}

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

{

    XmOutlineWidget ow = (XmOutlineWidget) w;

    if (XmHierarchy_refigure_mode(ow)) {

	if(XmOutline_constrain_width(ow))

	    CalcLocations(w, False);

	LayoutChildren(w, NULL);

	if (XtIsRealized((Widget)ow)) {

	    XClearArea(XtDisplay(ow), XtWindow(ow),

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

	}

    }

}

/*	Function Name: Redisplay

 *	Description:   This function deals with any pending moves/maps/unmaps

 *                     in the queue before redisplay

 *	Arguments:     w - the Outline 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)

{

    XmOutlineWidget ow = (XmOutlineWidget) w;

    XEvent junk;

    RedispInfo info;

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

    XmDropSiteStartUpdate(w);

    /*

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

     */

    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 < XmOutline_ul_point(ow).x) 

	XmOutline_ul_point(ow).x = event->xexpose.x;

    if (event->xexpose.y < XmOutline_ul_point(ow).y) 

	XmOutline_ul_point(ow).y = event->xexpose.y;

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

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

    if (lrx > XmOutline_lr_point(ow).x) 

	XmOutline_lr_point(ow).x = lrx;

    if (lry > XmOutline_lr_point(ow).y) 

	XmOutline_lr_point(ow).y = lry;

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

	XRectangle rect;

	rect.x = XmOutline_ul_point(ow).x;

	rect.y = XmOutline_ul_point(ow).y;

	rect.width = XmOutline_lr_point(ow).x - XmOutline_ul_point(ow).x;

	rect.height = XmOutline_lr_point(ow).y - XmOutline_ul_point(ow).y;

	ProcessChildQueue((XmOutlineWidget) w, &rect);

	if (XmOutline_connect_nodes(w))

		RedrawOutlineLines(w,&rect);

	/*

	 * Reset upper right and lower left points.

	 */

	XmOutline_ul_point(ow).x = w->core.width;

	XmOutline_ul_point(ow).y = w->core.height;

	XmOutline_lr_point(ow).x = XmOutline_lr_point(ow).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: 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)

{

    Dimension *width_intended = NULL;

    Dimension *height_intended = NULL;

    if(!(intended->request_mode & XtCWQueryOnly)) {

	if(intended->request_mode & CWWidth)

	    width_intended = &(intended->width);

	if(intended->request_mode & CWHeight)

	    height_intended = &(intended->height);

    }

    GetDesiredSize(w, width_intended, height_intended,

		   &(preferred->width), &(preferred->height), True, False);

    preferred->request_mode = CWWidth | CWHeight;

    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)

{

    XmOutlineWidget c_outline = (XmOutlineWidget) current; 

    XmOutlineWidget outline = (XmOutlineWidget) set;

    Boolean layout = False;

    Boolean retval = False;

    if ((XmHierarchy_v_margin(c_outline) != XmHierarchy_v_margin(outline)) ||

	(XmHierarchy_h_margin(c_outline) != XmHierarchy_h_margin(outline)))

    {

	layout = True;

    }

    if (XmOutline_indent_space(c_outline) != XmOutline_indent_space(outline))

    {

	layout = True;

    }

    if (XmOutline_constrain_width(c_outline)

	!= XmOutline_constrain_width(outline))

    {

	layout = True;

    }

    if (XmHierarchy_refigure_mode(c_outline) != XmHierarchy_refigure_mode(outline))

	layout = XmHierarchy_refigure_mode(outline);

    if (XmOutline_connect_nodes(c_outline) != XmOutline_connect_nodes(outline))

	retval = True;

    if (layout) {

	XmOutlineWidgetClass oc = (XmOutlineWidgetClass) XtClass(set);

	XmOutlineCalcLocationProc calc_locations;

        _XmProcessLock()

	calc_locations = oc->outline_class.calc_locations;

        _XmProcessUnlock()

	(*calc_locations)(set, True);

	LayoutChildren(set, NULL);

	retval = True;

    }

    if (c_outline->manager.foreground != outline->manager.foreground)

	{

  	XtReleaseGC(current,XmOutline_draw_gc(c_outline));

	CreateGC(outline);

	retval = True;

	}

    return(retval);

}

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

 *

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

{

    XmOutlineWidgetClass oc = (XmOutlineWidgetClass) XtClass(w);

    XmOutlineWidget ow = (XmOutlineWidget) w;

    if (XmHierarchy_refigure_mode(ow)) {

	XmOutlineCalcLocationProc calc_locations;

	_XmProcessLock()

	calc_locations = oc->outline_class.calc_locations;

	_XmProcessUnlock()

	(*calc_locations)(w, True);

	LayoutChildren(w, NULL);

	if (XtIsRealized((Widget)ow)) {

	    XClearArea(XtDisplay(ow), XtWindow(ow),

		       0, 0, ow->core.width, ow->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)

{

    XmOutlineWidgetClass oc = (XmOutlineWidgetClass) XtClass(XtParent(w));

    XmOutlineWidget ow = (XmOutlineWidget)(XtParent(w));

    result->request_mode = 0;

    /* if nothing we're interested in, say No */

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

	return(XtGeometryNo);

    if((XmOutline_constrain_width(ow)) &&

       (request->request_mode & CWWidth) &&

       (request->width > w->core.width))

    {

	result->request_mode = CWWidth;

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

	return XtGeometryAlmost;

    }

    /* else we have something that we're interested in. Do we also have

    ** something that we're not granting? If so, say that we'll grant the

    ** stuff that we're interested in but not the other items

    */

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

	{

	result->request_mode = request->request_mode & (CWWidth | CWHeight | CWBorderWidth);

	result->width = request->width;

	result->height = request->height;

	result->border_width = request->border_width;

	return(XtGeometryAlmost);

	}

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

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

	result->request_mode |= CWWidth;

    }

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

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

	result->request_mode |= CWBorderWidth;

    }

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

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

	result->request_mode |= CWHeight;

    }

    *result = *request;

    if (request->request_mode & XtCWQueryOnly) 

	return(XtGeometryYes);

    /*

     * Correct for stupid children

     */

    if(result->width  <= 0) result->width  = 1;

    if(result->height <= 0) result->height = 1;

    /*

     * A real allowed request, make the change.

     */

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

    if (XmHierarchy_refigure_mode(ow)) {

	XmOutlineCalcLocationProc calc_locations;

	_XmProcessLock()

	calc_locations = oc->outline_class.calc_locations;

	_XmProcessUnlock()

	(*calc_locations)(XtParent(w), True);

	LayoutChildren(XtParent(w), w);

	if (XtIsRealized((Widget)ow)) {

	    XClearArea(XtDisplay(ow), XtWindow(ow),

		       0, 0, ow->core.width, ow->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)

{

    XmOutlineC_widget_x(set->core.constraints)

      = XmOutlineC_open_close_x(set->core.constraints) = 0;

}

/*	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 ow = XtParent(set);

    OutlineConstraints set_node = GetNodeInfo(set);

    OutlineConstraints old_node = GetNodeInfo(current);

    Boolean insert_change = False, redisplay = False;

    int i;

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

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

	    insert_change = True;

	    break;

	}

    /*

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

     */

    if (!XtIsRealized(set))

	return(False);

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

	(XmHierarchyC_state(set_node) != XmHierarchyC_state(old_node)) ||

	(insert_change))

    {

	/*

	 * Other operations have already been performed by my superclass. 

	 */

	if (XmHierarchy_refigure_mode((XmOutlineWidget)ow)) {

	    CalcLocations(ow, True);

	    LayoutChildren(ow, NULL);

	    redisplay = True;

	}

	 /*

	  * Since Layout children has (possibily) moved this widget

	  * to a new location.  The current state of the widget

	  * must be updated so that neither the intrinsics nor

	  * any sub-classes of this widget attempt to move it

	  * to the new location, since it is already there.

	  */

	 current->core.x = set->core.x;

	 current->core.y = set->core.y;

     }

    if (XtIsRealized(ow) && redisplay && 

        (XmHierarchy_refigure_mode((XmOutlineWidget)ow)))

    {

	XClearArea(XtDisplay(ow), XtWindow(ow),

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

    }

    return(False);   

}

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

{

    OutlineConstraints node = GetNodeInfo(w);

    XmListElem *elem, *next;

    XmOutlineWidget ow;

    if (XmHierarchyC_state(node) == XmNotInHierarchy) 

	return;

    ow = (XmOutlineWidget) XtParent(w);

    elem = XmListFirst(XmOutline_child_op_list(ow)); 

    while(elem != NULL) {

	OutlineConstraints info = (OutlineConstraints) XmListElemData(elem);

	next = XmListElemNext(elem);

	if (XmHierarchyC_widget(info) == w) {

	    /*

	     * Each widget will only be in the list once.

	     */

	    _XmListRemove(XmOutline_child_op_list(ow), elem);

	    break;

	}

	elem = next;

    }

}

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

 *

 *  Hierarchy Widget class proceedures.

 *

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

/*	Function Name: ToggleNodeState

 *	Description:   Toggles the open/close state of a toggle button.

 *	Arguments:     w - the command button that activated this.

 *                     node_ptr - a pointer to the node info.

 *                     call_data - UNUSED.

 *	Returns:       none.

 */

/*ARGSUSED*/

static void

ToggleNodeState(Widget w, XtPointer node_ptr, XtPointer call_data)

{

    Widget ow = XtParent(w);

    XmOutlineWidgetClass oc = (XmOutlineWidgetClass) XtClass(ow);

    {

	XtCallbackProc toggle_node_state;

	_XmProcessLock()

	toggle_node_state = SUPERCLASS->hierarchy_class.toggle_node_state;

	_XmProcessUnlock()

	(*toggle_node_state)(w, node_ptr, call_data);

    }

    {

	XmOutlineCalcLocationProc calc_locations;

	_XmProcessLock()

	calc_locations = oc->outline_class.calc_locations;

	_XmProcessUnlock()

	(*calc_locations)(ow, True);

    }

    LayoutChildren(ow, NULL);

    /*

     * Could check for a size change and abort if we really wanted

     * to be clever.

     */

    if (XtIsRealized(ow)) {

	XClearArea(XtDisplay(ow), XtWindow(ow),

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

    }

}

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

 *

 *  Outline widget class proceedures.

 *

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

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

 *

 * Actions and Callbacks.

 *

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

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

 *

 * Internal routines.

 *

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

/*	Function Name: CalcLocations

 *	Description:   Calculates the location of each widget in the outline.