![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Scroll.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 Scroll.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)ScrollBar.c 1.8 2/25/87";
3: #endif lint
4: /*
5: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
6: *
7: * All Rights Reserved
8: *
9: * Permission to use, copy, modify, and distribute this software and its
10: * documentation for any purpose and without fee is hereby granted,
11: * provided that the above copyright notice appear in all copies and that
12: * both that copyright notice and this permission notice appear in
13: * supporting documentation, and that the name of Digital Equipment
14: * Corporation not be used in advertising or publicity pertaining to
15: * distribution of the software without specific, written prior permission.
16: *
17: *
18: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
19: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
20: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
21: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
23: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
24: * SOFTWARE.
25: */
26:
27:
28: /* ScrollBar.c */
29: /* created by weissman, Mon Jul 7 13:20:03 1986 */
30:
31: #include "X.h"
32: #include "Xlib.h"
33: #include "Intrinsic.h"
34: #include "Scroll.h"
35: #include "Atoms.h"
36: #include "cursorfont.h"
37:
38: /* Private definitions. */
39:
40: typedef void (*NotifyProc)();
41:
42: typedef struct _WidgetDataRec
43: {
44: Display *dpy; /* Display connection */
45: Window scrollbarWindow;/* Window containing the scrollbar */
46: XtOrientation orientation; /* Horizontal or vertical? */
47: int *value; /* client data to pass in call-back procs */
48: Position x, y; /* Location of the scroll bar */
49: Dimension width, height, borderwidth;
50: /* Dimensions of the scroll bar */
51: NotifyProc ScrollProc; /* Call to scroll content */
52: NotifyProc ThumbProc; /* Call if user thumbs scrollbar */
53: float top; /* What percent is above the win's top */
54: float shown; /* What percent is shown in the win */
55: int topLoc; /* Pixel that corresponds to top */
56: int shownLength; /* Num pixels corresponding to shown */
57: int foreground; /* thumb color */
58: Pixmap customthumb; /* thumb pixmap */
59: Pixel background; /* window background color. */
60: Pixel border; /* What to use for painting the border. */
61: XtEventsPtr eventTable; /* Table for Translation Manager */
62: caddr_t state; /* state for Translation Manager */
63: int eventlevels; /* recursion levels of event handling */
64: Cursor NormalCursor; /* The normal cursor for scrollbar window */
65: Cursor ButtonCursors[4];/* The cursors to use with each button */
66: short curbutton; /* Which button is currently held down. */
67: GC gc; /*this will go away if thumb becomes a window*/
68: } WidgetDataRec, *WidgetData;
69:
70: static int dummyvalue;
71: extern void Dummy ();
72: static WidgetDataRec globaldata;
73: static WidgetDataRec globalinit = {
74: NULL, /* Display dpy; */
75: NULL, /* scrollBar window */
76: XtorientVertical,/*orientation */
77: &dummyvalue, /* client data */
78: 0,0, /* x,y */
79: 10,20, /* width,height */
80: 1, /* borderwidth */
81: Dummy, /* void (*proc)(); */
82: Dummy, /* void (*proc)(); */
83: 0.0, /* fraction above top */
84: 0.0, /* shown fraction */
85: NULL, /* top percent pixel */
86: NULL, /* shown length */
87: NULL, /* foreground */
88: NULL, /* customthumb */
89: 0, /* background pixel*/
90: 0, /* border pixel */
91: NULL, /* table for TM */
92: NULL, /* state for TM */
93: NULL, /* eventlevels */
94: NULL, /* normal cursor */
95: {NULL,NULL,NULL,NULL}, /*ButtonCursors */
96: NULL, /*curbotton */
97: NULL /*gc*/
98: };
99:
100:
101: static Resource resources[] = {
102: {XtNwindow, XtCWindow, XrmRWindow, sizeof(Window),
103: (caddr_t)&globaldata.scrollbarWindow, NULL},
104: {XtNorientation, XtCOrientation, XtROrientation, sizeof(XtOrientation),
105: (caddr_t)&globaldata.orientation, NULL},
106: {XtNvalue, XtCValue, XrmRPointer, sizeof(caddr_t),
107: (caddr_t)&globaldata.value,(caddr_t)NULL},
108: {XtNx, XtCX, XrmRInt,
109: sizeof(int),(caddr_t)&globaldata.x, (caddr_t)NULL },
110: {XtNy, XtCY, XrmRInt,
111: sizeof(int),(caddr_t)&globaldata.y, (caddr_t)NULL },
112: {XtNwidth, XtCWidth, XrmRInt, sizeof(int),
113: (caddr_t)&globaldata.width, NULL},
114: {XtNheight, XtCHeight, XrmRInt, sizeof(int),
115: (caddr_t)&globaldata.height, NULL},
116: {XtNborderWidth, XtCBorderWidth, XrmRInt, sizeof(int),
117: (caddr_t)&globaldata.borderwidth, NULL},
118: {XtNborder, XtCColor, XrmRPixel, sizeof(int),
119: (caddr_t)&globaldata.border, (caddr_t)&XtDefaultFGPixel},
120: {XtNscrollUpDownProc, XtCFunction, XtRFunction,
121: sizeof(globaldata.ScrollProc),
122: (caddr_t)&globaldata.ScrollProc, NULL},
123: {XtNthumbProc, XtCFunction, XtRFunction, sizeof(globaldata.ThumbProc),
124: (caddr_t)&globaldata.ThumbProc, NULL},
125: {XtNforeground, XtCColor, XrmRPixel, sizeof(int),
126: (caddr_t)&globaldata.foreground, (caddr_t)&XtDefaultFGPixel},
127: {XtNcustomthumb, XtCPixmap, XrmRPixmap, sizeof(Pixmap),
128: (caddr_t)&globaldata.customthumb,NULL},
129: {XtNbackground, XtCColor, XrmRPixel, sizeof(int),
130: (caddr_t)&globaldata.background, (caddr_t)&XtDefaultBGPixel},
131: {XtNtop, XtCFraction, XrmRFloat, sizeof(float),
132: (caddr_t)&globaldata.top, NULL},
133: {XtNshown, XtCFraction, XrmRFloat, sizeof(float),
134: (caddr_t)&globaldata.shown, NULL},
135: {XtNeventBindings,XtCEventBindings,XtREventBindings,
136: sizeof(caddr_t), (caddr_t)&globaldata.eventTable, NULL}
137: };
138:
139: static XContext widgetContext;
140:
141:
142:
143: #define MINBARHEIGHT 7 /* How many pixels of scrollbar to always show */
144: #define NoButton -1
145: #define PICKLENGTH(data,x,y) \
146: ((data->orientation == XtorientHorizontal) ? x : y)
147: #define PICKTHICKNESS(data,x,y) \
148: ((data->orientation == XtorientHorizontal) ? y : x)
149: #define MIN(x,y) ((x) < (y) ? (x) : (y))
150: #define MAX(x,y) ((x) > (y) ? (x) : (y))
151:
152:
153: /* Orientation enumeration constants */
154:
155: static XrmQuark XtQEhorizontal;
156: static XrmQuark XtQEvertical;
157:
158: /*ARGSUSED*/
159: #define done(address, type) \
160: { (*toVal).size = sizeof(type); (*toVal).addr = (caddr_t) address; }
161:
162: extern void _XLowerCase();
163:
164: static void CvtStringToOrientation(fromVal, toVal)
165: XrmValue fromVal;
166: XrmValue *toVal;
167: {
168: static XtOrientation orient;
169: XrmQuark q;
170: char lowerName[1000];
171:
172: /* ||| where to put LowerCase */
173: _XLowerCase((char *) fromVal.addr, lowerName);
174: q = XrmAtomToQuark(lowerName);
175: if (q == XtQEhorizontal) {
176: orient = XtorientHorizontal;
177: done(&orient, XtOrientation);
178: return;
179: }
180: if (q == XtQEvertical) {
181: orient = XtorientVertical;
182: done(&orient, XtOrientation);
183: return;
184: }
185: };
186:
187:
188: static char *defaultEventBindings[] = {
189: "<ButtonPress>left: startup\n",
190: "<ButtonPress>middle: startscroll\n",
191: "<ButtonPress>right: startdown\n",
192: "<ButtonRelease>left: doup\n",
193: "<ButtonRelease>middle: doscroll\n",
194: "<ButtonRelease>right: dodown\n",
195: "<MotionNotify>middle: movebar\n", /*bug in TM forces button spec here */
196: NULL
197: };
198:
199: static void Ignore()
200: {
201: (void)printf("you are being ignored\n");
202: }
203:
204: static Boolean initialized = FALSE;
205: static void ScrollBarInitialize ()
206: {
207: widgetContext = XUniqueContext();
208: globalinit.eventTable = XtParseEventBindings(defaultEventBindings);
209: XtQEhorizontal = XrmAtomToQuark(XtEhorizontal);
210: XtQEvertical = XrmAtomToQuark(XtEvertical);
211: XrmRegisterTypeConverter(XrmRString, XtROrientation, CvtStringToOrientation);
212: initialized = TRUE;
213: }
214:
215: /*
216: * Given a display and window, get the widget data.
217: */
218:
219: static WidgetData DataFromWindow(dpy, window)
220: Display *dpy;
221: Window window;
222: {
223: WidgetData result;
224: if (XFindContext(dpy, window, widgetContext, (caddr_t *)&result))
225: return NULL;
226: return result;
227: }
228:
229: /* ARGSUSED */
230: static void Dummy(p) /* default call back proc */
231: caddr_t p;
232: {
233: (void) printf("dummy call back for ScrollBar\n");
234: }
235:
236: /*
237: * Make sure the first number is within the range specified by the other
238: * two numbers.
239: */
240:
241: static int InRange(num, small, big)
242: int num, small, big;
243: {
244: return (num < small) ? small : ((num > big) ? big : num);
245: }
246:
247: /*
248: * Same as above, but for floating numbers.
249: */
250:
251: static float FloatInRange(num, small, big)
252: float num, small, big;
253: {
254: return (num < small) ? small : ((num > big) ? big : num);
255: }
256:
257: /* Given the scrollbar window, return the SbarInfo record for it. */
258: static WidgetData SbarInfoFromSbarWindow(dpy, window)
259: Display *dpy;
260: Window window; /* Scrollbar window */
261: {
262: WidgetData result;
263: if (XFindContext(dpy, window, widgetContext, (caddr_t *)&result))
264: return NULL;
265: return result;
266: }
267:
268:
269:
270:
271: /* Given a WidgetData record and a point in the scrollbarWindow, determine */
272: /* what percentage that point indicates. */
273:
274:
275:
276:
277:
278: /* Fill the area specified by top and bottom with the given pattern. */
279: float FractionLoc(data,x,y)
280: WidgetData data;
281: int x,y;
282: {
283: float result;
284: result = PICKLENGTH(data, (float) x/data->width, (float) y/data->height);
285: return FloatInRange(result, 0.0, 1.0);
286: }
287:
288:
289: static FillArea(data, top, bottom, thumb)
290: WidgetData data;
291: Position top, bottom;
292: int thumb;
293: {
294: Dimension length = bottom-top;
295: switch(thumb) {
296: /* Fill the new Thumb location */
297: case 1:
298: if (data->orientation == XtorientHorizontal)
299: XFillRectangle(data->dpy, data->scrollbarWindow, data->gc,
300: top, 1, length, data->height-2);
301:
302: else XFillRectangle(data->dpy, data->scrollbarWindow, data->gc,
303: 1, top, data->width-2, length);
304:
305: break;
306: /* Clear the old Thumb location */
307: case 0:
308: if (data->orientation == XtorientHorizontal)
309: XClearArea(data->dpy, data->scrollbarWindow, top, 1,
310: length, data->height-2, FALSE);
311:
312: else XClearArea(data->dpy, data->scrollbarWindow, 1, top,
313: data->width-2, length, FALSE);
314:
315: }
316: }
317:
318:
319: /* Paint the thumb in the area specified by data->top and
320: data->shown. The old area is erased. The painting and
321: erasing is done cleverly so that no flickering will occur. */
322:
323: static PaintThumb(data)
324: WidgetData data;
325: {
326: int length, oldtop, oldbot, newtop, newbot;
327: length = PICKLENGTH(data, data->width, data->height);
328: oldtop = data->topLoc;
329: oldbot = oldtop + data->shownLength;
330: newtop = length * data->top;
331: newbot = newtop + length * (data->shown);
332: if (newbot < newtop + MINBARHEIGHT) newbot = newtop + MINBARHEIGHT;
333: if (newtop < oldtop)
334: FillArea(data, newtop, MIN(newbot, oldtop),1);
335: if (newtop > oldtop)
336: FillArea(data, oldtop, MIN(newtop, oldbot), 0);
337: if (newbot < oldbot)
338: FillArea(data, MAX(newbot, oldtop), oldbot,0);
339: if (newbot > oldbot)
340: FillArea(data, MAX(newtop, oldbot), newbot, 1);
341: data->topLoc = newtop;
342: data->shownLength = newbot - newtop;
343: }
344:
345:
346: /* Move the thumb to the value corresponding to the given point. */
347:
348: static MoveThumb(data,x,y)
349: WidgetData data;
350: int x,y;
351: {
352: data->top = FractionLoc(data, x, y);
353: PaintThumb(data);
354: }
355:
356:
357:
358:
359:
360: StartScroll(data,button)
361: WidgetData data;
362: unsigned int button;
363: {
364: if (data->curbutton != 0) return;
365: data->curbutton = button;
366:
367: XDefineCursor(data->dpy, data->scrollbarWindow,
368: data->ButtonCursors[data->curbutton]);
369: XFlush(data->dpy);
370:
371: }
372:
373:
374:
375: ScrollElevator(data,button,x,y)
376: WidgetData data;
377: Position x,y;
378: unsigned int button;
379: {
380: if (data->curbutton != 0) return;
381: data->curbutton = button;
382: XDefineCursor(data->dpy, data->scrollbarWindow,
383: data->ButtonCursors[data->curbutton]);
384: XFlush(data->dpy);
385:
386: MoveThumb(data,x,y);
387: }
388:
389:
390:
391: /* The user has thumbed to the location he wants; tell the other module where
392: the thumb now is. */
393:
394: static FinalThumbLoc(data,x,y)
395: WidgetData data;
396: Position x,y;
397: {
398: MoveThumb(data, x, y);
399: (*(data->ThumbProc)) (data->dpy, data->scrollbarWindow,
400: data->value,
401: data->top);
402: }
403:
404:
405: static NotifyScroll(data,x,y)
406: WidgetData data;
407: Position x,y;
408: {
409: if (data->curbutton == 0) return;
410: XDefineCursor(data->dpy,data->scrollbarWindow, data->NormalCursor);
411: XFlush(data->dpy);
412: (*(data->ScrollProc)) (data->dpy, data->scrollbarWindow,
413: data->value,
414: InRange(PICKLENGTH(data, x,y),
415: 0,
416: (int)PICKLENGTH(data, data->width, data->height)));
417: data->curbutton = AnyButton; /*means NoButton */
418:
419:
420: }
421:
422: static NotifyScroll1(data,x,y)
423: WidgetData data;
424: Position x,y;
425: {
426: if (data->curbutton == 0) return;
427: XDefineCursor(data->dpy,data->scrollbarWindow, data->NormalCursor);
428: XFlush(data->dpy);
429: (*(data->ScrollProc)) (data->dpy, data->scrollbarWindow,
430: data->value,
431: -InRange(PICKLENGTH(data, x,y),
432: 0,
433: (int)PICKLENGTH(data, data->width, data->height)));
434: data->curbutton = AnyButton; /*means NoButton */
435:
436:
437: }
438: static NotifyThumb(data,x,y)
439: WidgetData data;
440: Position x,y;
441: {
442: if (data->curbutton == 0) return;
443: XDefineCursor(data->dpy,data->scrollbarWindow, data->NormalCursor);
444: XFlush(data->dpy);
445:
446: FinalThumbLoc(data, x, y);
447: data->curbutton = AnyButton; /*means NoButton */
448:
449: }
450:
451:
452:
453:
454: static MoveElevator(data, x,y)
455: WidgetData data;
456: Position x,y;
457: {
458: if (data->curbutton == 0) return;
459: MoveThumb(data, x, y);
460: }
461:
462:
463:
464: /* Handle an event in a scrollBar window. */
465:
466: static XtEventReturnCode HandleScrollBarEvent(event, eventdata)
467: XEvent *event; /* The event itself. */
468: caddr_t eventdata;
469: {
470: WidgetData data = (WidgetData) eventdata;
471: XtActionTokenPtr actionList;
472: NotifyProc proc;
473:
474: data->eventlevels++;
475: switch (event->type) {
476: case Expose:
477: if (event->xexpose.count == 0){
478: data->topLoc = -1000; /* Forces entire thumb to be painted. */
479: PaintThumb(data);
480: }
481: return XteventHandled;
482: case DestroyNotify:
483: XtScrollBarDestroy(event->xany.display, event->xany.window);
484: return XteventHandled;
485: case ConfigureNotify:
486: data->width = event->xconfigure.width;
487: data->height = event->xconfigure.height;
488: FillArea(data, data->topLoc,
489: data->topLoc + data->shownLength, 0);
490:
491: data->topLoc = -1000; /* Forces entire thumb to be painted. */
492: PaintThumb(data);
493: return (XteventHandled);
494:
495: default:
496: actionList = (XtActionTokenPtr) XtTranslateEvent(
497: event, (TranslationPtr) data->state);
498: for (; actionList != NULL; actionList = actionList ->next) {
499: if (actionList ->type ==XttokenAction) {
500: proc = (NotifyProc)XtInterpretAction(data->dpy, (TranslationPtr) data->state, actionList->value.action);
501:
502: /* HACK until TM passes data */
503: if (proc == (NotifyProc)StartScroll) StartScroll(data,event->xbutton.button);
504: else if (proc == (NotifyProc)ScrollElevator) ScrollElevator(data,event->xbutton.button,event->xbutton.x,event->xbutton.y);
505: else if (proc == (NotifyProc)NotifyScroll) NotifyScroll(data, event->xbutton.x, event->xbutton.y);
506: else if (proc == (NotifyProc)NotifyThumb) NotifyThumb(data, event->xbutton.x,event->xbutton.y);
507: else if (proc == (NotifyProc)NotifyScroll1) NotifyScroll1(data,event->xbutton.x,event->xbutton.y);
508: else if (proc == (NotifyProc)MoveElevator) MoveElevator(data, event->xmotion.x, event->xmotion.y);
509:
510: /* (*proc) (data); */
511: }
512: }
513: break;
514:
515: }
516: data->eventlevels--;
517: return (XteventHandled);
518: }
519:
520:
521: /* Public routines. */
522:
523: /* Set the scroll bar to the given location. */
524:
525: void XtScrollBarSetThumb(dpy, scrollbarWindow,top,shown)
526: Display *dpy;
527: Window scrollbarWindow;
528: float top, shown;
529: {
530: WidgetData data;
531: data = SbarInfoFromSbarWindow(dpy, scrollbarWindow);
532: data->top = top;
533: data->shown = shown;
534: PaintThumb(data);
535: }
536:
537:
538: /* scroll bar already destroyed, remove its associated data. */
539: void XtScrollBarDestroy(dpy, scrollbarWindow)
540: Display *dpy;
541: Window scrollbarWindow;
542: {
543: XtFree((char *)SbarInfoFromSbarWindow(dpy, scrollbarWindow));
544: XtClearEventHandlers(dpy, scrollbarWindow);
545: (void) XDeleteContext(dpy, scrollbarWindow,widgetContext);
546: }
547:
548:
549:
550: /* Given a window definition, make it a scroll bar. */
551: Window XtScrollBarCreate(dpy, parent, args, argCount)
552: Display *dpy;
553: Window parent;
554: ArgList args;
555: int argCount;
556: {
557: WidgetData data; /* Record for info about this scrollBar */
558: XrmNameList names;
559: XrmClassList classes;
560: XGCValues values; /* goes away if thumb becomes a window */
561: unsigned long valuemask;
562: XImage image;
563:
564: static short pixmap_bits[] = {
565: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
566: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
567: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
568: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
569: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
570: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
571: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
572: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
573: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
574: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
575: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
576: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
577: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
578: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
579: 0xaaaa, 0xaaaa, 0x5555, 0x5555,
580: 0xaaaa, 0xaaaa, 0x5555, 0x5555
581: };
582:
583: #define default_width 32
584: #define default_height 32
585:
586: static XtActionsRec actionsTable[] = {
587: {"startup", (caddr_t)StartScroll},
588: {"startscroll", (caddr_t)ScrollElevator},
589: {"startdown", (caddr_t)StartScroll},
590: {"doup", (caddr_t)NotifyScroll},
591: {"doscroll", (caddr_t)NotifyThumb},
592: {"dodown", (caddr_t)NotifyScroll1},
593: {"movebar", (caddr_t)MoveElevator},
594: {NULL,NULL}
595: };
596:
597: if (!initialized) ScrollBarInitialize();
598:
599:
600: globaldata = globalinit;
601: globaldata.dpy = dpy;
602: XtGetResources(dpy,
603: resources, XtNumber(resources), args, argCount, parent,
604: "scrollBar","ScrollBar",&names, &classes);
605:
606: data = (WidgetData) XtMalloc(sizeof(WidgetDataRec));
607: *data = globaldata;
608:
609: data->state = XtSetActionBindings(data->dpy, data->eventTable, actionsTable, (caddr_t) Ignore);
610:
611: if (data->scrollbarWindow == NULL) {
612: if (data->width == 0) data->width = 1;
613: if (data->height == 0) data->height = 1;
614: data->scrollbarWindow = XCreateSimpleWindow(
615: data->dpy, parent, data->x, data->y,
616: data->width, data->height, 1,
617: data->border, data->background);
618: } else {
619: XWindowChanges wc;
620: unsigned int valuemask;
621: valuemask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
622: wc.x = data->x; wc.y = data->y; wc.width = data->width;
623: wc.height=data->height; wc.border_width = data->borderwidth;
624: XConfigureWindow(data->dpy,data->scrollbarWindow,valuemask,&wc);
625: XReparentWindow(data->dpy,data->scrollbarWindow,parent,data->x,data->y);
626: }
627:
628: if (data->orientation == XtorientHorizontal) {
629: if (data->NormalCursor == NULL)
630: data->NormalCursor = XtGetCursor(dpy, XC_sb_h_double_arrow);
631: if (data -> ButtonCursors[Button1] == NULL )
632: data->ButtonCursors[Button1] = XtGetCursor(dpy, XC_sb_left_arrow);
633: if (data -> ButtonCursors[Button2] == NULL)
634: data->ButtonCursors[Button2] = XtGetCursor(dpy, XC_sb_up_arrow);
635: if (data -> ButtonCursors[Button3] == NULL)
636: data->ButtonCursors[Button3] = XtGetCursor(dpy, XC_sb_right_arrow);
637: } else { if (data->orientation == XtorientVertical) {
638: if (data->NormalCursor == NULL)
639: data->NormalCursor = XtGetCursor(dpy, XC_sb_v_double_arrow);
640: if (data -> ButtonCursors[Button1] == NULL )
641: data->ButtonCursors[Button1] = XtGetCursor(dpy, XC_sb_up_arrow);
642: if (data -> ButtonCursors[Button2] == NULL)
643: data->ButtonCursors[Button2] = XtGetCursor(dpy, XC_sb_left_arrow);
644: if (data -> ButtonCursors[Button3] == NULL)
645: data->ButtonCursors[Button3] = XtGetCursor(dpy, XC_sb_down_arrow);
646: }
647: }
648: if (data->foreground == NULL)
649: data->foreground = BlackPixel(data->dpy,DefaultScreen(dpy));
650:
651:
652:
653: if (data->customthumb == NULL) {
654: image.height = default_height;
655: image.width = default_width;
656: image.xoffset = 0;
657: image.format = XYBitmap;
658: image.data = (char*) pixmap_bits;
659: image.byte_order = ImageByteOrder(data->dpy);
660: image.bitmap_pad = BitmapPad(data->dpy);
661: image.bitmap_bit_order = BitmapBitOrder(data->dpy);
662: image.bitmap_unit = BitmapUnit(data->dpy);
663: image.depth = 1;
664: image.bytes_per_line = default_width/8;
665: image.obdata = NULL;
666:
667: data->customthumb = XCreatePixmap(data->dpy, data->scrollbarWindow,
668: (Dimension)image.width,
669: (Dimension)image.height,
670: DefaultDepth(
671: data->dpy, DefaultScreen(data->dpy)));
672:
673: values.foreground = data->foreground;
674: values.background = data->background;
675: values.function = GXcopy; /* need to be explicit about defaults */
676: values.plane_mask = AllPlanes; /* until XtGetGC is re-done */
677: valuemask = GCFunction | GCForeground | GCBackground | GCPlaneMask;
678: data->gc = XtGetGC( data->dpy, widgetContext, data->scrollbarWindow,
679: valuemask, &values);
680: XPutImage(data->dpy, data->customthumb, data->gc, &image, 0, 0, 0, 0,
681: (Dimension) image.width, (Dimension) image.height);
682:
683: values.fill_style = FillTiled;
684: values.tile = data->customthumb;
685: valuemask = GCFillStyle | GCTile;
686: data->gc = XtGetGC(data->dpy,widgetContext,data->scrollbarWindow,valuemask,&values);
687: }
688:
689: else {
690:
691: values.foreground = data->foreground;
692: values.fill_style = FillTiled;
693: values.tile = data->customthumb;
694: valuemask = GCForeground | GCFillStyle | GCTile;
695: data->gc = XtGetGC(data->dpy,widgetContext,data->scrollbarWindow,valuemask,&values);
696: }
697: XDefineCursor(data->dpy,data->scrollbarWindow, data->NormalCursor);
698:
699: XtSetNameAndClass(data->dpy, data->scrollbarWindow, names, classes);
700:
701: (void) XSaveContext(data->dpy, data->scrollbarWindow, widgetContext, (caddr_t)data);
702: XtSetEventHandler(data->dpy, data->scrollbarWindow,
703: (XtEventHandler)HandleScrollBarEvent,
704: ButtonPressMask | ExposureMask | ButtonReleaseMask |
705: Button2MotionMask | StructureNotifyMask,
706: (caddr_t) data);
707: return data->scrollbarWindow;
708: }
709:
710: void XtScrollBarGetValues(dpy, window, args, argCount)
711: Display *dpy;
712: Window window;
713: ArgList args;
714: int argCount;
715: {
716: WidgetData data;
717: data = DataFromWindow(dpy, window);
718: if (data == NULL) return;
719: globaldata = *data;
720: XtGetValues(resources, XtNumber(resources), args, argCount);
721: }
722:
723:
724: void XtScrollBarSetValues(dpy, window, args, argCount)
725: Display *dpy;
726: Window window;
727: ArgList args;
728: int argCount;
729: {
730: WidgetData data;
731: short thumbmoved, redraw;
732:
733: thumbmoved = redraw = FALSE;
734: data = DataFromWindow(dpy, window);
735: if (data == NULL) return;
736: globaldata = *data;
737: XtSetValues(resources, XtNumber(resources), args, argCount);
738: if (globaldata.border != data->border) {
739: data->border = globaldata.border;
740: if (data->borderwidth != 0)
741: XSetWindowBorder(data->dpy,data->scrollbarWindow, data->border);
742: }
743: data->ScrollProc = globaldata.ScrollProc;
744: data->ThumbProc = globaldata.ThumbProc;
745: if (globaldata.foreground != data->foreground
746: || globaldata.background != data->background) {
747:
748: }
749: if (globaldata.foreground != data->foreground) {
750: data->foreground = globaldata.foreground;
751: }
752: if (globaldata.background != data->background) {
753: data->background = globaldata.background;
754:
755: }
756:
757: if (globaldata.customthumb != data->customthumb)
758: data->customthumb = globaldata.customthumb;
759:
760: if (globaldata.top != data->top) {
761: data->top = globaldata.top;
762: thumbmoved = TRUE;
763: }
764: if (globaldata.shown != data->shown) {
765: data->shown = globaldata.shown;
766: thumbmoved = TRUE;
767: }
768: if (redraw) {
769: XClearWindow(data->dpy, data->scrollbarWindow);
770: data->topLoc = -1000;
771: PaintThumb(data);
772: } else if (thumbmoved)
773: PaintThumb(data);
774: }
775:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.