![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tkscale.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 tkscale.c CVS log | Up to [Micropolis - Activity] / micropolis / src / tk |
1.1 root 1: /*
2: * tkScale.c --
3: *
4: * This module implements a scale widgets for the Tk toolkit.
5: * A scale displays a slider that can be adjusted to change a
6: * value; it also displays numeric labels and a textual label,
7: * if desired.
8: *
9: * Copyright 1990 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/tkScale.c,v 1.28 92/08/21 11:45:25 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 scale
29: * widget managed by this file:
30: */
31:
32: typedef struct {
33: Tk_Window tkwin; /* Window that embodies the scale. 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 scale. */
38: Tk_Uid orientUid; /* Orientation for window ("vertical" or
39: * "horizontal"). */
40: int vertical; /* Non-zero means vertical orientation,
41: * zero means horizontal. */
42: int value; /* Current value of scale. */
43: int fromValue; /* Value corresponding to left or top of
44: * scale. */
45: int toValue; /* Value corresponding to right or bottom
46: * of scale. */
47: int tickInterval; /* Distance between tick marks; 0 means
48: * don't display any tick marks. */
49: char *command; /* Command prefix to use when invoking Tcl
50: * commands because the scale value changed.
51: * NULL means don't invoke commands.
52: * Malloc'ed. */
53: int commandLength; /* Number of non-NULL bytes in command. */
54: char *label; /* Label to display above or to right of
55: * scale; NULL means don't display a
56: * label. Malloc'ed. */
57: int labelLength; /* Number of non-NULL chars. in label. */
58: Tk_Uid state; /* Normal or disabled. Value cannot be
59: * changed when scale is disabled. */
60:
61: /*
62: * Information used when displaying widget:
63: */
64:
65: int borderWidth; /* Width of 3-D border around window. */
66: Tk_3DBorder bgBorder; /* Used for drawing background. */
67: Tk_3DBorder sliderBorder; /* Used for drawing slider in normal mode. */
68: Tk_3DBorder activeBorder; /* Used for drawing slider when active (i.e.
69: * when mouse is in window). */
70: XFontStruct *fontPtr; /* Information about text font, or NULL. */
71: XColor *textColorPtr; /* Color for drawing text. */
72: GC textGC; /* GC for drawing text in normal mode. */
73: int width; /* Desired narrow dimension of scale,
74: * in pixels. */
75: int length; /* Desired long dimension of scale,
76: * in pixels. */
77: int relief; /* Indicates whether window as a whole is
78: * raised, sunken, or flat. */
79: int offset; /* Zero if relief is TK_RELIEF_FLAT,
80: * borderWidth otherwise. Indicates how
81: * much interior stuff must be offset from
82: * outside edges to leave room for border. */
83: int sliderLength; /* Length of slider, measured in pixels along
84: * long dimension of scale. */
85: int showValue; /* Non-zero means to display the scale value
86: * below or to the left of the slider; zero
87: * means don't display the value. */
88: int tickPixels; /* Number of pixels required for widest tick
89: * mark. 0 means don't display ticks.*/
90: int valuePixels; /* Number of pixels required for value text. */
91: int labelPixels; /* Number of pixels required for label. 0
92: * means don't display label. */
93:
94: /*
95: * Miscellaneous information:
96: */
97:
98: Cursor cursor; /* Current cursor for window, or None. */
99: int flags; /* Various flags; see below for
100: * definitions. */
101: } Scale;
102:
103: /*
104: * Flag bits for scales:
105: *
106: * REDRAW_SLIDER - 1 means slider (and numerical readout) need
107: * to be redrawn.
108: * REDRAW_OTHER - 1 means other stuff besides slider and value
109: * need to be redrawn.
110: * REDRAW_ALL - 1 means the entire widget needs to be redrawn.
111: * ACTIVE - 1 means the widget is active (the mouse is
112: * in its window).
113: * BUTTON_PRESSED - 1 means a button press is in progress, so
114: * slider should appear depressed and should be
115: * draggable.
116: */
117:
118: #define REDRAW_SLIDER 1
119: #define REDRAW_OTHER 2
120: #define REDRAW_ALL 3
121: #define ACTIVE 4
122: #define BUTTON_PRESSED 8
123:
124: /*
125: * Space to leave between scale area and text.
126: */
127:
128: #define SPACING 2
129:
130: /*
131: * Information used for argv parsing.
132: */
133:
134:
135: static Tk_ConfigSpec configSpecs[] = {
136: {TK_CONFIG_BORDER, "-activeforeground", "activeForeground", "Background",
137: DEF_SCALE_ACTIVE_FG_COLOR, Tk_Offset(Scale, activeBorder),
138: TK_CONFIG_COLOR_ONLY},
139: {TK_CONFIG_BORDER, "-activeforeground", "activeForeground", "Background",
140: DEF_SCALE_ACTIVE_FG_MONO, Tk_Offset(Scale, activeBorder),
141: TK_CONFIG_MONO_ONLY},
142: {TK_CONFIG_BORDER, "-background", "background", "Background",
143: DEF_SCALE_BG_COLOR, Tk_Offset(Scale, bgBorder),
144: TK_CONFIG_COLOR_ONLY},
145: {TK_CONFIG_BORDER, "-background", "background", "Background",
146: DEF_SCALE_BG_MONO, Tk_Offset(Scale, bgBorder),
147: TK_CONFIG_MONO_ONLY},
148: {TK_CONFIG_SYNONYM, "-bd", "borderWidth", (char *) NULL,
149: (char *) NULL, 0, 0},
150: {TK_CONFIG_SYNONYM, "-bg", "background", (char *) NULL,
151: (char *) NULL, 0, 0},
152: {TK_CONFIG_PIXELS, "-borderwidth", "borderWidth", "BorderWidth",
153: DEF_SCALE_BORDER_WIDTH, Tk_Offset(Scale, borderWidth), 0},
154: {TK_CONFIG_STRING, "-command", "command", "Command",
155: (char *) NULL, Tk_Offset(Scale, command), 0},
156: {TK_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor",
157: DEF_SCALE_CURSOR, Tk_Offset(Scale, cursor), TK_CONFIG_NULL_OK},
158: {TK_CONFIG_SYNONYM, "-fg", "foreground", (char *) NULL,
159: (char *) NULL, 0, 0},
160: {TK_CONFIG_FONT, "-font", "font", "Font",
161: DEF_SCALE_FONT, Tk_Offset(Scale, fontPtr),
162: 0},
163: {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
164: DEF_SCALE_FG_COLOR, Tk_Offset(Scale, textColorPtr),
165: TK_CONFIG_COLOR_ONLY},
166: {TK_CONFIG_COLOR, "-foreground", "foreground", "Foreground",
167: DEF_SCALE_FG_MONO, Tk_Offset(Scale, textColorPtr),
168: TK_CONFIG_MONO_ONLY},
169: {TK_CONFIG_INT, "-from", "from", "From",
170: DEF_SCALE_FROM, Tk_Offset(Scale, fromValue), 0},
171: {TK_CONFIG_STRING, "-label", "label", "Label",
172: DEF_SCALE_LABEL, Tk_Offset(Scale, label), 0},
173: {TK_CONFIG_PIXELS, "-length", "length", "Length",
174: DEF_SCALE_LENGTH, Tk_Offset(Scale, length), 0},
175: {TK_CONFIG_UID, "-orient", "orient", "Orient",
176: DEF_SCALE_ORIENT, Tk_Offset(Scale, orientUid), 0},
177: {TK_CONFIG_RELIEF, "-relief", "relief", "Relief",
178: DEF_SCALE_RELIEF, Tk_Offset(Scale, relief), 0},
179: {TK_CONFIG_BOOLEAN, "-showvalue", "showValue", "ShowValue",
180: DEF_SCALE_SHOW_VALUE, Tk_Offset(Scale, showValue), 0},
181: {TK_CONFIG_BORDER, "-sliderforeground", "sliderForeground", "Background",
182: DEF_SCALE_SLIDER_FG_COLOR, Tk_Offset(Scale, sliderBorder),
183: TK_CONFIG_COLOR_ONLY},
184: {TK_CONFIG_BORDER, "-sliderforeground", "sliderForeground", "Background",
185: DEF_SCALE_SLIDER_FG_MONO, Tk_Offset(Scale, sliderBorder),
186: TK_CONFIG_MONO_ONLY},
187: {TK_CONFIG_PIXELS, "-sliderlength", "sliderLength", "SliderLength",
188: DEF_SCALE_SLIDER_LENGTH, Tk_Offset(Scale, sliderLength), 0},
189: {TK_CONFIG_UID, "-state", "state", "State",
190: DEF_SCALE_STATE, Tk_Offset(Scale, state), 0},
191: {TK_CONFIG_INT, "-tickinterval", "tickInterval", "TickInterval",
192: DEF_SCALE_TICK_INTERVAL, Tk_Offset(Scale, tickInterval), 0},
193: {TK_CONFIG_INT, "-to", "to", "To",
194: DEF_SCALE_TO, Tk_Offset(Scale, toValue), 0},
195: {TK_CONFIG_PIXELS, "-width", "width", "Width",
196: DEF_SCALE_WIDTH, Tk_Offset(Scale, width), 0},
197: {TK_CONFIG_END, (char *) NULL, (char *) NULL, (char *) NULL,
198: (char *) NULL, 0, 0}
199: };
200:
201: /*
202: * Forward declarations for procedures defined later in this file:
203: */
204:
205: static void ComputeScaleGeometry _ANSI_ARGS_((Scale *scalePtr));
206: static int ConfigureScale _ANSI_ARGS_((Tcl_Interp *interp,
207: Scale *scalePtr, int argc, char **argv,
208: int flags));
209: static void DestroyScale _ANSI_ARGS_((ClientData clientData));
210: static void DisplayHorizontalScale _ANSI_ARGS_((
211: ClientData clientData));
212: static void DisplayHorizontalValue _ANSI_ARGS_((Scale *scalePtr,
213: int value, int bottom));
214: static void DisplayVerticalScale _ANSI_ARGS_((
215: ClientData clientData));
216: static void DisplayVerticalValue _ANSI_ARGS_((Scale *scalePtr,
217: int value, int rightEdge));
218: static void EventuallyRedrawScale _ANSI_ARGS_((Scale *scalePtr,
219: int what));
220: static int PixelToValue _ANSI_ARGS_((Scale *scalePtr, int x,
221: int y));
222: static void ScaleEventProc _ANSI_ARGS_((ClientData clientData,
223: XEvent *eventPtr));
224: static void ScaleMouseProc _ANSI_ARGS_((ClientData clientData,
225: XEvent *eventPtr));
226: static int ScaleWidgetCmd _ANSI_ARGS_((ClientData clientData,
227: Tcl_Interp *interp, int argc, char **argv));
228: static void SetScaleValue _ANSI_ARGS_((Scale *scalePtr,
229: int value));
230: static int ValueToPixel _ANSI_ARGS_((Scale *scalePtr, int value));
231:
232: /*
233: *--------------------------------------------------------------
234: *
235: * Tk_ScaleCmd --
236: *
237: * This procedure is invoked to process the "scale" Tcl
238: * command. See the user documentation for details on what
239: * it does.
240: *
241: * Results:
242: * A standard Tcl result.
243: *
244: * Side effects:
245: * See the user documentation.
246: *
247: *--------------------------------------------------------------
248: */
249:
250: int
251: Tk_ScaleCmd(clientData, interp, argc, argv)
252: ClientData clientData; /* Main window associated with
253: * interpreter. */
254: Tcl_Interp *interp; /* Current interpreter. */
255: int argc; /* Number of arguments. */
256: char **argv; /* Argument strings. */
257: {
258: Tk_Window tkwin = (Tk_Window) clientData;
259: register Scale *scalePtr;
260: Tk_Window new;
261:
262: if (argc < 2) {
263: Tcl_AppendResult(interp, "wrong # args: should be \"",
264: argv[0], " pathName ?options?\"", (char *) NULL);
265: return TCL_ERROR;
266: }
267:
268: new = Tk_CreateWindowFromPath(interp, tkwin, argv[1], (char *) NULL);
269: if (new == NULL) {
270: return TCL_ERROR;
271: }
272:
273: /*
274: * Initialize fields that won't be initialized by ConfigureScale,
275: * or which ConfigureScale expects to have reasonable values
276: * (e.g. resource pointers).
277: */
278:
279: scalePtr = (Scale *) ckalloc(sizeof(Scale));
280: scalePtr->tkwin = new;
281: scalePtr->interp = interp;
282: scalePtr->value = 0;
283: scalePtr->command = NULL;
284: scalePtr->label = NULL;
285: scalePtr->state = tkNormalUid;
286: scalePtr->bgBorder = NULL;
287: scalePtr->sliderBorder = NULL;
288: scalePtr->activeBorder = NULL;
289: scalePtr->fontPtr = NULL;
290: scalePtr->textColorPtr = NULL;
291: scalePtr->textGC = None;
292: scalePtr->cursor = None;
293: scalePtr->flags = 0;
294:
295: Tk_SetClass(scalePtr->tkwin, "Scale");
296: Tk_CreateEventHandler(scalePtr->tkwin, ExposureMask|StructureNotifyMask,
297: ScaleEventProc, (ClientData) scalePtr);
298: Tk_CreateEventHandler(scalePtr->tkwin, EnterWindowMask|LeaveWindowMask
299: |PointerMotionMask|ButtonPressMask|ButtonReleaseMask,
300: ScaleMouseProc, (ClientData) scalePtr);
301: Tcl_CreateCommand(interp, Tk_PathName(scalePtr->tkwin), ScaleWidgetCmd,
302: (ClientData) scalePtr, (void (*)()) NULL);
303: if (ConfigureScale(interp, scalePtr, argc-2, argv+2, 0) != TCL_OK) {
304: goto error;
305: }
306:
307: interp->result = Tk_PathName(scalePtr->tkwin);
308: return TCL_OK;
309:
310: error:
311: Tk_DestroyWindow(scalePtr->tkwin);
312: return TCL_ERROR;
313: }
314:
315: /*
316: *--------------------------------------------------------------
317: *
318: * ScaleWidgetCmd --
319: *
320: * This procedure is invoked to process the Tcl command
321: * that corresponds to a widget managed by this module.
322: * See the user documentation for details on what it does.
323: *
324: * Results:
325: * A standard Tcl result.
326: *
327: * Side effects:
328: * See the user documentation.
329: *
330: *--------------------------------------------------------------
331: */
332:
333: static int
334: ScaleWidgetCmd(clientData, interp, argc, argv)
335: ClientData clientData; /* Information about scale
336: * widget. */
337: Tcl_Interp *interp; /* Current interpreter. */
338: int argc; /* Number of arguments. */
339: char **argv; /* Argument strings. */
340: {
341: register Scale *scalePtr = (Scale *) clientData;
342: int result = TCL_OK;
343: int length;
344: char c;
345:
346: if (argc < 2) {
347: Tcl_AppendResult(interp, "wrong # args: should be \"",
348: argv[0], " option ?arg arg ...?\"", (char *) NULL);
349: return TCL_ERROR;
350: }
351: Tk_Preserve((ClientData) scalePtr);
352: c = argv[1][0];
353: length = strlen(argv[1]);
354: if ((c == 'c') && (strncmp(argv[1], "configure", length) == 0)) {
355: if (argc == 2) {
356: result = Tk_ConfigureInfo(interp, scalePtr->tkwin, configSpecs,
357: (char *) scalePtr, (char *) NULL, 0);
358: } else if (argc == 3) {
359: result = Tk_ConfigureInfo(interp, scalePtr->tkwin, configSpecs,
360: (char *) scalePtr, argv[2], 0);
361: } else {
362: result = ConfigureScale(interp, scalePtr, argc-2, argv+2,
363: TK_CONFIG_ARGV_ONLY);
364: }
365: } else if ((c == 'g') && (strncmp(argv[1], "get", length) == 0)) {
366: if (argc != 2) {
367: Tcl_AppendResult(interp, "wrong # args: should be \"",
368: argv[0], " get\"", (char *) NULL);
369: goto error;
370: }
371: sprintf(interp->result, "%d", scalePtr->value);
372: } else if ((c == 's') && (strncmp(argv[1], "set", length) == 0)) {
373: int value;
374:
375: if (argc != 3) {
376: Tcl_AppendResult(interp, "wrong # args: should be \"",
377: argv[0], " set value\"", (char *) NULL);
378: goto error;
379: }
380: if (Tcl_GetInt(interp, argv[2], &value) != TCL_OK) {
381: goto error;
382: }
383: if (scalePtr->state == tkNormalUid) {
384: if ((value < scalePtr->fromValue)
385: ^ (scalePtr->toValue < scalePtr->fromValue)) {
386: value = scalePtr->fromValue;
387: }
388: if ((value > scalePtr->toValue)
389: ^ (scalePtr->toValue < scalePtr->fromValue)) {
390: value = scalePtr->toValue;
391: }
392: SetScaleValue(scalePtr, value);
393: }
394: } else {
395: Tcl_AppendResult(interp, "bad option \"", argv[1],
396: "\": must be configure, get, or set", (char *) NULL);
397: goto error;
398: }
399: Tk_Release((ClientData) scalePtr);
400: return result;
401:
402: error:
403: Tk_Release((ClientData) scalePtr);
404: return TCL_ERROR;
405: }
406:
407: /*
408: *----------------------------------------------------------------------
409: *
410: * DestroyScale --
411: *
412: * This procedure is invoked by Tk_EventuallyFree or Tk_Release
413: * to clean up the internal structure of a button at a safe time
414: * (when no-one is using it anymore).
415: *
416: * Results:
417: * None.
418: *
419: * Side effects:
420: * Everything associated with the scale is freed up.
421: *
422: *----------------------------------------------------------------------
423: */
424:
425: static void
426: DestroyScale(clientData)
427: ClientData clientData; /* Info about scale widget. */
428: {
429: register Scale *scalePtr = (Scale *) clientData;
430:
431: if (scalePtr->command != NULL) {
432: ckfree(scalePtr->command);
433: }
434: if (scalePtr->label != NULL) {
435: ckfree(scalePtr->label);
436: }
437: if (scalePtr->bgBorder != NULL) {
438: Tk_Free3DBorder(scalePtr->bgBorder);
439: }
440: if (scalePtr->sliderBorder != NULL) {
441: Tk_Free3DBorder(scalePtr->sliderBorder);
442: }
443: if (scalePtr->activeBorder != NULL) {
444: Tk_Free3DBorder(scalePtr->activeBorder);
445: }
446: if (scalePtr->fontPtr != NULL) {
447: Tk_FreeFontStruct(scalePtr->fontPtr);
448: }
449: if (scalePtr->textColorPtr != NULL) {
450: Tk_FreeColor(scalePtr->textColorPtr);
451: }
452: if (scalePtr->textGC != None) {
453: Tk_FreeGC(scalePtr->textGC);
454: }
455: if (scalePtr->cursor != None) {
456: Tk_FreeCursor(scalePtr->cursor);
457: }
458: ckfree((char *) scalePtr);
459: }
460:
461: /*
462: *----------------------------------------------------------------------
463: *
464: * ConfigureScale --
465: *
466: * This procedure is called to process an argv/argc list, plus
467: * the Tk option database, in order to configure (or
468: * reconfigure) a scale widget.
469: *
470: * Results:
471: * The return value is a standard Tcl result. If TCL_ERROR is
472: * returned, then interp->result contains an error message.
473: *
474: * Side effects:
475: * Configuration information, such as colors, border width,
476: * etc. get set for scalePtr; old resources get freed,
477: * if there were any.
478: *
479: *----------------------------------------------------------------------
480: */
481:
482: static int
483: ConfigureScale(interp, scalePtr, argc, argv, flags)
484: Tcl_Interp *interp; /* Used for error reporting. */
485: register Scale *scalePtr; /* Information about widget; may or may
486: * not already have values for some fields. */
487: int argc; /* Number of valid entries in argv. */
488: char **argv; /* Arguments. */
489: int flags; /* Flags to pass to Tk_ConfigureWidget. */
490: {
491: XGCValues gcValues;
492: GC newGC;
493: int length;
494:
495: if (Tk_ConfigureWidget(interp, scalePtr->tkwin, configSpecs,
496: argc, argv, (char *) scalePtr, 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(scalePtr->orientUid);
506: if (strncmp(scalePtr->orientUid, "vertical", length) == 0) {
507: scalePtr->vertical = 1;
508: } else if (strncmp(scalePtr->orientUid, "horizontal", length) == 0) {
509: scalePtr->vertical = 0;
510: } else {
511: Tcl_AppendResult(interp, "bad orientation \"", scalePtr->orientUid,
512: "\": must be vertical or horizontal", (char *) NULL);
513: return TCL_ERROR;
514: }
515:
516: if ((scalePtr->state != tkNormalUid)
517: && (scalePtr->state != tkDisabledUid)) {
518: Tcl_AppendResult(interp, "bad state value \"", scalePtr->state,
519: "\": must be normal or disabled", (char *) NULL);
520: scalePtr->state = tkNormalUid;
521: return TCL_ERROR;
522: }
523:
524: /*
525: * Make sure that the tick interval has the right sign so that
526: * addition moves from fromValue to toValue.
527: */
528:
529: if ((scalePtr->tickInterval < 0)
530: ^ ((scalePtr->toValue - scalePtr->fromValue) < 0)) {
531: scalePtr->tickInterval = -scalePtr->tickInterval;
532: }
533:
534: /*
535: * Set the scale value to itself; all this does is to make sure
536: * that the scale's value is within the new acceptable range for
537: * the scale.
538: */
539:
540: SetScaleValue(scalePtr, scalePtr->value);
541:
542: if (scalePtr->command != NULL) {
543: scalePtr->commandLength = strlen(scalePtr->command);
544: } else {
545: scalePtr->commandLength = 0;
546: }
547:
548: if (scalePtr->label != NULL) {
549: scalePtr->labelLength = strlen(scalePtr->label);
550: } else {
551: scalePtr->labelLength = 0;
552: }
553:
554: Tk_SetBackgroundFromBorder(scalePtr->tkwin, scalePtr->bgBorder);
555:
556: gcValues.font = scalePtr->fontPtr->fid;
557: gcValues.foreground = scalePtr->textColorPtr->pixel;
558: newGC = Tk_GetGC(scalePtr->tkwin, GCForeground|GCFont, &gcValues);
559: if (scalePtr->textGC != None) {
560: Tk_FreeGC(scalePtr->textGC);
561: }
562: scalePtr->textGC = newGC;
563:
564: if (scalePtr->relief != TK_RELIEF_FLAT) {
565: scalePtr->offset = scalePtr->borderWidth;
566: } else {
567: scalePtr->offset = 0;
568: }
569:
570: /*
571: * Recompute display-related information, and let the geometry
572: * manager know how much space is needed now.
573: */
574:
575: ComputeScaleGeometry(scalePtr);
576:
577: EventuallyRedrawScale(scalePtr, REDRAW_ALL);
578: return TCL_OK;
579: }
580:
581: /*
582: *----------------------------------------------------------------------
583: *
584: * ComputeScaleGeometry --
585: *
586: * This procedure is called to compute various geometrical
587: * information for a scale, such as where various things get
588: * displayed. It's called when the window is reconfigured.
589: *
590: * Results:
591: * None.
592: *
593: * Side effects:
594: * Display-related numbers get changed in *scrollPtr. The
595: * geometry manager gets told about the window's preferred size.
596: *
597: *----------------------------------------------------------------------
598: */
599:
600: static void
601: ComputeScaleGeometry(scalePtr)
602: register Scale *scalePtr; /* Information about widget. */
603: {
604: XCharStruct bbox;
605: char valueString[30];
606: int dummy, lineHeight;
607:
608: /*
609: * Horizontal scales are simpler than vertical ones because
610: * all sizes are the same (the height of a line of text);
611: * handle them first and then quit.
612: */
613:
614: if (!scalePtr->vertical) {
615: lineHeight = scalePtr->fontPtr->ascent + scalePtr->fontPtr->descent;
616: if (scalePtr->tickInterval != 0) {
617: scalePtr->tickPixels = lineHeight;
618: } else {
619: scalePtr->tickPixels = 0;
620: }
621: if (scalePtr->showValue) {
622: scalePtr->valuePixels = lineHeight + SPACING;
623: } else {
624: scalePtr->valuePixels = 0;
625: }
626: if (scalePtr->labelLength != 0) {
627: scalePtr->labelPixels = lineHeight;
628: } else {
629: scalePtr->labelPixels = 0;
630: }
631:
632: Tk_GeometryRequest(scalePtr->tkwin,
633: scalePtr->length + 2*scalePtr->offset,
634: scalePtr->tickPixels + scalePtr->valuePixels
635: + scalePtr->width + 2*scalePtr->borderWidth
636: + scalePtr->labelPixels + 2*scalePtr->offset);
637: Tk_SetInternalBorder(scalePtr->tkwin, scalePtr->borderWidth);
638: return;
639: }
640:
641: /*
642: * Vertical scale: compute the amount of space needed for tick marks
643: * and current value by formatting strings for the two end points;
644: * use whichever length is longer.
645: */
646:
647: sprintf(valueString, "%d", scalePtr->fromValue);
648: XTextExtents(scalePtr->fontPtr, valueString, strlen(valueString),
649: &dummy, &dummy, &dummy, &bbox);
650: scalePtr->tickPixels = bbox.rbearing + bbox.lbearing;
651: sprintf(valueString, "%d", scalePtr->toValue);
652: XTextExtents(scalePtr->fontPtr, valueString, strlen(valueString),
653: &dummy, &dummy, &dummy, &bbox);
654: if (scalePtr->tickPixels < bbox.rbearing + bbox.lbearing) {
655: scalePtr->tickPixels = bbox.rbearing + bbox.lbearing;
656: }
657:
658: /*
659: * Pad the value with a bit of extra space for prettier printing.
660: */
661:
662: scalePtr->tickPixels += scalePtr->fontPtr->ascent/2;
663: scalePtr->valuePixels = scalePtr->tickPixels;
664: if (scalePtr->tickInterval == 0) {
665: scalePtr->tickPixels = 0;
666: }
667: if (!scalePtr->showValue) {
668: scalePtr->valuePixels = 0;
669: }
670:
671: if (scalePtr->labelLength == 0) {
672: scalePtr->labelPixels = 0;
673: } else {
674: XTextExtents(scalePtr->fontPtr, scalePtr->label,
675: scalePtr->labelLength, &dummy, &dummy, &dummy, &bbox);
676: scalePtr->labelPixels = bbox.rbearing + bbox.lbearing
677: + scalePtr->fontPtr->ascent;
678: }
679: Tk_GeometryRequest(scalePtr->tkwin, 4*scalePtr->borderWidth
680: + scalePtr->tickPixels + scalePtr->valuePixels + SPACING
681: + scalePtr->width + scalePtr->labelPixels,
682: scalePtr->length);
683: Tk_SetInternalBorder(scalePtr->tkwin, scalePtr->borderWidth);
684: }
685:
686: /*
687: *--------------------------------------------------------------
688: *
689: * DisplayVerticalScale --
690: *
691: * This procedure redraws the contents of a vertical scale
692: * window. It is invoked as a do-when-idle handler, so it only
693: * runs when there's nothing else for the application to do.
694: *
695: * Results:
696: * None.
697: *
698: * Side effects:
699: * Information appears on the screen.
700: *
701: *--------------------------------------------------------------
702: */
703:
704: static void
705: DisplayVerticalScale(clientData)
706: ClientData clientData; /* Information about widget. */
707: {
708: register Scale *scalePtr = (Scale *) clientData;
709: register Tk_Window tkwin = scalePtr->tkwin;
710: int tickRightEdge, valueRightEdge, labelLeftEdge, scaleLeftEdge;
711: int totalPixels, x, y, width, height, shadowWidth, tickValue;
712: int relief;
713: Tk_3DBorder sliderBorder;
714:
715: if ((scalePtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
716: goto done;
717: }
718:
719: /*
720: * Scanning from left to right across the window, the window
721: * will contain four columns: ticks, value, scale, and label.
722: * Compute the x-coordinate for each of the columns.
723: */
724:
725: totalPixels = scalePtr->tickPixels + scalePtr->valuePixels
726: + 2*scalePtr->borderWidth + scalePtr->width
727: + 2*SPACING + scalePtr->labelPixels;
728: tickRightEdge = (Tk_Width(tkwin) - totalPixels)/2 + scalePtr->tickPixels;
729: valueRightEdge = tickRightEdge + scalePtr->valuePixels;
730: scaleLeftEdge = valueRightEdge + SPACING;
731: labelLeftEdge = scaleLeftEdge + 2*scalePtr->borderWidth
732: + scalePtr->width + scalePtr->fontPtr->ascent/2;
733:
734: /*
735: * Display the information from left to right across the window.
736: */
737:
738: if (scalePtr->flags & REDRAW_OTHER) {
739: XClearWindow(Tk_Display(tkwin), Tk_WindowId(tkwin));
740:
741: /*
742: * Display the tick marks.
743: */
744:
745: if (scalePtr->tickPixels != 0) {
746: for (tickValue = scalePtr->fromValue; ;
747: tickValue += scalePtr->tickInterval) {
748: if (scalePtr->toValue > scalePtr->fromValue) {
749: if (tickValue > scalePtr->toValue) {
750: break;
751: }
752: } else {
753: if (tickValue < scalePtr->toValue) {
754: break;
755: }
756: }
757: DisplayVerticalValue(scalePtr, tickValue, tickRightEdge);
758: }
759: }
760: }
761:
762: /*
763: * Display the value, if it is desired. If not redisplaying the
764: * entire window, clear the area of the value to get rid of the
765: * old value displayed there.
766: */
767:
768: if (scalePtr->showValue) {
769: if (!(scalePtr->flags & REDRAW_OTHER)) {
770: XClearArea(Tk_Display(tkwin), Tk_WindowId(tkwin),
771: valueRightEdge-scalePtr->valuePixels, scalePtr->offset,
772: scalePtr->valuePixels,
773: Tk_Height(tkwin) - 2*scalePtr->offset, False);
774: }
775: DisplayVerticalValue(scalePtr, scalePtr->value, valueRightEdge);
776: }
777:
778: /*
779: * Display the scale and the slider. If not redisplaying the
780: * entire window, must clear the trench area to erase the old
781: * slider, but don't need to redraw the border.
782: */
783:
784: if (scalePtr->flags & REDRAW_OTHER) {
785: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin),
786: scalePtr->bgBorder, scaleLeftEdge, scalePtr->offset,
787: scalePtr->width + 2*scalePtr->borderWidth,
788: Tk_Height(tkwin) - 2*scalePtr->offset, scalePtr->borderWidth,
789: TK_RELIEF_SUNKEN);
790: } else {
791: XClearArea(Tk_Display(tkwin), Tk_WindowId(tkwin),
792: scaleLeftEdge + scalePtr->borderWidth,
793: scalePtr->offset + scalePtr->borderWidth,
794: scalePtr->width,
795: Tk_Height(tkwin) - 2*scalePtr->offset
796: - 2*scalePtr->borderWidth, False);
797: }
798: if (scalePtr->flags & ACTIVE) {
799: sliderBorder = scalePtr->activeBorder;
800: } else {
801: sliderBorder = scalePtr->sliderBorder;
802: }
803: width = scalePtr->width;
804: height = scalePtr->sliderLength/2;
805: x = scaleLeftEdge + scalePtr->borderWidth;
806: y = ValueToPixel(scalePtr, scalePtr->value) - height;
807: shadowWidth = scalePtr->borderWidth/2;
808: if (shadowWidth == 0) {
809: shadowWidth = 1;
810: }
811: relief = (scalePtr->flags & BUTTON_PRESSED) ? TK_RELIEF_SUNKEN
812: : TK_RELIEF_RAISED;
813: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), sliderBorder,
814: x, y, width, 2*height, shadowWidth, relief);
815: x += shadowWidth;
816: y += shadowWidth;
817: width -= 2*shadowWidth;
818: height -= shadowWidth;
819: Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), sliderBorder,
820: x, y, width, height, shadowWidth, relief);
821: Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), sliderBorder,
822: x, y+height, width, height, shadowWidth, relief);
823:
824: /*
825: * Draw the label to the right of the scale.
826: */
827:
828: if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelPixels != 0)) {
829: XDrawString(Tk_Display(scalePtr->tkwin), Tk_WindowId(scalePtr->tkwin),
830: scalePtr->textGC, labelLeftEdge,
831: scalePtr->offset + (3*scalePtr->fontPtr->ascent)/2,
832: scalePtr->label, scalePtr->labelLength);
833: }
834:
835: /*
836: * Draw the window border.
837: */
838:
839: if ((scalePtr->flags & REDRAW_OTHER)
840: && (scalePtr->relief != TK_RELIEF_FLAT)) {
841: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin),
842: scalePtr->bgBorder, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin),
843: scalePtr->borderWidth, scalePtr->relief);
844: }
845:
846: done:
847: scalePtr->flags &= ~REDRAW_ALL;
848: }
849:
850: /*
851: *----------------------------------------------------------------------
852: *
853: * DisplayVerticalValue --
854: *
855: * This procedure is called to display values (scale readings)
856: * for vertically-oriented scales.
857: *
858: * Results:
859: * None.
860: *
861: * Side effects:
862: * The numerical value corresponding to value is displayed with
863: * its right edge at "rightEdge", and at a vertical position in
864: * the scale that corresponds to "value".
865: *
866: *----------------------------------------------------------------------
867: */
868:
869: static void
870: DisplayVerticalValue(scalePtr, value, rightEdge)
871: register Scale *scalePtr; /* Information about widget in which to
872: * display value. */
873: int value; /* Y-coordinate of number to display,
874: * specified in application coords, not
875: * in pixels (we'll compute pixels). */
876: int rightEdge; /* X-coordinate of right edge of text,
877: * specified in pixels. */
878: {
879: register Tk_Window tkwin = scalePtr->tkwin;
880: int y, dummy, length;
881: char valueString[30];
882: XCharStruct bbox;
883:
884: y = ValueToPixel(scalePtr, value) + scalePtr->fontPtr->ascent/2;
885: sprintf(valueString, "%d", value);
886: length = strlen(valueString);
887: XTextExtents(scalePtr->fontPtr, valueString, length,
888: &dummy, &dummy, &dummy, &bbox);
889:
890: /*
891: * Adjust the y-coordinate if necessary to keep the text entirely
892: * inside the window.
893: */
894:
895: if ((y - bbox.ascent) < scalePtr->offset) {
896: y = scalePtr->offset + bbox.ascent;
897: }
898: if ((y + bbox.descent) > (Tk_Height(tkwin) - scalePtr->offset)) {
899: y = Tk_Height(tkwin) - scalePtr->offset - bbox.descent;
900: }
901: XDrawString(Tk_Display(tkwin), Tk_WindowId(tkwin),
902: scalePtr->textGC, rightEdge - bbox.rbearing,
903: y, valueString, length);
904: }
905:
906: /*
907: *--------------------------------------------------------------
908: *
909: * DisplayHorizontalScale --
910: *
911: * This procedure redraws the contents of a horizontal scale
912: * window. It is invoked as a do-when-idle handler, so it only
913: * runs when there's nothing else for the application to do.
914: *
915: * Results:
916: * None.
917: *
918: * Side effects:
919: * Information appears on the screen.
920: *
921: *--------------------------------------------------------------
922: */
923:
924: static void
925: DisplayHorizontalScale(clientData)
926: ClientData clientData; /* Information about widget. */
927: {
928: register Scale *scalePtr = (Scale *) clientData;
929: register Tk_Window tkwin = scalePtr->tkwin;
930: int tickBottom, valueBottom, labelBottom, scaleBottom;
931: int totalPixels, x, y, width, height, shadowWidth, tickValue;
932: int relief;
933: Tk_3DBorder sliderBorder;
934:
935: if ((scalePtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
936: goto done;
937: }
938:
939: /*
940: * Scanning from bottom to top across the window, the window
941: * will contain four rows: ticks, value, scale, and label.
942: * Compute the y-coordinate for each of the rows.
943: */
944:
945: totalPixels = scalePtr->tickPixels + scalePtr->valuePixels
946: + 2*scalePtr->borderWidth + scalePtr->width
947: + scalePtr->labelPixels;
948: tickBottom = (Tk_Height(tkwin) + totalPixels)/2 - 1;
949: valueBottom = tickBottom - scalePtr->tickPixels;
950: scaleBottom = valueBottom - scalePtr->valuePixels;
951: labelBottom = scaleBottom - 2*scalePtr->borderWidth - scalePtr->width;
952:
953: /*
954: * Display the information from bottom to top across the window.
955: */
956:
957: if (scalePtr->flags & REDRAW_OTHER) {
958: XClearWindow(Tk_Display(tkwin), Tk_WindowId(tkwin));
959:
960: /*
961: * Display the tick marks.
962: */
963:
964: if (scalePtr->tickPixels != 0) {
965: for (tickValue = scalePtr->fromValue; ;
966: tickValue += scalePtr->tickInterval) {
967: if (scalePtr->toValue > scalePtr->fromValue) {
968: if (tickValue > scalePtr->toValue) {
969: break;
970: }
971: } else {
972: if (tickValue < scalePtr->toValue) {
973: break;
974: }
975: }
976: DisplayHorizontalValue(scalePtr, tickValue, tickBottom);
977: }
978: }
979: }
980:
981: /*
982: * Display the value, if it is desired. If not redisplaying the
983: * entire window, clear the area of the value to get rid of the
984: * old value displayed there.
985: */
986:
987: if (scalePtr->showValue) {
988: if (!(scalePtr->flags & REDRAW_OTHER)) {
989: XClearArea(Tk_Display(tkwin), Tk_WindowId(tkwin),
990: scalePtr->offset, scaleBottom + 1,
991: Tk_Width(tkwin) - 2*scalePtr->offset,
992: valueBottom - scaleBottom, False);
993: }
994: DisplayHorizontalValue(scalePtr, scalePtr->value, valueBottom);
995: }
996:
997: /*
998: * Display the scale and the slider. If not redisplaying the
999: * entire window, must clear the trench area to erase the old
1000: * slider, but don't need to redraw the border.
1001: */
1002:
1003: y = scaleBottom - 2*scalePtr->borderWidth - scalePtr->width + 1;
1004: if (scalePtr->flags & REDRAW_OTHER) {
1005: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin),
1006: scalePtr->bgBorder, scalePtr->offset, y,
1007: Tk_Width(tkwin) - 2*scalePtr->offset,
1008: scalePtr->width + 2*scalePtr->borderWidth,
1009: scalePtr->borderWidth, TK_RELIEF_SUNKEN);
1010: } else {
1011: XClearArea(Tk_Display(tkwin), Tk_WindowId(tkwin),
1012: scalePtr->offset + scalePtr->borderWidth,
1013: y + scalePtr->borderWidth,
1014: Tk_Width(tkwin) - 2*scalePtr->offset - 2*scalePtr->borderWidth,
1015: scalePtr->width, False);
1016: }
1017: if (scalePtr->flags & ACTIVE) {
1018: sliderBorder = scalePtr->activeBorder;
1019: } else {
1020: sliderBorder = scalePtr->sliderBorder;
1021: }
1022: width = scalePtr->sliderLength/2;
1023: height = scalePtr->width;
1024: x = ValueToPixel(scalePtr, scalePtr->value) - width;
1025: y += scalePtr->borderWidth;
1026: shadowWidth = scalePtr->borderWidth/2;
1027: if (shadowWidth == 0) {
1028: shadowWidth = 1;
1029: }
1030: relief = (scalePtr->flags & BUTTON_PRESSED) ? TK_RELIEF_SUNKEN
1031: : TK_RELIEF_RAISED;
1032: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), sliderBorder,
1033: x, y, 2*width, height, shadowWidth, relief);
1034: x += shadowWidth;
1035: y += shadowWidth;
1036: width -= shadowWidth;
1037: height -= 2*shadowWidth;
1038: Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), sliderBorder,
1039: x, y, width, height, shadowWidth, relief);
1040: Tk_Fill3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin), sliderBorder,
1041: x+width, y, width, height, shadowWidth, relief);
1042:
1043: /*
1044: * Draw the label to the top of the scale.
1045: */
1046:
1047: if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelPixels != 0)) {
1048: XDrawString(Tk_Display(scalePtr->tkwin), Tk_WindowId(scalePtr->tkwin),
1049: scalePtr->textGC, scalePtr->offset + scalePtr->fontPtr->ascent/2,
1050: labelBottom - scalePtr->fontPtr->descent,
1051: scalePtr->label, scalePtr->labelLength);
1052: }
1053:
1054: /*
1055: * Draw the window border.
1056: */
1057:
1058: if ((scalePtr->flags & REDRAW_OTHER)
1059: && (scalePtr->relief != TK_RELIEF_FLAT)) {
1060: Tk_Draw3DRectangle(Tk_Display(tkwin), Tk_WindowId(tkwin),
1061: scalePtr->bgBorder, 0, 0, Tk_Width(tkwin), Tk_Height(tkwin),
1062: scalePtr->borderWidth, scalePtr->relief);
1063: }
1064:
1065: done:
1066: scalePtr->flags &= ~REDRAW_ALL;
1067: }
1068:
1069: /*
1070: *----------------------------------------------------------------------
1071: *
1072: * DisplayHorizontalValue --
1073: *
1074: * This procedure is called to display values (scale readings)
1075: * for horizontally-oriented scales.
1076: *
1077: * Results:
1078: * None.
1079: *
1080: * Side effects:
1081: * The numerical value corresponding to value is displayed with
1082: * its bottom edge at "bottom", and at a horizontal position in
1083: * the scale that corresponds to "value".
1084: *
1085: *----------------------------------------------------------------------
1086: */
1087:
1088: static void
1089: DisplayHorizontalValue(scalePtr, value, bottom)
1090: register Scale *scalePtr; /* Information about widget in which to
1091: * display value. */
1092: int value; /* Y-coordinate of number to display,
1093: * specified in application coords, not
1094: * in pixels (we'll compute pixels). */
1095: int bottom; /* Y-coordinate of bottom edge of text,
1096: * specified in pixels. */
1097: {
1098: register Tk_Window tkwin = scalePtr->tkwin;
1099: int x, y, dummy, length;
1100: char valueString[30];
1101: XCharStruct bbox;
1102:
1103: x = ValueToPixel(scalePtr, value);
1104: y = bottom - scalePtr->fontPtr->descent;
1105: sprintf(valueString, "%d", value);
1106: length = strlen(valueString);
1107: XTextExtents(scalePtr->fontPtr, valueString, length,
1108: &dummy, &dummy, &dummy, &bbox);
1109:
1110: /*
1111: * Adjust the x-coordinate if necessary to keep the text entirely
1112: * inside the window.
1113: */
1114:
1115: x -= (bbox.lbearing + bbox.rbearing)/2;
1116: if ((x - bbox.lbearing) < scalePtr->offset) {
1117: x = scalePtr->offset + bbox.lbearing;
1118: }
1119: if ((y + bbox.rbearing) > (Tk_Width(tkwin) - scalePtr->offset)) {
1120: x = Tk_Width(tkwin) - scalePtr->offset - bbox.rbearing;
1121: }
1122: XDrawString(Tk_Display(tkwin), Tk_WindowId(tkwin),
1123: scalePtr->textGC, x, y, valueString, length);
1124: }
1125:
1126: /*
1127: *----------------------------------------------------------------------
1128: *
1129: * PixelToValue --
1130: *
1131: * Given a pixel within a scale window, return the scale
1132: * reading corresponding to that pixel.
1133: *
1134: * Results:
1135: * An integer scale reading.
1136: *
1137: * Side effects:
1138: * None.
1139: *
1140: *----------------------------------------------------------------------
1141: */
1142:
1143: static int
1144: PixelToValue(scalePtr, x, y)
1145: register Scale *scalePtr; /* Information about widget. */
1146: int x, y; /* Coordinates of point within
1147: * window. */
1148: {
1149: int value, pixelRange;
1150:
1151: if (scalePtr->vertical) {
1152: pixelRange = Tk_Height(scalePtr->tkwin) - scalePtr->sliderLength
1153: - 2*scalePtr->offset - 2*scalePtr->borderWidth;
1154: value = y;
1155: } else {
1156: pixelRange = Tk_Width(scalePtr->tkwin) - scalePtr->sliderLength
1157: - 2*scalePtr->offset - 2*scalePtr->borderWidth;
1158: value = x;
1159: }
1160:
1161: if (pixelRange <= 0) {
1162: /*
1163: * Not enough room for the slider to actually slide: just return
1164: * the scale's current value.
1165: */
1166:
1167: return scalePtr->value;
1168: }
1169: value -= scalePtr->sliderLength/2 + scalePtr->offset
1170: + scalePtr->borderWidth;
1171: if (value < 0) {
1172: value = 0;
1173: }
1174: if (value > pixelRange) {
1175: value = pixelRange;
1176: }
1177: if (scalePtr->toValue > scalePtr->fromValue) {
1178: value = scalePtr->fromValue +
1179: ((value * (scalePtr->toValue - scalePtr->fromValue))
1180: + pixelRange/2)/pixelRange;
1181: } else {
1182: value = scalePtr->toValue +
1183: (((pixelRange - value)
1184: * (scalePtr->fromValue - scalePtr->toValue))
1185: + pixelRange/2)/pixelRange;
1186: }
1187: return value;
1188: }
1189:
1190: /*
1191: *----------------------------------------------------------------------
1192: *
1193: * ValueToPixel --
1194: *
1195: * Given a reading of the scale, return the x-coordinate or
1196: * y-coordinate corresponding to that reading, depending on
1197: * whether the scale is vertical or horizontal, respectively.
1198: *
1199: * Results:
1200: * An integer value giving the pixel location corresponding
1201: * to reading. The value is restricted to lie within the
1202: * defined range for the scale.
1203: *
1204: * Side effects:
1205: * None.
1206: *
1207: *----------------------------------------------------------------------
1208: */
1209:
1210: static int
1211: ValueToPixel(scalePtr, value)
1212: register Scale *scalePtr; /* Information about widget. */
1213: int value; /* Reading of the widget. */
1214: {
1215: int y, pixelRange, valueRange;
1216:
1217: valueRange = scalePtr->toValue - scalePtr->fromValue;
1218: pixelRange = (scalePtr->vertical ? Tk_Height(scalePtr->tkwin)
1219: : Tk_Width(scalePtr->tkwin)) - scalePtr->sliderLength
1220: - 2*scalePtr->offset - 2*scalePtr->borderWidth;
1221: y = ((value - scalePtr->fromValue) * pixelRange
1222: + valueRange/2) / valueRange;
1223: if (y < 0) {
1224: y = 0;
1225: } else if (y > pixelRange) {
1226: y = pixelRange;
1227: }
1228: y += scalePtr->sliderLength/2 + scalePtr->offset + scalePtr->borderWidth;
1229: return y;
1230: }
1231:
1232: /*
1233: *--------------------------------------------------------------
1234: *
1235: * ScaleEventProc --
1236: *
1237: * This procedure is invoked by the Tk dispatcher for various
1238: * events on scales.
1239: *
1240: * Results:
1241: * None.
1242: *
1243: * Side effects:
1244: * When the window gets deleted, internal structures get
1245: * cleaned up. When it gets exposed, it is redisplayed.
1246: *
1247: *--------------------------------------------------------------
1248: */
1249:
1250: static void
1251: ScaleEventProc(clientData, eventPtr)
1252: ClientData clientData; /* Information about window. */
1253: XEvent *eventPtr; /* Information about event. */
1254: {
1255: Scale *scalePtr = (Scale *) clientData;
1256:
1257: if ((eventPtr->type == Expose) && (eventPtr->xexpose.count == 0)) {
1258: EventuallyRedrawScale(scalePtr, REDRAW_ALL);
1259: } else if (eventPtr->type == DestroyNotify) {
1260: Tcl_DeleteCommand(scalePtr->interp, Tk_PathName(scalePtr->tkwin));
1261: scalePtr->tkwin = NULL;
1262: if (scalePtr->flags & REDRAW_ALL) {
1263: if (scalePtr->vertical) {
1264: Tk_CancelIdleCall(DisplayVerticalScale, (ClientData) scalePtr);
1265: } else {
1266: Tk_CancelIdleCall(DisplayHorizontalScale,
1267: (ClientData) scalePtr);
1268: }
1269: }
1270: Tk_EventuallyFree((ClientData) scalePtr, DestroyScale);
1271: } else if (eventPtr->type == ConfigureNotify) {
1272: ComputeScaleGeometry(scalePtr);
1273: }
1274: }
1275:
1276: /*
1277: *--------------------------------------------------------------
1278: *
1279: * ScaleMouseProc --
1280: *
1281: * This procedure is called back by Tk in response to
1282: * mouse events such as window entry, window exit, mouse
1283: * motion, and button presses.
1284: *
1285: * Results:
1286: * None.
1287: *
1288: * Side effects:
1289: * This procedure implements the "feel" of the scale by
1290: * issuing commands in response to button presses and mouse
1291: * motion.
1292: *
1293: *--------------------------------------------------------------
1294: */
1295:
1296: static void
1297: ScaleMouseProc(clientData, eventPtr)
1298: ClientData clientData; /* Information about window. */
1299: register XEvent *eventPtr; /* Information about event. */
1300: {
1301: register Scale *scalePtr = (Scale *) clientData;
1302:
1303: if (scalePtr->state != tkNormalUid) {
1304: return;
1305: }
1306:
1307: Tk_Preserve((ClientData) scalePtr);
1308: if (eventPtr->type == EnterNotify) {
1309: scalePtr->flags |= ACTIVE;
1310: EventuallyRedrawScale(scalePtr, REDRAW_SLIDER);
1311: } else if (eventPtr->type == LeaveNotify) {
1312: scalePtr->flags &= ~ACTIVE;
1313: EventuallyRedrawScale(scalePtr, REDRAW_SLIDER);
1314: } else if ((eventPtr->type == MotionNotify)
1315: && (scalePtr->flags & BUTTON_PRESSED)) {
1316: SetScaleValue(scalePtr, PixelToValue(scalePtr,
1317: eventPtr->xmotion.x, eventPtr->xmotion.y));
1318: } else if ((eventPtr->type == ButtonPress)
1319: /* && (eventPtr->xbutton.button == Button1) */
1320: && (eventPtr->xbutton.state == 0)) {
1321: scalePtr->flags |= BUTTON_PRESSED;
1322: SetScaleValue(scalePtr, PixelToValue(scalePtr,
1323: eventPtr->xbutton.x, eventPtr->xbutton.y));
1324: EventuallyRedrawScale(scalePtr, REDRAW_SLIDER);
1325: } else if ((eventPtr->type == ButtonRelease)
1326: /* && (eventPtr->xbutton.button == Button1) */
1327: && (scalePtr->flags & BUTTON_PRESSED)) {
1328: scalePtr->flags &= ~BUTTON_PRESSED;
1329: EventuallyRedrawScale(scalePtr, REDRAW_SLIDER);
1330: }
1331: Tk_Release((ClientData) scalePtr);
1332: }
1333:
1334: /*
1335: *--------------------------------------------------------------
1336: *
1337: * SetScaleValue --
1338: *
1339: * This procedure changes the value of a scale and invokes
1340: * a Tcl command to reflect the current position of a scale
1341: *
1342: * Results:
1343: * None.
1344: *
1345: * Side effects:
1346: * A Tcl command is invoked, and an additional error-processing
1347: * command may also be invoked. The scale's slider is redrawn.
1348: *
1349: *--------------------------------------------------------------
1350: */
1351:
1352: static void
1353: SetScaleValue(scalePtr, value)
1354: register Scale *scalePtr; /* Info about widget. */
1355: int value; /* New value for scale. Gets
1356: * adjusted if it's off the scale. */
1357: {
1358: int result;
1359: char string[20];
1360:
1361: if ((value < scalePtr->fromValue)
1362: ^ (scalePtr->toValue < scalePtr->fromValue)) {
1363: value = scalePtr->fromValue;
1364: }
1365: if ((value > scalePtr->toValue)
1366: ^ (scalePtr->toValue < scalePtr->fromValue)) {
1367: value = scalePtr->toValue;
1368: }
1369: if (value == scalePtr->value) {
1370: return;
1371: }
1372: scalePtr->value = value;
1373: EventuallyRedrawScale(scalePtr, REDRAW_SLIDER);
1374:
1375: sprintf(string, " %d", scalePtr->value);
1376: result = Tcl_VarEval(scalePtr->interp, scalePtr->command, string,
1377: (char *) NULL);
1378: if (result != TCL_OK) {
1379: TkBindError(scalePtr->interp);
1380: }
1381: }
1382:
1383: /*
1384: *--------------------------------------------------------------
1385: *
1386: * EventuallyRedrawScale --
1387: *
1388: * Arrange for part or all of a scale widget to redrawn at
1389: * the next convenient time in the future.
1390: *
1391: * Results:
1392: * None.
1393: *
1394: * Side effects:
1395: * If "what" is REDRAW_SLIDER then just the slider and the
1396: * value readout will be redrawn; if "what" is REDRAW_ALL
1397: * then the entire widget will be redrawn.
1398: *
1399: *--------------------------------------------------------------
1400: */
1401:
1402: static void
1403: EventuallyRedrawScale(scalePtr, what)
1404: register Scale *scalePtr; /* Information about widget. */
1405: int what; /* What to redraw: REDRAW_SLIDER
1406: * or REDRAW_ALL. */
1407: {
1408: if ((what == 0) || (scalePtr->tkwin == NULL)
1409: || !Tk_IsMapped(scalePtr->tkwin)) {
1410: return;
1411: }
1412: if ((scalePtr->flags & REDRAW_ALL) == 0) {
1413: if (scalePtr->vertical) {
1414: Tk_DoWhenIdle(DisplayVerticalScale, (ClientData) scalePtr);
1415: } else {
1416: Tk_DoWhenIdle(DisplayHorizontalScale, (ClientData) scalePtr);
1417: }
1418: }
1419: scalePtr->flags |= what;
1420: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.