/[dtapublic]/projs/trunk/shared_source/tk_base/tkwinscrlbr.c
ViewVC logotype

Contents of /projs/trunk/shared_source/tk_base/tkwinscrlbr.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 25 - (show annotations) (download)
Sat Oct 8 06:43:03 2016 UTC (7 years, 9 months ago) by dashley
Original Path: sf_code/esrgpcpj/shared/tk_base/tkwinscrlbr.c
File MIME type: text/plain
File size: 20632 byte(s)
Initial commit.
1 /* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tk_base/tkwinscrlbr.c,v 1.1.1.1 2001/06/13 05:14:22 dtashley Exp $ */
2
3 /*
4 * tkWinScrollbar.c --
5 *
6 * This file implements the Windows specific portion of the scrollbar
7 * widget.
8 *
9 * Copyright (c) 1996 by Sun Microsystems, Inc.
10 *
11 * See the file "license.terms" for information on usage and redistribution
12 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13 *
14 * RCS: @(#) $Id: tkwinscrlbr.c,v 1.1.1.1 2001/06/13 05:14:22 dtashley Exp $
15 */
16
17 #include "tkWinInt.h"
18 #include "tkScrollbar.h"
19
20
21 /*
22 * The following constant is used to specify the maximum scroll position.
23 * This value is limited by the Win32 API to either 16-bits or 32-bits,
24 * depending on the context. For now we'll just use a value small
25 * enough to fit in 16-bits, but which gives us 4-digits of precision.
26 */
27
28 #define MAX_SCROLL 10000
29
30 /*
31 * Declaration of Windows specific scrollbar structure.
32 */
33
34 typedef struct WinScrollbar {
35 TkScrollbar info; /* Generic scrollbar info. */
36 WNDPROC oldProc; /* Old window procedure. */
37 int lastVertical; /* 1 if was vertical at last refresh. */
38 HWND hwnd; /* Current window handle. */
39 int winFlags; /* Various flags; see below. */
40 } WinScrollbar;
41
42 /*
43 * Flag bits for native scrollbars:
44 *
45 * IN_MODAL_LOOP: Non-zero means this scrollbar is in the middle
46 * of a modal loop.
47 * ALREADY_DEAD: Non-zero means this scrollbar has been
48 * destroyed, but has not been cleaned up.
49 */
50
51 #define IN_MODAL_LOOP 1
52 #define ALREADY_DEAD 2
53
54 /*
55 * Cached system metrics used to determine scrollbar geometry.
56 */
57
58 static int initialized = 0;
59 static int hArrowWidth, hThumb; /* Horizontal control metrics. */
60 static int vArrowWidth, vArrowHeight, vThumb; /* Vertical control metrics. */
61
62 TCL_DECLARE_MUTEX(winScrlbrMutex)
63
64 /*
65 * This variable holds the default width for a scrollbar in string
66 * form for use in a Tk_ConfigSpec.
67 */
68
69 static char defWidth[TCL_INTEGER_SPACE];
70
71 /*
72 * Declarations for functions defined in this file.
73 */
74
75 static Window CreateProc _ANSI_ARGS_((Tk_Window tkwin,
76 Window parent, ClientData instanceData));
77 static void ModalLoopProc _ANSI_ARGS_((Tk_Window tkwin,
78 XEvent *eventPtr));
79 static int ScrollbarBindProc _ANSI_ARGS_((ClientData clientData,
80 Tcl_Interp *interp, XEvent *eventPtr,
81 Tk_Window tkwin, KeySym keySym));
82 static LRESULT CALLBACK ScrollbarProc _ANSI_ARGS_((HWND hwnd, UINT message,
83 WPARAM wParam, LPARAM lParam));
84 static void UpdateScrollbar _ANSI_ARGS_((
85 WinScrollbar *scrollPtr));
86 static void UpdateScrollbarMetrics _ANSI_ARGS_((void));
87
88 /*
89 * The class procedure table for the scrollbar widget.
90 */
91
92 TkClassProcs tkpScrollbarProcs = {
93 CreateProc, /* createProc */
94 NULL, /* geometryProc */
95 ModalLoopProc, /* modalProc */
96 };
97
98
99 /*
100 *----------------------------------------------------------------------
101 *
102 * TkpCreateScrollbar --
103 *
104 * Allocate a new TkScrollbar structure.
105 *
106 * Results:
107 * Returns a newly allocated TkScrollbar structure.
108 *
109 * Side effects:
110 * Registers an event handler for the widget.
111 *
112 *----------------------------------------------------------------------
113 */
114
115 TkScrollbar *
116 TkpCreateScrollbar(tkwin)
117 Tk_Window tkwin;
118 {
119 WinScrollbar *scrollPtr;
120 TkWindow *winPtr = (TkWindow *)tkwin;
121
122 if (!initialized) {
123 Tcl_MutexLock(&winScrlbrMutex);
124 UpdateScrollbarMetrics();
125 initialized = 1;
126 Tcl_MutexUnlock(&winScrlbrMutex);
127 }
128
129 scrollPtr = (WinScrollbar *) ckalloc(sizeof(WinScrollbar));
130 scrollPtr->winFlags = 0;
131 scrollPtr->hwnd = NULL;
132
133 Tk_CreateEventHandler(tkwin,
134 ExposureMask|StructureNotifyMask|FocusChangeMask,
135 TkScrollbarEventProc, (ClientData) scrollPtr);
136
137 if (!Tcl_GetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL)) {
138 Tcl_SetAssocData(winPtr->mainPtr->interp, "TkScrollbar", NULL,
139 (ClientData)1);
140 TkCreateBindingProcedure(winPtr->mainPtr->interp,
141 winPtr->mainPtr->bindingTable,
142 (ClientData)Tk_GetUid("Scrollbar"), "<ButtonPress>",
143 ScrollbarBindProc, NULL, NULL);
144 }
145
146 return (TkScrollbar*) scrollPtr;
147 }
148
149 /*
150 *----------------------------------------------------------------------
151 *
152 * UpdateScrollbar --
153 *
154 * This function updates the position and size of the scrollbar
155 * thumb based on the current settings.
156 *
157 * Results:
158 * None.
159 *
160 * Side effects:
161 * Moves the thumb.
162 *
163 *----------------------------------------------------------------------
164 */
165
166 static void
167 UpdateScrollbar(scrollPtr)
168 WinScrollbar *scrollPtr;
169 {
170 SCROLLINFO scrollInfo;
171 double thumbSize;
172
173 /*
174 * Update the current scrollbar position and shape.
175 */
176
177 scrollInfo.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
178 scrollInfo.cbSize = sizeof(scrollInfo);
179 scrollInfo.nMin = 0;
180 scrollInfo.nMax = MAX_SCROLL;
181 thumbSize = (scrollPtr->info.lastFraction - scrollPtr->info.firstFraction);
182 scrollInfo.nPage = ((UINT) (thumbSize * (double) MAX_SCROLL)) + 1;
183 if (thumbSize < 1.0) {
184 scrollInfo.nPos = (int)
185 ((scrollPtr->info.firstFraction / (1.0-thumbSize))
186 * (MAX_SCROLL - (scrollInfo.nPage - 1)));
187 } else {
188 scrollInfo.nPos = 0;
189 }
190 SetScrollInfo(scrollPtr->hwnd, SB_CTL, &scrollInfo, TRUE);
191 }
192
193 /*
194 *----------------------------------------------------------------------
195 *
196 * CreateProc --
197 *
198 * This function creates a new Scrollbar control, subclasses
199 * the instance, and generates a new Window object.
200 *
201 * Results:
202 * Returns the newly allocated Window object, or None on failure.
203 *
204 * Side effects:
205 * Causes a new Scrollbar control to come into existence.
206 *
207 *----------------------------------------------------------------------
208 */
209
210 static Window
211 CreateProc(tkwin, parentWin, instanceData)
212 Tk_Window tkwin; /* Token for window. */
213 Window parentWin; /* Parent of new window. */
214 ClientData instanceData; /* Scrollbar instance data. */
215 {
216 DWORD style;
217 Window window;
218 HWND parent;
219 TkWindow *winPtr;
220 WinScrollbar *scrollPtr = (WinScrollbar *)instanceData;
221
222 parent = Tk_GetHWND(parentWin);
223
224 if (scrollPtr->info.vertical) {
225 style = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS
226 | SBS_VERT | SBS_RIGHTALIGN;
227 } else {
228 style = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS
229 | SBS_HORZ | SBS_BOTTOMALIGN;
230 }
231
232 scrollPtr->hwnd = CreateWindow("SCROLLBAR", NULL, style,
233 Tk_X(tkwin), Tk_Y(tkwin), Tk_Width(tkwin), Tk_Height(tkwin),
234 parent, NULL, Tk_GetHINSTANCE(), NULL);
235
236 /*
237 * Ensure new window is inserted into the stacking order at the correct
238 * place.
239 */
240
241 SetWindowPos(scrollPtr->hwnd, HWND_TOP, 0, 0, 0, 0,
242 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
243
244 for (winPtr = ((TkWindow*)tkwin)->nextPtr; winPtr != NULL;
245 winPtr = winPtr->nextPtr) {
246 if ((winPtr->window != None) && !(winPtr->flags & TK_TOP_LEVEL)) {
247 TkWinSetWindowPos(scrollPtr->hwnd, Tk_GetHWND(winPtr->window),
248 Below);
249 break;
250 }
251 }
252
253 scrollPtr->lastVertical = scrollPtr->info.vertical;
254 scrollPtr->oldProc = (WNDPROC)SetWindowLong(scrollPtr->hwnd, GWL_WNDPROC,
255 (DWORD) ScrollbarProc);
256 window = Tk_AttachHWND(tkwin, scrollPtr->hwnd);
257
258 UpdateScrollbar(scrollPtr);
259 return window;
260 }
261
262 /*
263 *--------------------------------------------------------------
264 *
265 * TkpDisplayScrollbar --
266 *
267 * This procedure redraws the contents of a scrollbar window.
268 * It is invoked as a do-when-idle handler, so it only runs
269 * when there's nothing else for the application to do.
270 *
271 * Results:
272 * None.
273 *
274 * Side effects:
275 * Information appears on the screen.
276 *
277 *--------------------------------------------------------------
278 */
279
280 void
281 TkpDisplayScrollbar(clientData)
282 ClientData clientData; /* Information about window. */
283 {
284 WinScrollbar *scrollPtr = (WinScrollbar *) clientData;
285 Tk_Window tkwin = scrollPtr->info.tkwin;
286
287 scrollPtr->info.flags &= ~REDRAW_PENDING;
288 if ((tkwin == NULL) || !Tk_IsMapped(tkwin)) {
289 return;
290 }
291
292 /*
293 * Destroy and recreate the scrollbar control if the orientation
294 * has changed.
295 */
296
297 if (scrollPtr->lastVertical != scrollPtr->info.vertical) {
298 HWND hwnd = Tk_GetHWND(Tk_WindowId(tkwin));
299
300 SetWindowLong(hwnd, GWL_WNDPROC, (DWORD) scrollPtr->oldProc);
301 DestroyWindow(hwnd);
302
303 CreateProc(tkwin, Tk_WindowId(Tk_Parent(tkwin)),
304 (ClientData) scrollPtr);
305 } else {
306 UpdateScrollbar(scrollPtr);
307 }
308 }
309
310 /*
311 *----------------------------------------------------------------------
312 *
313 * TkpDestroyScrollbar --
314 *
315 * Free data structures associated with the scrollbar control.
316 *
317 * Results:
318 * None.
319 *
320 * Side effects:
321 * Restores the default control state.
322 *
323 *----------------------------------------------------------------------
324 */
325
326 void
327 TkpDestroyScrollbar(scrollPtr)
328 TkScrollbar *scrollPtr;
329 {
330 WinScrollbar *winScrollPtr = (WinScrollbar *)scrollPtr;
331 HWND hwnd = winScrollPtr->hwnd;
332 if (hwnd) {
333 SetWindowLong(hwnd, GWL_WNDPROC, (DWORD) winScrollPtr->oldProc);
334 if (winScrollPtr->winFlags & IN_MODAL_LOOP) {
335 ((TkWindow *)scrollPtr->tkwin)->flags |= TK_DONT_DESTROY_WINDOW;
336 SetParent(hwnd, NULL);
337 }
338 }
339 winScrollPtr->winFlags |= ALREADY_DEAD;
340 }
341
342 /*
343 *----------------------------------------------------------------------
344 *
345 * UpdateScrollbarMetrics --
346 *
347 * This function retrieves the current system metrics for a
348 * scrollbar.
349 *
350 * Results:
351 * None.
352 *
353 * Side effects:
354 * Updates the geometry cache info for all scrollbars.
355 *
356 *----------------------------------------------------------------------
357 */
358
359 void
360 UpdateScrollbarMetrics()
361 {
362 Tk_ConfigSpec *specPtr;
363
364 hArrowWidth = GetSystemMetrics(SM_CXHSCROLL);
365 hThumb = GetSystemMetrics(SM_CXHTHUMB);
366 vArrowWidth = GetSystemMetrics(SM_CXVSCROLL);
367 vArrowHeight = GetSystemMetrics(SM_CYVSCROLL);
368 vThumb = GetSystemMetrics(SM_CYVTHUMB);
369
370 sprintf(defWidth, "%d", vArrowWidth);
371 for (specPtr = tkpScrollbarConfigSpecs; specPtr->type != TK_CONFIG_END;
372 specPtr++) {
373 if (specPtr->offset == Tk_Offset(TkScrollbar, width)) {
374 specPtr->defValue = defWidth;
375 }
376 }
377 }
378
379 /*
380 *----------------------------------------------------------------------
381 *
382 * TkpComputeScrollbarGeometry --
383 *
384 * After changes in a scrollbar's size or configuration, this
385 * procedure recomputes various geometry information used in
386 * displaying the scrollbar.
387 *
388 * Results:
389 * None.
390 *
391 * Side effects:
392 * The scrollbar will be displayed differently.
393 *
394 *----------------------------------------------------------------------
395 */
396
397 void
398 TkpComputeScrollbarGeometry(scrollPtr)
399 register TkScrollbar *scrollPtr; /* Scrollbar whose geometry may
400 * have changed. */
401 {
402 int fieldLength, minThumbSize;
403
404 /*
405 * Windows doesn't use focus rings on scrollbars, but we still
406 * perform basic sanity checks to appease backwards compatibility.
407 */
408
409 if (scrollPtr->highlightWidth < 0) {
410 scrollPtr->highlightWidth = 0;
411 }
412
413 if (scrollPtr->vertical) {
414 scrollPtr->arrowLength = vArrowHeight;
415 fieldLength = Tk_Height(scrollPtr->tkwin);
416 minThumbSize = vThumb;
417 } else {
418 scrollPtr->arrowLength = hArrowWidth;
419 fieldLength = Tk_Width(scrollPtr->tkwin);
420 minThumbSize = hThumb;
421 }
422 fieldLength -= 2*scrollPtr->arrowLength;
423 if (fieldLength < 0) {
424 fieldLength = 0;
425 }
426 scrollPtr->sliderFirst = (int) ((double)fieldLength
427 * scrollPtr->firstFraction);
428 scrollPtr->sliderLast = (int) ((double)fieldLength
429 * scrollPtr->lastFraction);
430
431 /*
432 * Adjust the slider so that some piece of it is always
433 * displayed in the scrollbar and so that it has at least
434 * a minimal width (so it can be grabbed with the mouse).
435 */
436
437 if (scrollPtr->sliderFirst > fieldLength) {
438 scrollPtr->sliderFirst = fieldLength;
439 }
440 if (scrollPtr->sliderFirst < 0) {
441 scrollPtr->sliderFirst = 0;
442 }
443 if (scrollPtr->sliderLast < (scrollPtr->sliderFirst
444 + minThumbSize)) {
445 scrollPtr->sliderLast = scrollPtr->sliderFirst + minThumbSize;
446 }
447 if (scrollPtr->sliderLast > fieldLength) {
448 scrollPtr->sliderLast = fieldLength;
449 }
450 scrollPtr->sliderFirst += scrollPtr->arrowLength;
451 scrollPtr->sliderLast += scrollPtr->arrowLength;
452
453 /*
454 * Register the desired geometry for the window (leave enough space
455 * for the two arrows plus a minimum-size slider, plus border around
456 * the whole window, if any). Then arrange for the window to be
457 * redisplayed.
458 */
459
460 if (scrollPtr->vertical) {
461 Tk_GeometryRequest(scrollPtr->tkwin,
462 scrollPtr->width, 2*scrollPtr->arrowLength + minThumbSize);
463 } else {
464 Tk_GeometryRequest(scrollPtr->tkwin,
465 2*scrollPtr->arrowLength + minThumbSize, scrollPtr->width);
466 }
467 Tk_SetInternalBorder(scrollPtr->tkwin, 0);
468 }
469
470 /*
471 *----------------------------------------------------------------------
472 *
473 * ScrollbarProc --
474 *
475 * This function is call by Windows whenever an event occurs on
476 * a scrollbar control created by Tk.
477 *
478 * Results:
479 * Standard Windows return value.
480 *
481 * Side effects:
482 * May generate events.
483 *
484 *----------------------------------------------------------------------
485 */
486
487 static LRESULT CALLBACK
488 ScrollbarProc(hwnd, message, wParam, lParam)
489 HWND hwnd;
490 UINT message;
491 WPARAM wParam;
492 LPARAM lParam;
493 {
494 LRESULT result;
495 POINT point;
496 WinScrollbar *scrollPtr;
497 Tk_Window tkwin = Tk_HWNDToWindow(hwnd);
498
499 if (tkwin == NULL) {
500 panic("ScrollbarProc called on an invalid HWND");
501 }
502 scrollPtr = (WinScrollbar *)((TkWindow*)tkwin)->instanceData;
503
504 switch(message) {
505 case WM_HSCROLL:
506 case WM_VSCROLL: {
507 Tcl_Interp *interp;
508 Tcl_DString cmdString;
509 int command = LOWORD(wParam);
510 int code;
511
512 GetCursorPos(&point);
513 Tk_TranslateWinEvent(NULL, WM_MOUSEMOVE, 0,
514 MAKELPARAM(point.x, point.y), &result);
515
516 if (command == SB_ENDSCROLL) {
517 return 0;
518 }
519
520 /*
521 * Bail out immediately if there isn't a command to invoke.
522 */
523
524 if (scrollPtr->info.commandSize == 0) {
525 Tcl_ServiceAll();
526 return 0;
527 }
528
529 Tcl_DStringInit(&cmdString);
530 Tcl_DStringAppend(&cmdString, scrollPtr->info.command,
531 scrollPtr->info.commandSize);
532
533 if (command == SB_LINELEFT || command == SB_LINERIGHT) {
534 Tcl_DStringAppendElement(&cmdString, "scroll");
535 Tcl_DStringAppendElement(&cmdString,
536 (command == SB_LINELEFT ) ? "-1" : "1");
537 Tcl_DStringAppendElement(&cmdString, "units");
538 } else if (command == SB_PAGELEFT || command == SB_PAGERIGHT) {
539 Tcl_DStringAppendElement(&cmdString, "scroll");
540 Tcl_DStringAppendElement(&cmdString,
541 (command == SB_PAGELEFT ) ? "-1" : "1");
542 Tcl_DStringAppendElement(&cmdString, "pages");
543 } else {
544 char valueString[TCL_DOUBLE_SPACE];
545 double pos = 0.0;
546 switch (command) {
547 case SB_THUMBPOSITION:
548 pos = ((double)HIWORD(wParam)) / MAX_SCROLL;
549 break;
550
551 case SB_THUMBTRACK:
552 pos = ((double)HIWORD(wParam)) / MAX_SCROLL;
553 break;
554
555 case SB_TOP:
556 pos = 0.0;
557 break;
558
559 case SB_BOTTOM:
560 pos = 1.0;
561 break;
562 }
563 sprintf(valueString, "%g", pos);
564 Tcl_DStringAppendElement(&cmdString, "moveto");
565 Tcl_DStringAppendElement(&cmdString, valueString);
566 }
567
568 interp = scrollPtr->info.interp;
569 code = Tcl_GlobalEval(interp, cmdString.string);
570 if (code != TCL_OK && code != TCL_CONTINUE && code != TCL_BREAK) {
571 Tcl_AddErrorInfo(interp, "\n (scrollbar command)");
572 Tcl_BackgroundError(interp);
573 }
574 Tcl_DStringFree(&cmdString);
575
576 Tcl_ServiceAll();
577 return 0;
578 }
579
580 default:
581 if (Tk_TranslateWinEvent(hwnd, message, wParam, lParam, &result)) {
582 return result;
583 }
584 }
585 return CallWindowProc(scrollPtr->oldProc, hwnd, message, wParam, lParam);
586 }
587
588 /*
589 *----------------------------------------------------------------------
590 *
591 * TkpConfigureScrollbar --
592 *
593 * This procedure is called after the generic code has finished
594 * processing configuration options, in order to configure
595 * platform specific options.
596 *
597 * Results:
598 * None.
599 *
600 * Side effects:
601 * None.
602 *
603 *----------------------------------------------------------------------
604 */
605
606 void
607 TkpConfigureScrollbar(scrollPtr)
608 register TkScrollbar *scrollPtr; /* Information about widget; may or
609 * may not already have values for
610 * some fields. */
611 {
612 }
613
614 /*
615 *--------------------------------------------------------------
616 *
617 * ScrollbarBindProc --
618 *
619 * This procedure is invoked when the default <ButtonPress>
620 * binding on the Scrollbar bind tag fires.
621 *
622 * Results:
623 * None.
624 *
625 * Side effects:
626 * The event enters a modal loop.
627 *
628 *--------------------------------------------------------------
629 */
630
631 static int
632 ScrollbarBindProc(clientData, interp, eventPtr, tkwin, keySym)
633 ClientData clientData;
634 Tcl_Interp *interp;
635 XEvent *eventPtr;
636 Tk_Window tkwin;
637 KeySym keySym;
638 {
639 TkWindow *winPtr = (TkWindow*)tkwin;
640 if (eventPtr->type == ButtonPress) {
641 winPtr->flags |= TK_DEFER_MODAL;
642 }
643 return TCL_OK;
644 }
645
646 /*
647 *----------------------------------------------------------------------
648 *
649 * ModalLoopProc --
650 *
651 * This function is invoked at the end of the event processing
652 * whenever the ScrollbarBindProc has been invoked for a ButtonPress
653 * event.
654 *
655 * Results:
656 * None.
657 *
658 * Side effects:
659 * Enters a modal loop.
660 *
661 *----------------------------------------------------------------------
662 */
663
664 static void
665 ModalLoopProc(tkwin, eventPtr)
666 Tk_Window tkwin;
667 XEvent *eventPtr;
668 {
669 TkWindow *winPtr = (TkWindow*)tkwin;
670 WinScrollbar *scrollPtr = (WinScrollbar *) winPtr->instanceData;
671 int oldMode;
672
673 if (scrollPtr->hwnd) {
674 Tcl_Preserve((ClientData)scrollPtr);
675 scrollPtr->winFlags |= IN_MODAL_LOOP;
676 oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
677 TkWinResendEvent(scrollPtr->oldProc, scrollPtr->hwnd, eventPtr);
678 (void) Tcl_SetServiceMode(oldMode);
679 scrollPtr->winFlags &= ~IN_MODAL_LOOP;
680 if (scrollPtr->hwnd && scrollPtr->winFlags & ALREADY_DEAD) {
681 DestroyWindow(scrollPtr->hwnd);
682 }
683 Tcl_Release((ClientData)scrollPtr);
684 }
685 }
686
687 /*
688 *--------------------------------------------------------------
689 *
690 * TkpScrollbarPosition --
691 *
692 * Determine the scrollbar element corresponding to a
693 * given position.
694 *
695 * Results:
696 * One of TOP_ARROW, TOP_GAP, etc., indicating which element
697 * of the scrollbar covers the position given by (x, y). If
698 * (x,y) is outside the scrollbar entirely, then OUTSIDE is
699 * returned.
700 *
701 * Side effects:
702 * None.
703 *
704 *--------------------------------------------------------------
705 */
706
707 int
708 TkpScrollbarPosition(scrollPtr, x, y)
709 register TkScrollbar *scrollPtr; /* Scrollbar widget record. */
710 int x, y; /* Coordinates within scrollPtr's
711 * window. */
712 {
713 int length, width, tmp;
714
715 if (scrollPtr->vertical) {
716 length = Tk_Height(scrollPtr->tkwin);
717 width = Tk_Width(scrollPtr->tkwin);
718 } else {
719 tmp = x;
720 x = y;
721 y = tmp;
722 length = Tk_Width(scrollPtr->tkwin);
723 width = Tk_Height(scrollPtr->tkwin);
724 }
725
726 if ((x < scrollPtr->inset) || (x >= (width - scrollPtr->inset))
727 || (y < scrollPtr->inset) || (y >= (length - scrollPtr->inset))) {
728 return OUTSIDE;
729 }
730
731 /*
732 * All of the calculations in this procedure mirror those in
733 * TkpDisplayScrollbar. Be sure to keep the two consistent.
734 */
735
736 if (y < (scrollPtr->inset + scrollPtr->arrowLength)) {
737 return TOP_ARROW;
738 }
739 if (y < scrollPtr->sliderFirst) {
740 return TOP_GAP;
741 }
742 if (y < scrollPtr->sliderLast) {
743 return SLIDER;
744 }
745 if (y >= (length - (scrollPtr->arrowLength + scrollPtr->inset))) {
746 return BOTTOM_ARROW;
747 }
748 return BOTTOM_GAP;
749 }
750
751
752 /* $History: tkWinScrlbr.c $
753 *
754 * ***************** Version 1 *****************
755 * User: Dtashley Date: 1/02/01 Time: 3:19a
756 * Created in $/IjuScripter, IjuConsole/Source/Tk Base
757 * Initial check-in.
758 */
759
760 /* End of TKWINSCRLBR.C */

dashley@gmail.com
ViewVC Help
Powered by ViewVC 1.1.25