![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkscrbar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Micropolis - Activity] / micropolis / src / tk|
Return to tkscrbar.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 1: /*
2: * tkScrollbar.c --
3: *
4: * This module implements a scrollbar widgets for the Tk
5: * toolkit. A scrollbar displays a slider and two arrows;
6: * mouse clicks on features within the scrollbar cause
7: * scrolling commands to be invoked.
8: *
9: * Copyright 1990-1992 Regents of the University of California.
10: * Permission to use, copy, modify, and distribute this
11: * software and its documentation for any purpose and without
12: * fee is hereby granted, provided that the above copyright
13: * notice appear in all copies. The University of California
14: * makes no representations about the suitability of this
15: * software for any purpose. It is provided "as is" without
16: * express or implied warranty.
17: */
18:
19: #ifndef lint
20: static char rcsid[] = "$Header: /user6/ouster/wish/RCS/tkScrollbar.c,v 1.35 92/05/22 16:57:27 ouster Exp $ SPRITE (Berkeley)";
21: #endif
22:
23: #include "tkconfig.h"
24: #include "default.h"
25: #include "tkint.h"
26:
27: /*
28: * A data structure of the following type is kept for each scrollbar
29: * widget managed by this file:
30: */
31:
32: typedef struct {
33: Tk_Window tkwin; /* Window that embodies the scrollbar. NULL
34: * means that the window has been destroyed
35: * but the data structures haven't yet been
36: * cleaned up.*/
37: Tcl_Interp *interp; /* Interpreter associated with scrollbar. */
38: Tk_Uid orientUid; /* Orientation for window ("vertical" or
39: * "horizontal"). */
40: int vertical; /* Non-zero means vertical orientation
41: * requested, zero means horizontal. */
42: int width; /* Desired narrow dimension of scrollbar,
43: * in pixels. */
44: char *command; /* Command prefix to use when invoking
45: * scrolling commands. NULL means don't
46: * invoke commands. Malloc'ed. */
47: int commandSize; /* Number of non-NULL bytes in command. */
48: int repeatDelay; /* How long to wait before auto-repeating
49: * on scrolling actions (in ms). */
50: int repeatInterval; /* Interval between autorepeats (in ms). */
51:
52: /*
53: * Information used when displaying widget:
54: */
55:
56: int borderWidth; /* Width of 3-D borders. */
57: Tk_3DBorder bgBorder; /* Used for drawing background. */
58: Tk_3DBorder fgBorder; /* For drawing foreground shapes. */
59: Tk_3DBorder activeBorder; /* For drawing foreground shapes when
60: * active (i.e. when mouse is positioned
61: * over element). NULL means use fgBorder. */
62: GC copyGC; /* Used for copying from pixmap onto screen. */
63: int relief; /* Indicates whether window as a whole is
64: * raised, sunken, or flat. */
65: int offset; /* Zero if relief is TK_RELIEF_FLAT,
66: * borderWidth otherwise. Indicates how
67: * much interior stuff must be offset from
68: * outside edges to leave room for border. */
69: int arrowLength; /* Length of arrows along long dimension of
70: * scrollbar. Recomputed on window size
71: * changes. */
72: int sliderFirst; /* Pixel coordinate of top or left edge
73: * of slider area, including border. */
74: int sliderLast; /* Coordinate of pixel just after bottom
75: * or right edge of slider area, including
76: * border. */
77: int mouseField; /* Indicates which scrollbar element is
78: * under mouse (e.g. TOP_ARROW; see below
79: * for possible values). */
80: int pressField; /* Field in which button was pressed, or -1
81: * if no button is down. */
82: int pressPos; /* Position of mouse when button was
83: * pressed (y for vertical scrollbar, x
84: * for horizontal). */
85: int pressFirstUnit; /* Value of "firstUnit" when mouse button
86: * was pressed. */
87:
88: /*
89: * Information describing the application related to the scrollbar.
90: * This information is provided by the application by invoking the
91: * "set" widget command.
92: */
93:
94: int totalUnits; /* Total dimension of application, in
95: * units. */
96: int windowUnits; /* Maximum number of units that can
97: * be displayed in the window at
98: * once. */
99: int firstUnit; /* Number of last unit visible in
100: * application's window. */
101: int lastUnit; /* Index of last unit visible in window. */
102:
103: /*
104: * Miscellaneous information:
105: */
106:
107: Cursor cursor; /* Current cursor for window, or None. */
108: Tk_TimerToken autoRepeat; /* Token for auto-repeat that's
109: * currently in progress. NULL means no
110: * auto-repeat in progress. */
111: int flags; /* Various flags; see below for
112: * definitions. */
113: } Scrollbar;
114:
115: /*
116: * Legal values for "mouseField" field of Scrollbar structures. These
117: * are also the return values from the ScrollbarPosition procedure.
118: */
119:
120: #define TOP_ARROW 1
121: #define TOP_GAP 2
122: #define SLIDER 3
123: #define BOTTOM_GAP 4
124: #define BOTTOM_ARROW 5
125: #define OUTSIDE 6
126:
127: /*
128: * Flag bits for scrollbars:
129: *
130: * REDRAW_PENDING: Non-zero means a DoWhenIdle handler
131: * has already been queued to redraw
132: * this window.
133: */
134:
135: #define REDRAW_PENDING 1
136:
137: /*
138: * Information used for argv parsing.
139: */
140:
141:
142: static Tk_ConfigSpec configSpecs[] = {
143: {TK_CONFIG_BORDER, "-activeforeground", "activeForeground", "Background",
144: DEF_SCROLLBAR_ACTIVE_FG_COLOR, Tk_Offset(Scrollbar, activeBorder),
145: TK_CONFIG_COLOR_ONLY},
146: {TK_CONFIG_BORDER, "-activeforeground", "activeForeground", "Background",
147: DEF_SCROLLBAR_ACTIVE_FG_MONO, Tk_Offset(Scrollbar, activeBorder),
148: TK_CONFIG_MONO_ONLY},
149: {TK_CONFIG_BORDER, "-background", "background", "Background",
150: DEF_SCROLLBAR_BG_COLOR, Tk_Offset(Scrollbar, bgBorder),
151: TK_CONFIG_COLOR_ONLY},
152: {TK_CONFIG_BORDER, "-background", "background", "Background",
153: DEF_SCROLLBAR_BG_MONO, Tk_Offset(Scrollbar, bgBorder),
154: TK_CONFIG_MONO_ONLY},
155: {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
156: (char *) NULL, 0, 0},
157: {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
158: (char *) NULL, 0, 0},
159: {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
160: DEF_SCROLLBAR_BORDER_WIDTH, Tk_Offset(Scrollbar, borderWidth), 0},
161: {TK_CONFIG_STRING, "-command", "command", "Command",
162: DEF_SCROLLBAR_COMMAND, Tk_Offset(Scrollbar, command), 0},
163: {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
164: DEF_SCROLLBAR_CURSOR, Tk_Offset(Scrollbar, cursor), TK_CONFIG_NULL_OK},
165: {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,
166: (char *) NULL, 0, 0},
167: {TK_CONFIG_BORDER, "-foreground", "foreground", "Foreground",
168: DEF_SCROLLBAR_FG_COLOR, Tk_Offset(Scrollbar, fgBorder),
169: TK_CONFIG_COLOR_ONLY},
170: {TK_CONFIG_BORDER, "-foreground", "foreground", "Foreground",
171: DEF_SCROLLBAR_FG_MONO, Tk_Offset(Scrollbar, fgBorder),
172: TK_CONFIG_MONO_ONLY},
173: {TK_CONFIG_UID, "-orient", "orient", "Orient",
174: DEF_SCROLLBAR_ORIENT, Tk_Offset(Scrollbar, orientUid), 0},
175: {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
176: DEF_SCROLLBAR_RELIEF, Tk_Offset(Scrollbar, relief), 0},
177: {TK_CONFIG_INT, "-repeatdelay", "repeatDelay", "RepeatDelay",
178: DEF_SCROLLBAR_REPEAT_DELAY, Tk_Offset(Scrollbar, repeatDelay), 0},
179: {TK_CONFIG_INT, "-repeatinterval", "repeatInterval", "RepeatInterval",
180: DEF_SCROLLBAR_REPEAT_INTERVAL, Tk_Offset(Scrollbar, repeatInterval), 0},
181: {TK_CONFIG_PIXELS, "-width", "width", "Width",
182: DEF_SCROLLBAR_WIDTH, Tk_Offset(Scrollbar, width), 0},
183: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
184: (char *) NULL, 0, 0}
185: };
186:
187: /*
188: * Forward declarations for procedures defined later in this file:
189: */
190:
191: static void ComputeScrollbarGeometry _ANSI_ARGS_((
192: Scrollbar *scrollPtr));
193: static int ConfigureScrollbar _ANSI_ARGS_((Tcl_Interp *interp,
194: Scrollbar *scrollPtr, int argc, char **argv,
195: int flags));
196: static void DestroyScrollbar _ANSI_ARGS_((ClientData clientData));
197: static void DisplayScrollbar _ANSI_ARGS_((ClientData clientData));
198: static void EventuallyRedraw _ANSI_ARGS_((Scrollbar *scrollPtr));
199: static void ScrollbarEventProc _ANSI_ARGS_((ClientData clientData,
200: XEvent *eventPtr));
201: static void ScrollbarMouseProc _ANSI_ARGS_((ClientData clientData,
202: XEvent *eventPtr));
203: static void ScrollbarNewField _ANSI_ARGS_((Scrollbar *scrollPtr,
204: int field));
205: static int ScrollbarPosition _ANSI_ARGS_((Scrollbar *scrollPtr,
206: int x, int y));
207: static void ScrollbarTimerProc _ANSI_ARGS_((
208: ClientData clientData));
209: static int ScrollbarWidgetCmd _ANSI_ARGS_((ClientData clientData,
210: Tcl_Interp *, int argc, char **argv));
211: static void ScrollCmd _ANSI_ARGS_((Scrollbar *scrollPtr,
212: int unit));
213:
214: /*
215: *--------------------------------------------------------------
216: *
217: * Tk_ScrollbarCmd --
218: *
219: * This procedure is invoked to process the "scrollbar" Tcl
220: * command. See the user documentation for details on what
221: * it does.
222: *
223: * Results:
224: * A standard Tcl result.
225: *
226: * Side effects:
227: * See the user documentation.
228: *
229: *--------------------------------------------------------------
230: */
231:
232: int
233: Tk_ScrollbarCmd(clientData, interp, argc, argv)
234: ClientData clientData; /* Main window associated with
235: * interpreter. */
236: Tcl_Interp *interp; /* Current interpreter. */
237: int argc; /* Number of arguments. */
238: char **argv; /* Argument strings. */
239: {
240: Tk_Window tkwin = (Tk_Window) clientData;
241: register Scrollbar *scrollPtr;
242: Tk_Window new;
243:
244: if (argc < 2) {
245: Tcl_AppendResult(interp, "wrong # args: should be \"",
246: argv[0], " pathName ?options?\"", (char *) NULL);
247: return TCL_ERROR;
248: }
249:
250: new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], (char *) NULL);
251: if (new == NULL) {
252: return TCL_ERROR;
253: }
254:
255: /*
256: * Initialize fields that won't be initialized by ConfigureScrollbar,
257: * or which ConfigureScrollbar expects to have reasonable values
258: * (e.g. resource pointers).
259: */
260:
261: scrollPtr = (Scrollbar *) ckalloc(sizeof(Scrollbar));
262: scrollPtr->tkwin = new;
263: scrollPtr->interp = interp;
264: scrollPtr->command = NULL;
265: scrollPtr->bgBorder = NULL;
266: scrollPtr->fgBorder = NULL;
267: scrollPtr->activeBorder = NULL;
268: scrollPtr->copyGC = None;
269: scrollPtr->mouseField = OUTSIDE;
270: scrollPtr->pressField = -1;
271: scrollPtr->totalUnits = 0;
272: scrollPtr->windowUnits = 0;
273: scrollPtr->firstUnit = 0;
274: scrollPtr->lastUnit = 0;
275: scrollPtr->cursor = None;
276: scrollPtr->autoRepeat = NULL;
277: scrollPtr->flags = 0;
278:
279: Tk_SetClass(scrollPtr->tkwin, "Scrollbar");
280: Tk_CreateEventHandler(scrollPtr->tkwin, ExposureMask|StructureNotifyMask,
281: ScrollbarEventProc, (ClientData) scrollPtr);
282: Tk_CreateEventHandler(scrollPtr->tkwin, EnterWindowMask|LeaveWindowMask
283: |PointerMotionMask|ButtonPressMask|ButtonReleaseMask,
284: ScrollbarMouseProc, (ClientData) scrollPtr);
285: Tcl_CreateCommand(interp, Tk_PathName(scrollPtr->tkwin), ScrollbarWidgetCmd,
286: (ClientData) scrollPtr, (void (*)()) NULL);
287: if (ConfigureScrollbar(interp, scrollPtr, argc-2, argv+2, 0) != TCL_OK) {
288: goto error;
289: }
290:
291: interp->result = Tk_PathName(scrollPtr->tkwin);
292: return TCL_OK;
293:
294: error:
295: Tk_DestroyWindow(scrollPtr->tkwin);
296: return TCL_ERROR;
297: }
298:
299: /*
300: *--------------------------------------------------------------
301: *
302: * ScrollbarWidgetCmd --
303: *
304: * This procedure is invoked to process the Tcl command
305: * that corresponds to a widget managed by this module.
306: * See the user documentation for details on what it does.
307: *
308: * Results:
309: * A standard Tcl result.
310: *
311: * Side effects:
312: * See the user documentation.
313: *
314: *--------------------------------------------------------------
315: */
316:
317: static int
318: ScrollbarWidgetCmd(clientData, interp, argc, argv)
319: ClientData clientData; /* Information about scrollbar
320: * widget. */
321: Tcl_Interp *interp; /* Current interpreter. */
322: int argc; /* Number of arguments. */
323: char **argv; /* Argument strings. */
324: {
325: register Scrollbar *scrollPtr = (Scrollbar *) clientData;
326: int result = TCL_OK;
327: int length;
328: char c;
329:
330: if (argc < 2) {
331: Tcl_AppendResult(interp, "wrong # args: should be \"",
332: argv[0], " option ?arg arg ...?\"", (char *) NULL);
333: return TCL_ERROR;
334: }
335: Tk_Preserve((ClientData) scrollPtr);
336: c = argv[1][0];
337: length = strlen(argv[1]);
338: if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) {
339: if (argc == 2) {
340: result = Tk_ConfigureInfo(interp, scrollPtr->tkwin, configSpecs,
341: (char *) scrollPtr, (char *) NULL, 0);
342: } else if (argc == 3) {
343: result = Tk_ConfigureInfo(interp, scrollPtr->tkwin, configSpecs,
344: (char *) scrollPtr, argv[2], 0);
345: } else {
346: result = ConfigureScrollbar(interp, scrollPtr, argc-2, argv+2,
347: TK_CONFIG_ARGV_ONLY);
348: }
349: } else if ((c == 'g') && (strncmp(argv[1], "get", length) == 0)) {
350: if (argc != 2) {
351: Tcl_AppendResult(interp, "wrong # args: should be \"",
352: argv[0], " get\"", (char *) NULL);
353: goto error;
354: }
355: sprintf(interp->result, "%d %d %d %d", scrollPtr->totalUnits,
356: scrollPtr->windowUnits, scrollPtr->firstUnit,
357: scrollPtr->lastUnit);
358: } else if ((c == 's') && (strncmp(argv[1], "set", length) == 0)) {
359: int totalUnits, windowUnits, firstUnit, lastUnit;
360:
361: if (argc != 6) {
362: Tcl_AppendResult(interp, "wrong # args: should be \"",
363: argv[0],
364: " set totalUnits windowUnits firstUnit lastUnit\"",
365: (char *) NULL);
366: goto error;
367: }
368: if (Tcl_GetInt(interp, argv[2], &totalUnits) != TCL_OK) {
369: goto error;
370: }
371: if (totalUnits < 0) {
372: sprintf(interp->result, "illegal totalUnits %d", totalUnits);
373: goto error;
374: }
375: if (Tcl_GetInt(interp, argv[3], &windowUnits) != TCL_OK) {
376: goto error;
377: }
378: if (windowUnits < 0) {
379: sprintf(interp->result, "illegal windowUnits %d", windowUnits);
380: goto error;
381: }
382: if (Tcl_GetInt(interp, argv[4], &firstUnit) != TCL_OK) {
383: goto error;
384: }
385: if (Tcl_GetInt(interp, argv[5], &lastUnit) != TCL_OK) {
386: goto error;
387: }
388: if (totalUnits > 0) {
389: if (lastUnit < firstUnit) {
390: sprintf(interp->result, "illegal lastUnit %d", lastUnit);
391: goto error;
392: }
393: } else {
394: firstUnit = lastUnit = 0;
395: }
396: scrollPtr->totalUnits = totalUnits;
397: scrollPtr->windowUnits = windowUnits;
398: scrollPtr->firstUnit = firstUnit;
399: scrollPtr->lastUnit = lastUnit;
400: ComputeScrollbarGeometry(scrollPtr);
401: EventuallyRedraw(scrollPtr);
402: } else {
403: Tcl_AppendResult(interp, "bad option \"", argv[1],
404: "\": must be configure, get, or set", (char *) NULL);
405: goto error;
406: }
407: Tk_Release((ClientData) scrollPtr);
408: return result;
409:
410: error:
411: Tk_Release((ClientData) scrollPtr);
412: return TCL_ERROR;
413: }
414:
415: /*
416: *----------------------------------------------------------------------
417: *
418: * DestroyScrollbar --
419: *
420: * This procedure is invoked by Tk_EventuallyFree or Tk_Release
421: * to clean up the internal structure of a scrollbar at a safe time
422: * (when no-one is using it anymore).
423: *
424: * Results:
425: * None.
426: *
427: * Side effects:
428: * Everything associated with the scrollbar is freed up.
429: *
430: *----------------------------------------------------------------------
431: */
432:
433: static void
434: DestroyScrollbar(clientData)
435: ClientData clientData; /* Info about scrollbar widget. */
436: {
437: register Scrollbar *scrollPtr = (Scrollbar *) clientData;
438:
439: if (scrollPtr->command != NULL) {
440: ckfree(scrollPtr->command);
441: }
442: if (scrollPtr->bgBorder != NULL) {
443: Tk_Free3DBorder(scrollPtr->bgBorder);
444: }
445: if (scrollPtr->fgBorder != NULL) {
446: Tk_Free3DBorder(scrollPtr->fgBorder);
447: }
448: if (scrollPtr->activeBorder != NULL) {
449: Tk_Free3DBorder(scrollPtr->activeBorder);
450: }
451: if (scrollPtr->copyGC != None) {
452: Tk_FreeGC(scrollPtr->copyGC);
453: }
454: if (scrollPtr->cursor != None) {
455: Tk_FreeCursor(scrollPtr->cursor);
456: }
457: ckfree((char *) scrollPtr);
458: }
459:
460: /*
461: *----------------------------------------------------------------------
462: *
463: * ConfigureScrollbar --
464: *
465: * This procedure is called to process an argv/argc list, plus
466: * the Tk option database, in order to configure (or
467: * reconfigure) a scrollbar widget.
468: *
469: * Results:
470: * The return value is a standard Tcl result. If TCL_ERROR is
471: * returned, then interp->result contains an error message.
472: *
473: * Side effects:
474: * Configuration information, such as colors, border width,
475: * etc. get set for scrollPtr; old resources get freed,
476: * if there were any.
477: *
478: *----------------------------------------------------------------------
479: */
480:
481: static int
482: ConfigureScrollbar(interp, scrollPtr, argc, argv, flags)
483: Tcl_Interp *interp; /* Used for error reporting. */
484: register Scrollbar *scrollPtr; /* Information about widget; may or
485: * may not already have values for
486: * some fields. */
487: int argc; /* Number of valid entries in argv. */
488: char **argv; /* Arguments. */
489: int flags; /* Flags to pass to
490: * Tk_ConfigureWidget. */
491: {
492: int length;
493: XGCValues gcValues;
494:
495: if (Tk_ConfigureWidget(interp, scrollPtr->tkwin, configSpecs,
496: argc, argv, (char *) scrollPtr, flags) != TCL_OK) {
497: return TCL_ERROR;
498: }
499:
500: /*
501: * A few options need special processing, such as parsing the
502: * orientation or setting the background from a 3-D border.
503: */
504:
505: length = strlen(scrollPtr->orientUid);
506: if (strncmp(scrollPtr->orientUid, "vertical", length) == 0) {
507: scrollPtr->vertical = 1;
508: } else if (strncmp(scrollPtr->orientUid, "horizontal", length) == 0) {
509: scrollPtr->vertical = 0;
510: } else {
511: Tcl_AppendResult(interp, "bad orientation \"", scrollPtr->orientUid,
512: "\": must be vertical or horizontal", (char *) NULL);
513: return TCL_ERROR;
514: }
515:
516: if (scrollPtr->command != NULL) {
517: scrollPtr->commandSize = strlen(scrollPtr->command);
518: } else {
519: scrollPtr->commandSize = 0;
520: }
521:
522: Tk_SetBackgroundFromBorder(scrollPtr->tkwin, scrollPtr->bgBorder);
523:
524: if (scrollPtr->copyGC == None) {
525: gcValues.graphics_exposures = False;
526: scrollPtr->copyGC = Tk_GetGC(scrollPtr->tkwin, GCGraphicsExposures,
527: &gcValues);
528: }
529:
530: /*
531: * Register the desired geometry for the window (leave enough space
532: * for the two arrows plus a minimum-size slider, plus border around
533: * the whole window, if any). Then arrange for the window to be
534: * redisplayed.
535: */
536:
537: ComputeScrollbarGeometry(scrollPtr);
538: EventuallyRedraw(scrollPtr);
539: return TCL_OK;
540: }
541:
542: /*
543: *--------------------------------------------------------------
544: *
545: * DisplayScrollbar --
546: *
547: * This procedure redraws the contents of a scrollbar window.
548: * It is invoked as a do-when-idle handler, so it only runs
549: * when there's nothing else for the application to do.
550: *
551: * Results:
552: * None.
553: *
554: * Side effects:
555: * Information appears on the screen.
556: *
557: *--------------------------------------------------------------
558: */
559:
560: static void
561: DisplayScrollbar(clientData)
562: ClientData clientData; /* Information about window. */
563: {
564: register Scrollbar *scrollPtr = (Scrollbar *) clientData;
565: register Tk_Window tkwin = scrollPtr->tkwin;
566: XPoint points[7];
567: Tk_3DBorder border;
568: int relief, width, fieldLength;
569: Pixmap pixmap;
570:
571: if ((scrollPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
572: goto done;
573: }
574:
575: if (scrollPtr->vertical) {
576: width = Tk_Width(tkwin) - 2*scrollPtr->offset;
577: } else {
578: width = Tk_Height(tkwin) - 2*scrollPtr->offset;
579: }
580:
581: /*
582: * In order to avoid screen flashes, this procedure redraws
583: * the scrollbar in a pixmap, then copies the pixmap to the
584: * screen in a single operation. This means that there's no
585: * point in time where the on-sreen image has been cleared.
586: */
587:
588: pixmap = XCreatePixmap(Tk_Display(tkwin), Tk_WindowId(tkwin),
589: Tk_Width(tkwin), Tk_Height(tkwin),
590: Tk_DefaultDepth(Tk_Screen(tkwin)));
591: Tk_Fill3DRectangle(Tk_Display(tkwin), pixmap, scrollPtr->bgBorder,
592: 0, 0, Tk_Width(tkwin), Tk_Height(tkwin),
593: scrollPtr->borderWidth, scrollPtr->relief);
594:
595: /*
596: * Draw the top or left arrow. The coordinates of the polygon
597: * points probably seem odd, but they were carefully chosen with
598: * respect to X's rules for filling polygons. These point choices
599: * cause the arrows to just fill the narrow dimension of the
600: * scrollbar and be properly centered.
601: */
602:
603: if (scrollPtr->mouseField == TOP_ARROW) {
604: border = scrollPtr->activeBorder;
605: relief = scrollPtr->pressField == TOP_ARROW ? TK_RELIEF_SUNKEN
606: : TK_RELIEF_RAISED;
607: } else {
608: border = scrollPtr->fgBorder;
609: relief = TK_RELIEF_RAISED;
610: }
611: if (scrollPtr->vertical) {
612: points[0].x = scrollPtr->offset - 1;
613: points[0].y = scrollPtr->arrowLength + scrollPtr->offset;
614: points[1].x = width + scrollPtr->offset;
615: points[1].y = points[0].y;
616: points[2].x = width/2 + scrollPtr->offset;
617: points[2].y = scrollPtr->offset - 1;
618: Tk_Fill3DPolygon(Tk_Display(tkwin), pixmap, border,
619: points, 3, scrollPtr->borderWidth, relief);
620: } else {
621: points[0].x = scrollPtr->arrowLength + scrollPtr->offset;
622: points[0].y = scrollPtr->offset - 1;
623: points[1].x = scrollPtr->offset;
624: points[1].y = width/2 + scrollPtr->offset;
625: points[2].x = points[0].x;
626: points[2].y = width + scrollPtr->offset;
627: Tk_Fill3DPolygon(Tk_Display(tkwin), pixmap, border,
628: points, 3, scrollPtr->borderWidth, relief);
629: }
630:
631: /*
632: * Display the bottom or right arrow.
633: */
634:
635: if (scrollPtr->mouseField == BOTTOM_ARROW) {
636: border = scrollPtr->activeBorder;
637: relief = scrollPtr->pressField == BOTTOM_ARROW ? TK_RELIEF_SUNKEN
638: : TK_RELIEF_RAISED;
639: } else {
640: border = scrollPtr->fgBorder;
641: relief = TK_RELIEF_RAISED;
642: }
643: if (scrollPtr->vertical) {
644: points[0].x = scrollPtr->offset;
645: points[0].y = Tk_Height(tkwin) - scrollPtr->arrowLength
646: - scrollPtr->offset;
647: points[1].x = width/2 + scrollPtr->offset;
648: points[1].y = Tk_Height(tkwin) - scrollPtr->offset;
649: points[2].x = width + scrollPtr->offset;
650: points[2].y = points[0].y;
651: Tk_Fill3DPolygon(Tk_Display(tkwin), pixmap, border,
652: points, 3, scrollPtr->borderWidth, relief);
653: } else {
654: points[0].x = Tk_Width(tkwin) - scrollPtr->arrowLength
655: - scrollPtr->offset;
656: points[0].y = scrollPtr->offset - 1;
657: points[1].x = points[0].x;
658: points[1].y = width + scrollPtr->offset;
659: points[2].x = Tk_Width(tkwin) - scrollPtr->offset;
660: points[2].y = width/2 + scrollPtr->offset;
661: Tk_Fill3DPolygon(Tk_Display(tkwin), pixmap, border,
662: points, 3, scrollPtr->borderWidth, relief);
663: }
664:
665: /*
666: * Display the slider.
667: */
668:
669: if (scrollPtr->mouseField == SLIDER) {
670: border = scrollPtr->activeBorder;
671: relief = scrollPtr->pressField == SLIDER ? TK_RELIEF_SUNKEN
672: : TK_RELIEF_RAISED;
673: } else {
674: border = scrollPtr->fgBorder;
675: relief = TK_RELIEF_RAISED;
676: }
677: fieldLength = (scrollPtr->vertical ? Tk_Height(tkwin) : Tk_Width(tkwin))
678: - 2*(scrollPtr->arrowLength + scrollPtr->offset);
679: if (fieldLength < 0) {
680: fieldLength = 0;
681: }
682: if (scrollPtr->vertical) {
683: Tk_Fill3DRectangle(Tk_Display(tkwin), pixmap, border,
684: 1 + scrollPtr->offset, scrollPtr->sliderFirst,
685: width-2, scrollPtr->sliderLast - scrollPtr->sliderFirst,
686: scrollPtr->borderWidth, relief);
687: } else {
688: Tk_Fill3DRectangle(Tk_Display(tkwin), pixmap, border,
689: scrollPtr->sliderFirst, 1 + scrollPtr->offset,
690: scrollPtr->sliderLast - scrollPtr->sliderFirst, width-2,
691: scrollPtr->borderWidth, relief);
692: }
693:
694: /*
695: * Copy the information from the off-screen pixmap onto the screen,
696: * then delete the pixmap.
697: */
698:
699: XCopyArea(Tk_Display(tkwin), pixmap, Tk_WindowId(tkwin),
700: scrollPtr->copyGC, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin), 0, 0);
701: XFreePixmap(Tk_Display(tkwin), pixmap);
702:
703: done:
704: scrollPtr->flags &= ~REDRAW_PENDING;
705: }
706:
707: /*
708: *--------------------------------------------------------------
709: *
710: * ScrollbarEventProc --
711: *
712: * This procedure is invoked by the Tk dispatcher for various
713: * events on scrollbars.
714: *
715: * Results:
716: * None.
717: *
718: * Side effects:
719: * When the window gets deleted, internal structures get
720: * cleaned up. When it gets exposed, it is redisplayed.
721: *
722: *--------------------------------------------------------------
723: */
724:
725: static void
726: ScrollbarEventProc(clientData, eventPtr)
727: ClientData clientData; /* Information about window. */
728: XEvent *eventPtr; /* Information about event. */
729: {
730: Scrollbar *scrollPtr = (Scrollbar *) clientData;
731:
732: if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
733: EventuallyRedraw(scrollPtr);
734: } else if (eventPtr->type == DestroyNotify) {
735: Tcl_DeleteCommand(scrollPtr->interp, Tk_PathName(scrollPtr->tkwin));
736: scrollPtr->tkwin = NULL;
737: if (scrollPtr->flags & REDRAW_PENDING) {
738: Tk_CancelIdleCall(DisplayScrollbar, (ClientData) scrollPtr);
739: }
740: Tk_EventuallyFree((ClientData) scrollPtr, DestroyScrollbar);
741: } else if (eventPtr->type == ConfigureNotify) {
742: ComputeScrollbarGeometry(scrollPtr);
743: }
744: }
745:
746: /*
747: *----------------------------------------------------------------------
748: *
749: * ComputeScrollbarGeometry --
750: *
751: * After changes in a scrollbar's size or configuration, this
752: * procedure recomputes various geometry information used in
753: * displaying the scrollbar.
754: *
755: * Results:
756: * None.
757: *
758: * Side effects:
759: * The scrollbar will be displayed differently.
760: *
761: *----------------------------------------------------------------------
762: */
763:
764: static void
765: ComputeScrollbarGeometry(scrollPtr)
766: register Scrollbar *scrollPtr; /* Scrollbar whose geometry may
767: * have changed. */
768: {
769: int width, fieldLength;
770:
771: if (scrollPtr->relief == TK_RELIEF_FLAT) {
772: scrollPtr->offset = 0;
773: } else {
774: scrollPtr->offset = scrollPtr->borderWidth;
775: }
776: width = (scrollPtr->vertical) ? Tk_Width(scrollPtr->tkwin)
777: : Tk_Height(scrollPtr->tkwin);
778: scrollPtr->arrowLength =
779: (((width - 2*scrollPtr->offset)*173) + 100) / 200;
780: fieldLength = (scrollPtr->vertical ? Tk_Height(scrollPtr->tkwin)
781: : Tk_Width(scrollPtr->tkwin))
782: - 2*(scrollPtr->arrowLength + scrollPtr->offset);
783: if (fieldLength < 0) {
784: fieldLength = 0;
785: }
786: if (scrollPtr->totalUnits <= 0) {
787: scrollPtr->sliderFirst = 0;
788: scrollPtr->sliderLast = fieldLength;
789: } else {
790: scrollPtr->sliderFirst = (fieldLength*scrollPtr->firstUnit
791: + scrollPtr->totalUnits/2)/scrollPtr->totalUnits;
792: scrollPtr->sliderLast = (fieldLength*(scrollPtr->lastUnit+1)
793: + scrollPtr->totalUnits/2)/scrollPtr->totalUnits;
794:
795: /*
796: * Adjust the slider so that some piece of it is always
797: * displayed in the scrollbar and so that it has at least
798: * a minimal width (so it can be grabbed with the mouse).
799: */
800:
801: if (scrollPtr->sliderFirst > (fieldLength - 2*scrollPtr->borderWidth)) {
802: scrollPtr->sliderFirst = fieldLength - 2*scrollPtr->borderWidth;
803: }
804: if (scrollPtr->sliderFirst < 0) {
805: scrollPtr->sliderFirst = 0;
806: }
807: if (scrollPtr->sliderLast < (scrollPtr->sliderFirst
808: + 2*scrollPtr->borderWidth)) {
809: scrollPtr->sliderLast = scrollPtr->sliderFirst
810: + 2*scrollPtr->borderWidth;
811: }
812: if (scrollPtr->sliderLast > fieldLength) {
813: scrollPtr->sliderLast = fieldLength;
814: }
815: }
816: scrollPtr->sliderFirst += scrollPtr->arrowLength + scrollPtr->offset;
817: scrollPtr->sliderLast += scrollPtr->arrowLength + scrollPtr->offset;
818:
819: /*
820: * Register the desired geometry for the window (leave enough space
821: * for the two arrows plus a minimum-size slider, plus border around
822: * the whole window, if any). Then arrange for the window to be
823: * redisplayed.
824: */
825:
826: if (scrollPtr->vertical) {
827: Tk_GeometryRequest(scrollPtr->tkwin,
828: scrollPtr->width + 2*scrollPtr->offset,
829: 2*(scrollPtr->arrowLength + scrollPtr->borderWidth
830: + scrollPtr->offset));
831: } else {
832: Tk_GeometryRequest(scrollPtr->tkwin,
833: 2*(scrollPtr->arrowLength + scrollPtr->borderWidth
834: + scrollPtr->offset), scrollPtr->width + 2*scrollPtr->offset);
835: }
836: Tk_SetInternalBorder(scrollPtr->tkwin, scrollPtr->borderWidth);
837:
838: }
839:
840: /*
841: *--------------------------------------------------------------
842: *
843: * ScrollbarPosition --
844: *
845: * Determine the scrollbar element corresponding to a
846: * given position.
847: *
848: * Results:
849: * One of TOP_ARROW, TOP_GAP, etc., indicating which element
850: * of the scrollbar covers the position given by (x, y). If
851: * (x,y) is outside the scrollbar entirely, then OUTSIDE is
852: * returned.
853: *
854: * Side effects:
855: * None.
856: *
857: *--------------------------------------------------------------
858: */
859:
860: static int
861: ScrollbarPosition(scrollPtr, x, y)
862: register Scrollbar *scrollPtr; /* Scrollbar widget record. */
863: int x, y; /* Coordinates within scrollPtr's
864: * window. */
865: {
866: int length, width, tmp;
867:
868: if (scrollPtr->vertical) {
869: length = Tk_Height(scrollPtr->tkwin);
870: width = Tk_Width(scrollPtr->tkwin);
871: } else {
872: tmp = x;
873: x = y;
874: y = tmp;
875: length = Tk_Width(scrollPtr->tkwin);
876: width = Tk_Height(scrollPtr->tkwin);
877: }
878:
879: if ((x < 0) || (x > width) || (y < 0)) {
880: return OUTSIDE;
881: }
882:
883: /*
884: * All of the calculations in this procedure mirror those in
885: * DisplayScrollbar. Be sure to keep the two consistent.
886: */
887:
888: if (y < (scrollPtr->offset + scrollPtr->arrowLength)) {
889: return TOP_ARROW;
890: }
891: if (y < scrollPtr->sliderFirst) {
892: return TOP_GAP;
893: }
894: if (y < scrollPtr->sliderLast) {
895: return SLIDER;
896: }
897: if (y >= (length - (scrollPtr->arrowLength + scrollPtr->offset))) {
898: return BOTTOM_ARROW;
899: }
900: return BOTTOM_GAP;
901: }
902:
903: /*
904: *--------------------------------------------------------------
905: *
906: * ScrollbarMouseProc --
907: *
908: * This procedure is called back by Tk in response to
909: * mouse events such as window entry, window exit, mouse
910: * motion, and button presses.
911: *
912: * Results:
913: * None.
914: *
915: * Side effects:
916: * This procedure implements the "feel" of the scrollbar
917: * by issuing scrolling commands in response to button presses
918: * and mouse motion.
919: *
920: *--------------------------------------------------------------
921: */
922:
923: static void
924: ScrollbarMouseProc(clientData, eventPtr)
925: ClientData clientData; /* Information about window. */
926: register XEvent *eventPtr; /* Information about event. */
927: {
928: register Scrollbar *scrollPtr = (Scrollbar *) clientData;
929:
930: Tk_Preserve((ClientData) scrollPtr);
931: if (eventPtr->type == EnterNotify) {
932: if (scrollPtr->pressField == -1) {
933: ScrollbarNewField(scrollPtr,
934: ScrollbarPosition(scrollPtr, eventPtr->xcrossing.x,
935: eventPtr->xcrossing.y));
936: }
937: } else if (eventPtr->type == LeaveNotify) {
938: if (scrollPtr->pressField == -1) {
939: ScrollbarNewField(scrollPtr, OUTSIDE);
940: }
941: } else if (eventPtr->type == MotionNotify) {
942: if (scrollPtr->pressField == SLIDER) {
943: int delta, length, newFirst;
944:
945: if (scrollPtr->vertical) {
946: delta = eventPtr->xmotion.y - scrollPtr->pressPos;
947: length = Tk_Height(scrollPtr->tkwin)
948: - 2*(scrollPtr->arrowLength + scrollPtr->offset);
949: } else {
950: delta = eventPtr->xmotion.x - scrollPtr->pressPos;
951: length = Tk_Width(scrollPtr->tkwin)
952: - 2*(scrollPtr->arrowLength + scrollPtr->offset);
953: }
954:
955: /*
956: * Do the division with positive numbers to avoid
957: * differences in negative-number truncation on different
958: * machines.
959: */
960:
961: if (delta >= 0) {
962: newFirst = scrollPtr->pressFirstUnit
963: + ((delta * scrollPtr->totalUnits) + (length/2))
964: / length;
965: } else {
966: newFirst = scrollPtr->pressFirstUnit
967: - (((-delta) * scrollPtr->totalUnits) + (length/2))
968: / length;
969: }
970: ScrollCmd(scrollPtr, newFirst);
971: } else if (scrollPtr->pressField == -1) {
972: ScrollbarNewField(scrollPtr,
973: ScrollbarPosition(scrollPtr, eventPtr->xmotion.x,
974: eventPtr->xmotion.y));
975: }
976: } else if ((eventPtr->type == ButtonPress)
977: && (eventPtr->xbutton.state == 0)) {
978: scrollPtr->pressField = scrollPtr->mouseField;
979: if (scrollPtr->pressField != SLIDER) {
980: scrollPtr->autoRepeat = Tk_CreateTimerHandler(
981: scrollPtr->repeatDelay,
982: ScrollbarTimerProc, (ClientData) scrollPtr);
983: }
984: if (scrollPtr->vertical) {
985: scrollPtr->pressPos = eventPtr->xbutton.y;
986: } else {
987: scrollPtr->pressPos = eventPtr->xbutton.x;
988: }
989: scrollPtr->pressFirstUnit = scrollPtr->firstUnit;
990: if (scrollPtr->pressFirstUnit <= -scrollPtr->windowUnits) {
991: scrollPtr->pressFirstUnit = 1-scrollPtr->windowUnits;
992: }
993: if (scrollPtr->pressFirstUnit >= scrollPtr->totalUnits) {
994: scrollPtr->pressFirstUnit = scrollPtr->totalUnits-1;
995: }
996: EventuallyRedraw(scrollPtr);
997: } else if (eventPtr->type == ButtonRelease) {
998: if (scrollPtr->pressField == scrollPtr->mouseField) {
999: switch (scrollPtr->pressField) {
1000: case TOP_ARROW:
1001: ScrollCmd(scrollPtr, scrollPtr->firstUnit-1);
1002: break;
1003: case TOP_GAP:
1004: if (scrollPtr->windowUnits <= 1) {
1005: ScrollCmd(scrollPtr, scrollPtr->firstUnit - 1);
1006: } else {
1007: ScrollCmd(scrollPtr, scrollPtr->firstUnit
1008: - (scrollPtr->windowUnits-1));
1009: }
1010: break;
1011: case BOTTOM_GAP: {
1012: if (scrollPtr->windowUnits <= 1) {
1013: ScrollCmd(scrollPtr, scrollPtr->firstUnit + 1);
1014: } else {
1015: ScrollCmd(scrollPtr, scrollPtr->firstUnit
1016: + (scrollPtr->windowUnits-1));
1017: }
1018: break;
1019: }
1020: case BOTTOM_ARROW:
1021: ScrollCmd(scrollPtr, scrollPtr->firstUnit+1);
1022: break;
1023: }
1024: }
1025: if (scrollPtr->autoRepeat != NULL) {
1026: Tk_DeleteTimerHandler(scrollPtr->autoRepeat);
1027: scrollPtr->autoRepeat = NULL;
1028: }
1029: EventuallyRedraw(scrollPtr);
1030: scrollPtr->pressField = -1;
1031: ScrollbarNewField(scrollPtr,
1032: ScrollbarPosition(scrollPtr, eventPtr->xbutton.x,
1033: eventPtr->xbutton.y));
1034: }
1035: Tk_Release((ClientData) scrollPtr);
1036: }
1037:
1038: /*
1039: *--------------------------------------------------------------
1040: *
1041: * ScrollCmd --
1042: *
1043: * This procedure takes care of invoking a scrolling Tcl
1044: * command and reporting any error that occurs in it.
1045: *
1046: * Results:
1047: * None.
1048: *
1049: * Side effects:
1050: * A Tcl command is invoked, and an additional error-processing
1051: * command may also be invoked.
1052: *
1053: *--------------------------------------------------------------
1054: */
1055:
1056: static void
1057: ScrollCmd(scrollPtr, unit)
1058: register Scrollbar *scrollPtr; /* Scrollbar from which to issue
1059: * command. */
1060: int unit; /* Unit position within thing being
1061: * being displayed that should appear
1062: * at top or right of screen. */
1063: {
1064: char string[20];
1065: int result;
1066:
1067: if ((unit == scrollPtr->firstUnit) || (scrollPtr->command == NULL)) {
1068: return;
1069: }
1070: sprintf(string, " %d", unit);
1071: result = Tcl_VarEval(scrollPtr->interp, scrollPtr->command, string,
1072: (char *) NULL);
1073: if (result != TCL_OK) {
1074: TkBindError(scrollPtr->interp);
1075: }
1076: }
1077:
1078: /*
1079: *--------------------------------------------------------------
1080: *
1081: * EventuallyRedraw --
1082: *
1083: * Arrange for one or more of the fields of a scrollbar
1084: * to be redrawn.
1085: *
1086: * Results:
1087: * None.
1088: *
1089: * Side effects:
1090: * None.
1091: *
1092: *--------------------------------------------------------------
1093: */
1094:
1095: static void
1096: EventuallyRedraw(scrollPtr)
1097: register Scrollbar *scrollPtr; /* Information about widget. */
1098: {
1099: if ((scrollPtr->tkwin == NULL) || (!Tk_IsMapped(scrollPtr->tkwin))) {
1100: return;
1101: }
1102: if ((scrollPtr->flags & REDRAW_PENDING) == 0) {
1103: Tk_DoWhenIdle(DisplayScrollbar, (ClientData) scrollPtr);
1104: scrollPtr->flags |= REDRAW_PENDING;
1105: }
1106: }
1107:
1108: /*
1109: *--------------------------------------------------------------
1110: *
1111: * ScrollbarNewField --
1112: *
1113: * This procedure is called to declare that the mouse is in
1114: * a particular field of the scrollbar (e.g. top arrow), so
1115: * that the field can be highlighed and the previous field
1116: * can be returned to normal display.
1117: *
1118: * Results:
1119: * None.
1120: *
1121: * Side effects:
1122: * Fields may be redisplayed.
1123: *
1124: *--------------------------------------------------------------
1125: */
1126:
1127: static void
1128: ScrollbarNewField(scrollPtr, field)
1129: register Scrollbar *scrollPtr; /* Information about widget. */
1130: int field; /* Identifies field under mouse,
1131: * e.g. TOP_ARROW. */
1132: {
1133: if (field == scrollPtr->mouseField) {
1134: return;
1135: }
1136: EventuallyRedraw(scrollPtr);
1137: scrollPtr->mouseField = field;
1138: }
1139:
1140: /*
1141: *--------------------------------------------------------------
1142: *
1143: * ScrollbarTimerProc --
1144: *
1145: * This procedure is invoked as a Tk timer handler for actions
1146: * that auto-repeat (mouse presses in an arrow or gap). It
1147: * performs the auto-repeat action.
1148: *
1149: * Results:
1150: * None.
1151: *
1152: * Side effects:
1153: * Whatever action corresponds to the current mouse button
1154: * is repeated, and this procedure is rescheduled to execute
1155: * again later.
1156: *
1157: *--------------------------------------------------------------
1158: */
1159:
1160: static void
1161: ScrollbarTimerProc(clientData)
1162: ClientData clientData; /* Information about widget. */
1163: {
1164: register Scrollbar *scrollPtr = (Scrollbar *) clientData;
1165:
1166: Tk_Preserve((ClientData) scrollPtr);
1167: switch(scrollPtr->pressField) {
1168: case TOP_ARROW:
1169: ScrollCmd(scrollPtr, scrollPtr->firstUnit-1);
1170: break;
1171: case TOP_GAP:
1172: ScrollCmd(scrollPtr, scrollPtr->firstUnit
1173: - (scrollPtr->windowUnits-1));
1174: break;
1175: case BOTTOM_GAP: {
1176: ScrollCmd(scrollPtr, scrollPtr->firstUnit
1177: + (scrollPtr->windowUnits-1));
1178: break;
1179: }
1180: case BOTTOM_ARROW:
1181: ScrollCmd(scrollPtr, scrollPtr->firstUnit+1);
1182: break;
1183: }
1184: if (scrollPtr->tkwin != NULL) {
1185: scrollPtr->autoRepeat = Tk_CreateTimerHandler(
1186: scrollPtr->repeatInterval, ScrollbarTimerProc,
1187: (ClientData) scrollPtr);
1188: }
1189: Tk_Release((ClientData) scrollPtr);
1190: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.