Debian Codegraph @

src/Paned.c

raw
1 /***********************************************************
2
3 Copyright 1987, 1988, 1994, 1998 The Open Group
4
5 Permission to use, copy, modify, distribute, and sell this software and its
6 documentation for any purpose is hereby granted without fee, provided that
7 the above copyright notice appear in all copies and that both that
8 copyright notice and this permission notice appear in supporting
9 documentation.
10
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21 Except as contained in this notice, the name of The Open Group shall not be
22 used in advertising or otherwise to promote the sale, use or other dealings
23 in this Software without prior written authorization from The Open Group.
24
25
26 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
27
28 All Rights Reserved
29
30 Permission to use, copy, modify, and distribute this software and its
31 documentation for any purpose and without fee is hereby granted,
32 provided that the above copyright notice appear in all copies and that
33 both that copyright notice and this permission notice appear in
34 supporting documentation, and that the name of Digital not be
35 used in advertising or publicity pertaining to distribution of the
36 software without specific, written prior permission.
37
38 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
39 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
40 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
41 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
42 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
43 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
44 SOFTWARE.
45
46 ******************************************************************/
47
48 /*
49 * Updated and significantly modified from the Athena VPaned Widget.
50 *
51 * Date: March 1, 1989
52 *
53 * By: Chris D. Peterson
54 * MIT X Consortium
55 * [email protected]
56 */
57
58 #ifdef HAVE_CONFIG_H
59 #include <config.h>
60 #endif
61 #include <X11/IntrinsicP.h>
62 #include <X11/cursorfont.h>
63 #include <X11/StringDefs.h>
64 #include <X11/Xmu/CharSet.h>
65 #include <X11/Xmu/Converters.h>
66 #include <X11/Xmu/Misc.h>
67 #include <X11/Xaw/Grip.h>
68 #include <X11/Xaw/PanedP.h>
69 #include <X11/Xaw/XawImP.h>
70 #include <X11/Xaw/XawInit.h>
71 #include "Private.h"
72
73 typedef enum {
74 UpLeftPane = 'U',
75 LowRightPane = 'L',
76 ThisBorderOnly = 'T',
77 AnyPane = 'A'
78 } Direction;
79
80 #define NO_INDEX -100
81 #define IS_GRIP NULL
82
83 #define PaneInfo(w) ((Pane)(w)->core.constraints)
84 #define HasGrip(w) (PaneInfo(w)->grip != NULL)
85 #define IsPane(w) ((w)->core.widget_class != gripWidgetClass)
86 #define PaneIndex(w) (PaneInfo(w)->position)
87 #define IsVert(w) ((w)->paned.orientation == XtorientVertical)
88
89 #define ForAllPanes(pw, childP) \
90 for ((childP) = (pw)->composite.children; \
91 (childP) < (pw)->composite.children + (pw)->paned.num_panes; \
92 (childP)++)
93
94 #define ForAllChildren(pw, childP) \
95 for ((childP) = (pw)->composite.children; \
96 (childP) < (pw)->composite.children + (pw)->composite.num_children; \
97 (childP)++)
98
99 #define PaneSize(paned, vertical) \
100 ((vertical) ? XtHeight(paned) : XtWidth(paned))
101
102 #define GetRequestInfo(geo, vertical) \
103 ((vertical) ? (geo)->height : (geo)->width)
104
105 #define SatisfiesRule1(pane, shrink) \
106 (((shrink) && ((pane)->size != (pane)->min)) \
107 || (!(shrink) && ((pane)->size != (pane)->max)))
108
109 #define SatisfiesRule2(pane) \
110 (!(pane)->skip_adjust || (pane)->paned_adjusted_me)
111
112 #define SatisfiesRule3(pane, shrink) \
113 ((pane)->paned_adjusted_me \
114 && (((shrink) && ((int)(pane)->wp_size <= (pane)->size)) \
115 || (!(shrink) && ((int)(pane)->wp_size >= (pane)->size))))
116
117
118 /*
119 * Class Methods
120 */
121 static void XawPanedClassInitialize(void);
122 static void XawPanedChangeManaged(Widget);
123 static void XawPanedDeleteChild(Widget);
124 static void XawPanedDestroy(Widget);
125 static XtGeometryResult XawPanedGeometryManager(Widget, XtWidgetGeometry*,
126 XtWidgetGeometry*);
127 static void XawPanedInitialize(Widget, Widget, ArgList, Cardinal*);
128 static void XawPanedInsertChild(Widget);
129 static Boolean XawPanedPaneSetValues(Widget, Widget, Widget,
130 ArgList, Cardinal*);
131 static void XawPanedRealize(Widget, Mask*, XSetWindowAttributes*);
132 static void XawPanedRedisplay(Widget, XEvent*, Region);
133 static void XawPanedResize(Widget);
134 static Boolean XawPanedSetValues(Widget, Widget, Widget, ArgList, Cardinal*);
135
136 /*
137 * Prototypes
138 */
139 static void _DrawInternalBorders(PanedWidget, GC);
140 static void _DrawRect(PanedWidget, GC, int, int, unsigned int, unsigned int);
141 static void _DrawTrackLines(PanedWidget, Bool);
142 static void AdjustPanedSize(PanedWidget, unsigned int, XtGeometryResult*,
143 Dimension*, Dimension*);
144 static void ChangeAllGripCursors(PanedWidget);
145 static Pane ChoosePaneToResize(PanedWidget, int, Direction, Bool);
146 static void ClearPaneStack(PanedWidget);
147 static void CommitGripAdjustment(PanedWidget);
148 static void CreateGrip(Widget);
149 static int GetEventLocation(PanedWidget, XEvent*);
150 static void GetGCs(Widget);
151 static void GetPaneStack(PanedWidget, Bool, Pane*, int*);
152 static void HandleGrip(Widget, XtPointer, XtPointer);
153 static void LoopAndRefigureChildren(PanedWidget, int, Direction, int*);
154 static void ManageAndUnmanageGrips(PanedWidget);
155 static void MoveGripAdjustment(PanedWidget, Widget, Direction, int);
156 static Bool PopPaneStack(PanedWidget);
157 static void PushPaneStack(PanedWidget, Pane);
158 static void RefigureLocations(PanedWidget, int, Direction);
159 static void RefigureLocationsAndCommit(Widget);
160 static void ReleaseGCs(Widget);
161 static void ResortChildren(PanedWidget);
162 static void SetChildrenPrefSizes(PanedWidget, unsigned int);
163 static void StartGripAdjustment(PanedWidget, Widget, Direction);
164
165 /*
166 * Initialization
167 */
168 static char defGripTranslations[] =
169 "<Btn1Down>:" "GripAction(Start,UpLeftPane)\n"
170 "<Btn2Down>:" "GripAction(Start,ThisBorderOnly)\n"
171 "<Btn3Down>:" "GripAction(Start,LowRightPane)\n"
172 "<Btn1Motion>:" "GripAction(Move,UpLeft)\n"
173 "<Btn2Motion>:" "GripAction(Move,ThisBorder)\n"
174 "<Btn3Motion>:" "GripAction(Move,LowRight)\n"
175 "Any<BtnUp>:" "GripAction(Commit)\n"
176 ;
177
178 #define offset(field) XtOffsetOf(PanedRec, paned.field)
179 static XtResource resources[] = {
180 {
181 XtNinternalBorderColor,
182 XtCBorderColor,
183 XtRPixel,
184 sizeof(Pixel),
185 offset(internal_bp),
186 XtRString,
187 (XtPointer)XtDefaultForeground
188 },
189 {
190 XtNinternalBorderWidth,
191 XtCBorderWidth,
192 XtRDimension,
193 sizeof(Dimension),
194 offset(internal_bw),
195 XtRImmediate,
196 (XtPointer)1
197 },
198 {
199 XtNgripIndent,
200 XtCGripIndent,
201 XtRPosition,
202 sizeof(Position),
203 offset(grip_indent),
204 XtRImmediate,
205 (XtPointer)10
206 },
207 {
208 XtNrefigureMode,
209 XtCBoolean,
210 XtRBoolean,
211 sizeof(Boolean),
212 offset(refiguremode),
213 XtRImmediate,
214 (XtPointer)True
215 },
216 {
217 XtNgripTranslations,
218 XtCTranslations,
219 XtRTranslationTable,
220 sizeof(XtTranslations),
221 offset(grip_translations),
222 XtRString,
223 (XtPointer)defGripTranslations
224 },
225 {
226 XtNorientation,
227 XtCOrientation,
228 XtROrientation,
229 sizeof(XtOrientation),
230 offset(orientation),
231 XtRImmediate,
232 (XtPointer)XtorientVertical
233 },
234 {
235 XtNcursor,
236 XtCCursor,
237 XtRCursor,
238 sizeof(Cursor),
239 offset(cursor),
240 XtRImmediate,
241 NULL
242 },
243 {
244 XtNgripCursor,
245 XtCCursor,
246 XtRCursor,
247 sizeof(Cursor),
248 offset(grip_cursor),
249 XtRImmediate,
250 NULL
251 },
252 {
253 XtNverticalGripCursor,
254 XtCCursor,
255 XtRCursor,
256 sizeof(Cursor),
257 offset(v_grip_cursor),
258 XtRString,
259 (XtPointer)"sb_v_double_arrow"
260 },
261 {
262 XtNhorizontalGripCursor,
263 XtCCursor,
264 XtRCursor,
265 sizeof(Cursor),
266 offset(h_grip_cursor),
267 XtRString,
268 (XtPointer)"sb_h_double_arrow"
269 },
270 {
271 XtNbetweenCursor,
272 XtCCursor,
273 XtRCursor,
274 sizeof(Cursor),
275 offset(adjust_this_cursor),
276 XtRString,
277 NULL
278 },
279 {
280 XtNverticalBetweenCursor,
281 XtCCursor,
282 XtRCursor,
283 sizeof(Cursor),
284 offset(v_adjust_this_cursor),
285 XtRString,
286 (XtPointer)"sb_left_arrow"
287 },
288 {
289 XtNhorizontalBetweenCursor,
290 XtCCursor,
291 XtRCursor,
292 sizeof(Cursor),
293 offset(h_adjust_this_cursor),
294 XtRString,
295 (XtPointer)"sb_up_arrow"
296 },
297 {
298 XtNupperCursor,
299 XtCCursor,
300 XtRCursor,
301 sizeof(Cursor),
302 offset(adjust_upper_cursor),
303 XtRString,
304 (XtPointer)"sb_up_arrow"
305 },
306 {
307 XtNlowerCursor,
308 XtCCursor,
309 XtRCursor,
310 sizeof(Cursor),
311 offset(adjust_lower_cursor),
312 XtRString,
313 (XtPointer)"sb_down_arrow"
314 },
315 {
316 XtNleftCursor,
317 XtCCursor,
318 XtRCursor,
319 sizeof(Cursor),
320 offset(adjust_left_cursor),
321 XtRString,
322 (XtPointer)"sb_left_arrow"
323 },
324 {
325 XtNrightCursor,
326 XtCCursor,
327 XtRCursor,
328 sizeof(Cursor),
329 offset(adjust_right_cursor),
330 XtRString,
331 (XtPointer)"sb_right_arrow"
332 },
333 };
334 #undef offset
335
336 #define offset(field) XtOffsetOf(PanedConstraintsRec, paned.field)
337 static XtResource subresources[] = {
338 {
339 XtNallowResize,
340 XtCBoolean,
341 XtRBoolean,
342 sizeof(Boolean),
343 offset(allow_resize),
344 XtRImmediate,
345 (XtPointer)False
346 },
347 {
348 XtNposition,
349 XtCPosition,
350 XtRInt,
351 sizeof(int),
352 offset(position),
353 XtRImmediate,
354 (XtPointer)0
355 },
356 {
357 XtNmin,
358 XtCMin,
359 XtRDimension,
360 sizeof(Dimension),
361 offset(min),
362 XtRImmediate,
363 (XtPointer)PANED_GRIP_SIZE
364 },
365 {
366 XtNmax,
367 XtCMax,
368 XtRDimension,
369 sizeof(Dimension),
370 offset(max),
371 XtRImmediate,
372 (XtPointer)~0
373 },
374 {
375 XtNpreferredPaneSize,
376 XtCPreferredPaneSize,
377 XtRDimension,
378 sizeof(Dimension),
379 offset(preferred_size),
380 XtRImmediate,
381 (XtPointer)PANED_ASK_CHILD
382 },
383 {
384 XtNresizeToPreferred,
385 XtCBoolean,
386 XtRBoolean,
387 sizeof(Boolean),
388 offset(resize_to_pref),
389 XtRImmediate,
390 (XtPointer)False
391 },
392 {
393 XtNskipAdjust,
394 XtCBoolean,
395 XtRBoolean,
396 sizeof(Boolean),
397 offset(skip_adjust),
398 XtRImmediate,
399 (XtPointer)False
400 },
401 {
402 XtNshowGrip,
403 XtCShowGrip,
404 XtRBoolean,
405 sizeof(Boolean),
406 offset(show_grip),
407 XtRImmediate,
408 (XtPointer)True
409 },
410 };
411 #undef offset
412
413 #define SuperClass ((ConstraintWidgetClass)&constraintClassRec)
414
415 PanedClassRec panedClassRec = {
416 /* core */
417 {
418 (WidgetClass)SuperClass, /* superclass */
419 "Paned", /* class name */
420 sizeof(PanedRec), /* size */
421 XawPanedClassInitialize, /* class_initialize */
422 NULL, /* class_part init */
423 False, /* class_inited */
424 XawPanedInitialize, /* initialize */
425 NULL, /* initialize_hook */
426 XawPanedRealize, /* realize */
427 NULL, /* actions */
428 0, /* num_actions */
429 resources, /* resources */
430 XtNumber(resources), /* num_resources */
431 NULLQUARK, /* xrm_class */
432 True, /* compress_motion */
433 True, /* compress_exposure */
434 True, /* compress_enterleave */
435 False, /* visible_interest */
436 XawPanedDestroy, /* destroy */
437 XawPanedResize, /* resize */
438 XawPanedRedisplay, /* expose */
439 XawPanedSetValues, /* set_values */
440 NULL, /* set_values_hook */
441 XtInheritSetValuesAlmost, /* set_values_almost */
442 NULL, /* get_values_hook */
443 NULL, /* accept_focus */
444 XtVersion, /* version */
445 NULL, /* callback_private */
446 NULL, /* tm_table */
447 XtInheritQueryGeometry, /* query_geometry */
448 XtInheritDisplayAccelerator, /* display_accelerator */
449 NULL, /* extension */
450 },
451 /* composite */
452 {
453 XawPanedGeometryManager, /* geometry_manager */
454 XawPanedChangeManaged, /* change_managed */
455 XawPanedInsertChild, /* insert_child */
456 XawPanedDeleteChild, /* delete_child */
457 NULL, /* extension */
458 },
459 /* constraint */
460 {
461 subresources, /* subresources */
462 XtNumber(subresources), /* subresource_count */
463 sizeof(PanedConstraintsRec), /* constraint_size */
464 NULL, /* initialize */
465 NULL, /* destroy */
466 XawPanedPaneSetValues, /* set_values */
467 NULL, /* extension */
468 },
469 /* paned */
470 {
471 NULL, /* extension */
472 }
473 };
474
475 WidgetClass panedWidgetClass = (WidgetClass)&panedClassRec;
476 WidgetClass vPanedWidgetClass = (WidgetClass)&panedClassRec;
477
478 /*
479 * Implementation
480 */
481 /* Function:
482 * AdjustPanedSize
483 *
484 * Parameters:
485 * pw - paned widget to adjust
486 * off_size - new off_size to use
487 * result_ret - result of query (return)
488 * on_size_ret - new on_size (return)
489 * off_size_ret - new off_size (return)
490 *
491 * Description:
492 * Adjusts the size of the pane.
493 *
494 * Returns:
495 * amount of change in size
496 */
497 static void
498 AdjustPanedSize(PanedWidget pw, unsigned int off_size,
499 XtGeometryResult *result_ret,
500 Dimension *on_size_ret, Dimension *off_size_ret)
501 {
502 Dimension old_size = PaneSize((Widget)pw, IsVert(pw));
503 Dimension newsize = 0;
504 Widget *childP;
505 XtWidgetGeometry request, reply;
506
507 request.request_mode = CWWidth | CWHeight;
508
509 ForAllPanes(pw, childP) {
510 int size = Max(PaneInfo(*childP)->size, (int)PaneInfo(*childP)->min);
511
512 AssignMin(size, (int)PaneInfo(*childP)->max);
513 newsize = (Dimension)(newsize + (size + pw->paned.internal_bw));
514 }
515 newsize = (Dimension)(newsize - pw->paned.internal_bw);
516
517 if (newsize < 1)
518 newsize = 1;
519
520 if (IsVert(pw)) {
521 request.width = (Dimension)off_size;
522 request.height = newsize;
523 }
524 else {
525 request.width = newsize;
526 request.height = (Dimension)off_size;
527 }
528
529 if (result_ret != NULL) {
530 request.request_mode |= XtCWQueryOnly;
531
532 *result_ret = XtMakeGeometryRequest((Widget)pw, &request, &reply);
533 _XawImCallVendorShellExtResize((Widget)pw);
534
535 if (newsize == old_size || *result_ret == XtGeometryNo) {
536 *on_size_ret = old_size;
537 *off_size_ret = (Dimension)off_size;
538 return;
539 }
540 if (*result_ret != XtGeometryAlmost) {
541 *on_size_ret = GetRequestInfo(&request, IsVert(pw));
542 *off_size_ret = GetRequestInfo(&request, !IsVert(pw));
543 return;
544 }
545 *on_size_ret = GetRequestInfo(&reply, IsVert(pw));
546 *off_size_ret = GetRequestInfo(&reply, !IsVert(pw));
547 return;
548 }
549
550 if (newsize == old_size)
551 return;
552
553 if (XtMakeGeometryRequest((Widget)pw, &request, &reply) == XtGeometryAlmost)
554 XtMakeGeometryRequest((Widget)pw, &reply, &request);
555 }
556
557 /*
558 * Function:
559 * ChoosePaneToResize.
560 *
561 * Parameters:
562 * pw - paned widget
563 * paneindex - index of the current pane
564 * dir - direction to search first
565 * shrink - True if we need to shrink a pane, False otherwise
566 *
567 * Description:
568 * This function chooses a pane to resize.
569 * They are chosen using the following rules:
570 *
571 * 1) size < max && size > min
572 * 2) skip adjust == False
573 * 3) widget not its preferred height
574 * && this change will bring it closer
575 * && The user has not resized this pane.
576 *
577 * If no widgets are found that fits all the rules then
578 * rule #3 is broken.
579 * If there are still no widgets found than
580 * rule #2 is broken.
581 * Rule #1 is never broken.
582 * If no widgets are found then NULL is returned.
583 *
584 * Returns:
585 * pane to resize or NULL
586 */
587 static Pane
588 ChoosePaneToResize(PanedWidget pw, int paneindex, Direction dir, Bool shrink)
589 {
590 Widget *childP;
591 int rules = 3;
592 Direction _dir = dir;
593 int _index = paneindex;
594
595 if (paneindex == NO_INDEX || dir == AnyPane) { /* Use defaults */
596 _dir = LowRightPane; /* Go up - really */
597 _index = pw->paned.num_panes - 1; /* Start the last pane, and work
598 backwards */
599 }
600 childP = pw->composite.children + _index;
601
602 /*CONSTCOND*/
603 while(True) {
604 Pane pane = PaneInfo(*childP);
605
606 if ((rules < 3 || SatisfiesRule3(pane, shrink))
607 && (rules < 2 || SatisfiesRule2(pane))
608 && SatisfiesRule1(pane, shrink)
609 && (paneindex != PaneIndex(*childP) || dir == AnyPane))
610 return (pane);
611
612 /*
613 * This is counter-intuitive, but if we are resizing the pane
614 * above the grip we want to choose a pane below the grip to lose,
615 * and visa-versa
616 */
617 if (_dir == LowRightPane)
618 --childP;
619 else
620 ++childP;
621
622 /*
623 * If we have come to and edge then reduce the rule set, and try again
624 * If we are reduced the rules to none, then return NULL
625 */
626 if ((childP - pw->composite.children) < 0 ||
627 (childP - pw->composite.children) >= pw->paned.num_panes) {
628 if (--rules < 1) /* less strict rules */
629 return (NULL);
630 childP = pw->composite.children + _index;
631 }
632 }
633 }
634
635 /*
636 * Function:
637 * LoopAndRefigureChildren
638 *
639 * Parameters:
640 * pw - paned widget
641 * paneindex - number of the pane border we are moving
642 * dir - pane to move (either UpLeftPane or LowRightPane)
643 * sizeused - current amount of space used (used and returned)
644 *
645 * Description:
646 * If we are resizing either the UpleftPane or LowRight Pane loop
647 * through all the children to see if any will allow us to resize them.
648 */
649 static void
650 LoopAndRefigureChildren(PanedWidget pw, int paneindex, Direction dir,
651 int *sizeused)
652 {
653 int pane_size = (int)PaneSize((Widget)pw, IsVert(pw));
654 Boolean shrink = (*sizeused > pane_size);
655
656 if (dir == LowRightPane)
657 paneindex++;
658
659 /* While all panes do not fit properly */
660 while (*sizeused != pane_size) {
661 /*
662 * Choose a pane to resize
663 * First look on the Pane Stack, and then go hunting for another one
664 * If we fail to find a pane to resize then give up
665 */
666 Pane pane;
667 int start_size;
668 Dimension old;
669 Boolean rule3_ok = False, from_stack = True;
670
671 GetPaneStack(pw, shrink, &pane, &start_size);
672 if (pane == NULL) {
673 pane = ChoosePaneToResize(pw, paneindex, dir, shrink);
674 if (pane == NULL)
675 return; /* no one to resize, give up */
676
677 rule3_ok = SatisfiesRule3(pane, shrink);
678 from_stack = False;
679 PushPaneStack(pw, pane);
680 }
681
682 /*
683 * Try to resize this pane so that all panes will fit, take min and max
684 * into account
685 */
686 old = (Dimension) pane->size;
687 pane->size += pane_size - *sizeused;
688
689 if (from_stack) {
690 if (shrink) {
691 AssignMax(pane->size, start_size);
692 } /* don't remove these braces */
693 else
694 AssignMin(pane->size, start_size);
695
696 if (pane->size == start_size)
697 (void)PopPaneStack(pw);
698 }
699 else if (rule3_ok) {
700 if (shrink) {
701 AssignMax(pane->size, (int)pane->wp_size);
702 } /* don't remove these braces */
703 else
704 AssignMin(pane->size, (int)pane->wp_size);
705 }
706
707 pane->paned_adjusted_me = pane->size != pane->wp_size;
708 AssignMax(pane->size, (int)pane->min);
709 AssignMin(pane->size, (int)pane->max);
710 *sizeused += (pane->size - old);
711 }
712 }
713
714 /*
715 * Function:
716 * RefigureLocations
717 *
718 * Parameters:
719 * pw - paned widget
720 * paneindex - child to start refiguring at
721 * dir - direction to move from child
722 *
723 * Description:
724 * Refigures all locations of children.
725 * There are special arguments to paneindex and dir, they are:
726 * paneindex - NO_INDEX.
727 * dir - AnyPane.
728 *
729 * If either of these is true then all panes may be resized and
730 * the choosing of panes proceeds in reverse order starting with the
731 * last child.
732 */
733 static void
734 RefigureLocations(PanedWidget pw, int paneindex, Direction dir)
735 {
736 Widget *childP;
737 int pane_size = (int)PaneSize((Widget)pw, IsVert(pw));
738 int sizeused = 0;
739 Position loc = 0;
740
741 if (pw->paned.num_panes == 0 || !pw->paned.refiguremode)
742 return;
743
744 /*
745 * Get an initial estimate of the size we will use
746 */
747 ForAllPanes(pw, childP) {
748 Pane pane = PaneInfo(*childP);
749
750 AssignMax(pane->size, (int) pane->min);
751 AssignMin(pane->size, (int) pane->max);
752 sizeused += (int)pane->size + (int)pw->paned.internal_bw;
753 }
754 sizeused -= (int)pw->paned.internal_bw;
755
756 if (dir != ThisBorderOnly && sizeused != pane_size)
757 LoopAndRefigureChildren(pw, paneindex, dir, &sizeused);
758
759 /*
760 * If we still are not the right size, then tell the pane that
761 * wanted to resize that it can't
762 */
763 if (paneindex != NO_INDEX && dir != AnyPane) {
764 Pane pane = PaneInfo(*(pw->composite.children + paneindex));
765 Dimension old = (Dimension)pane->size;
766
767 pane->size += pane_size - sizeused;
768 AssignMax(pane->size, (int) pane->min);
769 AssignMin(pane->size, (int) pane->max);
770 sizeused += pane->size - old;
771 }
772
773 /*
774 * It is possible that the panes will not fit inside the vpaned widget, but
775 * we have tried out best
776 *
777 * Assign each pane a location
778 */
779 ForAllPanes(pw, childP) {
780 PaneInfo(*childP)->delta = loc;
781 loc = (Position)(loc + (PaneInfo(*childP)->size + pw->paned.internal_bw));
782 }
783 }
784
785 /*
786 * Function:
787 * CommitNewLocations
788 *
789 * Parameters:
790 * pw - paned widget
791 *
792 * Description:
793 * Commits all of the previously figured locations.
794 */
795 static void
796 CommitNewLocations(PanedWidget pw)
797 {
798 Widget *childP;
799 XWindowChanges changes = { .stack_mode = Above };
800
801 ForAllPanes(pw, childP) {
802 Pane pane = PaneInfo(*childP);
803 Widget grip = pane->grip; /* may be NULL */
804
805 if (IsVert(pw)) {
806 XtMoveWidget(*childP, (Position) 0, pane->delta);
807 XtResizeWidget(*childP, XtWidth(pw), (Dimension)pane->size, 0);
808
809 if (HasGrip(*childP)) { /* Move and Display the Grip */
810 changes.x = XtWidth(pw) - pw->paned.grip_indent -
811 XtWidth(grip) - (XtBorderWidth(grip) << 1);
812 changes.y = XtY(*childP) + XtHeight(*childP) -
813 (XtHeight(grip) >> 1) - XtBorderWidth(grip) +
814 (pw->paned.internal_bw >> 1);
815 }
816 }
817 else {
818 XtMoveWidget(*childP, pane->delta, 0);
819 XtResizeWidget(*childP, (Dimension)pane->size, (Dimension)XtHeight(pw), 0);
820
821 if (HasGrip(*childP)) { /* Move and Display the Grip */
822 changes.x = XtX(*childP) + XtWidth(*childP) -
823 (XtWidth(grip) >> 1) - XtBorderWidth(grip) +
824 (pw->paned.internal_bw >> 1);
825 changes.y = XtHeight(pw) - pw->paned.grip_indent -
826 XtHeight(grip) - (XtBorderWidth(grip) << 1);
827 }
828 }
829
830 /*
831 * This should match XtMoveWidget, except that we're also insuring the
832 * grip is Raised in the same request
833 */
834
835 if (HasGrip(*childP)) {
836 XtX(grip) = (Position)changes.x;
837 XtY(grip) = (Position)changes.y;
838
839 if (XtIsRealized(pane->grip))
840 XConfigureWindow(XtDisplay(pane->grip), XtWindow(pane->grip),
841 CWX | CWY | CWStackMode, &changes);
842 }
843 }
844 ClearPaneStack(pw);
845 }
846
847 /*
848 * Function:
849 * RefigureLocationsAndCommit
850 *
851 * Parameters:
852 * pw - paned widget
853 *
854 * Description:
855 * Refigures all locations in a paned widget and commits them immediately.
856 *
857 * This function does nothing if any of the following are true.
858 * o refiguremode is false.
859 * o The widget is unrealized.
860 * o There are no panes is the paned widget.
861 */
862 static void
863 RefigureLocationsAndCommit(Widget w)
864 {
865 PanedWidget pw = (PanedWidget)w;
866
867 if (pw->paned.refiguremode && XtIsRealized(w) && pw->paned.num_panes > 0) {
868 RefigureLocations(pw, NO_INDEX, AnyPane);
869 CommitNewLocations(pw);
870 }
871 }
872
873 /*
874 * Function:
875 * _DrawRect
876 *
877 * Parameters:
878 * pw - paned widget
879 * gc - gc to used for the draw
880 * on_olc - location of upper left corner of rect
881 * off_loc - ""
882 * on_size - size of rectangle
883 * off_size - ""
884 *
885 * Description:
886 * Draws a rectangle in the proper orientation.
887 */
888 static void
889 _DrawRect(PanedWidget pw, GC gc, int on_loc, int off_loc,
890 unsigned int on_size, unsigned int off_size)
891 {
892 if (IsVert(pw))
893 XFillRectangle(XtDisplay((Widget)pw), XtWindow((Widget)pw), gc,
894 off_loc, on_loc, off_size, on_size);
895 else
896 XFillRectangle(XtDisplay((Widget)pw), XtWindow((Widget)pw), gc,
897 on_loc, off_loc, on_size, off_size);
898 }
899
900 /*
901 * Function:
902 * _DrawInternalBorders
903 *
904 * Parameters:
905 * pw - paned widget
906 * gc - GC to use to draw the borders
907 *
908 * Description:
909 * Draws the internal borders into the paned widget.
910 */
911 static void
912 _DrawInternalBorders(PanedWidget pw, GC gc)
913 {
914 Widget *childP;
915 int off_loc;
916 unsigned int on_size, off_size;
917
918 /*
919 * This is an optimization. Do not paint the internal borders if
920 * they are the same color as the background
921 */
922 if (pw->core.background_pixel == pw->paned.internal_bp)
923 return;
924
925 off_loc = 0;
926 off_size = (unsigned int) PaneSize((Widget)pw, !IsVert(pw));
927 on_size = (unsigned int)pw->paned.internal_bw;
928
929 ForAllPanes(pw, childP) {
930 int on_loc = IsVert(pw) ? XtY(*childP) : XtX(*childP);
931 on_loc -= (int)on_size;
932
933 _DrawRect(pw, gc, on_loc, off_loc, on_size, off_size);
934 }
935 }
936
937 #define DrawInternalBorders(pw) \
938 _DrawInternalBorders((pw), (pw)->paned.normgc)
939 #define EraseInternalBorders(pw) \
940 _DrawInternalBorders((pw), (pw)->paned.invgc)
941 /*
942 * Function Name:
943 * _DrawTrackLines
944 *
945 * Parameters:
946 * pw - Paned widget
947 * erase - if True then just erase track lines, else draw them in
948 *
949 * Description:
950 * Draws the lines that animate the pane borders when the grips are moved.
951 */
952 static void
953 _DrawTrackLines(PanedWidget pw, Bool erase)
954 {
955 Widget *childP;
956 Pane pane;
957 int on_loc, off_loc;
958 unsigned int on_size, off_size;
959
960 off_loc = 0;
961 off_size = PaneSize((Widget)pw, !IsVert(pw));
962
963 ForAllPanes(pw, childP) {
964 pane = PaneInfo(*childP);
965 if (erase || pane->olddelta != pane->delta) {
966 on_size = pw->paned.internal_bw;
967 if (!erase) {
968 on_loc = PaneInfo(*childP)->olddelta - (int) on_size;
969 _DrawRect(pw, pw->paned.flipgc,
970 on_loc, off_loc, on_size, off_size);
971 }
972
973 on_loc = PaneInfo(*childP)->delta - (int)on_size;
974
975 _DrawRect(pw, pw->paned.flipgc,
976 on_loc, off_loc, on_size, off_size);
977
978 pane->olddelta = pane->delta;
979 }
980 }
981 }
982
983 #define DrawTrackLines(pw) _DrawTrackLines((pw), False);
984 #define EraseTrackLines(pw) _DrawTrackLines((pw), True);
985 /*
986 * Function:
987 * GetEventLocation
988 *
989 * Parameters:
990 * pw - the paned widget
991 * event - pointer to an event
992 *
993 * Description:
994 * Converts and event to an x and y location.
995 *
996 * Returns:
997 * if this is a vertical pane then (y) else (x)
998 */
999 static int
1000 GetEventLocation(PanedWidget pw, XEvent *event)
1001 {
1002 int x, y;
1003
1004 switch (event->xany.type) {
1005 case ButtonPress:
1006 case ButtonRelease:
1007 x = event->xbutton.x_root;
1008 y = event->xbutton.y_root;
1009 break;
1010 case KeyPress:
1011 case KeyRelease:
1012 x = event->xkey.x_root;
1013 y = event->xkey.y_root;
1014 break;
1015 case MotionNotify:
1016 x = event->xmotion.x_root;
1017 y = event->xmotion.y_root;
1018 break;
1019 default:
1020 x = pw->paned.start_loc;
1021 y = pw->paned.start_loc;
1022 }
1023
1024 if (IsVert(pw))
1025 return (y);
1026
1027 return (x);
1028 }
1029
1030 /*
1031 * Function:
1032 * StartGripAdjustment
1033 *
1034 * Parameters:
1035 * pw - paned widget
1036 * grip - grip widget selected
1037 * dir - direction that we are to be moving
1038 *
1039 * Description:
1040 * Starts the grip adjustment procedure.
1041 */
1042 static void
1043 StartGripAdjustment(PanedWidget pw, Widget grip, Direction dir)
1044 {
1045 Widget *childP;
1046
1047 pw->paned.whichadd = pw->paned.whichsub = NULL;
1048
1049 if (dir == ThisBorderOnly || dir == UpLeftPane)
1050 pw->paned.whichadd = pw->composite.children[PaneIndex(grip)];
1051 if (dir == ThisBorderOnly || dir == LowRightPane)
1052 pw->paned.whichsub = pw->composite.children[PaneIndex(grip) + 1];
1053
1054 /*
1055 * Change the cursor
1056 */
1057 if (XtIsRealized(grip)) {
1058 Cursor cursor;
1059
1060 if (IsVert(pw)) {
1061 if (dir == UpLeftPane)
1062 cursor = pw->paned.adjust_upper_cursor;
1063 else if (dir == LowRightPane)
1064 cursor = pw->paned.adjust_lower_cursor;
1065 else {
1066 if (pw->paned.adjust_this_cursor == None)
1067 cursor = pw->paned.v_adjust_this_cursor;
1068 else
1069 cursor = pw->paned.adjust_this_cursor;
1070 }
1071 }
1072 else {
1073 if (dir == UpLeftPane)
1074 cursor = pw->paned.adjust_left_cursor;
1075 else if (dir == LowRightPane)
1076 cursor = pw->paned.adjust_right_cursor;
1077 else {
1078 if (pw->paned.adjust_this_cursor == None)
1079 cursor = pw->paned.h_adjust_this_cursor;
1080 else
1081 cursor = pw->paned.adjust_this_cursor;
1082 }
1083 }
1084
1085 XDefineCursor(XtDisplay(grip), XtWindow(grip), cursor);
1086 }
1087
1088 EraseInternalBorders(pw);
1089 ForAllPanes(pw, childP)
1090 PaneInfo(*childP)->olddelta = -99;
1091
1092 EraseTrackLines(pw);
1093 }
1094
1095 /*
1096 * Function:
1097 * MoveGripAdjustment
1098 *
1099 * Parameters:
1100 * pw - paned widget
1101 * grip - grip that we are moving
1102 * dir - direction the pane we are interested is w.r.t the grip
1103 * loc - location of pointer in proper direction
1104 *
1105 * Description:
1106 * This routine moves all panes around when a grip is moved.
1107 */
1108 static void
1109 MoveGripAdjustment(PanedWidget pw, Widget grip, Direction dir, int loc)
1110 {
1111 int diff, add_size = 0, sub_size = 0;
1112
1113 diff = loc - pw->paned.start_loc;
1114
1115 if (pw->paned.whichadd)
1116 add_size = PaneSize(pw->paned.whichadd, IsVert(pw)) + diff;
1117
1118 if (pw->paned.whichsub)
1119 sub_size = PaneSize(pw->paned.whichsub, IsVert(pw)) - diff;
1120
1121 /*
1122 * If moving this border only then do not allow either of the borders
1123 * to go beyond the min or max size allowed
1124 */
1125 if (dir == ThisBorderOnly) {
1126 int old_add_size = add_size, old_sub_size;
1127
1128 if (pw->paned.whichadd == NULL)
1129 return;
1130
1131 AssignMax(add_size, (int)PaneInfo(pw->paned.whichadd)->min);
1132 AssignMin(add_size, (int)PaneInfo(pw->paned.whichadd)->max);
1133 if (add_size != old_add_size)
1134 sub_size += old_add_size - add_size;
1135
1136 if (pw->paned.whichsub == NULL)
1137 return;
1138
1139 old_sub_size = sub_size;
1140 AssignMax(sub_size, (int)PaneInfo(pw->paned.whichsub)->min);
1141 AssignMin(sub_size, (int)PaneInfo(pw->paned.whichsub)->max);
1142 if (sub_size != old_sub_size)
1143 return; /* Abort to current sizes */
1144 }
1145
1146 if (add_size != 0)
1147 PaneInfo(pw->paned.whichadd)->size = add_size;
1148 if (sub_size != 0)
1149 PaneInfo(pw->paned.whichsub)->size = sub_size;
1150 RefigureLocations(pw, PaneIndex(grip), dir);
1151 DrawTrackLines(pw);
1152 }
1153
1154 /*
1155 * Function:
1156 * CommitGripAdjustment
1157 *
1158 * Parameters:
1159 * pw - paned widget
1160 *
1161 * Description:
1162 * Commits the grip adjustment.
1163 */
1164 static void
1165 CommitGripAdjustment(PanedWidget pw)
1166 {
1167 EraseTrackLines(pw);
1168 CommitNewLocations(pw);
1169 DrawInternalBorders(pw);
1170
1171 /*
1172 * Since the user selected this size then use it as the preferred size
1173 */
1174 if (pw->paned.whichadd) {
1175 Pane pane = PaneInfo(pw->paned.whichadd);
1176
1177 pane->wp_size = (Dimension)pane->size;
1178 }
1179 if (pw->paned.whichsub) {
1180 Pane pane = PaneInfo(pw->paned.whichsub);
1181
1182 pane->wp_size = (Dimension)pane->size;
1183 }
1184 }
1185
1186 /*
1187 * Function:
1188 * HandleGrip
1189 *
1190 * Parameters:
1191 * grip - grip widget that has been moved
1192 * temp - (not used)
1193 * call_data - data passed to us from the grip widget
1194 *
1195 * Description:
1196 * Handles the grip manipulations.
1197 */
1198 /*ARGSUSED*/
1199 static void
1200 HandleGrip(Widget grip, XtPointer temp _X_UNUSED, XtPointer callData)
1201 {
1202 XawGripCallData call_data = (XawGripCallData)callData;
1203 PanedWidget pw = (PanedWidget) XtParent(grip);
1204 int loc;
1205 char action_type[2], direction[2];
1206 Cursor cursor;
1207 Arg arglist[1];
1208
1209 if (call_data->num_params)
1210 XmuNCopyISOLatin1Uppered(action_type, call_data->params[0],
1211 sizeof(action_type));
1212
1213 if (call_data->num_params == 0
1214 || (action_type[0] == 'C' && call_data->num_params != 1)
1215 || (action_type[0] != 'C' && call_data->num_params != 2))
1216 XtAppError(XtWidgetToApplicationContext(grip),
1217 "Paned GripAction has been passed incorrect parameters.");
1218
1219 loc = GetEventLocation(pw, (XEvent *)call_data->event);
1220
1221 if (action_type[0] != 'C')
1222 XmuNCopyISOLatin1Uppered(direction, call_data->params[1],
1223 sizeof(direction));
1224
1225 switch (action_type[0]) {
1226 case 'S': /* Start adjustment */
1227 pw->paned.resize_children_to_pref = False;
1228 StartGripAdjustment(pw, grip, (Direction)direction[0]);
1229 pw->paned.start_loc = loc;
1230 break;
1231 case 'M':
1232 MoveGripAdjustment(pw, grip, (Direction)direction[0], loc);
1233 break;
1234 case 'C':
1235 XtSetArg(arglist[0], XtNcursor, &cursor);
1236 XtGetValues(grip, arglist, 1);
1237 XDefineCursor(XtDisplay(grip), XtWindow(grip), cursor);
1238 CommitGripAdjustment(pw);
1239 break;
1240 default:
1241 XtAppError(XtWidgetToApplicationContext(grip),
1242 "Paned GripAction(); 1st parameter invalid");
1243 break;
1244 }
1245 }
1246
1247 /*
1248 * Function:
1249 * ResortChildren
1250 *
1251 * Arguments:
1252 * pw - paned widget
1253 *
1254 * Description:
1255 * Resorts the children so that all managed children are first.
1256 */
1257 static void
1258 ResortChildren(PanedWidget pw)
1259 {
1260 Widget *unmanagedP, *childP;
1261
1262 unmanagedP = NULL;
1263 ForAllChildren(pw, childP) {
1264 if (!IsPane(*childP) || !XtIsManaged(*childP)) {
1265 /*
1266 * We only keep track of the first unmanaged pane
1267 */
1268 if (unmanagedP == NULL)
1269 unmanagedP = childP;
1270 }
1271 else { /* must be a managed pane */
1272 /*
1273 * If an earlier widget was not a managed pane, then swap
1274 */
1275 if (unmanagedP != NULL) {
1276 Widget child = *unmanagedP;
1277
1278 *unmanagedP = *childP;
1279 *childP = child;
1280 childP = unmanagedP; /* easiest to just back-track */
1281 unmanagedP = NULL; /* in case there is another managed */
1282 }
1283 }
1284 }
1285 }
1286
1287 /*
1288 * Function:
1289 * ManageAndUnmanageGrips
1290 *
1291 * Parameters:
1292 * pw - paned widget
1293 *
1294 * Description:
1295 * This function manages and unmanages the grips so that
1296 * the managed state of each grip matches that of its pane.
1297 */
1298 static void
1299 ManageAndUnmanageGrips(PanedWidget pw)
1300 {
1301 WidgetList managed_grips, unmanaged_grips;
1302 Widget *managedP, *unmanagedP, *childP;
1303 Cardinal alloc_size;
1304
1305 alloc_size = (Cardinal)(sizeof(Widget) * (pw->composite.num_children >> 1));
1306 managedP = managed_grips = (WidgetList)XtMalloc(alloc_size);
1307 unmanagedP = unmanaged_grips = (WidgetList)XtMalloc(alloc_size);
1308
1309 ForAllChildren(pw, childP)
1310 if (IsPane(*childP) && HasGrip(*childP)) {
1311 if (XtIsManaged(*childP))
1312 *managedP++ = PaneInfo(*childP)->grip;
1313 else
1314 *unmanagedP++ = PaneInfo(*childP)->grip;
1315 }
1316
1317 if (managedP != managed_grips) {
1318 *unmanagedP++ = *--managedP; /* Last grip is never managed */
1319 XtManageChildren(managed_grips, (Cardinal)(managedP - managed_grips));
1320 }
1321
1322 if (unmanagedP != unmanaged_grips)
1323 XtUnmanageChildren(unmanaged_grips, (Cardinal)(unmanagedP - unmanaged_grips));
1324
1325 XtFree((char *)managed_grips);
1326 XtFree((char *)unmanaged_grips);
1327 }
1328
1329 /*
1330 * Function:
1331 * CreateGrip
1332 *
1333 * Parameters:
1334 * child - child that wants a grip to be created for it
1335 *
1336 * Description:
1337 * Creates a grip widget.
1338 */
1339 static void
1340 CreateGrip(Widget child)
1341 {
1342 PanedWidget pw = (PanedWidget)XtParent(child);
1343 Arg arglist[2];
1344 Cardinal num_args = 0;
1345 Cursor cursor;
1346
1347 XtSetArg(arglist[num_args], XtNtranslations, pw->paned.grip_translations);
1348 num_args++;
1349 if ((cursor = pw->paned.grip_cursor) == None) {
1350 if (IsVert(pw))
1351 cursor = pw->paned.v_grip_cursor;
1352 else
1353 cursor = pw->paned.h_grip_cursor;
1354 }
1355
1356 XtSetArg(arglist[num_args], XtNcursor, cursor);
1357 num_args++;
1358 PaneInfo(child)->grip = XtCreateWidget("grip", gripWidgetClass, (Widget)pw,
1359 arglist, num_args);
1360
1361 XtAddCallback(PaneInfo(child)->grip, XtNcallback,
1362 HandleGrip, (XtPointer)child);
1363 }
1364
1365 /*
1366 * Function:
1367 * GetGCs
1368 *
1369 * Parameters:
1370 * w - paned widget
1371 */
1372 static void
1373 GetGCs(Widget w)
1374 {
1375 PanedWidget pw = (PanedWidget)w;
1376 XtGCMask valuemask;
1377 XGCValues values;
1378
1379 /*
1380 * Draw pane borders in internal border color
1381 */
1382 values.foreground = pw->paned.internal_bp;
1383 valuemask = GCForeground;
1384 pw->paned.normgc = XtGetGC(w, valuemask, &values);
1385
1386 /*
1387 * Erase pane borders with background color
1388 */
1389 values.foreground = pw->core.background_pixel;
1390 valuemask = GCForeground;
1391 pw->paned.invgc = XtGetGC(w, valuemask, &values);
1392
1393 /*
1394 * Draw Track lines (animate pane borders) in
1395 * internal border color ^ bg color
1396 */
1397 values.function = GXinvert;
1398 values.plane_mask = pw->paned.internal_bp ^ pw->core.background_pixel;
1399 values.subwindow_mode = IncludeInferiors;
1400 valuemask = GCPlaneMask | GCFunction | GCSubwindowMode;
1401 pw->paned.flipgc = XtGetGC(w, valuemask, &values);
1402 }
1403
1404 /*
1405 * Function:
1406 * SetChildrenPrefSizes
1407 *
1408 * Parameters:
1409 * pw - paned widget
1410 *
1411 * Description:
1412 * Sets the preferred sizes of the children.
1413 */
1414 static void
1415 SetChildrenPrefSizes(PanedWidget pw, unsigned int off_size)
1416 {
1417 Widget *childP;
1418 Boolean vert = IsVert(pw);
1419 XtWidgetGeometry request, reply;
1420
1421 ForAllPanes(pw, childP)
1422 if (pw->paned.resize_children_to_pref || PaneInfo(*childP)->size == 0 ||
1423 PaneInfo(*childP)->resize_to_pref) {
1424 if (PaneInfo(*childP)->preferred_size != PANED_ASK_CHILD)
1425 PaneInfo(*childP)->wp_size = PaneInfo(*childP)->preferred_size;
1426 else {
1427 if(vert) {
1428 request.request_mode = CWWidth;
1429 request.width = (Dimension) off_size;
1430 }
1431 else {
1432 request.request_mode = CWHeight;
1433 request.height = (Dimension) off_size;
1434 }
1435
1436 if ((XtQueryGeometry(*childP, &request, &reply)
1437 == XtGeometryAlmost)
1438 && (reply.request_mode = (vert ? CWHeight : CWWidth)))
1439 PaneInfo(*childP)->wp_size = GetRequestInfo(&reply, vert);
1440 else
1441 PaneInfo(*childP)->wp_size = PaneSize(*childP, vert);
1442 }
1443
1444 PaneInfo(*childP)->size = PaneInfo(*childP)->wp_size;
1445 }
1446 }
1447
1448 /*
1449 * Function:
1450 * ChangeAllGripCursors
1451 *
1452 * Parameters:
1453 * pw - paned widget
1454 *
1455 * Description:
1456 * Changes all the grip cursors.
1457 */
1458 static void
1459 ChangeAllGripCursors(PanedWidget pw)
1460 {
1461 Widget *childP;
1462
1463 ForAllPanes(pw, childP) {
1464 Cursor cursor;
1465
1466 if ((cursor = pw->paned.grip_cursor) == None) {
1467 if (IsVert(pw))
1468 cursor = pw->paned.v_grip_cursor;
1469 else
1470 cursor = pw->paned.h_grip_cursor;
1471 }
1472
1473 if (HasGrip(*childP)) {
1474 Arg arglist[1];
1475
1476 XtSetArg(arglist[0], XtNcursor, cursor);
1477 XtSetValues(PaneInfo(*childP)->grip, arglist, 1);
1478 }
1479 }
1480 }
1481
1482 /*
1483 * Function:
1484 * PushPaneStack
1485 *
1486 * Parameters:
1487 * pw - paned widget
1488 * pane - pane that we are pushing
1489 *
1490 * Description:
1491 * Pushes a value onto the pane stack.
1492 */
1493 static void
1494 PushPaneStack(PanedWidget pw, Pane pane)
1495 {
1496 PaneStack *stack = (PaneStack *)XtMalloc(sizeof(PaneStack));
1497
1498 stack->next = pw->paned.stack;
1499 stack->pane = pane;
1500 stack->start_size = pane->size;
1501
1502 pw->paned.stack = stack;
1503 }
1504
1505 /*
1506 * Function:
1507 * GetPaneStack
1508 *
1509 * Parameters:
1510 * pw - paned widget
1511 * shrink - True if we want to shrink this pane, False otherwise
1512 * pane - pane that we are popping (return)
1513 * start_size - size that this pane started at (return)
1514 *
1515 * Description:
1516 * Gets the top value from the pane stack.
1517 */
1518 static void
1519 GetPaneStack(PanedWidget pw, Bool shrink, Pane *pane, int *start_size)
1520 {
1521 if (pw->paned.stack == NULL) {
1522 *pane = NULL;
1523 return;
1524 }
1525
1526 *pane = pw->paned.stack->pane;
1527 *start_size = pw->paned.stack->start_size;
1528
1529 if (shrink != ((*pane)->size > *start_size))
1530 *pane = NULL;
1531 }
1532
1533 /*
1534 * Function:
1535 * PopPaneStack
1536 *
1537 * Parameters:
1538 * pw - paned widget
1539 *
1540 * Description:
1541 * Pops the top item off the pane stack.
1542 *
1543 * Returns: True if this is not the last element on the stack
1544 */
1545 static Bool
1546 PopPaneStack(PanedWidget pw)
1547 {
1548 PaneStack *stack = pw->paned.stack;
1549
1550 if (stack == NULL)
1551 return (False);
1552
1553 pw->paned.stack = stack->next;
1554 XtFree((char *)stack);
1555
1556 if (pw->paned.stack == NULL)
1557 return (False);
1558
1559 return (True);
1560 }
1561
1562 /*
1563 * Function:
1564 * ClearPaneStack
1565 *
1566 * Parameters:
1567 * pw - paned widget
1568 *
1569 * Description:
1570 * Removes all entries from the pane stack.
1571 */
1572 static void
1573 ClearPaneStack(PanedWidget pw)
1574 {
1575 while(PopPaneStack(pw))
1576 ;
1577 }
1578
1579 static void
1580 XawPanedClassInitialize(void)
1581 {
1582 XawInitializeWidgetSet();
1583 XtAddConverter(XtRString, XtROrientation, XmuCvtStringToOrientation,
1584 NULL, 0);
1585 XtSetTypeConverter(XtROrientation, XtRString, XmuCvtOrientationToString,
1586 NULL, 0, XtCacheNone, NULL);
1587 }
1588
1589 /* The Geometry Manager only allows changes after Realize if
1590 * allow_resize is True in the constraints record.
1591 *
1592 * For vertically paned widgets:
1593 *
1594 * It only allows height changes, but offers the requested height
1595 * as a compromise if both width and height changes were requested.
1596 *
1597 * For horizontal widgets the converse is true.
1598 * As all good Geometry Managers should, we will return No if the
1599 * request will have no effect; i.e. when the requestor is already
1600 * of the desired geometry.
1601 */
1602 static XtGeometryResult
1603 XawPanedGeometryManager(Widget w, XtWidgetGeometry *request,
1604 XtWidgetGeometry *reply)
1605 {
1606 PanedWidget pw = (PanedWidget)XtParent(w);
1607 XtGeometryMask mask = request->request_mode;
1608 Dimension old_size, old_wpsize, old_paned_size;
1609 Pane pane = PaneInfo(w);
1610 Boolean vert = IsVert(pw);
1611 Dimension on_size, off_size;
1612 XtGeometryResult result;
1613 Boolean almost = False;
1614
1615 /*
1616 * If any of the following is true, disallow the geometry change
1617 *
1618 * o The paned widget is realized and allow_resize is false for the pane
1619 * o The child did not ask to change the on_size
1620 * o The request is not a width or height request
1621 * o The requested size is the same as the current size
1622 */
1623
1624 if ((XtIsRealized((Widget)pw) && !pane->allow_resize)
1625 || !(mask & (vert ? CWHeight : CWWidth))
1626 || (mask & (XtGeometryMask)(~(CWWidth | CWHeight)))
1627 || GetRequestInfo(request, vert) == PaneSize(w, vert))
1628 return (XtGeometryNo);
1629
1630 old_paned_size = PaneSize((Widget)pw, vert);
1631 old_wpsize = pane->wp_size;
1632 old_size = (Dimension)pane->size;
1633
1634 pane->wp_size = (Dimension)(pane->size = GetRequestInfo(request, vert));
1635
1636 AdjustPanedSize(pw, PaneSize((Widget)pw, !vert), &result, &on_size,
1637 &off_size);
1638
1639 /*
1640 * Fool the Refigure Locations proc to thinking that we are
1641 * a different on_size
1642 */
1643
1644 if (result != XtGeometryNo) {
1645 if (vert)
1646 XtHeight(pw) = on_size;
1647 else
1648 XtWidth(pw) = on_size;
1649 }
1650
1651 RefigureLocations(pw, PaneIndex(w), AnyPane);
1652
1653 /*
1654 * Set up reply struct and reset core on_size
1655 */
1656 if (vert) {
1657 XtHeight(pw) = old_paned_size;
1658 reply->height = (Dimension) pane->size;
1659 reply->width = off_size;
1660 }
1661 else {
1662 XtWidth(pw) = old_paned_size;
1663 reply->height = off_size;
1664 reply->width = (Dimension) pane->size;
1665 }
1666
1667 /*
1668 * IF either of the following is true
1669 *
1670 * o There was a "off_size" request and the new "off_size" is different
1671 * from that requested
1672 * o There was no "off_size" request and the new "off_size" is different
1673 *
1674 * o The "on_size" we will allow is different from that requested
1675 *
1676 * THEN: set almost
1677 */
1678 if (!((vert ? CWWidth : CWHeight) & mask)) {
1679 if (vert)
1680 request->width = XtWidth(w);
1681 else
1682 request->height = XtHeight(w);
1683 }
1684
1685 almost = GetRequestInfo(request, !vert) != GetRequestInfo(reply, !vert);
1686 almost = (Boolean)(almost | (GetRequestInfo(request, vert) != GetRequestInfo(reply, vert)));
1687
1688 if ((mask & XtCWQueryOnly) || almost) {
1689 pane->wp_size = old_wpsize;
1690 pane->size = old_size;
1691 RefigureLocations(pw, PaneIndex(w), AnyPane);
1692 reply->request_mode = CWWidth | CWHeight;
1693 if (almost)
1694 return (XtGeometryAlmost);
1695 }
1696 else {
1697 AdjustPanedSize(pw, PaneSize((Widget) pw, !vert), NULL, NULL, NULL);
1698 CommitNewLocations(pw); /* layout already refigured */
1699 }
1700
1701 return (XtGeometryDone);
1702 }
1703
1704 /*ARGSUSED*/
1705 static void
1706 XawPanedInitialize(Widget request _X_UNUSED, Widget cnew,
1707 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED)
1708 {
1709 PanedWidget pw = (PanedWidget)cnew;
1710
1711 GetGCs((Widget)pw);
1712
1713 pw->paned.recursively_called = False;
1714 pw->paned.stack = NULL;
1715 pw->paned.resize_children_to_pref = True;
1716 pw->paned.num_panes = 0;
1717 }
1718
1719 static void
1720 XawPanedRealize(Widget w, Mask *valueMask, XSetWindowAttributes *attributes)
1721 {
1722 PanedWidget pw = (PanedWidget)w;
1723 Widget *childP;
1724
1725 if ((attributes->cursor = pw->paned.cursor) != None)
1726 *valueMask |= CWCursor;
1727
1728 (*SuperClass->core_class.realize)(w, valueMask, attributes);
1729
1730 /*
1731 * Before we commit the new locations we need to realize all the panes and
1732 * their grips
1733 */
1734 ForAllPanes(pw, childP) {
1735 XtRealizeWidget(*childP);
1736 if (HasGrip(*childP))
1737 XtRealizeWidget(PaneInfo(*childP)->grip);
1738 }
1739
1740 RefigureLocationsAndCommit(w);
1741 pw->paned.resize_children_to_pref = False;
1742 }
1743
1744 static void
1745 XawPanedDestroy(Widget w)
1746 {
1747 ReleaseGCs(w);
1748 }
1749
1750 static void
1751 ReleaseGCs(Widget w)
1752 {
1753 PanedWidget pw = (PanedWidget)w;
1754
1755 XtReleaseGC(w, pw->paned.normgc);
1756 XtReleaseGC(w, pw->paned.invgc);
1757 XtReleaseGC(w, pw->paned.flipgc);
1758 }
1759
1760 static void
1761 XawPanedInsertChild(Widget w)
1762 {
1763 Pane pane = PaneInfo(w);
1764
1765 /* insert the child widget in the composite children list with the
1766 superclass insert_child routine
1767 */
1768 (*SuperClass->composite_class.insert_child)(w);
1769
1770 if (!IsPane(w))
1771 return;
1772
1773 if (pane->show_grip == True) {
1774 CreateGrip(w);
1775 if (pane->min == PANED_GRIP_SIZE)
1776 pane->min = PaneSize(pane->grip, IsVert((PanedWidget)XtParent(w)));
1777 }
1778 else {
1779 if (pane->min == PANED_GRIP_SIZE)
1780 pane->min = 1;
1781 pane->grip = NULL;
1782 }
1783
1784 pane->size = 0;
1785 pane->paned_adjusted_me = False;
1786 }
1787
1788 static void
1789 XawPanedDeleteChild(Widget w)
1790 {
1791 /* remove the subwidget info and destroy the grip */
1792 if (IsPane(w) && HasGrip(w))
1793 XtDestroyWidget(PaneInfo(w)->grip);
1794
1795 /* delete the child widget in the composite children list with the
1796 superclass delete_child routine
1797 */
1798 (*SuperClass->composite_class.delete_child)(w);
1799 }
1800
1801 static void
1802 XawPanedChangeManaged(Widget w)
1803 {
1804 PanedWidget pw = (PanedWidget)w;
1805 Boolean vert = IsVert(pw);
1806 Dimension size;
1807 Widget *childP;
1808
1809 if (pw->paned.recursively_called++)
1810 return;
1811
1812 /*
1813 * If the size is zero then set it to the size of the widest or tallest pane
1814 */
1815
1816 if ((size = PaneSize((Widget)pw, !vert)) == 0) {
1817 size = 1;
1818 ForAllChildren(pw, childP)
1819 if (XtIsManaged(*childP) && (PaneSize(*childP, !vert) > size))
1820 size = PaneSize(*childP, !vert);
1821 }
1822
1823 ManageAndUnmanageGrips(pw);
1824 pw->paned.recursively_called = False;
1825 ResortChildren(pw);
1826
1827 pw->paned.num_panes = 0;
1828 ForAllChildren(pw, childP)
1829 if (IsPane(*childP)) {
1830 if (XtIsManaged(*childP)) {
1831 Pane pane = PaneInfo(*childP);
1832
1833 if (HasGrip(*childP))
1834 PaneInfo(pane->grip)->position = pw->paned.num_panes;
1835 pane->position = pw->paned.num_panes; /* TEMPORARY -CDP 3/89 */
1836 pw->paned.num_panes++;
1837 }
1838 else
1839 break; /* This list is already sorted */
1840 }
1841
1842 SetChildrenPrefSizes((PanedWidget) w, size);
1843
1844 /*
1845 * ForAllPanes can now be used
1846 */
1847 if (PaneSize((Widget) pw, vert) == 0)
1848 AdjustPanedSize(pw, size, NULL, NULL, NULL);
1849
1850 if (XtIsRealized((Widget)pw))
1851 RefigureLocationsAndCommit((Widget)pw);
1852 }
1853
1854 static void
1855 XawPanedResize(Widget w)
1856 {
1857 SetChildrenPrefSizes((PanedWidget)w,
1858 PaneSize(w, !IsVert((PanedWidget)w)));
1859 RefigureLocationsAndCommit(w);
1860 }
1861
1862 /*ARGSUSED*/
1863 static void
1864 XawPanedRedisplay(Widget w, XEvent *event _X_UNUSED, Region region _X_UNUSED)
1865 {
1866 DrawInternalBorders((PanedWidget)w);
1867 }
1868
1869 /*ARGSUSED*/
1870 static Boolean
1871 XawPanedSetValues(Widget old, Widget request _X_UNUSED, Widget cnew,
1872 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED)
1873 {
1874 PanedWidget old_pw = (PanedWidget)old;
1875 PanedWidget new_pw = (PanedWidget)cnew;
1876 Boolean redisplay = False;
1877
1878 if ((old_pw->paned.cursor != new_pw->paned.cursor) && XtIsRealized(cnew))
1879 XDefineCursor(XtDisplay(cnew), XtWindow(cnew), new_pw->paned.cursor);
1880
1881 if (old_pw->paned.internal_bp != new_pw->paned.internal_bp ||
1882 old_pw->core.background_pixel != new_pw->core.background_pixel) {
1883 ReleaseGCs(old);
1884 GetGCs(cnew);
1885 redisplay = True;
1886 }
1887
1888 if (old_pw->paned.grip_cursor != new_pw->paned.grip_cursor ||
1889 old_pw->paned.v_grip_cursor != new_pw->paned.v_grip_cursor ||
1890 old_pw->paned.h_grip_cursor != new_pw->paned.h_grip_cursor)
1891 ChangeAllGripCursors(new_pw);
1892
1893 if (IsVert(old_pw) != IsVert(new_pw)) {
1894 /*
1895 * We are fooling the paned widget into thinking that is needs to
1896 * fully refigure everything, which is what we want
1897 */
1898 if (IsVert(new_pw))
1899 XtWidth(new_pw) = 0;
1900 else
1901 XtHeight(new_pw) = 0;
1902
1903 new_pw->paned.resize_children_to_pref = True;
1904 XawPanedChangeManaged(cnew); /* Seems weird, but does the right thing */
1905 new_pw->paned.resize_children_to_pref = False;
1906 if (new_pw->paned.grip_cursor == None)
1907 ChangeAllGripCursors(new_pw);
1908 return (True);
1909 }
1910
1911 if (old_pw->paned.internal_bw != new_pw->paned.internal_bw) {
1912 AdjustPanedSize(new_pw, PaneSize(cnew, !IsVert(old_pw)),
1913 NULL, NULL, NULL);
1914 RefigureLocationsAndCommit(cnew);
1915 return (True); /* We have done a full configuration, return */
1916 }
1917
1918 if (old_pw->paned.grip_indent != new_pw->paned.grip_indent &&
1919 XtIsRealized(cnew)) {
1920 CommitNewLocations(new_pw);
1921 redisplay = True;
1922 }
1923
1924 return (redisplay);
1925 }
1926
1927 /*ARGSUSED*/
1928 static Boolean
1929 XawPanedPaneSetValues(Widget old, Widget request _X_UNUSED, Widget cnew,
1930 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED)
1931 {
1932 Pane old_pane = PaneInfo(old);
1933 Pane new_pane = PaneInfo(cnew);
1934 Boolean redisplay = False;
1935
1936 /* Check for new min and max */
1937 if (old_pane->min != new_pane->min || old_pane->max != new_pane->max)
1938 XawPanedSetMinMax(cnew, (int)new_pane->min, (int)new_pane->max);
1939
1940 /* Check for change in XtNshowGrip */
1941 if (old_pane->show_grip != new_pane->show_grip) {
1942 if (new_pane->show_grip == True) {
1943 CreateGrip(cnew);
1944 if (XtIsRealized(XtParent(cnew))) {
1945 if (XtIsManaged(cnew)) /* if paned is unrealized this will
1946 happen automatically at realize time
1947 */
1948 XtManageChild(PaneInfo(cnew)->grip); /* manage the grip */
1949 XtRealizeWidget(PaneInfo(cnew)->grip); /* realize the grip */
1950 CommitNewLocations((PanedWidget)XtParent(cnew));
1951 }
1952 }
1953 else if (HasGrip(old)) {
1954 XtDestroyWidget(old_pane->grip);
1955 new_pane->grip = NULL;
1956 redisplay = True;
1957 }
1958 }
1959
1960 return (redisplay);
1961 }
1962
1963 /*
1964 * Public routines
1965 */
1966 /*
1967 * Function:
1968 * XawPanedSetMinMax
1969 *
1970 * Parameters:
1971 * widget - widget that is a child of the Paned widget
1972 * min - new min and max size for the pane
1973 * max - ""
1974 *
1975 * Description:
1976 * Sets the min and max size for a pane.
1977 */
1978 void
1979 XawPanedSetMinMax(Widget widget, int min, int max)
1980 {
1981 Pane pane = PaneInfo(widget);
1982
1983 pane->min = (Dimension) min;
1984 pane->max = (Dimension) max;
1985 RefigureLocationsAndCommit(widget->core.parent);
1986 }
1987
1988 /*
1989 * Function:
1990 * XawPanedGetMinMax
1991 *
1992 * Parameters:
1993 * widget - widget that is a child of the Paned widget
1994 * min - current min and max size for the pane (return)
1995 * max - ""
1996 *
1997 * Description:
1998 * Gets the min and max size for a pane.
1999 */
2000 void
2001 XawPanedGetMinMax(Widget widget, int *min, int *max)
2002 {
2003 Pane pane = PaneInfo(widget);
2004
2005 *min = pane->min;
2006 *max = pane->max;
2007 }
2008
2009 /*
2010 * Function:
2011 * XawPanedSetRefigureMode
2012 *
2013 * Parameters:
2014 * w - paned widget
2015 * mode - if False then inhibit refigure
2016 *
2017 * Description:
2018 * Allows a flag to be set the will inhibit
2019 * the paned widgets relayout routine.
2020 */
2021 void
2022 XawPanedSetRefigureMode(Widget w,
2023 #if NeedWidePrototypes
2024 int mode
2025 #else
2026 Boolean mode
2027 #endif
2028 )
2029 {
2030 ((PanedWidget)w)->paned.refiguremode = mode;
2031 RefigureLocationsAndCommit(w);
2032 }
2033
2034 /*
2035 * Function:
2036 * XawPanedGetNumSub
2037 *
2038 * Parameters:
2039 * w - paned widget
2040 *
2041 * Description:
2042 * Returns the number of panes in the paned widget.
2043 * Returns:
2044 * the number of panes in the paned widget
2045 */
2046 int
2047 XawPanedGetNumSub(Widget w)
2048 {
2049 return (((PanedWidget)w)->paned.num_panes);
2050 }
2051
2052 /*
2053 * Function:
2054 * XawPanedAllowResize
2055 *
2056 * Parameters:
2057 * widget - child of the paned widget
2058 *
2059 * Description:
2060 * Allows a flag to be set that determines if the paned
2061 * widget will allow geometry requests from this child.
2062 */
2063 void
2064 XawPanedAllowResize(Widget widget,
2065 #if NeedWidePrototypes
2066 int allow_resize
2067 #else
2068 Boolean allow_resize
2069 #endif
2070 )
2071 {
2072 PaneInfo(widget)->allow_resize = allow_resize;
2073 }