![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to VPane.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xtk|
Return to VPane.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xtk |
1.1 root 1: #ifndef lint
2: static char rcsid[] = "$Header: VPane.c,v 1.7 87/09/13 13:31:15 swick Exp $";
3: #endif lint
4:
5: /*
6: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
7: *
8: * All Rights Reserved
9: *
10: * Permission to use, copy, modify, and distribute this software and its
11: * documentation for any purpose and without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and that
13: * both that copyright notice and this permission notice appear in
14: * supporting documentation, and that the name of Digital Equipment
15: * Corporation not be used in advertising or publicity pertaining to
16: * distribution of the software without specific, written prior permission.
17: *
18: *
19: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
20: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
21: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
22: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
23: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
25: * SOFTWARE.
26: */
27: /*
28: * VPane.c - VPane composite Widget (Converted to classing toolkit)
29: *
30: * Author: Jeanne M. Rich (Original Terry Weissman)
31: * Digital Equipment Corporation
32: * Western Research Laboratory
33: * Date: Friday, Aug 28 1987
34: *
35: */
36:
37: #include "Xlib.h"
38: #include "cursorfont.h"
39: #include "Intrinsic.h"
40: #include "VPaneP.h"
41: #include "VPane.h"
42: #include "Knob.h"
43: #include "Atoms.h"
44:
45: #define offset(field) XtOffset(VPaneWidget,v_pane.field)
46: #define suboffset(field) XtOffset(SubWidgetPtr,field)
47:
48: /**********************************************************************************
49: *
50: * Full instance record declaration
51: *
52: *********************************************************************************/
53:
54: static XtResource resources[] = {
55: {XtNforeground, XtCColor, XrmRPixel, sizeof(Pixel),
56: offset(foreground_pixel), XrmRString, "Black"},
57: {XtNknobWidth, XtCWidth, XrmRInt, sizeof(int),
58: offset(knob_width), XrmRString, "9"},
59: {XtNknobHeight, XtCHeight, XrmRInt, sizeof(int),
60: offset(knob_height), XrmRString, "9"},
61: {XtNknobIndent, XtCKnobIndent, XrmRInt, sizeof(int),
62: offset(knob_indent), XrmRString, "16"},
63: {XtNknobPixel, XtCKnobPixel, XrmRPixel, sizeof(int),
64: offset(knob_pixel), XrmRString, "Black"},
65: {XtNrefigureMode, XtCRefigureMode, XrmRBoolean, sizeof(int),
66: offset(refiguremode), XrmRString, "On"}
67: };
68:
69: static XtResource subresources[] = {
70: {XtNposition, XtCPosition, XrmRInt, sizeof(int),
71: suboffset(position), XrmRString, "0"},
72: {XtNmin, XtCMin, XrmRInt, sizeof(int),
73: suboffset(min), XrmRString, "0"},
74: {XtNmax, XtCMax, XrmRInt, sizeof(int),
75: suboffset(max), XrmRString, "1000"},
76: {XtNautoChange, XtCAutoChange, XrmRBoolean, sizeof(int),
77: suboffset(autochange), XrmRString, "On"}
78: };
79:
80: static void Initialize();
81: static void Realize();
82: static void Destroy();
83: static void Resize();
84: static void SetValues();
85: static XtGeometryResult GeometryManager();
86: static void ChangeManaged();
87: static void InsertChild();
88: static void DeleteChild();
89:
90: VPaneClassRec vPaneClassRec = {
91: {
92: /* core class fields */
93: /* superclass */ (WidgetClass) &constraintClassRec,
94: /* class name */ "VPane",
95: /* size */ sizeof(VPaneRec),
96: /* class initialize */ NULL,
97: /* class_inited */ FALSE,
98: /* initialize */ Initialize,
99: /* realize */ Realize,
100: /* actions */ NULL,
101: /* num_actions */ 0,
102: /* resourses */ resources,
103: /* resource_count */ XtNumber(resources),
104: /* xrm_class */ NULLQUARK,
105: /* compress_motion */ TRUE,
106: /* compress_exposure */ TRUE,
107: /* visible_interest */ FALSE,
108: /* destroy */ Destroy,
109: /* resize */ Resize,
110: /* expose */ NULL,
111: /* set_values */ SetValues,
112: /* accept_focus */ NULL
113: }, {
114: /* composite class fields */
115: /* geometry_manager */ GeometryManager,
116: /* change_managed */ ChangeManaged,
117: /* insert_child */ InsertChild,
118: /* delete_child */ DeleteChild,
119: /* move_focus_to_next */ NULL,
120: /* move_focus_to_prev */ NULL
121: }, {
122: /* constraint class fields */
123: /* subresourses */ subresources,
124: /* subresource_count */ XtNumber(subresources)
125: }, {
126: /* mumble */ 0 /* make C compiler happy */
127: }
128: };
129:
130: static int CursorNums[4] = {0,
131: XC_sb_up_arrow,
132: XC_sb_v_double_arrow,
133: XC_sb_down_arrow};
134:
135: static Boolean NeedsAdjusting(vpw)
136: VPaneWidget vpw;
137: {
138:
139: int needed, i;
140:
141: for (i = 0; i < (vpw->composite.num_children/2); i++) {
142: if (vpw->composite.children[i * 2]->core.managed)
143: needed += sublist[i].dheight + BORDERWIDTH;
144: }
145: needed -= BORDERWIDTH;
146: if (needed > vpw->composite.children[i * 2]->core.height)
147: return(TRUE);
148: else return(FALSE);
149:
150: }
151:
152: static void AdjustVPaneHeight(vpw, newheight)
153: VPaneWidget vpw;
154: Dimension newheight;
155: {
156: XtWidgetGeometry request, reply;
157: XtGeometryResult result;
158: if (newheight < 1) newheight = 1;
159: request.height = newheight;
160: request.request_mode = CWHeight;
161: result = XtMakeGeometryRequest(vpw, &request, &reply);
162: if (result == XtGeometryAlmost) {
163: request = reply;
164: result = XtMakeGeometryRequest(vpw, &request, &reply);
165: }
166: if (result == XtGeometryYes) {
167: vpw->core.height = reply.height;
168: }
169: }
170:
171:
172: static RefigureLocations(vpw, position, dir)
173: VPaneWidget vpw;
174: int position;
175: int dir; /* -1 = up, 1 = down, 0 = this border only */
176: {
177: SubWidgetPtr sub, firstsub;
178: WidgetList children;
179: int i, old, y, cdir, num_children, child, firstchild;
180:
181: if (vpw->composite.num_mapped_children == 0 || !vpw->v_pane.refiguremode)
182: return;
183:
184: children = vpw->composite.children;
185: num_children = vpw->composite.num_children / 2;
186: do {
187: vpw->v_pane.heightused = 0;
188: for (i = 0, sub = vpw->v_pane.sublist; i < num_children; i++, sub++) {
189: if (children[i * 2]->core.managed) {
190: if (sub->dheight < sub->min)
191: sub->dheight = sub->min;
192: if (sub->dheight > sub->max)
193: sub->dheight = sub->max;
194: vpw->v_pane.heightused += sub->dheight + BORDERWIDTH;
195: }
196: }
197: vpw->v_pane.heightused -= BORDERWIDTH;
198: if (dir == 0 && vpw->v_pane.heightused != vpw->core.height) {
199: for (i = 0, sub = vpw->v_pane.sublist; i < num_children; i++, sub++) {
200: if (children[i * 2]->core.managed) {
201: if (sub->dheight != children[i * 2]->core.height)
202: sub->dheight += vpw->core.height - vpw->v_pane.heightused;
203: }
204: }
205: }
206: } while (dir == 0 && vpw->v_pane.heightused != vpw->core.height);
207:
208: firstsub = vpw->v_pane.sublist + position;
209: firstchild = position * 2;
210: sub = firstsub;
211: child = firstchild;
212: cdir = dir;
213: while (vpw->v_pane.heightused != vpw->core.height) {
214: if (children[child]->core.managed) {
215: if (sub->autochange || cdir != dir) {
216: old = sub->dheight;
217: sub->dheight = vpw->core.height - vpw->v_pane.heightused + old;
218: if (sub->dheight < sub->min)
219: sub->dheight = sub->min;
220: if (sub->dheight > sub->max)
221: sub->dheight = sub->max;
222: vpw->v_pane.heightused += (sub->dheight - old);
223: }
224: sub += cdir;
225: child += (cdir * 2);
226: while (sub < vpw->v_pane.sublist ||
227: sub - vpw->v_pane.sublist == num_children) {
228: cdir = -cdir;
229: if (cdir == dir) goto triplebreak;
230: sub = firstsub + cdir;
231: child = firstchild + (cdir * 2);
232: }
233: }
234: }
235: triplebreak:
236: y = -BORDERWIDTH;
237: for (i = 0, sub = vpw->v_pane.sublist; i < num_children; i++, sub++) {
238: if (child[i * 2]->core.managed) {
239: sub->dy = y;
240: y += sub->dheight + BORDERWIDTH;
241: }
242: }
243: }
244:
245:
246: static CommitNewLocations(vpw)
247: VPaneWidget vpw;
248: {
249: int i, kx, ky, num_children;
250: WidgetList children;
251: KnobWidget lastknob;
252: SubWidgetPtr sub;
253:
254: num_children = vpw->composite.num_children / 2;
255: children = vpw->composite.children
256: lastknob = NULL:
257:
258: /* First unmap all the knobs that are not managed */
259: for (i = 0; i < vpw_composite.num_children; i+2)
260: if (children[i]->core.managed == FALSE) {
261: if (children[i + 1]->core.managed == TRUE) {
262: XtUnmapWidget(children[i + 1]);
263: children[i + 1]->core.managed = FALSE;
264: }
265: }
266: }
267:
268: for (i = 0, sub = vpw->v_pane.sublist; i < num_children; i++, sub++) {
269: if (children[i * 2]->core.managed) {
270:
271: /* see if the widget needs to be moved */
272: if (sub->dy != children[i * 2]->core.y)
273: XtMoveWidget(children[i * 2], sub->dy, -BORDERWIDTH);
274:
275: /* see if the widget needs to be resized */
276: if ((sub->dheight != children[i * 2]->core.height) ||
277: (children[i * 2]->core.width != vpw->core.width) ||
278: (children[i * 2]->core.borderwidth != BORDERWIDTH))
279: XtResizeWidget(children[i * 2], vpw->core.height, sub->dheight,
280: BORDERWIDTH);
281:
282: /* Move and Display the Knob */
283: kx = vpw->core.width - vpw->v_pane.knobindent;
284: ky = children[i * 2]->core.y + children[i * 2]->core.height -
285: (vpw->v_pane.knobheight/2)+1;
286: XtMoveWidget(sub->knob, kx, ky);
287: if (sub->knob->core.managed == FALSE) {
288: XtMapWidget(sub->knob);
289: sub->knob->core.managed = TRUE;
290: }
291: XRaiseWindow(XtDisplay(sub->knob), XtWindow(sub->knob));
292: lastknob = sub->knob;
293:
294: }
295: }
296:
297: if (lastknob != NULL) {
298: XtUnMapWidget(lastknob);
299: lastknob->core.managed = FALSE;
300: }
301: }
302:
303:
304: static RefigureLocationsAndCommit(vpw, position, dir)
305: VPaneWidget data;
306: int position, dir;
307: {
308: RefigureLocations(vpw, position, dir);
309: CommitNewLocations(vpw);
310: }
311:
312:
313: EraseInternalBorders(data)
314: WidgetData data;
315: {
316: int i;
317: for (i = 1; i < data->numsubwindows; i++)
318: XFillRectangle(data->dpy, data->window, data->invgc,
319: 0, data->sub[i].y, data->width, BORDERWIDTH);
320: }
321: /*
322:
323: DrawInternalBorders(data)
324: WidgetData data;
325: {
326: int i;
327: for (i = 1; i < data->numsubwindows; i++)
328: XFillRectangle(data->dpy, data->window, data->normgc,
329: 0, data->sub[i].y, data->width, BORDERWIDTH);
330: }
331:
332:
333: static DrawTrackLines(data)
334: WidgetData data;
335: {
336: int i;
337: SubWindowPtr sub;
338: for (i = 1, sub = data->sub + 1; i < data->numsubwindows; i++, sub++) {
339: if (sub->olddy != sub->dy) {
340: XDrawLine(data->dpy, data->window, data->flipgc,
341: 0, sub->olddy, (Position) data->width, sub->olddy);
342: XDrawLine(data->dpy, data->window, data->flipgc,
343: 0, sub->dy, (Position) data->width, sub->dy);
344: sub->olddy = sub->dy;
345: }
346: }
347: }
348:
349: static EraseTrackLines(data)
350: WidgetData data;
351: {
352: int i;
353: SubWindowPtr sub;
354: for (i = 1, sub = data->sub + 1; i < data->numsubwindows; i++, sub++)
355: XDrawLine(data->dpy, data->window, data->flipgc,
356: 0, sub->olddy, (Position) data->width, sub->olddy);
357: }
358:
359: static XtEventReturnCode HandleKnob(event)
360: XEvent *event;
361: {
362: WidgetData data;
363: int position, diff, y, i;
364:
365: data = DataFromWindow(event->xbutton.display, event->xbutton.window);
366: if (!data) return XteventNotHandled;
367: switch (event->type) {
368: case ButtonPress:
369: y = event->xbutton.y;
370: if (data->whichtracking != -1)
371: return XteventNotHandled;
372: for (position = 0; position < data->numsubwindows; position++)
373: if (data->sub[position].knob == event->xbutton.window)
374: break;
375: if (position >= data->numsubwindows)
376: return XteventNotHandled;
377:
378: (void) XGrabPointer(data->dpy, event->xbutton.window, FALSE,
379: (unsigned int)PointerMotionMask | ButtonReleaseMask,
380: GrabModeAsync, GrabModeAsync, None,
381: XtGetCursor(data->dpy,
382: CursorNums[event->xbutton.button]),
383: CurrentTime);
384: data->whichadd = data->whichsub = NULL;
385: data->whichdirection = 2 - event->xbutton.button; * Hack! *
386: data->starty = y;
387: if (data->whichdirection >= 0) {
388: data->whichadd = data->sub + position;
389: while (data->whichadd->max == data->whichadd->min &&
390: data->whichadd > data->sub)
391: (data->whichadd)--;
392: }
393: if (data->whichdirection <= 0) {
394: data->whichsub = data->sub + position + 1;
395: while (data->whichsub->max == data->whichsub->min &&
396: data->whichsub < data->sub + data->numsubwindows - 1)
397: (data->whichsub)++;
398: }
399: data->whichtracking = position;
400: if (data->whichdirection == 1)
401: (data->whichtracking)++;
402: EraseInternalBorders(data);
403: for (i = 0; i < data->numsubwindows; i++)
404: data->sub[i].olddy = -99;
405: * Fall through *
406:
407: case MotionNotify:
408: case ButtonRelease:
409: if (event->type == MotionNotify) y = event->xmotion.y;
410: else y = event->xbutton.y;
411: if (data->whichtracking == -1)
412: return XteventNotHandled;
413: for (i = 0; i < data->numsubwindows; i++)
414: data->sub[i].dheight = data->sub[i].height;
415: diff = y - data->starty;
416: if (data->whichadd)
417: data->whichadd->dheight = data->whichadd->height + diff;
418: if (data->whichsub)
419: data->whichsub->dheight = data->whichsub->height - diff;
420: RefigureLocations(data, data->whichtracking, data->whichdirection);
421:
422: if (event->type != ButtonRelease) {
423: DrawTrackLines(data); * Draw new borders *
424: return XteventHandled;
425: }
426: XUngrabPointer(data->dpy, CurrentTime);
427: EraseTrackLines(data);
428: CommitNewLocations(data);
429: DrawInternalBorders(data);
430: data->whichtracking = -1;
431: return XteventHandled;
432: }
433: return XteventNotHandled;
434: }
435: */
436:
437: /* Semi-public routines. */
438:
439: static XtGeometryReturnCode GeometryManager(w, request, reply)
440: Widget w;
441: WidgetGeometry *request, *reply;
442: {
443:
444: return(XtgeometryNo);
445:
446: }
447:
448: static void Initialize(w)
449: Widget w;
450: {
451:
452: VPaneWidget vpw = (VPaneWidget) w;
453: unsigned long valuemask;
454: XGCValues values;
455:
456: values.foreground = vpw->v_pane.foreground_pixel;
457: values.function = GXcopy;
458: values.plane_mask = ~0;
459: values.fill_style = FillSolid;
460: values.fill_rule = EvenOddRule;
461: values.subwindow_mode = IncludeInferiors;
462: valuemask = GCForeground | GCFunction | GCPlaneMask | GCFillStyle
463: | GCFillRule | GCSubwindowMode;
464: vpw->v_pane.normgc = XtGetGC(vpw->core.display, vpw->core.window, valuemask,
465: &values);
466: values.foreground = vpw->core.background_pixel;
467: vpw->v_pane.invgc = XtGetGC(vpw->core.display, vpw->core.window, valuemask,
468: &values);
469: values.function = GXinvert;
470: #if BORDERWIDTH == 1
471: values.line_width = 0; /* Take advantage of fast server lines. */
472: #else
473: values.line_width = BORDERWIDTH;
474: #endif
475: values.line_style = LineSolid;
476: valuemask |= GCLineWidth | GCLineStyle;
477: vpw->v_pane.flipgc = XtGetGC(vpw->core.display, vpw->core.window, valuemask,
478: &values);
479: vpw->v_pane.heightused = 0;
480: vpw->v_pane.sublist = NULL;
481: vpw->v_pane.whichtracking = -1;
482: vpw->v_pane.refiguremode = TRUE;
483: }
484:
485:
486: static void Realize(w, valueMask, attributes)
487: register Widget w;
488: Mask valueMask;
489: XSetWindowAttributes *attributes;
490:
491: {
492:
493: attributes->bit_gravity = NorthWestGravity;
494: valueMask |= CWBitGravity;
495:
496: w->core.window =
497: XCreateWindow(w->core.display, w->core.parent, w->core.x, w->core.y,
498: w->core.width, w->core.height, w_core.border_width,
499: 0, InputOutput, (Visual *)CopyFromParent, valueMask,
500: attributes);
501: } /* Realize */
502:
503: static void Destroy(vpw)
504: register VPaneWidget vpw;
505: {
506:
507: XtFree((char *) vpw->v_pane.sublist);
508:
509: } /* Destroy */
510:
511:
512: static void InsertChild(w, args, argcount)
513: register Widget w;
514: ArgList args;
515: int argcount;
516: {
517:
518: static Arg knobargs[] = {
519: {XtNwidth, (XtArgVal) 0},
520: {XtNheight, (XtArgVal) 0},
521: {XtNbackground, (XtArgVal) "Black"}
522: };
523:
524: Cardinal position;
525: VPaneWidgetClass myclass;
526: ConstraintWidgetClass superclass;
527: ConstraintWidget cw;
528: SubWidgetPtr sub;
529: int i;
530:
531: myclass = (VPaneWidgetClass) vPaneWidgetClass;
532: superclass = (ConstraintWidgetClass) myclass->core_class.superclass;
533:
534: /* insert the child widget in the composite children list with the */
535: /* superclass insert_child routine. */
536: superclass->composite_class.insert_child(w, args, argcount);
537:
538: if (!XtIsSubclass(w, KnobWidgetClass)) {
539: cw = w->core.parent;
540:
541: /* ||| Panes will be added in the order they are created, temporarilly */
542: /* they are also managed at creation time. */
543:
544: /* will normally get the position from the insert position routine */
545: position = cw->composite_widget.num_children / 2;
546: cw->v_pane.sublist =
547: (SubWidgetPtr) XtRealloc((caddr_t) cw->v_pane.sublist,
548: ((cw->composite_widget.num_children/2 + 1) * sizeof(SubWidgetInfo)));
549:
550: /* shift up pane info then position new pane info */
551: for (i = cw->composite_widget.num_children/2; i > position; i++)
552: cw->v_pane.sublist[i] = cw->v_pane.sublist[i - 1];
553:
554: /* set the desired height of the pane */
555: cw->v_pane.sublist[position].dheight = w->core.height;
556:
557: /* Get the subresources for this child widget */
558: sub = &(cw->v_pane.sublist[position]);
559: XtGetSubResources(cw, sub, w->core.name,
560: w->core.widget_class->core_class.class_name,
561: subresources, XtNumber(subresources), args, argcount);
562:
563: /* Create the Knob Widget */
564: knobargs[0].value = (XtArgVal) cw->v_pane.knob_width;
565: knobargs[1].value = (XtArgVal) cw->v_pane.knob_height;
566: knobargs[2].value = (XtArgVal) cw->v_pane.knob_pixel;
567: sub->knob = XtCreateWidget("Knob", KnobWidgetClass, (CompositeWidget) cw,
568: knobargs, XtNumber(knobargs));
569: /*
570: XtSetEventHandler(sub->knob,
571: ButtonPressMask | ButtonReleaseMask | ButtonMotionMask, FALSE, HandleKnob,
572: (caddr_t) NULL);
573: */
574:
575: XDefineCursor(XtDisplay(sub->knob), sub->knob,
576: XtGetCursor(XtDisplay(sub->knob), XC_double_arrow));
577:
578: }
579:
580: } /* InsertChild */
581:
582: static void DeleteChild(w)
583: Widget w;
584: {
585:
586: Cardinal position;
587: VPaneWidgetClass myclass;
588: ConstraintWidgetClass superclass;
589: ConstraintWidget cw;
590: SubWidgetPtr sub;
591:
592: /* remove the subwidget info and destroy the knob */
593: if (!XtIsSubClass(w, KnobWidgetClass)) {
594: cw = w->core.parent;
595:
596: /* find out the postion of the widget */
597: for (position = 0; position < cw->composite.num_children; position++) {
598: if (cw->composite.children[position] == w)
599: break;
600: }
601: position = position/2;
602:
603: /* Destroy the knob */
604: XtDestroyWidget(cw->v_pane.sublist[position].knob);
605:
606: /* Ripple the subwidget info down, over the deleted pane */
607: for (i = position; i < cw->composite.num_children/2; i++)
608: cw->v_pane.sublist[i] = cw->v_pane.sublist[i + 1];
609:
610: }
611:
612: myclass = (VPaneWidgetClass) vPaneWidgetClass;
613: superclass = (ConstraintWidgetClass) myclass->core_class.superclass;
614:
615: /* delete the child widget in the composite children list with the */
616: /* superclass delete_child routine. */
617: superclass->composite_class.delete_child(w);
618:
619: } /* DeleteChild */
620:
621: static void ChangeManaged(vpw)
622: VPaneWidget vpw;
623: {
624:
625: /* see if the height of the VPane needs to be adjusted to fit all the panes */
626: if (NeedsAdjusting(vpw))
627: AdjustVPaneHeight(vpw);
628: RefigureLocationsAndCommit(vpw, 0, 1);
629:
630: } /* ChangeManaged */
631:
632: static void Resize(vpw)
633: VPaneWidget vpw;
634: {
635:
636: RefigureLocationsAndCommit(vpw, 0, 1);
637:
638: } /* Resize */
639:
640: static void SetValues(oldvpw, newvpw)
641: VPaneWidget oldvpw, newvpw;
642: {
643: } /* SetValues */
644:
645:
646: /* Change the min and max size of the given sub window. */
647:
648: void XtVPanedSetMinMax(vpw, paneWidget, min, max)
649: VPaneWidget vpw;
650: Widget paneWidget;
651: int min, max;
652: {
653:
654: int i;
655:
656: for (i = 0; i < vpw->composite.num_children; i + 2) {
657: if (vpw->composite.children[i] == paneWidget) {
658: vpw->v_pane.sublist[i / 2].min = min;
659: vpw->v_pane.sublist[i / 2].max = max;
660: RefigureLocationsAndCommit(vpw, i/2, 1);
661: return;
662: }
663: }
664: }
665:
666:
667: /* Get the min and max size of the given sub window. */
668:
669: void XtVPanedGetMinMax(vpw, paneWidget, min, max)
670: VPaneWidget vpw;
671: Widget paneWindow;
672: int *min, *max;
673: {
674:
675: int i;
676:
677: for (i = 0; i < vpw->composite.num_children; i + 2) {
678: if (vpw->composite.children[i] == paneWidget) {
679: *min = vpw->v_pane.sublist[i / 2].min;
680: *max = vpw->v_pane.sublist[i / 2].max;
681: return;
682: }
683: }
684: }
685:
686: int XtVPanedGetNumSub(vpw)
687: VPaneWidget vpw;
688: {
689:
690: int i, num_sub_widgets;
691:
692: num_sub_widgets = 0;
693:
694: for (i = 0; i < vpw->composite.num_children; i + 2) {
695: if (vpw->composite.children[i]->core.managed)
696: num_sub_widgets++;
697: }
698:
699: return(num_sub_widgets);
700: }
701:
702:
703:
704:
705: void XtVPanedRefigureMode(vpw, mode)
706: VPaneWidget vpw;
707: Boolean mode;
708: {
709: vpw->v_pane.refiguremode = mode;
710: if (mode)
711: RefigureLocationsAndCommit(vpw, vpw->composite.num_children/2 - 1, -1);
712: }
713: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.