/* 

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

#ifndef lint

static char rcsid[] = "$TOG: PanedW.c /main/24 1999/07/13 07:46:01 mgreess $"

#endif

#endif

/* (c) Copyright 1989, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/* (c) Copyright 1987, 1988, 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

/* (c) Copyright 1988 MASSACHUSETTS INSTITUTE OF TECHNOLOGY  */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <ctype.h>

#include <X11/cursorfont.h>

#include "XmI.h"

#include <Xm/PanedWP.h>

#include <Xm/SeparatoG.h>

#include <Xm/SashP.h>

#include <Xm/VaSimpleP.h>

#include "MessagesI.h"

#include "RepTypeI.h"

typedef enum {FirstPane='U', LastPane='L'} Direction;

#define MESSAGE4	_XmMMsgPanedW_0000

#define MESSAGE5	_XmMMsgPanedW_0001

#define MESSAGE6	_XmMMsgPanedW_0002

#define MESSAGE8	_XmMMsgPanedW_0004

#define MESSAGE9	_XmMMsgPanedW_0005

#define PaneInfo(w)	((XmPanedWindowConstraintPtr)(w)->core.constraints)

#define IsPane(w)	(PaneInfo(w)->panedw.isPane)

#define PaneIndex(w)	(PaneInfo(w)->panedw.position)

#define PanePosIndex(w)	(PaneInfo(w)->panedw.position_index)

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

/* Code used for carrying the orientation code is a clean way.

   Do not manipulate width, height, or x and y anymore, but

   a major and minor dimension and an independant position */

#define Horizontal(pw) ((pw)->paned_window.orientation == XmHORIZONTAL)

/* since we cannot change the instance record field name, for binary 

   compatibility,  we have to macro those as well */

#define PaneDMajor(w)	(PaneInfo(w)->panedw.dheight)

#define PaneDPos(w)	(PaneInfo(w)->panedw.dy)

#define PaneOldDPos(w)	(PaneInfo(w)->panedw.olddy)

#define PaneStartPos(w)	(w->paned_window.starty)

#define PaneFirst(w)	(w->paned_window.top_pane)

#define PaneLast(w)	(w->paned_window.bottom_pane)

#define PaneFirstDMajor(w) (w->paned_window.top_pane->panedw.dheight)

#define PaneLastDMajor(w)  (w->paned_window.bottom_pane->panedw.dheight)

/* then come all the new paradigm of major/minor dimension */

#define Major(pw, w, h) ((Horizontal(pw))?w:h)

#define Minor(pw, w, h) (Major(pw,h,w))

#define MajorMargin(pw) (Major(pw, (pw)->paned_window.margin_width,\

			    (pw)->paned_window.margin_height))

#define MinorMargin(pw) (Major(pw, (pw)->paned_window.margin_height,\

			    (pw)->paned_window.margin_width))

#define MajorSize(pw) (Major(pw, (pw)->core.width, (pw)->core.height))

#define MinorSize(pw) (Major(pw, (pw)->core.height, (pw)->core.width))

#define MajorChildSize(pw, child) (Major(pw, \

                       (child)->core.width, (child)->core.height))

#define MinorChildSize(pw, child) (Major(pw, \

                       (child)->core.height, (child)->core.width))

#define MajorChildPos(pw, child) (Major(pw, (child)->core.x, (child)->core.y))

#define MajorReq(pw, request) (Major(pw, (request)->width, (request)->height))

#define MinorReq(pw, request) (Major(pw, (request)->height, (request)->width))

#define MajorAssign(pw,x,v) if (Horizontal(pw)) (x).width = v; else (x).height = v

#define MinorAssign(pw,x,v) if (Horizontal(pw)) (x).height = v; else (x).width = v

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

#define XmBLOCK	10  /* used for the list of managed children */

#define DEFAULT_SASH_INDENT_LTOR       -10

#define DEFAULT_SASH_INDENT_RTOL        10

/* Enumerated values used for HandleSash action, whose parameters

   are processing using reptype. */

enum { _START, _MOVE, _COMMIT, _KEY };

enum { _DEFAULT_INCR, _LARGE_INCR };

enum { _UP, _DOWN, _RIGHT, _LEFT, _FIRST, _LAST };

/********    Static Function Declarations    ********/

static void ReManageChildren( 

                        XmPanedWindowWidget pw) ;

static int NeedsAdjusting( 

                        register XmPanedWindowWidget pw) ;

static XtGeometryResult AdjustPanedWindowMajor( 

                        XmPanedWindowWidget pw,

#if NeedWidePrototypes

                        int newdim,

#else

                        Dimension newdim,

#endif /* NeedWidePrototypes */

                        Dimension *reply_dim) ;

static void ResetDMajors( 

                        XmPanedWindowWidget pw) ;

static void RefigureLocations( 

                        register XmPanedWindowWidget pw,

                        int c_index,

                        Direction dir,

#if NeedWidePrototypes

                        int rflag,

			int sflag) ;

#else

                        Boolean rflag,

                        Boolean sflag) ;

#endif /* NeedWidePrototypes */

static void CommitNewLocations( 

                        XmPanedWindowWidget pw,

                        Widget instigator) ;

static void RefigureLocationsAndCommit( 

                        XmPanedWindowWidget pw,

                        int c_index,

                        Direction dir,

#if NeedWidePrototypes

                        int rflag) ;

#else

                        Boolean rflag) ;

#endif /* NeedWidePrototypes */

static void DrawTrackLines( 

                        XmPanedWindowWidget pw) ;

static void EraseTrackLines( 

                        XmPanedWindowWidget pw) ;

static void ProcessKeyEvent( 

                        XtPointer client_data,

                        XtIntervalId *id) ;

static void HandleSash( 

                        Widget w,

                        XtPointer closure,

                        XtPointer callData) ;

static XtGeometryResult GeometryManager( 

                        Widget w,

                        XtWidgetGeometry *request,

                        XtWidgetGeometry *reply) ;

static void SashIndentDefault(Widget widget,

			      int offset,

			      XrmValue *value );

static void ClassPartInitialize( 

                        WidgetClass wc) ;

static void Initialize( 

                        Widget request,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void ConstraintInit( 

                        Widget request,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void Realize( 

                        Widget w,

                        XtValueMask *p_valueMask,

                        XSetWindowAttributes *attributes) ;

static void Destroy( 

                        Widget w) ;

static Cardinal InsertOrder( 

                        Widget w) ;

static void InsertChild( 

                        register Widget w) ;

static void ChangeManaged( 

                        Widget w) ;

static void Resize( 

                        Widget wid) ;

static Boolean SetValues( 

                        Widget cw,

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static Boolean PaneSetValues( 

                        Widget old,

                        Widget request,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void ConstraintDestroy( 

                        Widget w) ;

static void AdjustGC( 

                        XmPanedWindowWidget pw) ;

static void GetFlipGC( 

                        XmPanedWindowWidget pw) ;

/********    End Static Function Declarations    ********/

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

 *

 * Paned Window Resources

 *

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

#define Offset(field) XtOffsetOf( struct _XmPanedWindowRec, paned_window.field)

static XtResource resources[] = {

    {XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension, sizeof(Dimension),

       Offset(margin_width), XmRImmediate, (XtPointer) 3},

    {XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension, sizeof(Dimension),

       Offset(margin_height), XmRImmediate, (XtPointer) 3},

/* need to change the XmR to something dynamic: XmRPanedWMajorDimension,

   that checks eh orientation first */

    {XmNspacing, XmCSpacing, XmRVerticalDimension, sizeof(Dimension),

       Offset(spacing), XmRImmediate, (XtPointer) 8},

    {XmNrefigureMode, XmCBoolean, XmRBoolean, sizeof(Boolean),

       Offset(refiguremode), XmRImmediate, (XtPointer) TRUE},

    {XmNseparatorOn, XmCSeparatorOn, XmRBoolean, sizeof(Boolean),

       Offset(separator_on), XmRImmediate, (XtPointer) TRUE},

/* need to change the XmR to something dynamic XmRPanedWMinorDimension */

    {XmNsashIndent, XmCSashIndent, XmRHorizontalPosition, sizeof(Position),

       Offset(sash_indent), XmRCallProc, (XtPointer) SashIndentDefault},

    {XmNsashWidth, XmCSashWidth, XmRHorizontalDimension, sizeof(Dimension),

       Offset(sash_width), XmRImmediate, (XtPointer) 10},

    {XmNsashHeight, XmCSashHeight, XmRVerticalDimension, sizeof(Dimension),

       Offset(sash_height), XmRImmediate, (XtPointer) 10},

    {XmNsashShadowThickness, XmCShadowThickness, XmRHorizontalDimension,

       sizeof(Dimension), Offset(sash_shadow_thickness), XmRCallProc,

       (XtPointer) _XmSetThickness},

    {XtNinsertPosition, XtCInsertPosition, XtRFunction, sizeof(XtOrderProc),

       XtOffsetOf(XmPanedWindowRec, composite.insert_position),

       XtRImmediate, (XtPointer) InsertOrder},

    {XmNorientation, XmCOrientation, XmROrientation, 

       sizeof(unsigned char),  Offset(orientation), 

       XmRImmediate, (XtPointer) XmVERTICAL

    },

};

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

static XmSyntheticResource get_resources[] =

{

   { XmNmarginWidth, 

     sizeof(Dimension),

     Offset(margin_width),

     XmeFromHorizontalPixels,

     XmeToHorizontalPixels

   },

   { XmNmarginHeight,

     sizeof(Dimension),

     Offset(margin_height),

     XmeFromVerticalPixels,

     XmeToVerticalPixels

   },

   { XmNspacing,

     sizeof(Dimension),

     Offset(spacing),

/* need to change to something dynamic FromPanedWMajorPixels, and

   ToPanedWMajorPixels, that check orientation first  */

     XmeFromVerticalPixels,

     XmeToVerticalPixels

   },

   { XmNsashIndent,

     sizeof(Position),

     Offset(sash_indent),

/* need to change to FromPanedWMinorPixels, and  ToPanedWMinorPixels */

     XmeFromVerticalPixels,

     XmeToVerticalPixels

   },

   { XmNsashWidth,

     sizeof(Dimension),

     Offset(sash_width),

     XmeFromHorizontalPixels,

     XmeToHorizontalPixels

   },

   { XmNsashHeight,

     sizeof(Dimension),

     Offset(sash_height),

     XmeFromVerticalPixels,

     XmeToVerticalPixels

   },

   { XmNsashShadowThickness,

     sizeof(Dimension),

     Offset(sash_shadow_thickness),

     XmeFromHorizontalPixels,

     XmeToHorizontalPixels

   },

};

#undef Offset

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

 *

 * Paned Window Constraint Resources For Its Constraint Record

 *

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

#define Offset(field) XtOffsetOf( struct _XmPanedWindowConstraintRec, panedw.field)

static XtResource constraint_resources[] = {

    {XmNallowResize, XmCBoolean, XmRBoolean, sizeof(Boolean),

	 Offset(allow_resize), XmRImmediate, (XtPointer) FALSE},

/* need to change the XmR to XmRPanedWMajorDimension */

    {XmNpaneMinimum, XmCPaneMinimum, XmRVerticalDimension, sizeof(Dimension),

         Offset(min), XmRImmediate, (XtPointer) 1},

    {XmNpaneMaximum, XmCPaneMaximum, XmRVerticalDimension, sizeof(Dimension),

         Offset(max), XmRImmediate, (XtPointer) 1000},

    {XmNskipAdjust, XmCBoolean, XmRBoolean, sizeof(Boolean),

         Offset(skip_adjust), XmRImmediate, (XtPointer) FALSE},

    {XmNpositionIndex, XmCPositionIndex, XmRShort, sizeof(short),

         Offset(position_index), XmRImmediate, (XtPointer) XmLAST_POSITION},

};

/* Definition for constraint resources that need special */

/* processing in get values                              */

static XmSyntheticResource get_constraint_resources[] =

{

    {  XmNpaneMinimum,

       sizeof(Dimension),

       Offset(min),

/* need to change to FromPanedWMajorPixels and ToPanedWMajorPixels */

       XmeFromVerticalPixels,

       XmeToVerticalPixels

    },

    {  XmNpaneMaximum,

       sizeof(Dimension),

       Offset(max),

/* need to change to FromPanedWMajorPixels and ToPanedWMajorPixels */

       XmeFromVerticalPixels,

       XmeToVerticalPixels

    },

};

#undef Offset

/*************************************<->*************************************

 *

 *

 *   Description:  PanedWindow full class record

 *   -----------

 *************************************<->***********************************/

externaldef(xmpanedwindowclassrec) XmPanedWindowClassRec xmPanedWindowClassRec =

{

   {	 					/* core class fields   */

      (WidgetClass) &xmManagerClassRec,		/* superclass          */

      "XmPanedWindow",				/* class name          */

      sizeof(XmPanedWindowRec),			/* size                */

      NULL,					/* class initialize    */

      ClassPartInitialize,			/* class_part_inite    */

      FALSE,					/* class_inited        */

      Initialize,				/* initialize          */

      NULL,					/* initialize_hook     */

      Realize,					/* realize             */

      NULL,          				/* actions             */

      0,                			/* num_actions         */

      resources,				/* resourses           */

      XtNumber(resources),			/* resource_count      */

      NULLQUARK,				/* xrm_class           */

      TRUE,					/* compress_motion     */

      XtExposeCompressMaximal,			/* compress_exposure   */

      TRUE,					/* compress_enter/lv   */

      FALSE,					/* visible_interest    */

      Destroy,					/* destroy             */

      Resize,					/* resize              */

      XmeRedisplayGadgets,			/* expose              */

      SetValues,				/* set_values          */

      NULL,					/* set_values_hook     */

      XtInheritSetValuesAlmost,			/* set_values_almost   */

      NULL,					/* get_values_hook     */

      NULL,					/* accept_focus        */

      XtVersion,				/* version             */

      NULL, 					/* callback_private    */

      XtInheritTranslations,			/* tm_table            */

      NULL,					/* Query Geometry proc */

      NULL,					/* display accelerator */

      NULL,					/* extension           */

   },

   {						/* composite class fields */

      GeometryManager,				/* geometry_manager       */

      ChangeManaged,				/* change_managed         */

      InsertChild,				/* insert_child           */

      XtInheritDeleteChild,			/* delete_child           */

      NULL,					/* extension              */

   },

   {						/* constraint class fields */

      constraint_resources,			/* subresourses            */

      XtNumber(constraint_resources),		/* subresource_count       */

      sizeof(XmPanedWindowConstraintRec),	/* constraint_size         */

      ConstraintInit,				/* initialize              */

      ConstraintDestroy,			/* destroy                 */

      PaneSetValues,				/* set_values              */

      NULL,					/* extension               */

  }, 

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

  }

};

externaldef(xmpanedwindowwidgetclass) WidgetClass xmPanedWindowWidgetClass =

					   (WidgetClass) &xmPanedWindowClassRec;

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

 *

 *  SashIndentDefault

 *     Set up the default sash indentation

 *

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

/*ARGSUSED*/

static void 

SashIndentDefault(Widget widget,

		  int offset,	/* unused */

		  XrmValue *value )

{

  static Position indent;

  value->addr = (XPointer) &indent;

  if (LayoutIsRtoLM(widget))

    indent = (Position) DEFAULT_SASH_INDENT_RTOL;

  else

    indent = (Position) DEFAULT_SASH_INDENT_LTOR;

}

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

 *

 *  ClassPartInitialize

 *     Set up the fast subclassing for the widget.

 *

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

static void 

ClassPartInitialize(

        WidgetClass wc )

{

  _XmFastSubclassInit (wc, XmPANED_WINDOW_BIT);

}

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

 *

 *  Initialize

 *     The main widget instance initialization routine.

 *

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

/* ARGSUSED */

static void 

Initialize(

        Widget request,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

  XmPanedWindowWidget pw = (XmPanedWindowWidget) new_w;

 /* Protect against empty widgets */

  pw->paned_window.pane_count = 0;

  pw->paned_window.managed_children =

                          (WidgetList) XtMalloc(XmBLOCK*sizeof(Widget));

  pw->paned_window.num_slots = XmBLOCK;

  pw->paned_window.num_managed_children = 0;

  PaneStartPos(pw) = 0;

  PaneFirst(pw) = NULL;

  PaneLast(pw) = NULL;

  pw->paned_window.flipgc = NULL;

  pw->paned_window.increment_count = 0;

  pw->paned_window.resize_at_realize = True;

  pw->paned_window.timer = 0 ;

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

 * NOTE: that sash_indent is made to conform to a correct size

 * during changed managed time/layout time.  Since the size of

 * the window may change we won't require that 

 * abs(sash_indent) <= width of a pane.

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

  pw -> paned_window.recursively_called = FALSE;

  /* DON'T ALLOW HEIGHT/WIDTH TO BE 0, OR X DOESN'T HANDLE THIS WELL */

  if (pw->core.width == 0) pw->core.width = 10;

  if (pw->core.height == 0) pw->core.height = 10;

  /* Check orientation value */

  if(!XmRepTypeValidValue(XmRID_ORIENTATION, 

			  pw->paned_window.orientation, (Widget) pw)) {

      pw->paned_window.orientation = XmVERTICAL;

  }

}

/*************************************<->*************************************

 *

 *  Realize

 *

 *   Description:

 *   -----------

 *    Create our window, set NW gravity (Realize), set up

 *

 *

 *************************************<->***********************************/

static void 

Realize(

        Widget w,

        XtValueMask *p_valueMask,

        XSetWindowAttributes *attributes )

{

    register XmPanedWindowWidget pw = (XmPanedWindowWidget)w;

    WidgetList children = pw->paned_window.managed_children;

    int num_children = pw->paned_window.num_managed_children;

    Widget *childP;

    Mask valueMask = *p_valueMask;

    valueMask |= CWBitGravity | CWDontPropagate;

    attributes->bit_gravity = NorthWestGravity;

    attributes->do_not_propagate_mask = ButtonPressMask|

	ButtonReleaseMask|KeyPressMask|KeyReleaseMask|PointerMotionMask;

    XtCreateWindow (w, InputOutput, CopyFromParent, valueMask, attributes);

    GetFlipGC(pw);

    /* one last time, in case we grew to try to return an

     * XtGeometryAlmost for a child, but the child decided not to grow 

     * or in case some child grew itself and we didn't hear about it.

     */

    if (pw->paned_window.resize_at_realize) {

	XtWidgetProc resize;

	_XmProcessLock();

	resize = pw->core.widget_class->core_class.resize;

	_XmProcessUnlock();

	(*resize)( (Widget) pw );

    }

    ReManageChildren(pw);

    children = pw->paned_window.managed_children;

    num_children = pw->paned_window.num_managed_children;

    /* now we have to make sure all the sashs are on above their

     * panes, which means that we have to realize all our children

     * here and now.  If we realize from the beginning of the list,

     * then the sashs (which are at the end) will be Above by default. */

    for (childP = children; childP - children < num_children; childP++)

	    XtRealizeWidget( *childP );

} /* Realize */

/*************************************<->*************************************

 *

 *  Destroy

 *

 *************************************<->***********************************/

static void 

Destroy(

        Widget w )

{

    XmPanedWindowWidget pw = (XmPanedWindowWidget)w;

    if (pw->paned_window.timer)

	XtRemoveTimeOut(pw->paned_window.timer);

    if (pw->paned_window.flipgc != NULL) {

       XtReleaseGC(w, pw->paned_window.flipgc);

       pw->paned_window.flipgc = NULL;

    }

    XtFree( (char *) pw->paned_window.managed_children);

} /* Destroy */

/*************************************<->*************************************

 *

 *  Resize

 *

 *************************************<->***********************************/

static void 

Resize(

        Widget wid )

{

    XmPanedWindowWidget pw = (XmPanedWindowWidget) wid ;

    RefigureLocationsAndCommit( pw, pw->paned_window.pane_count - 1, 

			       LastPane, True);

} /* Resize */

/*************************************<->*************************************

 *

 *  ConstraintDestroy

 *

 *   Description:

 *   -----------

 *    Destroy the sash of any pane which is being destroyed.

 *

 *

 *************************************<->***********************************/

static void 

ConstraintDestroy(

        Widget w )

{

   if (!XtIsRectObj(w)) return;

   /* 

    * If this is an ordinary pane,  delete its sash (if it has one)

    * and separator (if it has one) and then invoke the standard

    * inherited delete child routines.

    */

   if (XtIsRectObj(w) && IsPane(w))

   {

        if (PaneInfo(w)->panedw.sash != NULL)

          XtDestroyWidget(PaneInfo(w)->panedw.sash);

        if (PaneInfo(w)->panedw.separator != NULL)

          XtDestroyWidget(PaneInfo(w)->panedw.separator);

 	/* the destroyed child has already been removed from the list of

 	** children, so update the other panes so that their positions match

 	** their positionIndex values (no need to be clever and update only 

 	** those that change)

 	*/

 	{

 	XmPanedWindowWidget pw = (XmPanedWindowWidget)w->core.parent;

	if (!(pw->core.being_destroyed))

 	  { 	

	      int i;

	      for (i = 0; 

		   (i < pw->composite.num_children) 

		       && IsPane(pw->composite.children[i]); 

		   i++)

		  PanePosIndex(pw->composite.children[i]) = i;

	  }

 	}

   }

}

/*************************************<->*************************************

 *

 *  void AdjustGC(pw)

 *          XmPanedWindowWidget  pw;

 *

 *   Description:

 *   -----------

 *   Set up the clip regions so the track lines do not draw on

 *   top of the sashes.

 *

 *************************************<->***********************************/

static void 

AdjustGC(

        XmPanedWindowWidget pw )

{

    XRectangle clip_rect;

    register int i;

    Region sash_region, clip_region;

    if (pw->composite.num_children > 0) {

    	sash_region = XCreateRegion();

    	clip_region = XCreateRegion();

    	/* find all the managed sashes and add their area to the sash region */

    	for (i = 0; i < pw->composite.num_children; i++)

    	{

        	if (XmIsSash(pw->composite.children[i]) &&

            		XtIsManaged(pw->composite.children[i])) {

    	   	clip_rect.width = pw->composite.children[i]->core.width;

    	   	clip_rect.height = pw->composite.children[i]->core.height;

    	   	clip_rect.x = pw->composite.children[i]->core.x;

    	   	clip_rect.y = pw->composite.children[i]->core.y;

	   	XUnionRectWithRegion(&clip_rect, sash_region, sash_region);

        	}

    	}

    	/* set up the initial clip region */

    	clip_rect.width = pw->core.width;

    	clip_rect.height = pw->core.height;

    	clip_rect.x = 0;

    	clip_rect.y = 0;

    	XUnionRectWithRegion(&clip_rect, clip_region, clip_region);

    	/* remove the sash regions from the clip region */

    	XSubtractRegion(clip_region, sash_region, clip_region);

    	/* set the clip region, so the track

	   lines won't be draw on the sashes */

    	XSetRegion(XtDisplay(pw), pw->paned_window.flipgc, clip_region);

    	/* remove the clip regions */

    	XDestroyRegion(sash_region);

    	XDestroyRegion(clip_region);

   }

}

/*************************************<->*************************************

 *

 *  void GetFlipGC(pw)

 *          XmPanedWindowWidget  pw;

 *

 *   Description:

 *   -----------

 *   Create a GC which can be used to draw/erase track lines when the

 *   the size of the panes is being changed.

 *

 *************************************<->***********************************/

static void 

GetFlipGC(

        XmPanedWindowWidget pw )

{

    unsigned long valuemask = GCForeground | GCSubwindowMode | GCFunction;

    unsigned long dynamicMask = GCClipMask;

    XGCValues	values;

    values.foreground = pw->core.background_pixel ^ pw->manager.foreground;

    values.subwindow_mode = IncludeInferiors;

    values.function = GXxor;

    pw->paned_window.flipgc = XtAllocateGC((Widget)pw, 0, valuemask, &values,

					   dynamicMask, 0);

}

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

 *

 *  ReManageChildren

 *	This procedure will be called by the ChangeManged procedure 

 *	It will reassemble the currently managed children into the 

 *      "paned_window.managed_children" list.

 *  One day I think I'm gonna remove this stuff... dd

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

static void 

ReManageChildren(

        XmPanedWindowWidget pw )

{

   int i;

   pw->paned_window.num_managed_children = 0;

   for (i = 0; i < pw->composite.num_children; i++)

   {

       if (XtIsManaged(pw->composite.children[i]))

       {

	    if ((pw->paned_window.num_managed_children+1) >

				 pw->paned_window.num_slots)

            {

	       pw->paned_window.num_slots += XmBLOCK;

	       pw->paned_window.managed_children = (WidgetList)

		  XtRealloc ((char *) pw->paned_window.managed_children,

			     (pw->paned_window.num_slots * sizeof(Widget)));

            }

	    pw->paned_window.managed_children

	            [pw->paned_window.num_managed_children++] =

		       pw->composite.children[i];

       }

   }

}

/*************************************<->*************************************

 *

 *  NeedsAdjusting (pw)

 *

 *   Description:

 *   -----------

 *     Calculate the major size needed to fully display this paned window.

 *

 *************************************<->***********************************/

static int 

NeedsAdjusting(

        register XmPanedWindowWidget pw )

{

   int needed, i;

   needed = 0;

   for (i = 0; i < pw->paned_window.pane_count; i++) {

     needed += PaneDMajor(pw->paned_window.managed_children[i]) +

                 2 * pw->paned_window.managed_children[i]->core.border_width +

                 pw->paned_window.spacing;

   }

  /*

   * Get rid of extra spacing from previous 'for' loop and add in

   * major margin at the top and bottom of the panedw window

   */

   if (pw->paned_window.pane_count > 0)

       needed += 2 * MajorMargin(pw) - pw->paned_window.spacing;

   return (needed != MajorSize(pw)) ? needed : 0 ;

}

/*************************************<->*************************************

 *

 *  AdjustPanedWindowMajor

 *

 *   Description:

 *   -----------

 *     Request a new size for the paned window from its parent.

 *     If the requested new dim is less than 1, then ask for size of 1.

 *

 *************************************<->***********************************/

static XtGeometryResult 

AdjustPanedWindowMajor(

        XmPanedWindowWidget pw,

#if NeedWidePrototypes

        int newdim,

#else

        Dimension newdim,