/[dtapublic]/projs/trunk/shared_source/c_tk_base_7_5_w_mods/tkunixscale.c
ViewVC logotype

Annotation of /projs/trunk/shared_source/c_tk_base_7_5_w_mods/tkunixscale.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 69 - (hide annotations) (download)
Sat Nov 5 10:54:17 2016 UTC (7 years, 11 months ago) by dashley
File MIME type: text/plain
File size: 21598 byte(s)
License and property (keyword) changes.
1 dashley 69 /* $Header$ */
2 dashley 25
3     /*
4     * tkUnixScale.c --
5     *
6     * This file implements the X specific portion of the scrollbar
7     * widget.
8     *
9     * Copyright (c) 1996 by Sun Microsystems, Inc.
10     * Copyright (c) 1998-2000 by Scriptics Corporation.
11     *
12     * See the file "license.terms" for information on usage and redistribution
13     * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
14     *
15     * RCS: @(#) $Id: tkunixscale.c,v 1.1.1.1 2001/06/13 05:11:27 dtashley Exp $
16     */
17    
18     #include "tkScale.h"
19     #include "tkInt.h"
20    
21     /*
22     * Forward declarations for procedures defined later in this file:
23     */
24    
25     static void DisplayHorizontalScale _ANSI_ARGS_((TkScale *scalePtr,
26     Drawable drawable, XRectangle *drawnAreaPtr));
27     static void DisplayHorizontalValue _ANSI_ARGS_((TkScale *scalePtr,
28     Drawable drawable, double value, int top));
29     static void DisplayVerticalScale _ANSI_ARGS_((TkScale *scalePtr,
30     Drawable drawable, XRectangle *drawnAreaPtr));
31     static void DisplayVerticalValue _ANSI_ARGS_((TkScale *scalePtr,
32     Drawable drawable, double value, int rightEdge));
33    
34     /*
35     *----------------------------------------------------------------------
36     *
37     * TkpCreateScale --
38     *
39     * Allocate a new TkScale structure.
40     *
41     * Results:
42     * Returns a newly allocated TkScale structure.
43     *
44     * Side effects:
45     * None.
46     *
47     *----------------------------------------------------------------------
48     */
49    
50     TkScale *
51     TkpCreateScale(tkwin)
52     Tk_Window tkwin;
53     {
54     return (TkScale *) ckalloc(sizeof(TkScale));
55     }
56    
57     /*
58     *----------------------------------------------------------------------
59     *
60     * TkpDestroyScale --
61     *
62     * Destroy a TkScale structure. It's necessary to do this with
63     * Tcl_EventuallyFree to allow the Tcl_Preserve(scalePtr) to work
64     * as expected in TkpDisplayScale. (hobbs)
65     *
66     * Results:
67     * None
68     *
69     * Side effects:
70     * Memory is freed.
71     *
72     *----------------------------------------------------------------------
73     */
74    
75     void
76     TkpDestroyScale(scalePtr)
77     TkScale *scalePtr;
78     {
79     Tcl_EventuallyFree((ClientData) scalePtr, TCL_DYNAMIC);
80     }
81    
82     /*
83     *--------------------------------------------------------------
84     *
85     * DisplayVerticalScale --
86     *
87     * This procedure redraws the contents of a vertical scale
88     * window. It is invoked as a do-when-idle handler, so it only
89     * runs when there's nothing else for the application to do.
90     *
91     * Results:
92     * There is no return value. If only a part of the scale needs
93     * to be redrawn, then drawnAreaPtr is modified to reflect the
94     * area that was actually modified.
95     *
96     * Side effects:
97     * Information appears on the screen.
98     *
99     *--------------------------------------------------------------
100     */
101    
102     static void
103     DisplayVerticalScale(scalePtr, drawable, drawnAreaPtr)
104     TkScale *scalePtr; /* Widget record for scale. */
105     Drawable drawable; /* Where to display scale (window
106     * or pixmap). */
107     XRectangle *drawnAreaPtr; /* Initally contains area of window;
108     * if only a part of the scale is
109     * redrawn, gets modified to reflect
110     * the part of the window that was
111     * redrawn. */
112     {
113     Tk_Window tkwin = scalePtr->tkwin;
114     int x, y, width, height, shadowWidth;
115     double tickValue, tickInterval = scalePtr->tickInterval;
116     Tk_3DBorder sliderBorder;
117    
118     /*
119     * Display the information from left to right across the window.
120     */
121    
122     if (!(scalePtr->flags & REDRAW_OTHER)) {
123     drawnAreaPtr->x = scalePtr->vertTickRightX;
124     drawnAreaPtr->y = scalePtr->inset;
125     drawnAreaPtr->width = scalePtr->vertTroughX + scalePtr->width
126     + 2*scalePtr->borderWidth - scalePtr->vertTickRightX;
127     drawnAreaPtr->height -= 2*scalePtr->inset;
128     }
129     Tk_Fill3DRectangle(tkwin, drawable, scalePtr->bgBorder,
130     drawnAreaPtr->x, drawnAreaPtr->y, drawnAreaPtr->width,
131     drawnAreaPtr->height, 0, TK_RELIEF_FLAT);
132     if (scalePtr->flags & REDRAW_OTHER) {
133     /*
134     * Display the tick marks.
135     */
136    
137     if (tickInterval != 0) {
138     double ticks, maxTicks;
139    
140     /*
141     * Ensure that we will only draw enough of the tick values
142     * such that they don't overlap
143     */
144     ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
145     / tickInterval);
146     maxTicks = (double) Tk_Height(tkwin)
147     / (double) scalePtr->fontHeight;
148     if (ticks > maxTicks) {
149     tickInterval *= (ticks / maxTicks);
150     }
151     for (tickValue = scalePtr->fromValue; ;
152     tickValue += tickInterval) {
153     /*
154     * The TkRoundToResolution call gets rid of accumulated
155     * round-off errors, if any.
156     */
157    
158     tickValue = TkRoundToResolution(scalePtr, tickValue);
159     if (scalePtr->toValue >= scalePtr->fromValue) {
160     if (tickValue > scalePtr->toValue) {
161     break;
162     }
163     } else {
164     if (tickValue < scalePtr->toValue) {
165     break;
166     }
167     }
168     DisplayVerticalValue(scalePtr, drawable, tickValue,
169     scalePtr->vertTickRightX);
170     }
171     }
172     }
173    
174     /*
175     * Display the value, if it is desired.
176     */
177    
178     if (scalePtr->showValue) {
179     DisplayVerticalValue(scalePtr, drawable, scalePtr->value,
180     scalePtr->vertValueRightX);
181     }
182    
183     /*
184     * Display the trough and the slider.
185     */
186    
187     Tk_Draw3DRectangle(tkwin, drawable,
188     scalePtr->bgBorder, scalePtr->vertTroughX, scalePtr->inset,
189     scalePtr->width + 2*scalePtr->borderWidth,
190     Tk_Height(tkwin) - 2*scalePtr->inset, scalePtr->borderWidth,
191     TK_RELIEF_SUNKEN);
192     XFillRectangle(scalePtr->display, drawable, scalePtr->troughGC,
193     scalePtr->vertTroughX + scalePtr->borderWidth,
194     scalePtr->inset + scalePtr->borderWidth,
195     (unsigned) scalePtr->width,
196     (unsigned) (Tk_Height(tkwin) - 2*scalePtr->inset
197     - 2*scalePtr->borderWidth));
198     if (scalePtr->state == STATE_ACTIVE) {
199     sliderBorder = scalePtr->activeBorder;
200     } else {
201     sliderBorder = scalePtr->bgBorder;
202     }
203     width = scalePtr->width;
204     height = scalePtr->sliderLength/2;
205     x = scalePtr->vertTroughX + scalePtr->borderWidth;
206     y = TkScaleValueToPixel(scalePtr, scalePtr->value) - height;
207     shadowWidth = scalePtr->borderWidth/2;
208     if (shadowWidth == 0) {
209     shadowWidth = 1;
210     }
211     Tk_Draw3DRectangle(tkwin, drawable, sliderBorder, x, y, width,
212     2*height, shadowWidth, scalePtr->sliderRelief);
213     x += shadowWidth;
214     y += shadowWidth;
215     width -= 2*shadowWidth;
216     height -= shadowWidth;
217     Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y, width,
218     height, shadowWidth, scalePtr->sliderRelief);
219     Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y+height,
220     width, height, shadowWidth, scalePtr->sliderRelief);
221    
222     /*
223     * Draw the label to the right of the scale.
224     */
225    
226     if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelLength != 0)) {
227     Tk_FontMetrics fm;
228    
229     Tk_GetFontMetrics(scalePtr->tkfont, &fm);
230     Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
231     scalePtr->tkfont, scalePtr->label,
232     scalePtr->labelLength, scalePtr->vertLabelX,
233     scalePtr->inset + (3*fm.ascent)/2);
234     }
235     }
236    
237     /*
238     *----------------------------------------------------------------------
239     *
240     * DisplayVerticalValue --
241     *
242     * This procedure is called to display values (scale readings)
243     * for vertically-oriented scales.
244     *
245     * Results:
246     * None.
247     *
248     * Side effects:
249     * The numerical value corresponding to value is displayed with
250     * its right edge at "rightEdge", and at a vertical position in
251     * the scale that corresponds to "value".
252     *
253     *----------------------------------------------------------------------
254     */
255    
256     static void
257     DisplayVerticalValue(scalePtr, drawable, value, rightEdge)
258     register TkScale *scalePtr; /* Information about widget in which to
259     * display value. */
260     Drawable drawable; /* Pixmap or window in which to draw
261     * the value. */
262     double value; /* Y-coordinate of number to display,
263     * specified in application coords, not
264     * in pixels (we'll compute pixels). */
265     int rightEdge; /* X-coordinate of right edge of text,
266     * specified in pixels. */
267     {
268     register Tk_Window tkwin = scalePtr->tkwin;
269     int y, width, length;
270     char valueString[PRINT_CHARS];
271     Tk_FontMetrics fm;
272    
273     Tk_GetFontMetrics(scalePtr->tkfont, &fm);
274     y = TkScaleValueToPixel(scalePtr, value) + fm.ascent/2;
275     sprintf(valueString, scalePtr->format, value);
276     length = strlen(valueString);
277     width = Tk_TextWidth(scalePtr->tkfont, valueString, length);
278    
279     /*
280     * Adjust the y-coordinate if necessary to keep the text entirely
281     * inside the window.
282     */
283    
284     if ((y - fm.ascent) < (scalePtr->inset + SPACING)) {
285     y = scalePtr->inset + SPACING + fm.ascent;
286     }
287     if ((y + fm.descent) > (Tk_Height(tkwin) - scalePtr->inset - SPACING)) {
288     y = Tk_Height(tkwin) - scalePtr->inset - SPACING - fm.descent;
289     }
290     Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
291     scalePtr->tkfont, valueString, length, rightEdge - width, y);
292     }
293    
294     /*
295     *--------------------------------------------------------------
296     *
297     * DisplayHorizontalScale --
298     *
299     * This procedure redraws the contents of a horizontal scale
300     * window. It is invoked as a do-when-idle handler, so it only
301     * runs when there's nothing else for the application to do.
302     *
303     * Results:
304     * There is no return value. If only a part of the scale needs
305     * to be redrawn, then drawnAreaPtr is modified to reflect the
306     * area that was actually modified.
307     *
308     * Side effects:
309     * Information appears on the screen.
310     *
311     *--------------------------------------------------------------
312     */
313    
314     static void
315     DisplayHorizontalScale(scalePtr, drawable, drawnAreaPtr)
316     TkScale *scalePtr; /* Widget record for scale. */
317     Drawable drawable; /* Where to display scale (window
318     * or pixmap). */
319     XRectangle *drawnAreaPtr; /* Initally contains area of window;
320     * if only a part of the scale is
321     * redrawn, gets modified to reflect
322     * the part of the window that was
323     * redrawn. */
324     {
325     register Tk_Window tkwin = scalePtr->tkwin;
326     int x, y, width, height, shadowWidth;
327     double tickValue, tickInterval = scalePtr->tickInterval;
328     Tk_3DBorder sliderBorder;
329    
330     /*
331     * Display the information from bottom to top across the window.
332     */
333    
334     if (!(scalePtr->flags & REDRAW_OTHER)) {
335     drawnAreaPtr->x = scalePtr->inset;
336     drawnAreaPtr->y = scalePtr->horizValueY;
337     drawnAreaPtr->width -= 2*scalePtr->inset;
338     drawnAreaPtr->height = scalePtr->horizTroughY + scalePtr->width
339     + 2*scalePtr->borderWidth - scalePtr->horizValueY;
340     }
341     Tk_Fill3DRectangle(tkwin, drawable, scalePtr->bgBorder,
342     drawnAreaPtr->x, drawnAreaPtr->y, drawnAreaPtr->width,
343     drawnAreaPtr->height, 0, TK_RELIEF_FLAT);
344     if (scalePtr->flags & REDRAW_OTHER) {
345     /*
346     * Display the tick marks.
347     */
348    
349     if (tickInterval != 0) {
350     char valueString[PRINT_CHARS];
351     double ticks, maxTicks;
352    
353     /*
354     * Ensure that we will only draw enough of the tick values
355     * such that they don't overlap. We base this off the width that
356     * fromValue would take. Not exact, but better than no constraint.
357     */
358     ticks = fabs((scalePtr->toValue - scalePtr->fromValue)
359     / tickInterval);
360     sprintf(valueString, scalePtr->format, scalePtr->fromValue);
361     maxTicks = (double) Tk_Width(tkwin)
362     / (double) Tk_TextWidth(scalePtr->tkfont, valueString, -1);
363     if (ticks > maxTicks) {
364     tickInterval *= (ticks / maxTicks);
365     }
366     for (tickValue = scalePtr->fromValue; ;
367     tickValue += tickInterval) {
368     /*
369     * The TkRoundToResolution call gets rid of accumulated
370     * round-off errors, if any.
371     */
372    
373     tickValue = TkRoundToResolution(scalePtr, tickValue);
374     if (scalePtr->toValue >= scalePtr->fromValue) {
375     if (tickValue > scalePtr->toValue) {
376     break;
377     }
378     } else {
379     if (tickValue < scalePtr->toValue) {
380     break;
381     }
382     }
383     DisplayHorizontalValue(scalePtr, drawable, tickValue,
384     scalePtr->horizTickY);
385     }
386     }
387     }
388    
389     /*
390     * Display the value, if it is desired.
391     */
392    
393     if (scalePtr->showValue) {
394     DisplayHorizontalValue(scalePtr, drawable, scalePtr->value,
395     scalePtr->horizValueY);
396     }
397    
398     /*
399     * Display the trough and the slider.
400     */
401    
402     y = scalePtr->horizTroughY;
403     Tk_Draw3DRectangle(tkwin, drawable,
404     scalePtr->bgBorder, scalePtr->inset, y,
405     Tk_Width(tkwin) - 2*scalePtr->inset,
406     scalePtr->width + 2*scalePtr->borderWidth,
407     scalePtr->borderWidth, TK_RELIEF_SUNKEN);
408     XFillRectangle(scalePtr->display, drawable, scalePtr->troughGC,
409     scalePtr->inset + scalePtr->borderWidth,
410     y + scalePtr->borderWidth,
411     (unsigned) (Tk_Width(tkwin) - 2*scalePtr->inset
412     - 2*scalePtr->borderWidth),
413     (unsigned) scalePtr->width);
414     if (scalePtr->state == STATE_ACTIVE) {
415     sliderBorder = scalePtr->activeBorder;
416     } else {
417     sliderBorder = scalePtr->bgBorder;
418     }
419     width = scalePtr->sliderLength/2;
420     height = scalePtr->width;
421     x = TkScaleValueToPixel(scalePtr, scalePtr->value) - width;
422     y += scalePtr->borderWidth;
423     shadowWidth = scalePtr->borderWidth/2;
424     if (shadowWidth == 0) {
425     shadowWidth = 1;
426     }
427     Tk_Draw3DRectangle(tkwin, drawable, sliderBorder,
428     x, y, 2*width, height, shadowWidth, scalePtr->sliderRelief);
429     x += shadowWidth;
430     y += shadowWidth;
431     width -= shadowWidth;
432     height -= 2*shadowWidth;
433     Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x, y, width, height,
434     shadowWidth, scalePtr->sliderRelief);
435     Tk_Fill3DRectangle(tkwin, drawable, sliderBorder, x+width, y,
436     width, height, shadowWidth, scalePtr->sliderRelief);
437    
438     /*
439     * Draw the label at the top of the scale.
440     */
441    
442     if ((scalePtr->flags & REDRAW_OTHER) && (scalePtr->labelLength != 0)) {
443     Tk_FontMetrics fm;
444    
445     Tk_GetFontMetrics(scalePtr->tkfont, &fm);
446     Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
447     scalePtr->tkfont, scalePtr->label,
448     scalePtr->labelLength, scalePtr->inset + fm.ascent/2,
449     scalePtr->horizLabelY + fm.ascent);
450     }
451     }
452    
453     /*
454     *----------------------------------------------------------------------
455     *
456     * DisplayHorizontalValue --
457     *
458     * This procedure is called to display values (scale readings)
459     * for horizontally-oriented scales.
460     *
461     * Results:
462     * None.
463     *
464     * Side effects:
465     * The numerical value corresponding to value is displayed with
466     * its bottom edge at "bottom", and at a horizontal position in
467     * the scale that corresponds to "value".
468     *
469     *----------------------------------------------------------------------
470     */
471    
472     static void
473     DisplayHorizontalValue(scalePtr, drawable, value, top)
474     register TkScale *scalePtr; /* Information about widget in which to
475     * display value. */
476     Drawable drawable; /* Pixmap or window in which to draw
477     * the value. */
478     double value; /* X-coordinate of number to display,
479     * specified in application coords, not
480     * in pixels (we'll compute pixels). */
481     int top; /* Y-coordinate of top edge of text,
482     * specified in pixels. */
483     {
484     register Tk_Window tkwin = scalePtr->tkwin;
485     int x, y, length, width;
486     char valueString[PRINT_CHARS];
487     Tk_FontMetrics fm;
488    
489     x = TkScaleValueToPixel(scalePtr, value);
490     Tk_GetFontMetrics(scalePtr->tkfont, &fm);
491     y = top + fm.ascent;
492     sprintf(valueString, scalePtr->format, value);
493     length = strlen(valueString);
494     width = Tk_TextWidth(scalePtr->tkfont, valueString, length);
495    
496     /*
497     * Adjust the x-coordinate if necessary to keep the text entirely
498     * inside the window.
499     */
500    
501     x -= (width)/2;
502     if (x < (scalePtr->inset + SPACING)) {
503     x = scalePtr->inset + SPACING;
504     }
505     if (x > (Tk_Width(tkwin) - scalePtr->inset)) {
506     x = Tk_Width(tkwin) - scalePtr->inset - SPACING - width;
507     }
508     Tk_DrawChars(scalePtr->display, drawable, scalePtr->textGC,
509     scalePtr->tkfont, valueString, length, x, y);
510     }
511    
512     /*
513     *----------------------------------------------------------------------
514     *
515     * TkpDisplayScale --
516     *
517     * This procedure is invoked as an idle handler to redisplay
518     * the contents of a scale widget.
519     *
520     * Results:
521     * None.
522     *
523     * Side effects:
524     * The scale gets redisplayed.
525     *
526     *----------------------------------------------------------------------
527     */
528    
529     void
530     TkpDisplayScale(clientData)
531     ClientData clientData; /* Widget record for scale. */
532     {
533     TkScale *scalePtr = (TkScale *) clientData;
534     Tk_Window tkwin = scalePtr->tkwin;
535     Tcl_Interp *interp = scalePtr->interp;
536     Pixmap pixmap;
537     int result;
538     char string[PRINT_CHARS];
539     XRectangle drawnArea;
540    
541     scalePtr->flags &= ~REDRAW_PENDING;
542     if ((scalePtr->tkwin == NULL) || !Tk_IsMapped(scalePtr->tkwin)) {
543     goto done;
544     }
545    
546     /*
547     * Invoke the scale's command if needed.
548     */
549     Tcl_Preserve((ClientData) scalePtr);
550     if ((scalePtr->flags & INVOKE_COMMAND) && (scalePtr->command != NULL)) {
551     Tcl_Preserve((ClientData) interp);
552     sprintf(string, scalePtr->format, scalePtr->value);
553     result = Tcl_VarEval(interp, scalePtr->command, " ", string,
554     (char *) NULL);
555     if (result != TCL_OK) {
556     Tcl_AddErrorInfo(interp, "\n (command executed by scale)");
557     Tcl_BackgroundError(interp);
558     }
559     Tcl_Release((ClientData) interp);
560     }
561     scalePtr->flags &= ~INVOKE_COMMAND;
562     if (scalePtr->flags & SCALE_DELETED) {
563     Tcl_Release((ClientData) scalePtr);
564     goto done;
565     }
566     Tcl_Release((ClientData) scalePtr);
567    
568     /*
569     * In order to avoid screen flashes, this procedure redraws
570     * the scale in a pixmap, then copies the pixmap to the
571     * screen in a single operation. This means that there's no
572     * point in time where the on-sreen image has been cleared.
573     */
574    
575     pixmap = Tk_GetPixmap(scalePtr->display, Tk_WindowId(tkwin),
576     Tk_Width(tkwin), Tk_Height(tkwin), Tk_Depth(tkwin));
577     drawnArea.x = 0;
578     drawnArea.y = 0;
579     drawnArea.width = Tk_Width(tkwin);
580     drawnArea.height = Tk_Height(tkwin);
581    
582     /*
583     * Much of the redisplay is done totally differently for
584     * horizontal and vertical scales. Handle the part that's
585     * different.
586     */
587    
588     if (scalePtr->orient == ORIENT_VERTICAL) {
589     DisplayVerticalScale(scalePtr, pixmap, &drawnArea);
590     } else {
591     DisplayHorizontalScale(scalePtr, pixmap, &drawnArea);
592     }
593    
594     /*
595     * Now handle the part of redisplay that is the same for
596     * horizontal and vertical scales: border and traversal
597     * highlight.
598     */
599    
600     if (scalePtr->flags & REDRAW_OTHER) {
601     if (scalePtr->relief != TK_RELIEF_FLAT) {
602     Tk_Draw3DRectangle(tkwin, pixmap, scalePtr->bgBorder,
603     scalePtr->highlightWidth, scalePtr->highlightWidth,
604     Tk_Width(tkwin) - 2*scalePtr->highlightWidth,
605     Tk_Height(tkwin) - 2*scalePtr->highlightWidth,
606     scalePtr->borderWidth, scalePtr->relief);
607     }
608     if (scalePtr->highlightWidth != 0) {
609     GC gc;
610    
611     if (scalePtr->flags & GOT_FOCUS) {
612     gc = Tk_GCForColor(scalePtr->highlightColorPtr, pixmap);
613     } else {
614     gc = Tk_GCForColor(
615     Tk_3DBorderColor(scalePtr->highlightBorder), pixmap);
616     }
617     Tk_DrawFocusHighlight(tkwin, gc, scalePtr->highlightWidth, pixmap);
618     }
619     }
620    
621     /*
622     * Copy the information from the off-screen pixmap onto the screen,
623     * then delete the pixmap.
624     */
625    
626     XCopyArea(scalePtr->display, pixmap, Tk_WindowId(tkwin),
627     scalePtr->copyGC, drawnArea.x, drawnArea.y, drawnArea.width,
628     drawnArea.height, drawnArea.x, drawnArea.y);
629     Tk_FreePixmap(scalePtr->display, pixmap);
630    
631     done:
632     scalePtr->flags &= ~REDRAW_ALL;
633     }
634    
635     /*
636     *----------------------------------------------------------------------
637     *
638     * TkpScaleElement --
639     *
640     * Determine which part of a scale widget lies under a given
641     * point.
642     *
643     * Results:
644     * The return value is either TROUGH1, SLIDER, TROUGH2, or
645     * OTHER, depending on which of the scale's active elements
646     * (if any) is under the point at (x,y).
647     *
648     * Side effects:
649     * None.
650     *
651     *----------------------------------------------------------------------
652     */
653    
654     int
655     TkpScaleElement(scalePtr, x, y)
656     TkScale *scalePtr; /* Widget record for scale. */
657     int x, y; /* Coordinates within scalePtr's window. */
658     {
659     int sliderFirst;
660    
661     if (scalePtr->orient == ORIENT_VERTICAL) {
662     if ((x < scalePtr->vertTroughX)
663     || (x >= (scalePtr->vertTroughX + 2*scalePtr->borderWidth +
664     scalePtr->width))) {
665     return OTHER;
666     }
667     if ((y < scalePtr->inset)
668     || (y >= (Tk_Height(scalePtr->tkwin) - scalePtr->inset))) {
669     return OTHER;
670     }
671     sliderFirst = TkScaleValueToPixel(scalePtr, scalePtr->value)
672     - scalePtr->sliderLength/2;
673     if (y < sliderFirst) {
674     return TROUGH1;
675     }
676     if (y < (sliderFirst+scalePtr->sliderLength)) {
677     return SLIDER;
678     }
679     return TROUGH2;
680     }
681    
682     if ((y < scalePtr->horizTroughY)
683     || (y >= (scalePtr->horizTroughY + 2*scalePtr->borderWidth +
684     scalePtr->width))) {
685     return OTHER;
686     }
687     if ((x < scalePtr->inset)
688     || (x >= (Tk_Width(scalePtr->tkwin) - scalePtr->inset))) {
689     return OTHER;
690     }
691     sliderFirst = TkScaleValueToPixel(scalePtr, scalePtr->value)
692     - scalePtr->sliderLength/2;
693     if (x < sliderFirst) {
694     return TROUGH1;
695     }
696     if (x < (sliderFirst+scalePtr->sliderLength)) {
697     return SLIDER;
698     }
699     return TROUGH2;
700     }
701    
702 dashley 69 /* End of tkunixscale.c */

Properties

Name Value
svn:keywords Header

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25