![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ScrollMgr.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 / oldXtk|
Return to ScrollMgr.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk |
1.1 root 1: /* $Header: ScrollMgr.c,v 1.1 87/09/11 07:59:35 toddb Exp $ */
2: #ifndef lint
3: static char *sccsid = "@(#)ScrollBarMgr.c 1.4 2/25/87";
4: #endif lint
5: /*
6: * COPYRIGHT 1987
7: * DIGITAL EQUIPMENT CORPORATION
8: * MAYNARD, MASSACHUSETTS
9: * ALL RIGHTS RESERVED.
10: *
11: * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
12: * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
13: * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR
14: * ANY PURPOSE. IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
15: *
16: * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT RIGHTS,
17: * APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN ADDITION TO THAT
18: * SET FORTH ABOVE.
19: *
20: *
21: * Permission to use, copy, modify, and distribute this software and its
22: * documentation for any purpose and without fee is hereby granted, provided
23: * that the above copyright notice appear in all copies and that both that
24: * copyright notice and this permission notice appear in supporting
25: * documentation, and that the name of Digital Equipment Corporation not be used
26: * in advertising or publicity pertaining to distribution of the software
27: * without specific, written prior permission.
28: */
29:
30:
31: /* ScrollBarMgr.c */
32: /* created by weissman: 24 Jul 86 16:26 */
33:
34: #include "Xlib.h"
35: #include "Intrinsic.h"
36: #include "Scroll.h"
37: #include "Atoms.h"
38:
39: /* Private definitions. */
40:
41: #define MAXBARS 4 /* How many scrollbars there can be, tops. */
42: #define DEFAULTTHICKNESS 15 /* Default thickness of scrollbars. */
43:
44: typedef struct {
45: Display *dpy; /* the scrollbar window display */
46: Window sbar; /* The scrollbar window itself. */
47: XtOrientation orientation; /* Orientation of the scrollbar. */
48: Boolean lowerRight; /* Should this one go on the bottom or right */
49: Position x, y; /* Location of this scroll bar. */
50: Dimension width, height; /* Size of this scroll bar. */
51: } ScrollBarData, *ScrollBarDataPtr;
52:
53: typedef struct {
54: Display *dpy; /* display connection for all this */
55: Window outer; /* All encompassing window. */
56: Window frame; /* Window that actually contains the data. */
57: Position x, y; /* Location of outer window. */
58: Dimension pwidth, pheight; /* Size of outer window. */
59: Dimension cwidth, cheight; /* Size of frame. */
60: Position cx, cy; /* Location of frame inside outer window. */
61: Pixel border; /* Pixmap for borders. */
62: Dimension borderWidth; /* Size of the borders. */
63: int thickness; /* Thickness of scroll bars. */
64: int numbars; /* How many scrollbars we have. */
65: ScrollBarData bar[MAXBARS]; /* Data on each scrollbar. */
66: } WidgetDataRec, *WidgetData;
67:
68: static WidgetDataRec globaldata;
69: static WidgetDataRec globalinit = {
70: NULL, /* display connection */
71: NULL, /* All encompassing window. */
72: NULL, /* Window that actually contains the data. */
73: 200,200, /* Location of outer window. */
74: 100,100, /* Size of outer window. */
75: 50,50, /* Size of frame. */
76: -99, -99, /* Location of frame. */
77: 0, /* Pixel for borders. */
78: 1, /* Size of the borders. */
79: DEFAULTTHICKNESS, /* Thickness of scroll bars. */
80: 0, /* How many scrollbars we have. */
81: {(Display *) NULL, (Window)NULL, XtorientVertical, (Boolean)0, 0,0, 0,0}
82:
83: };
84: static Resource resources[] = {
85: {XtNwindow, XtCWindow, XrmRWindow, sizeof(Window),
86: (caddr_t)&globaldata.outer, NULL},
87: {XtNchildWindow, XtCWindow, XrmRWindow, sizeof(Window),
88: (caddr_t)&globaldata.frame, NULL},
89: {XtNborderWidth, XtCBorderWidth, XrmRInt, sizeof(int),
90: (caddr_t)&globaldata.borderWidth, NULL},
91: {XtNborder, XtCColor, XrmRPixel, sizeof(int),
92: (caddr_t)&globaldata.border, (caddr_t)NULL},
93: {XtNthickness, XtCThickness, XrmRInt, sizeof(int),
94: (caddr_t)&globaldata.thickness, NULL},
95: {XtNwidth, XtCWidth, XrmRInt, sizeof(int),
96: (caddr_t)&globaldata.pwidth, NULL},
97: {XtNheight, XtCHeight, XrmRInt, sizeof(int),
98: (caddr_t)&globaldata.pheight, NULL},
99: {XtNx, XtCX, XrmRInt, sizeof(int),
100: (caddr_t)&globaldata.x, NULL},
101: {XtNy, XtCY, XrmRInt, sizeof(int),
102: (caddr_t)&globaldata.y, NULL},
103: };
104:
105:
106: static Boolean lowerRight;
107: static XtOrientation orientation;
108:
109: static Resource addResources[] = {
110: {XtNlowerRight, XtCBoolean, XrmRBoolean, sizeof(Boolean),
111: (caddr_t)&lowerRight, NULL},
112: {XtNorientation, XtCOrientation, XtROrientation, sizeof(XtOrientation),
113: (caddr_t)&orientation, NULL},
114: };
115:
116: static XContext scrollBarMgrContext;
117:
118: static Boolean initialized = FALSE;
119:
120: static void ScrollBarMgrInitialize ()
121: {
122: if (initialized)
123: return;
124: initialized = TRUE;
125:
126: scrollBarMgrContext = XUniqueContext ();
127: }
128:
129:
130: static WidgetData GetSBMgrInfoFromWindow(dpy, w)
131: Display *dpy;
132: Window w;
133: {
134: WidgetData data;
135: if (!XFindContext(dpy, w, scrollBarMgrContext, (caddr_t *) &data))
136: return data;
137: return 0;
138: }
139:
140:
141:
142: static ResizeEverything(data)
143: WidgetData data;
144: {
145: int top = 0,
146: bottom = 0,
147: left = 0,
148: right = 0;
149: Dimension thickness = data->thickness;
150: Position borderWidth = data->borderWidth;
151: Dimension pwidth = data->pwidth;
152: Dimension pheight = data->pheight;
153: Position x, y;
154: Dimension cwidth, cheight, width, height;
155: ScrollBarDataPtr bar;
156: for (bar = data->bar;
157: bar - data->bar < data->numbars;
158: bar++) {
159: if (bar->orientation == XtorientVertical) {
160: if (bar->lowerRight)
161: right = thickness;
162: else
163: left = thickness;
164: }
165: else {
166: if (bar->lowerRight)
167: bottom = thickness;
168: else
169: top = thickness;
170: }
171: }
172: cwidth = pwidth - left - right;
173: cheight = pheight - top - bottom;
174: if (cwidth < 1 || cheight < 1)
175: return; /* Everything is too small still. */
176: if (left != data->cx || top != data->cy ||
177: cwidth != data->cwidth || cheight != data->cheight) {
178: WindowBox box;
179: XMoveResizeWindow(data->dpy,data->frame,
180: box.x = data->cx = left,
181: box.y = data->cy = top,
182: box.width = data->cwidth = cwidth,
183: box.height = data->cheight = cheight);
184: (void) XtSendConfigureNotify(data->dpy, data->frame, &box);
185: }
186: for (bar = data->bar;
187: bar - data->bar < data->numbars;
188: bar++) {
189: if (bar->orientation == XtorientVertical) {
190: x = bar->lowerRight ? pwidth - thickness : -borderWidth;
191: y = top - borderWidth;
192: width = thickness - borderWidth;
193: height = pheight - top - bottom;
194: }
195: else {
196: x = left - borderWidth;
197: y = bar->lowerRight ? pheight - thickness : -borderWidth;
198: width = pwidth - left - right;
199: height = thickness - borderWidth;
200: }
201: if (width != bar->width || height != bar->height ||
202: x != bar->x || y != bar->y) {
203: WindowBox box;
204: XMoveResizeWindow(data->dpy, bar->sbar,
205: box.x = bar->x = x,
206: box.y = bar->y = y,
207: box.width = bar->width = width,
208: box.height = bar->height = height);
209: (void) XtSendConfigureNotify(data->dpy, bar->sbar, &box);
210: }
211: }
212: }
213:
214:
215:
216:
217: static XtEventReturnCode HandleEvents(event)
218: XEvent *event;
219: {
220: WidgetData data;
221: int i;
222:
223: data = GetSBMgrInfoFromWindow(event->xany.display, event->xany.window);
224: if (!data) return XteventNotHandled;
225:
226: switch(event->type){
227: case ConfigureNotify:
228: if (data->pwidth != event->xconfigure.width
229: || data->pheight != event->xconfigure.height) {
230: data->pwidth = event->xconfigure.width;
231: data->pheight = event->xconfigure.height;
232: ResizeEverything(data);
233: }
234: return XteventHandled;
235:
236: case DestroyNotify:
237: XtClearEventHandlers(data->dpy, data->outer);
238: for (i=0; i<MAXBARS; i++) {
239: if (data->bar[i].sbar != NULL)
240: (void) XtSendDestroyNotify(data->dpy,data->bar[i].sbar);
241: }
242: (void) XDeleteContext(data->dpy, data->outer,scrollBarMgrContext);
243: (void) XDeleteContext(data->dpy, data->frame,scrollBarMgrContext);
244: (void) XtSendDestroyNotify(data->dpy, data->frame);
245: XtClearEventHandlers(data->dpy, data->frame);
246: XtFree((char *)data);
247: return XteventHandled;
248: }
249:
250: return XteventNotHandled;
251: }
252:
253: static XtGeometryReturnCode
254: ScrollBarGeometryRequest(dpy, myWindow, request, requestBox, replyBox)
255: Display *dpy;
256: Window myWindow;
257: XtGeometryRequest request;
258: WindowBox *requestBox, *replyBox;
259: {
260: WidgetData data;
261: WindowBox myRequest, myReply;
262: XtGeometryReturnCode result;
263: data = GetSBMgrInfoFromWindow(dpy, myWindow);
264: if (!data || request != XtgeometryResize)
265: return XtgeometryNo;
266: myRequest.x = myRequest.y = 0;
267: myRequest.width = requestBox->width + data->pwidth - data->cwidth;
268: myRequest.height = requestBox->height + data->pheight - data->cheight;
269: result = XtMakeGeometryRequest(dpy, data->outer, request, &myRequest, &myReply);
270: if (result != XtgeometryNo) {
271: replyBox->width = myReply.width + data->cwidth - data->pwidth;
272: replyBox->width = myReply.height + data->cheight - data->pheight;
273: }
274: return result;
275: }
276:
277:
278:
279: /* Public routines. */
280:
281: /* Register this window as one that might require scrollbars within it.
282: Returns the window created within that will actually be used to store
283: the data. */
284:
285: /*
286: * Creates a new master window which will in turn contain a window that
287: * will be layed out some number of scrollbars. Returns the master window.
288: */
289:
290: Window XtScrollMgrCreate(dpy, parent, args, argCount)
291: Display *dpy;
292: Window parent;
293: ArgList args;
294: int argCount;
295: {
296: WidgetData data;
297: XrmNameList names;
298: XrmClassList classes;
299:
300: if (!initialized) ScrollBarMgrInitialize ();
301:
302: data = (WidgetData) XtMalloc(sizeof(WidgetDataRec));
303: globaldata = globalinit;
304: globaldata.dpy = dpy;
305: XtGetResources(dpy, resources, XtNumber(resources), args, argCount, parent,
306: "scrollBarMgr", "ScrollBarMgr", &names, &classes);
307: *data = globaldata;
308: if (data->outer != NULL) {
309: XWindowChanges wc;
310: unsigned int valuemask;
311: valuemask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
312: wc.x = data->x; wc.y = data->y; wc.width = data->pwidth;
313: wc.height = data->pheight; wc.border_width = data->borderWidth;
314: XConfigureWindow(data->dpy,data->outer,valuemask, &wc);
315: XReparentWindow(data->dpy,data->outer,parent,data->x,data->y);
316:
317: } else {
318: data->outer = XtCreateWindow(data->dpy, parent, data->x, data->y,
319: data->pwidth, data->pheight,
320: data->borderWidth,
321: data->border, (Pixel)NULL,
322: NorthWestGravity);
323: }
324: XtSetNameAndClass(data->dpy, data->outer, names, classes);
325: XrmFreeNameList(names);
326: XrmFreeClassList(classes);
327:
328: if (data->frame == NULL)
329: data->frame = XtCreateWindow(data->dpy, data->outer, 0, 0,
330: data->pwidth, data->pheight, 0,
331: (Pixel) 0, (Pixel) 1,
332: NorthWestGravity);
333: XMapWindow(data->dpy, data->frame);
334: (void) XSaveContext(data->dpy, data->outer, scrollBarMgrContext, (caddr_t) data);
335: (void) XSaveContext(data->dpy, data->frame, scrollBarMgrContext, (caddr_t) data);
336: data->numbars = 0;
337: (void) XtSetGeometryHandler(data->dpy, data->frame, (XtGeometryHandler) ScrollBarGeometryRequest);
338: (void) XtSetEventHandler(data->dpy, data->outer, (XtEventHandler) HandleEvents,
339: StructureNotifyMask, (caddr_t) NULL);
340: return data->outer;
341: }
342:
343:
344: Window XtScrollMgrGetChild(dpy, parent)
345: Display *dpy;
346: Window parent;
347: {
348: WidgetData data;
349: data = GetSBMgrInfoFromWindow(dpy, parent);
350: if (data) return data->frame;
351: else return NULL;
352: }
353:
354:
355: Window XtScrollMgrSetChild(dpy, parent, frame)
356: Display *dpy;
357: Window parent, frame;
358: {
359: WidgetData data;
360: data = GetSBMgrInfoFromWindow(dpy, parent);
361: if (data) {
362: XUnmapWindow(data->dpy,data->frame);
363: (void) XDeleteContext(data->dpy, data->frame, scrollBarMgrContext);
364: data->frame = frame;
365: (void) XSaveContext(data->dpy, data->frame, scrollBarMgrContext, (caddr_t) data);
366: (void) XtSetGeometryHandler(data->dpy, data->frame, ScrollBarGeometryRequest);
367: ResizeEverything(data);
368: XMapWindow(data->dpy,data->frame);
369: }
370: }
371:
372:
373: /* Stop this window from being managed as scrollbars. All windows are
374: destroyed, except for the outer one. */
375:
376: int XtScrollMgrDestroy(dpy, w)
377: Display *dpy;
378: Window w;
379: {
380: WidgetData data;
381: int i;
382: data = GetSBMgrInfoFromWindow(dpy, w);
383: if (!data) return;
384: for (i=data->numbars - 1 ; i>=0 ; i--)
385: XtDeleteScrollBar(dpy, w, data->bar[i].sbar);
386: (void) XDeleteContext(dpy, w, scrollBarMgrContext);
387: XDestroyWindow(data->dpy,data->frame);
388: XtFree((char *) data);
389: }
390:
391:
392:
393: /* Set the thickness to be used to draw scroll bars in the given window. Any
394: already existing scrollbars will be resized to match this. */
395:
396: XtScrollMgrSetThickness(dpy, w, thickness)
397: Display *dpy;
398: Window w;
399: int thickness;
400: {
401: WidgetData data;
402: data = GetSBMgrInfoFromWindow(dpy,w);
403: if (data->thickness != thickness) {
404: data->thickness = thickness;
405: ResizeEverything(data);
406: }
407: }
408:
409:
410: /* Find out the thickness of the scrollbars in the given window. */
411:
412: int XtScrollMgrGetThickness(dpy, w)
413: Display *dpy;
414: Window w;
415: {
416: WidgetData data;
417: data = GetSBMgrInfoFromWindow(dpy, w);
418: return data->thickness;
419: }
420:
421:
422: /* Add a scroll bar. */
423:
424: Window XtScrollMgrAddBar(dpy, parent, args, argCount)
425: Display *dpy;
426: Window parent;
427: ArgList args;
428: int argCount;
429: {
430: WidgetData data;
431: int i;
432: XrmNameList names;
433: XrmClassList classes;
434:
435: data = GetSBMgrInfoFromWindow(dpy, parent);
436: if (data->numbars < MAXBARS) {
437: orientation = XtorientVertical;
438: lowerRight = FALSE;
439: XtGetResources(data->dpy, addResources, XtNumber(addResources), args, argCount,
440: parent, "scrollBarMgr", "ScrollBarMgr", &names, &classes);
441: XrmFreeNameList(names);
442: XrmFreeClassList(classes);
443:
444: i = (data->numbars)++;
445: data->bar[i].sbar = XtScrollBarCreate(data->dpy, data->outer, args, argCount);
446: data->bar[i].orientation = orientation;
447: data->bar[i].lowerRight = lowerRight;
448: data->bar[i].width = 1;
449: data->bar[i].height = 1;
450: ResizeEverything(data);
451: XMapWindow(data->dpy,data->bar[i].sbar);
452: return data->bar[i].sbar;
453: }
454: else return 0;
455: }
456:
457:
458:
459: /* Delete a scroll bar. */
460:
461: XtDeleteScrollBar(dpy, parent, scrollbar)
462: Display *dpy;
463: Window parent, scrollbar;
464: {
465: WidgetData data;
466: int i;
467: data = GetSBMgrInfoFromWindow(dpy, parent);
468: for (i = 0; i < data->numbars; i++) {
469: if (data->bar[i].sbar == scrollbar) {
470: data->bar[i] = data->bar[--(data->numbars)];
471: XDestroyWindow(dpy, scrollbar);
472: XtSendDestroyNotify(dpy, scrollbar);
473: ResizeEverything(data);
474: break;
475: }
476: }
477: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.