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