/*

 * 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 <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include "XmI.h"

#include <Xm/PanedP.h>

#include <Xm/SashP.h>

#include <Xm/Separator.h>

#include <Xm/ExtP.h>

typedef enum {UpLeftPane = 'U',	/* Adjust panes above or to the left.*/

	      LowRightPane = 'L',/* Adjust panes below or the the right. */

	      AnyPane = 'A' } Direction;

#define NO_DELTA -99

#define NO_INDEX -100

#define BLOCK 10

#define LARGE_INC ("LargeIncr")

#define XmNisAPane "isAPane"

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

 *       GLOBAL DECLARATIONS

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

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

 *

 * Full instance record declaration

 *

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

/*

 * These characters all get compiled into each application as/is, so

 * the default translations table is not very readable, but is nice and small.

 */

static char defSashTranslations[] =

    "<Key>osfHelp: Help()\n\

     !c<Key>osfUp: SashAction(K,10,Up)\n\

     None<Key>osfUp: SashAction(K,1,Up)\n\

     !c<Key>osfDown: SashAction(K,10,Down)\n\

     None<Key>osfDown: SashAction(K,1,Down)\n\

     !c<Key>osfLeft: SashAction(K,10,Left)\n\

     None<Key>osfLeft: SashAction(K,1,Left)\n\

     !c<Key>osfRight: SashAction(K,10,Right)\n\

     None<Key>osfRight: SashAction(K,1,Right)\n\

     s~m~a<Key>Tab: PrevTabGroup()\n\

     ~m~a<Key>Tab: NextTabGroup()\n\

     ~c ~s ~m ~a <Btn1Down>: SashAction(S)\n\

     ~c ~s ~m ~a <Btn1Motion>: SashAction(M)\n\

     ~c ~s ~m ~a <BtnUp>: SashAction(C)\n\

     <FocusIn>: SashFocusIn()\n\

     <FocusOut>: SashFocusOut()\n\

     <Unmap>: PrimitiveUnmap()\n\

     <EnterWindow>: enter()\n\

     <LeaveWindow>: leave()";

/* Internal (yet useful) Motif routine. */

extern void _XmBackgroundColorDefault();

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

 *     Private functions. 

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

static void ClassInitialize();

static XmImportOperator ToPanedOppositePixels(Widget, int, XtArgVal *);

static XmImportOperator ToPanedChildPixels(Widget, int, XtArgVal *);

static Dimension PaneSize(Widget, Boolean);

static Dimension GetRequestInfo(XtWidgetGeometry *, Boolean);

static Pane ChoosePaneToResize(XmPanedWidget, int, Direction, Boolean);

static int GetEventLocation(XmPanedWidget, XEvent *);

static Boolean PopPaneStack(XmPanedWidget), IsPane(Widget);

static Boolean SatisfiesRule3(Pane, Boolean);

static Boolean SatisfiesRule2(Pane), SatisfiesRule1(Pane, Boolean, Direction);

static Boolean RefigureLocations(XmPanedWidget, int, Direction);

static XtGeometryResult AdjustPanedSize(XmPanedWidget, Dimension, Boolean,

					Boolean, Dimension *, Dimension *);

static void ResetSize(XmPanedWidget, Boolean);

static void GetPrefSizes(XmPanedWidget, Dimension *, Dimension *);

static void FromPanedChildPixels(Widget, int, XtArgVal *);

static void FromPanedOppositePixels(Widget, int, XtArgVal *);

static void LoopAndRefigureChildren(XmPanedWidget, int, int, Dimension *);

static void CommitNewLocations(XmPanedWidget, Widget);

static void RefigureLocationsAndCommit(Widget), CreateSeparator(Widget);

static void _DrawRect(XmPanedWidget, GC, int, int, unsigned int, unsigned int);

static void _DrawTrackLines(XmPanedWidget, Boolean), ResetSash(Widget);

static void StartSashAdjustment(XmPanedWidget, Widget);

static void MoveSashAdjustment(XmPanedWidget, Widget, int);

static void CommitSashAdjustment(XmPanedWidget, Widget), ReleaseGCs(Widget);

static void ProcessKeyEvent(XtPointer, XtIntervalId *);

static void HandleSash(Widget, XtPointer, XtPointer);

static void ManageAndUnmanageSashs(XmPanedWidget), CreateSash(Widget);

static void SetChildrenPrefSizes(XmPanedWidget, Dimension, Boolean, Boolean);

static void PushPaneStack(XmPanedWidget, Pane), ClearPaneStack(XmPanedWidget);

static void GetPaneStack(XmPanedWidget, Boolean, Pane *, int *);

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

 *  Semi-Public functions

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

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

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

static XtGeometryResult GeometryManager(Widget,	XtWidgetGeometry *,

					XtWidgetGeometry *);

static XtGeometryResult QueryGeometry(Widget, XtWidgetGeometry *,

				      XtWidgetGeometry *);

static void Destroy(Widget);

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

static void InsertChild(register Widget);

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

static void ConstraintDestroy(Widget), ReManageChildren(XmPanedWidget);

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

/*  Resource definitions for Subclasses of Primitive */

static Position def_pos = -10;	/* negative numbers cannot be set with immed.*/

static XtResource resources[] =

{

  {

    XmNspacing, XmCSpacing, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.internal_bw),

    XmRImmediate, (XtPointer) 10

  },

  {

    XmNmarginWidth, XmCMargin, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.margin_width),

    XmRImmediate, (XtPointer) 3

  },

  {

    XmNmarginHeight, XmCMargin, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.margin_height),

    XmRImmediate, (XtPointer) 3

  },

  {

    XmNrefigureMode, XmCBoolean, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedRec, paned.refiguremode),

    XmRImmediate, (XtPointer) TRUE

  },

  {

    XmNorientation, XmCOrientation, XmROrientation,

    sizeof(unsigned char), XtOffsetOf(XmPanedRec, paned.orientation),

    XmRImmediate, (XtPointer) XmVERTICAL

  },

  {

    XmNseparatorOn, XmCSeparatorOn, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedRec, paned.separator_on),

    XmRImmediate, (XtPointer) TRUE

  },

    /* Cursors - these are used in both horiz and vertical mode. */

  {

    XmNcursor, XmCCursor, XmRCursor,

    sizeof(Cursor), XtOffsetOf(XmPanedRec, paned.cursor),

    XmRImmediate, None

  },

    /* Sash control resources */

  {

    XmNsashIndent, XmCSashIndent, XmRHorizontalPosition,

    sizeof(Position), XtOffsetOf(XmPanedRec, paned.sash_indent),

    XmRHorizontalPosition, (XtPointer) &def_pos

  },

  {

    XmNsashTranslations, XmCTranslations, XmRTranslationTable,

    sizeof(XtTranslations), XtOffsetOf(XmPanedRec, paned.sash_translations),

    XmRString, (XtPointer)defSashTranslations

  },

  {

    XmNsashWidth, XmCSashWidth, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.sash_width),

    XmRImmediate, (XtPointer) 10

  },

  {

    XmNsashHeight, XmCSashHeight, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.sash_height),

    XmRImmediate, (XtPointer) 10

  },

  {

    XmNsashShadowThickness, XmCShadowThickness, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedRec, paned.sash_shadow_thickness),

    XmRImmediate, (XtPointer) 2

  },

  {

    XmNallowUnusedSpace, XmCAllowUnusedSpace, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedRec, paned.allow_unused_space),

    XmRImmediate, (XtPointer) TRUE

  }

};

/* Definition for resources that need special processing in get values */

static XmSyntheticResource get_resources[] =

{

  {

    XmNmarginWidth, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.margin_width),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  },

  {

    XmNmarginHeight, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.margin_height),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  },

  {

    XmNspacing, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.internal_bw),

    _XmFromPanedPixels, (XmImportProc) _XmToPanedPixels

  },

  {

    XmNsashIndent, sizeof(Position),

    XtOffsetOf(XmPanedRec, paned.sash_indent),

    FromPanedOppositePixels, (XmImportProc) ToPanedOppositePixels

  },

  {

    XmNsashWidth, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.sash_width),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  },

  {

    XmNsashHeight, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.sash_height),

    XmeFromVerticalPixels, (XmImportProc) XmeToVerticalPixels

  },

  {

    XmNsashShadowThickness, sizeof(Dimension),

    XtOffsetOf(XmPanedRec, paned.sash_shadow_thickness),

    XmeFromHorizontalPixels, (XmImportProc) XmeToHorizontalPixels

  }

};

static XtResource subresources[] =

{

  {

    XmNallowResize, XmCBoolean, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedConstraintsRec, paned.allow_resize),

    XmRImmediate, (XtPointer) FALSE

  },

  {

    XmNpaneMinimum, XmCPaneMinimum, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedConstraintsRec, paned.min),

    XmRImmediate, (XtPointer) 1

  },

  {

    XmNpaneMaximum, XmCPaneMaximum, XmRVerticalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedConstraintsRec, paned.max),

    XmRImmediate, (XtPointer) 1000

  },

#ifdef POSITION_IMPLEMENTED

  {

    XmNposition, XmCPosition, XmRInt,

    sizeof(int), XtOffsetOf(XmPanedConstraintsRec, paned.position),

    XmRImmediate, (XtPointer) 0

  },

#endif

  {

    XmNpreferredPaneSize, XmCPreferredPaneSize, XmRHorizontalDimension,

    sizeof(Dimension), XtOffsetOf(XmPanedConstraintsRec, paned.preferred_size),

    XmRImmediate, (XtPointer) XmPanedAskChild

  },

  /*

   * Overrides user's grip placement and go back to preferred size when

   * paned window is resized or a management change happens.

   */

  {

    XmNresizeToPreferred, XmCBoolean, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedConstraintsRec, paned.resize_to_pref),

    XmRImmediate, (XtPointer) FALSE

  },

  {

    XmNskipAdjust, XmCBoolean, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedConstraintsRec, paned.skip_adjust),

    XmRImmediate, (XtPointer) FALSE

  },

  {

    XmNshowSash, XmCShowSash, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedConstraintsRec, paned.show_sash),

    XmRImmediate, (XtPointer) TRUE

  },

    /* 

     * This is an internal constraint resources set on sashes and separators

     * at start up to False, it should be True for all real panes.

     */

  {

    XmNisAPane, XmNisAPane, XmRBoolean,

    sizeof(Boolean), XtOffsetOf(XmPanedConstraintsRec, paned.is_a_pane),

    XmRImmediate, (XtPointer) TRUE

  }

};

/* Definition for constraint resources that need special */

/* processing in get values                              */

static XmSyntheticResource get_constraint_resources[] =

{

  {

    XmNpaneMinimum, sizeof(Dimension),

    XtOffsetOf(XmPanedConstraintsRec, paned.min),

    FromPanedChildPixels, (XmImportProc) ToPanedChildPixels

  },

  {

    XmNpaneMaximum, sizeof(Dimension),

    XtOffsetOf(XmPanedConstraintsRec, paned.max),

    FromPanedChildPixels, (XmImportProc) ToPanedChildPixels

  },

  {

    XmNpreferredPaneSize, sizeof(Dimension),

    XtOffsetOf(XmPanedConstraintsRec, paned.preferred_size),

    FromPanedChildPixels, (XmImportProc) ToPanedChildPixels

  }

};

#define SuperClass ((ConstraintWidgetClass)&xmManagerClassRec)

XmPanedClassRec xmPanedClassRec = {

   {

/* core class fields */

    /* superclass         */   (WidgetClass) SuperClass,

    /* class name         */   "XmPaned",

    /* size               */   sizeof(XmPanedRec),

    /* class_initialize   */   ClassInitialize,

    /* class_part init    */   NULL,

    /* class_inited       */   FALSE,

    /* initialize         */   Initialize,

    /* initialize_hook    */   NULL,

    /* realize            */   Realize,

    /* actions            */   NULL,

    /* num_actions        */   0,

    /* resources          */   (XtResource*)resources,

    /* resource_count     */   XtNumber(resources),

    /* xrm_class          */   NULLQUARK,

    /* compress_motion    */   TRUE,

    /* compress_exposure  */   TRUE,

    /* compress_enterleave*/   TRUE,

    /* visible_interest   */   FALSE,

    /* destroy            */   Destroy,

    /* resize             */   Resize,

    /* expose             */   NULL,

    /* set_values         */   SetValues,

    /* set_values_hook    */   NULL,

    /* set_values_almost  */   XtInheritSetValuesAlmost,

    /* get_values_hook    */   NULL,

    /* accept_focus       */   NULL,

    /* version            */   XtVersion,

    /* callback_private   */   NULL,

    /* tm_table           */   XtInheritTranslations,

    /* query_geometry	  */   (XtGeometryHandler) QueryGeometry,

    /* display_accelerator*/   XtInheritDisplayAccelerator,

    /* extension          */   NULL

   }, {

/* composite class fields */

    /* geometry_manager   */   GeometryManager,

    /* change_managed     */   ChangeManaged,

    /* insert_child       */   InsertChild,

    /* delete_child       */   XtInheritDeleteChild,

    /* extension          */   NULL

   }, {

/* constraint class fields */

    /* subresources       */   (XtResource*)subresources,

    /* subresource_count  */   XtNumber(subresources),

    /* constraint_size    */   sizeof(XmPanedConstraintsRec),

    /* initialize         */   NULL,

    /* destroy            */   ConstraintDestroy,

    /* set_values         */   PaneSetValues,

    /* extension          */   NULL

   }, {

/* manager_class fields   */

      XtInheritTranslations,                    /* translations           */

      get_resources,                            /* get resources          */

      XtNumber(get_resources),                  /* num get_resources      */

      get_constraint_resources,                 /* get_cont_resources     */

      XtNumber(get_constraint_resources),       /* num_get_cont_resources */

      XmInheritParentProcess,                   /* parent_process         */

      NULL,                                     /* extension              */

  }, {

/* paned_window_class fields */

      NULL,                                     /* extension                 */

  }

};

WidgetClass xmPanedWidgetClass = (WidgetClass) &xmPanedClassRec;

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

 *

 * Private Functions.

 *

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

/*

 *     Function Name: ClassInitialize

 *     Description: Initialized XmPaned widget class

 *     Arguments: none

 *     Returns: nothing

 */

static void

ClassInitialize()

{

  /* do nothing */

}

/*	Function Name: AdjustPanedSize

 *	Description: Adjusts the size of the pane.

 *	Arguments: pw - the paned widget to adjust.

 *                 off_size - the new off_size to use.

 *                 always_compute_on_size - a self explanatory Boolean.

 *                 query_only - perform a query_only?

 *                 result_ret - result of query ** RETURNED **

 *                 on_size_ret - the new on_size ** RETURNED **

 *                 off_size_ret - the new off_size ** RETURNED **

 *	Returns: the amount of change in size.

 */

static XtGeometryResult

AdjustPanedSize(XmPanedWidget pw, Dimension off_size,

		Boolean always_compute_on_size, Boolean query_only,

		Dimension *on_size_ret, Dimension *off_size_ret)

{

    Dimension old_size = PaneSize( (Widget) pw, IsVert(pw));

    Dimension newsize = 0;

    XtWidgetGeometry request, reply;

    XtGeometryResult result;

    if ((PaneSize((Widget) pw, IsVert(pw)) <= 1) || always_compute_on_size) {

	GetPrefSizes(pw, &newsize, NULL);

	if (newsize < 1) 

	    newsize = 1;

    }

    else {

	if (IsVert(pw))

	    newsize = pw->core.height;

	else

	    newsize = pw->core.width;

    }

    if ( IsVert(pw) ) {

        request.width = off_size + 2 * XmPaned_margin_width(pw);

	request.height = newsize;

    }

    else {

        request.width = newsize;

	request.height = off_size + 2 * XmPaned_margin_height(pw);

    }

    request.request_mode = CWWidth | CWHeight;

    if (query_only)

	request.request_mode |= XtCWQueryOnly;

    result = XtMakeGeometryRequest( (Widget) pw, &request, &reply );

    if (result == XtGeometryAlmost)

    {

	if (query_only)

	    request = reply;

	else

	    result = XtMakeGeometryRequest((Widget) pw, &reply, &request);

    }

    reply = request;	/* simplifies things later... */

    if ( result == XtGeometryNo ) {

	if (on_size_ret != NULL)

	    *on_size_ret = old_size;

	if (off_size_ret != NULL)

	    *off_size_ret = PaneSize((Widget) pw, !IsVert(pw));

    }

    else {	/* result == XtGeometryYes */

	if (on_size_ret != NULL)

	    *on_size_ret = GetRequestInfo( &reply, IsVert(pw) );

	if (off_size_ret != NULL)

	    *off_size_ret = GetRequestInfo( &reply, !IsVert(pw) );

    }

    if ( IsVert(pw) ) {

	if (on_size_ret != NULL)

	    *on_size_ret -= 2 * XmPaned_margin_height(pw);

	if (off_size_ret != NULL)

	    *off_size_ret -= 2 * XmPaned_margin_width(pw);

    }

    else {

	if (on_size_ret != NULL)

	    *on_size_ret -= 2 * XmPaned_margin_width(pw);

	if (off_size_ret != NULL)

	    *off_size_ret -= 2 * XmPaned_margin_height(pw);

    }

    return(result);

}

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

 *

 *  Resolution Independance stuff for dealing in the face

 *  of orientation changes.

 *

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

/*	Function Name: FromPanedPixels

 *	Description: Converts from pixels to current unit type

 *                   does either horiz or vert depending on orientation.

 *	Arguments: widget - the paned widget.

 *                 offset, value - passed to correct function based

 *                                 on orientation.

 *	Returns: none

 */

void

_XmFromPanedPixels(Widget widget, int offset, XtArgVal *value)

{

    XmPanedWidget pw = (XmPanedWidget) widget;    

    if (IsVert(pw)) 

	XmeFromVerticalPixels(widget, offset, value);

    else

	XmeFromHorizontalPixels(widget, offset, value);

}

/*	Function Name: FromPanedChildPixels

 *	Description: Converts from pixels to current unit type

 *                   does either horiz or vert depending on 

 *                   of the parent of this widget orientation.

 *	Arguments: widget - the paned widget.

 *                 offset, value - passed to correct function based

 *                                 on orientation.

 *	Returns: none

 */

static void

FromPanedChildPixels(Widget widget, int offset, XtArgVal *value)

{

    XmPanedWidget pw = (XmPanedWidget) XtParent(widget);    

    if (IsVert(pw)) 

	XmeFromVerticalPixels(widget, offset, value);

    else

	XmeFromHorizontalPixels(widget, offset, value);

}

/*	Function Name: ToPanedPixels

 *	Description: Converts to pixels from current unit type

 *                   does either horiz or vert depending on orientation.

 *	Arguments: widget - the paned widget.

 *                 offset, value - passed to correct function based

 *                                 on orientation.

 *	Returns: none

 */

XmImportOperator

_XmToPanedPixels(Widget widget, int offset, XtArgVal *value)

{

    XmPanedWidget pw = (XmPanedWidget) widget;    

    if (IsVert(pw)) 

	return(XmeToVerticalPixels(widget, offset, value));

    else

	return(XmeToHorizontalPixels(widget, offset, value));

}

/*	Function Name: ToPanedChildPixels

 *	Description: Converts to pixels from current unit type

 *                   does either horiz or vert depending on parent's 

 *                   orientation.

 *	Arguments: widget - the paned widget.

 *                 offset, value - passed to correct function based

 *                                 on orientation.

 *	Returns: none

 */

static XmImportOperator

ToPanedChildPixels(Widget widget, int offset, XtArgVal *value)

{

    XmPanedWidget pw = (XmPanedWidget) XtParent(widget);    

    if (IsVert(pw)) 

	return(XmeToVerticalPixels(widget, offset, value));

    else

	return(XmeToHorizontalPixels(widget, offset, value));

}

/*	Function Name: FromPanedOppositePixels

 *	Description: Converts from pixels to current unit type

 *                   does either horiz or vert depending on orientation.

 *	Arguments: widget - the paned widget.

 *                 offset, value - passed to correct function based

 *                                 on orientation.

 *	Returns: none

 */

static void

FromPanedOppositePixels(Widget widget, int offset, XtArgVal *value)

{

    XmPanedWidget pw = (XmPanedWidget) widget;    

    if (IsVert(pw)) 

	XmeFromHorizontalPixels(widget, offset, value);

    else

	XmeFromVerticalPixels(widget, offset, value);

}

/*	Function Name: ToPanedOppositePixels

 *	Description: Converts to pixels from current unit type

 *                   does either horiz or vert depending on orientation.

 *	Arguments: widget - the paned widget.

 *                 offset, value - passed to correct function based

 *                                 on orientation.

 *	Returns: none

 */

static XmImportOperator

ToPanedOppositePixels(Widget widget, int offset, XtArgVal *value)

{

    XmPanedWidget pw = (XmPanedWidget) widget;    

    if (IsVert(pw)) 

	return(XmeToHorizontalPixels(widget, offset, value));

    else

	return(XmeToVerticalPixels(widget, offset, value));

}

/*	Function Name: PaneSize

 *	Description: returns the width or height of the pane depending

 *                   upon the orientation we are using.

 *	Arguments: w - and widget.

 *                 vertical - TRUE if this is vertically oriented pane.

 *	Returns: the size requested

 *

 *      vertical  - return height

 *      !vertical - return width

 */

static Dimension

PaneSize(Widget w, Boolean vertical)

{

    if (vertical)

	return (w->core.height);

    return (w->core.width);

}

/*	Function Name: GetRequestInfo

 *	Description: returns request information.

 *	Arguments:  geo_struct - a geometry struct to get information out of.

 *                  vert - TRUE if this is a vertical paned widget.

 *	Returns: the request information.

 */

static Dimension

GetRequestInfo(XtWidgetGeometry *geo_struct, Boolean vert)

{

    if (vert)

	return ((Dimension) geo_struct->height);

    return ((Dimension) geo_struct->width);

}

/*	Function Name: ChoosePaneToResize.

 *	Description: This function chooses a pane to resize.

 *                   They are chosen using the following rules:

 *

 *                   1) size < max && size > min

 *                      if pane is growing or has a sash. 

 *                      (keeps non sash panes from shrinking).

 *                   3) skip adjust == FALSE

 *                   4) widget not its prefered height &&

 *                      this change will bring it closer &&

 *                      The user has not resized this pane.

 *           

 *                   If no widgets are found that fits all the rules then

 *                      rule #3 is broken.

 *                   If there are still no widgets found than

 *                      rule #2 is broken.

 *                   Rule #1 is never broken.

 *                   If no widgets are found then NULL is returned.

 * 

 *	Arguments: pw - the paned widget.

 *                 paneindex - the index of the current pane.

 *                 dir - direction to search first.

 *                 shrink - TRUE if we need to shrink a pane, FALSE otherwise.

 *	Returns: pane to resize or NULL.

 */

static Pane

ChoosePaneToResize(XmPanedWidget pw,

		   int paneindex, Direction dir, Boolean shrink)

{

    Widget *childP;

    int rules = 3;

    Direction _dir = dir;

    int _index = paneindex;

    int curIndex;

    if ( (paneindex == NO_INDEX) || (dir == AnyPane) ) {  /* Use defaults. */

	_dir = LowRightPane;		/* Go up. - really. */

	_index = XmPaned_num_panes(pw) - 1;   /* Start the last pane, and work

					       backwards. */

    }

    childP = NthPane(pw, _index);

    while(TRUE) {

        register Pane pane = PaneInfo(*childP);

        if ((rules < 3 || SatisfiesRule3(pane, shrink)) &&

	    (rules < 2 || SatisfiesRule2(pane))         &&

	    (SatisfiesRule1(pane, shrink, dir))         &&

	    ((paneindex != PaneIndex(*childP)) || (dir == AnyPane)) )

	{

	    return(pane);

	}

	/*

	 * This is counter-intuitive, but if we are resizing the pane

	 * above the sash we want to choose a pane below the sash to lose,

	 * and visa-versa.

	 */

	if (shrink || (dir == AnyPane)) {

	    if (_dir == LowRightPane) 

		--childP; 

	    else

		++childP;

	}

	else {

	    if (_dir == LowRightPane) 

		++childP; 

	    else

		--childP;

	}

	/*

	 * If we have come to and edge then reduce the rule set, and try again.

	 * If we are reduced the rules to none, then return NULL.

	 */

	curIndex = childP - NthPane(pw, 0);

	if ((curIndex < 0) || (curIndex >= XmPaned_num_panes(pw))) {

	    if (--rules < 1)  /* less strict rules. */

		return(NULL);

	    childP = NthPane(pw, _index);

	}

    }

}

/*	Function Name: IsPane

 *	Description: Returns true if this is a pane.

 *	Arguments: w - a child of the paned widget.

 *	Returns: none.

 */

static Boolean

IsPane(Widget w) 

{

    Pane pane = PaneInfo(w);

    return ((pane != NULL) && pane->is_a_pane);

}

/*	Function Name: StatisfiesRule1

 *	Description: check for to see if this pane satisfies rule 1.

 *	Arguments: pane - the pane to check.

 *                 shrink -TRUE if we want to shrink this pane, FALSE otherwise

 *	rEturns: TRUE if the rule is satisfied.

 */

static Boolean

SatisfiesRule1(Pane pane, Boolean shrink, Direction dir)

{

    /*

     * If this pane is at its preferred size and is asked to shrink

     * while having no sash then do not allow it.

     *

     * NOTE: If Dir == AnyPane then this is not due to a grip resize

     *       and this rule does not take effect.

     */

    if ((dir != AnyPane) && 

	shrink && (pane->sash == NULL) && (pane->size == pane->wp_size))

    {

	return(False);

    }

    return((shrink && (pane->size != pane->min)) ||

	   (!shrink && (pane->size != pane->max)) );

}

/*	Function Name: StatisfiesRule2

 *	Description: check for to see if this pane satisfies rule 2.

 *	Arguments: pane - the pane to check.

 *	Returns: TRUE if the rule is satisfied.

 */

static Boolean

SatisfiesRule2(Pane pane)

{

    return(!pane->skip_adjust);

}

/*	Function Name: StatisfiesRule3

 *	Description: check for to see if this pane satisfies rule 3.

 *	Arguments: pane - the pane to check.

 *                 shrink -TRUE if we want to shrink this pane, FALSE otherwise

 *	Returns: TRUE if the rule is satisfied.

 */

static Boolean

SatisfiesRule3(Pane pane, Boolean shrink)

{

    return ((pane->size != pane->wp_size) &&

	    ((shrink && ((int)pane->wp_size <= pane->size)) ||

	     (!shrink && ((int)pane->wp_size >= pane->size))) );

}

/*	Function Name: LoopAndRefigureChildren.

 *	Description: if we are resizing either the UpleftPane or LowRight Pane

 *                   loop through all the children to see if any will allow us

 *                   to resize them.

 *	Arguments: pw - the paned widget.

 *                 paneindex - the number of the pane border we are moving.

 *                 dir - the pane to move (either UpLeftPane or LowRightPane).

 *                 sizeused - current amount of space used. 

 *                            THIS VALUE IS USED AND RETURNED.

 *	Returns: none.

 */