source: trunk/src/user32/new/scroll.cpp@ 493

Last change on this file since 493 was 387, checked in by cbratschi, 26 years ago

edit control
File size: 49.1 KB
Line 
1/* $Id: scroll.cpp,v 1.4 1999-07-24 17:10:25 cbratschi Exp $ */
2/*
3 * Scrollbar control
4 *
5 * Copyright 1999 Christoph Bratschi (ported from WINE)
6 *
7 * Copyright 1993 Martin Ayotte
8 * Copyright 1994, 1996 Alexandre Julliard
9 */
10
11/* CB:
12 - exported API removed, this functions are already implemented by Open32,
13 code perhaps useful for new user32
14 - only control, default scroll bars for windows need more work
15 - SystemTimer not implemented
16*/
17
18#include <stdlib.h>
19#include "winuser.h"
20#include "winbase.h"
21#include "controls.h"
22#include "scroll.h"
23
24static HBITMAP hUpArrow = 0;
25static HBITMAP hDnArrow = 0;
26static HBITMAP hLfArrow = 0;
27static HBITMAP hRgArrow = 0;
28static HBITMAP hUpArrowD = 0;
29static HBITMAP hDnArrowD = 0;
30static HBITMAP hLfArrowD = 0;
31static HBITMAP hRgArrowD = 0;
32static HBITMAP hUpArrowI = 0;
33static HBITMAP hDnArrowI = 0;
34static HBITMAP hLfArrowI = 0;
35static HBITMAP hRgArrowI = 0;
36
37#define TOP_ARROW(flags,pressed) \
38 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
39#define BOTTOM_ARROW(flags,pressed) \
40 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
41#define LEFT_ARROW(flags,pressed) \
42 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
43#define RIGHT_ARROW(flags,pressed) \
44 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
45
46
47 /* Minimum size of the rectangle between the arrows */
48#define SCROLL_MIN_RECT 4
49
50 /* Minimum size of the thumb in pixels */
51#define SCROLL_MIN_THUMB 6
52
53 /* Overlap between arrows and thumb */
54#define SCROLL_ARROW_THUMB_OVERLAP 1
55
56 /* Delay (in ms) before first repetition when holding the button down */
57#define SCROLL_FIRST_DELAY 200
58
59 /* Delay (in ms) between scroll repetitions */
60#define SCROLL_REPEAT_DELAY 50
61
62 /* Scroll timer id */
63#define SCROLL_TIMER 0
64
65 /* Scroll-bar hit testing */
66enum SCROLL_HITTEST
67{
68 SCROLL_NOWHERE, /* Outside the scroll bar */
69 SCROLL_TOP_ARROW, /* Top or left arrow */
70 SCROLL_TOP_RECT, /* Rectangle between the top arrow and the thumb */
71 SCROLL_THUMB, /* Thumb rectangle */
72 SCROLL_BOTTOM_RECT, /* Rectangle between the thumb and the bottom arrow */
73 SCROLL_BOTTOM_ARROW /* Bottom or right arrow */
74};
75
76 /* What to do after SCROLL_SetScrollInfo() */
77#define SA_SSI_HIDE 0x0001
78#define SA_SSI_SHOW 0x0002
79#define SA_SSI_REFRESH 0x0004
80#define SA_SSI_REPAINT_ARROWS 0x0008
81
82 /* Thumb-tracking info */
83static HWND SCROLL_TrackingWin = 0;
84static INT SCROLL_TrackingBar = 0;
85static INT SCROLL_TrackingPos = 0;
86static INT SCROLL_TrackingVal = 0;
87 /* Hit test code of the last button-down event */
88static enum SCROLL_HITTEST SCROLL_trackHitTest;
89static BOOL SCROLL_trackVertical;
90
91 /* Is the moving thumb being displayed? */
92static BOOL SCROLL_MovingThumb = FALSE;
93
94 /* Local functions */
95static BOOL SCROLL_ShowScrollBar( HWND hwnd, INT nBar,
96 BOOL fShowH, BOOL fShowV );
97static INT SCROLL_SetScrollInfo( HWND hwnd, INT nBar,
98 const SCROLLINFO *info, INT *action );
99
100/***********************************************************************
101 * SCROLL_LoadBitmaps
102 */
103static void SCROLL_LoadBitmaps(void)
104{
105 hUpArrow = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROW) );
106 hDnArrow = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROW) );
107 hLfArrow = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROW) );
108 hRgArrow = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROW) );
109 hUpArrowD = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWD) );
110 hDnArrowD = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWD) );
111 hLfArrowD = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWD) );
112 hRgArrowD = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWD) );
113 hUpArrowI = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWI) );
114 hDnArrowI = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWI) );
115 hLfArrowI = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWI) );
116 hRgArrowI = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWI) );
117}
118
119/***********************************************************************
120 * SCROLL_GetPtrScrollInfo
121 */
122static SCROLLBAR_INFO *SCROLL_GetPtrScrollInfo( HWND hwnd, INT nBar )
123{
124 SCROLLBAR_INFO *infoPtr;
125
126 switch(nBar)
127 {
128/* CB: implement this later!
129 case SB_HORZ:
130 infoPtr = (SCROLLBAR_INFO *)wndPtr->pHScroll;
131 break;
132 case SB_VERT:
133 infoPtr = (SCROLLBAR_INFO *)wndPtr->pVScroll;
134 break;
135*/
136 case SB_CTL:
137 infoPtr = (SCROLLBAR_INFO *)GetInfoPtr(hwnd);
138 break;
139 default: return NULL;
140 }
141
142 if (!infoPtr) /* Create the info structure if needed */
143 {
144 infoPtr = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
145 infoPtr->MinVal = infoPtr->CurVal = infoPtr->Page = 0;
146 infoPtr->MaxVal = 100;
147 infoPtr->flags = ESB_ENABLE_BOTH;
148
149 //CB: store in window class if not control!
150 SetInfoPtr(hwnd,(DWORD)infoPtr);
151
152 if (!hUpArrow) SCROLL_LoadBitmaps();
153 }
154 return infoPtr;
155}
156
157
158/***********************************************************************
159 * SCROLL_GetScrollInfo
160 */
161static SCROLLBAR_INFO *SCROLL_GetScrollInfo( HWND hwnd, INT nBar )
162{
163 return SCROLL_GetPtrScrollInfo( hwnd, nBar );
164}
165
166
167/***********************************************************************
168 * SCROLL_GetScrollBarRect
169 *
170 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
171 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
172 * 'arrowSize' returns the width or height of an arrow (depending on
173 * the orientation of the scrollbar), 'thumbSize' returns the size of
174 * the thumb, and 'thumbPos' returns the position of the thumb
175 * relative to the left or to the top.
176 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
177 */
178static BOOL SCROLL_GetScrollBarRect( HWND hwnd, INT nBar, RECT *lprect,
179 INT *arrowSize, INT *thumbSize,
180 INT *thumbPos )
181{
182 INT pixels;
183 BOOL vertical;
184 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
185 RECT rectClient;
186
187 switch(nBar)
188 {
189/* CB: implement later!
190 case SB_HORZ:
191 lprect->left = wndPtr->rectClient.left - wndPtr->rectWindow.left;
192 lprect->top = wndPtr->rectClient.bottom - wndPtr->rectWindow.top;
193 lprect->right = wndPtr->rectClient.right - wndPtr->rectWindow.left;
194 lprect->bottom = lprect->top + GetSystemMetrics(SM_CYHSCROLL);
195 if(dwStyle & WS_BORDER) {
196 lprect->left--;
197 lprect->right++;
198 } else if(dwStyle & WS_VSCROLL)
199 lprect->right++;
200 vertical = FALSE;
201 break;
202
203 case SB_VERT:
204 lprect->left = wndPtr->rectClient.right - wndPtr->rectWindow.left;
205 lprect->top = wndPtr->rectClient.top - wndPtr->rectWindow.top;
206 lprect->right = lprect->left + GetSystemMetrics(SM_CXVSCROLL);
207 lprect->bottom = wndPtr->rectClient.bottom - wndPtr->rectWindow.top;
208 if(wndPtr->dwStyle & WS_BORDER) {
209 lprect->top--;
210 lprect->bottom++;
211 } else if(wndPtr->dwStyle & WS_HSCROLL)
212 lprect->bottom++;
213 vertical = TRUE;
214 break;
215*/
216 case SB_CTL:
217 GetClientRect( hwnd, lprect );
218 vertical = ((dwStyle & SBS_VERT) != 0);
219 break;
220
221 default:
222 return FALSE;
223 }
224
225 if (vertical) pixels = lprect->bottom - lprect->top;
226 else pixels = lprect->right - lprect->left;
227
228 if (pixels <= 2*GetSystemMetrics(SM_CXVSCROLL) + SCROLL_MIN_RECT)
229 {
230 if (pixels > SCROLL_MIN_RECT)
231 *arrowSize = (pixels - SCROLL_MIN_RECT) / 2;
232 else
233 *arrowSize = 0;
234 *thumbPos = *thumbSize = 0;
235 }
236 else
237 {
238 SCROLLBAR_INFO *info = SCROLL_GetPtrScrollInfo( hwnd, nBar );
239
240 *arrowSize = GetSystemMetrics(SM_CXVSCROLL);
241 pixels -= (2 * (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP));
242
243 if (info->Page)
244 {
245 *thumbSize = pixels * info->Page / (info->MaxVal-info->MinVal+1);
246 if (*thumbSize < SCROLL_MIN_THUMB) *thumbSize = SCROLL_MIN_THUMB;
247 }
248 else *thumbSize = GetSystemMetrics(SM_CXVSCROLL);
249
250 if (((pixels -= *thumbSize ) < 0) ||
251 ((info->flags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH))
252 {
253 /* Rectangle too small or scrollbar disabled -> no thumb */
254 *thumbPos = *thumbSize = 0;
255 }
256 else
257 {
258 INT max = info->MaxVal - MAX( info->Page-1, 0 );
259 if (info->MinVal >= max)
260 *thumbPos = *arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
261 else
262 *thumbPos = *arrowSize - SCROLL_ARROW_THUMB_OVERLAP
263 + pixels * (info->CurVal-info->MinVal) / (max - info->MinVal);
264 }
265 }
266 return vertical;
267}
268
269
270/***********************************************************************
271 * SCROLL_GetThumbVal
272 *
273 * Compute the current scroll position based on the thumb position in pixels
274 * from the top of the scroll-bar.
275 */
276static UINT SCROLL_GetThumbVal( SCROLLBAR_INFO *infoPtr, RECT *rect,
277 BOOL vertical, INT pos )
278{
279 INT thumbSize;
280 INT pixels = vertical ? rect->bottom-rect->top : rect->right-rect->left;
281
282 if ((pixels -= 2*(GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP)) <= 0)
283 return infoPtr->MinVal;
284
285 if (infoPtr->Page)
286 {
287 thumbSize = pixels * infoPtr->Page/(infoPtr->MaxVal-infoPtr->MinVal+1);
288 if (thumbSize < SCROLL_MIN_THUMB) thumbSize = SCROLL_MIN_THUMB;
289 }
290 else thumbSize = GetSystemMetrics(SM_CXVSCROLL);
291
292 if ((pixels -= thumbSize) <= 0) return infoPtr->MinVal;
293
294 pos = MAX( 0, pos - (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP) );
295 if (pos > pixels) pos = pixels;
296
297 if (!infoPtr->Page) pos *= infoPtr->MaxVal - infoPtr->MinVal;
298 else pos *= infoPtr->MaxVal - infoPtr->MinVal - infoPtr->Page + 1;
299 return infoPtr->MinVal + ((pos + pixels / 2) / pixels);
300}
301
302/***********************************************************************
303 * SCROLL_PtInRectEx
304 */
305static BOOL SCROLL_PtInRectEx( LPRECT lpRect, POINT pt, BOOL vertical )
306{
307 RECT rect = *lpRect;
308
309 if (vertical)
310 {
311 rect.left -= lpRect->right - lpRect->left;
312 rect.right += lpRect->right - lpRect->left;
313 }
314 else
315 {
316 rect.top -= lpRect->bottom - lpRect->top;
317 rect.bottom += lpRect->bottom - lpRect->top;
318 }
319 return PtInRect( &rect, pt );
320}
321
322/***********************************************************************
323 * SCROLL_ClipPos
324 */
325static POINT SCROLL_ClipPos( LPRECT lpRect, POINT pt )
326{
327 if( pt.x < lpRect->left )
328 pt.x = lpRect->left;
329 else
330 if( pt.x > lpRect->right )
331 pt.x = lpRect->right;
332
333 if( pt.y < lpRect->top )
334 pt.y = lpRect->top;
335 else
336 if( pt.y > lpRect->bottom )
337 pt.y = lpRect->bottom;
338
339 return pt;
340}
341
342
343/***********************************************************************
344 * SCROLL_HitTest
345 *
346 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
347 */
348static enum SCROLL_HITTEST SCROLL_HitTest( HWND hwnd, INT nBar,
349 POINT pt, BOOL bDragging )
350{
351 INT arrowSize, thumbSize, thumbPos;
352 RECT rect;
353
354 BOOL vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
355 &arrowSize, &thumbSize, &thumbPos );
356
357 if ( (bDragging && !SCROLL_PtInRectEx( &rect, pt, vertical )) ||
358 (!PtInRect( &rect, pt )) ) return SCROLL_NOWHERE;
359
360 if (vertical)
361 {
362 if (pt.y < rect.top + arrowSize) return SCROLL_TOP_ARROW;
363 if (pt.y >= rect.bottom - arrowSize) return SCROLL_BOTTOM_ARROW;
364 if (!thumbPos) return SCROLL_TOP_RECT;
365 pt.y -= rect.top;
366 if (pt.y < thumbPos) return SCROLL_TOP_RECT;
367 if (pt.y >= thumbPos + thumbSize) return SCROLL_BOTTOM_RECT;
368 }
369 else /* horizontal */
370 {
371 if (pt.x < rect.left + arrowSize) return SCROLL_TOP_ARROW;
372 if (pt.x >= rect.right - arrowSize) return SCROLL_BOTTOM_ARROW;
373 if (!thumbPos) return SCROLL_TOP_RECT;
374 pt.x -= rect.left;
375 if (pt.x < thumbPos) return SCROLL_TOP_RECT;
376 if (pt.x >= thumbPos + thumbSize) return SCROLL_BOTTOM_RECT;
377 }
378 return SCROLL_THUMB;
379}
380
381
382/***********************************************************************
383 * SCROLL_DrawArrows
384 *
385 * Draw the scroll bar arrows.
386 */
387static void SCROLL_DrawArrows( HDC hdc, SCROLLBAR_INFO *infoPtr,
388 RECT *rect, INT arrowSize, BOOL vertical,
389 BOOL top_pressed, BOOL bottom_pressed )
390{
391 HDC hdcMem = CreateCompatibleDC( hdc );
392 HBITMAP hbmpPrev = SelectObject( hdcMem, vertical ?
393 TOP_ARROW(infoPtr->flags, top_pressed)
394 : LEFT_ARROW(infoPtr->flags, top_pressed));
395 INT offset = 1;
396
397 if (offset) arrowSize--;
398 SetStretchBltMode( hdc, STRETCH_DELETESCANS );
399 StretchBlt( hdc, rect->left+offset, rect->top+offset,
400 vertical ? rect->right-(rect->left+offset) : arrowSize,
401 vertical ? arrowSize : rect->bottom-(rect->top+offset),
402 hdcMem, 0, 0,
403 GetSystemMetrics(SM_CXVSCROLL),GetSystemMetrics(SM_CYHSCROLL),
404 SRCCOPY );
405
406 SelectObject( hdcMem, vertical ?
407 BOTTOM_ARROW( infoPtr->flags, bottom_pressed )
408 : RIGHT_ARROW( infoPtr->flags, bottom_pressed ) );
409 if (vertical)
410 StretchBlt( hdc, (rect->left+offset), rect->bottom - arrowSize,
411 rect->right - (rect->left+offset), arrowSize,
412 hdcMem, 0, 0,
413 GetSystemMetrics(SM_CXVSCROLL),GetSystemMetrics(SM_CYHSCROLL),
414 SRCCOPY );
415 else
416 StretchBlt( hdc, rect->right - arrowSize, rect->top+offset,
417 arrowSize, rect->bottom - (rect->top+offset),
418 hdcMem, 0, 0,
419 GetSystemMetrics(SM_CXVSCROLL), GetSystemMetrics(SM_CYHSCROLL),
420 SRCCOPY );
421 SelectObject( hdcMem, hbmpPrev );
422 DeleteDC( hdcMem );
423}
424
425
426/***********************************************************************
427 * SCROLL_DrawMovingThumb
428 *
429 * Draw the moving thumb rectangle.
430 */
431static void SCROLL_DrawMovingThumb( HDC hdc, RECT *rect, BOOL vertical,
432 INT arrowSize, INT thumbSize )
433{
434 RECT r = *rect;
435 if (vertical)
436 {
437 r.top += SCROLL_TrackingPos;
438 if (r.top < rect->top + arrowSize - SCROLL_ARROW_THUMB_OVERLAP)
439 r.top = rect->top + arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
440 if (r.top + thumbSize >
441 rect->bottom - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP))
442 r.top = rect->bottom - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP)
443 - thumbSize;
444 r.bottom = r.top + thumbSize;
445 }
446 else
447 {
448 r.left += SCROLL_TrackingPos;
449 if (r.left < rect->left + arrowSize - SCROLL_ARROW_THUMB_OVERLAP)
450 r.left = rect->left + arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
451 if (r.left + thumbSize >
452 rect->right - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP))
453 r.left = rect->right - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP)
454 - thumbSize;
455 r.right = r.left + thumbSize;
456 }
457 DrawFocusRect( hdc, &r );
458 SCROLL_MovingThumb = !SCROLL_MovingThumb;
459}
460
461
462/***********************************************************************
463 * SCROLL_DrawInterior
464 *
465 * Draw the scroll bar interior (everything except the arrows).
466 */
467static void SCROLL_DrawInterior( HWND hwnd, HDC hdc, INT nBar,
468 RECT *rect, INT arrowSize,
469 INT thumbSize, INT thumbPos,
470 UINT flags, BOOL vertical,
471 BOOL top_selected, BOOL bottom_selected )
472{
473 RECT r;
474 HPEN hSavePen;
475 HBRUSH hSaveBrush,hBrush;
476 BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
477
478 if (Save_SCROLL_MovingThumb &&
479 (SCROLL_TrackingWin == hwnd) &&
480 (SCROLL_TrackingBar == nBar))
481 SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
482
483 /* Select the correct brush and pen */
484
485 if ((flags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH)
486 {
487 /* This ought to be the color of the parent window */
488 //hBrush = GetSysColorBrush(COLOR_WINDOW);
489 /* Under Win9x look & feel, scrollbars don't have a solid border.
490 * To make scrollbar's background different from the window
491 * background, we need to apply a gray 0x55aa pattern brush.
492 * Otherwise it won't look good.
493 */
494 //hBrush = CACHE_GetPattern55AABrush();
495 hBrush = GetSysColorBrush(COLOR_3DFACE); //CB: improve!
496 }
497 else
498 {
499 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
500 * The window-owned scrollbars need to call DEFWND_ControlColor
501 * to correctly setup default scrollbar colors
502 */
503 if (nBar == SB_CTL) {
504 hBrush = (HBRUSH)SendMessageA( GetParent(hwnd), WM_CTLCOLORSCROLLBAR,
505 (WPARAM)hdc,(LPARAM)hwnd);
506 } else {
507/* CB: implement later!
508 hBrush = DEFWND_ControlColor( hdc, CTLCOLOR_SCROLLBAR );
509*/
510 }
511 }
512 hSavePen = SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
513 hSaveBrush = SelectObject( hdc, hBrush );
514
515 /* Calculate the scroll rectangle */
516
517 r = *rect;
518 if (vertical)
519 {
520 r.top += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
521 r.bottom -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
522 }
523 else
524 {
525 r.left += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
526 r.right -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
527 }
528
529 /* Draw the scroll rectangles and thumb */
530
531 if (!thumbPos) /* No thumb to draw */
532 {
533 PatBlt( hdc, r.left+1, r.top+1, r.right - r.left - 2,
534 r.bottom - r.top - 2, PATCOPY );
535
536 /* cleanup and return */
537 SelectObject( hdc, hSavePen );
538 SelectObject( hdc, hSaveBrush );
539 return;
540 }
541
542 if (vertical)
543 {
544 PatBlt( hdc, r.left + 1, r.top + 1,
545 r.right - r.left - 2,
546 thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP) - 1,
547 top_selected ? 0x0f0000 : PATCOPY );
548 r.top += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
549 PatBlt( hdc, r.left + 1, r.top + thumbSize,
550 r.right - r.left - 2,
551 r.bottom - r.top - thumbSize - 1,
552 bottom_selected ? 0x0f0000 : PATCOPY );
553 r.bottom = r.top + thumbSize;
554 }
555 else /* horizontal */
556 {
557 PatBlt( hdc, r.left + 1, r.top + 1,
558 thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP) - 1,
559 r.bottom - r.top - 2,
560 top_selected ? 0x0f0000 : PATCOPY );
561 r.left += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
562 PatBlt( hdc, r.left + thumbSize, r.top + 1,
563 r.right - r.left - thumbSize - 1,
564 r.bottom - r.top - 2,
565 bottom_selected ? 0x0f0000 : PATCOPY );
566 r.right = r.left + thumbSize;
567 }
568
569 /* Draw the thumb */
570
571 SelectObject( hdc, GetSysColorBrush(COLOR_BTNFACE) );
572
573 r.top++, r.left++;
574 r.bottom--; r.right--;
575 Rectangle( hdc, r.left, r.top, r.right-1, r.bottom-1 );
576
577 DrawEdge( hdc, &r, EDGE_RAISED, BF_RECT );
578
579 if (Save_SCROLL_MovingThumb &&
580 (SCROLL_TrackingWin == hwnd) &&
581 (SCROLL_TrackingBar == nBar))
582 SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
583
584 /* cleanup */
585 SelectObject( hdc, hSavePen );
586 SelectObject( hdc, hSaveBrush );
587}
588
589
590/***********************************************************************
591 * SCROLL_DrawScrollBar
592 *
593 * Redraw the whole scrollbar.
594 */
595void SCROLL_DrawScrollBar( HWND hwnd, HDC hdc, INT nBar,
596 BOOL arrows, BOOL interior )
597{
598 INT arrowSize, thumbSize, thumbPos;
599 RECT rect;
600 BOOL vertical;
601 SCROLLBAR_INFO *infoPtr = SCROLL_GetPtrScrollInfo( hwnd, nBar );
602 BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
603 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
604
605 if (!infoPtr ||
606 ((nBar == SB_VERT) && !(dwStyle & WS_VSCROLL)) ||
607 ((nBar == SB_HORZ) && !(dwStyle & WS_HSCROLL))) return;
608 //if (!WIN_IsWindowDrawable( hwnd, FALSE )) return; //CB: what's that???
609
610 vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
611 &arrowSize, &thumbSize, &thumbPos );
612
613 if (Save_SCROLL_MovingThumb &&
614 (SCROLL_TrackingWin == hwnd) &&
615 (SCROLL_TrackingBar == nBar))
616 SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
617
618 /* Draw the arrows */
619
620 if (arrows && arrowSize)
621 {
622 if( vertical == SCROLL_trackVertical && GetCapture() == hwnd )
623 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
624 (SCROLL_trackHitTest == SCROLL_TOP_ARROW),
625 (SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW) );
626 else
627 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
628 FALSE, FALSE );
629 }
630 if( interior )
631 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
632 thumbPos, infoPtr->flags, vertical, FALSE, FALSE );
633
634 if (Save_SCROLL_MovingThumb &&
635 (SCROLL_TrackingWin == hwnd) &&
636 (SCROLL_TrackingBar == nBar))
637 SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
638
639}
640
641
642/***********************************************************************
643 * SCROLL_RefreshScrollBar
644 *
645 * Repaint the scroll bar interior after a SetScrollRange() or
646 * SetScrollPos() call.
647 */
648static void SCROLL_RefreshScrollBar( HWND hwnd, INT nBar,
649 BOOL arrows, BOOL interior )
650{
651 HDC hdc = GetDCEx( hwnd, 0,
652 DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW) );
653 if (!hdc) return;
654
655 SCROLL_DrawScrollBar( hwnd, hdc, nBar, arrows, interior );
656 ReleaseDC( hwnd, hdc );
657}
658
659
660/***********************************************************************
661 * SCROLL_HandleKbdEvent
662 *
663 * Handle a keyboard event (only for SB_CTL scrollbars).
664 */
665static void SCROLL_HandleKbdEvent( HWND hwnd, WPARAM wParam )
666{
667 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
668 WPARAM msg;
669
670 switch(wParam)
671 {
672 case VK_PRIOR: msg = SB_PAGEUP; break;
673 case VK_NEXT: msg = SB_PAGEDOWN; break;
674 case VK_HOME: msg = SB_TOP; break;
675 case VK_END: msg = SB_BOTTOM; break;
676 case VK_UP: msg = SB_LINEUP; break;
677 case VK_DOWN: msg = SB_LINEDOWN; break;
678 default:
679 return;
680 }
681 SendMessageA( GetParent(hwnd),
682 (dwStyle & SBS_VERT) ? WM_VSCROLL : WM_HSCROLL,
683 msg, hwnd );
684}
685
686
687/***********************************************************************
688 * SCROLL_HandleScrollEvent
689 *
690 * Handle a mouse or timer event for the scrollbar.
691 * 'pt' is the location of the mouse event in client (for SB_CTL) or
692 * windows coordinates.
693 */
694void SCROLL_HandleScrollEvent( HWND hwnd, INT nBar, UINT msg, POINT pt)
695{
696 /* Previous mouse position for timer events */
697 static POINT prevPt;
698 /* Thumb position when tracking started. */
699 static UINT trackThumbPos;
700 /* Position in the scroll-bar of the last button-down event. */
701 static INT lastClickPos;
702 /* Position in the scroll-bar of the last mouse event. */
703 static INT lastMousePos;
704
705 enum SCROLL_HITTEST hittest;
706 HWND hwndOwner, hwndCtl;
707 BOOL vertical;
708 INT arrowSize, thumbSize, thumbPos;
709 RECT rect;
710 HDC hdc;
711
712 SCROLLBAR_INFO *infoPtr = SCROLL_GetScrollInfo( hwnd, nBar );
713 if (!infoPtr) return;
714 if ((SCROLL_trackHitTest == SCROLL_NOWHERE) && (msg != WM_LBUTTONDOWN))
715 return;
716
717 hdc = GetDCEx( hwnd, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
718 vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
719 &arrowSize, &thumbSize, &thumbPos );
720 hwndOwner = (nBar == SB_CTL) ? GetParent(hwnd) : hwnd;
721 hwndCtl = (nBar == SB_CTL) ? hwnd : 0;
722
723 switch(msg)
724 {
725 case WM_LBUTTONDOWN: /* Initialise mouse tracking */
726 SCROLL_trackVertical = vertical;
727 SCROLL_trackHitTest = hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
728 lastClickPos = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
729 lastMousePos = lastClickPos;
730 trackThumbPos = thumbPos;
731 prevPt = pt;
732 SetCapture( hwnd );
733 if (nBar == SB_CTL) SetFocus( hwnd );
734 break;
735
736 case WM_MOUSEMOVE:
737 hittest = SCROLL_HitTest( hwnd, nBar, pt, TRUE );
738 prevPt = pt;
739 break;
740
741 case WM_LBUTTONUP:
742 hittest = SCROLL_NOWHERE;
743 ReleaseCapture();
744 break;
745
746 case WM_SYSTIMER:
747 pt = prevPt;
748 hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
749 break;
750
751 default:
752 return; /* Should never happen */
753 }
754
755 //TRACE("Event: hwnd=%04x bar=%d msg=%x pt=%ld,%ld hit=%d\n",
756 // hwnd, nBar, msg, pt.x, pt.y, hittest );
757
758 switch(SCROLL_trackHitTest)
759 {
760 case SCROLL_NOWHERE: /* No tracking in progress */
761 break;
762
763 case SCROLL_TOP_ARROW:
764 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
765 (hittest == SCROLL_trackHitTest), FALSE );
766 if (hittest == SCROLL_trackHitTest)
767 {
768 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
769 {
770 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
771 SB_LINEUP, hwndCtl );
772 //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
773 // SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
774 // (TIMERPROC)0 );
775 }
776 }
777 //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
778 break;
779
780 case SCROLL_TOP_RECT:
781 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
782 thumbPos, infoPtr->flags, vertical,
783 (hittest == SCROLL_trackHitTest), FALSE );
784 if (hittest == SCROLL_trackHitTest)
785 {
786 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
787 {
788 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
789 SB_PAGEUP, hwndCtl );
790 //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
791 // SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
792 // (TIMERPROC)0 );
793 }
794 }
795 //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
796 break;
797
798 case SCROLL_THUMB:
799 if (msg == WM_LBUTTONDOWN)
800 {
801 SCROLL_TrackingWin = hwnd;
802 SCROLL_TrackingBar = nBar;
803 SCROLL_TrackingPos = trackThumbPos + lastMousePos - lastClickPos;
804 if (!SCROLL_MovingThumb)
805 SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
806 }
807 else if (msg == WM_LBUTTONUP)
808 {
809 if (SCROLL_MovingThumb)
810 SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
811 SCROLL_TrackingWin = 0;
812 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
813 thumbPos, infoPtr->flags, vertical,
814 FALSE, FALSE );
815 }
816 else /* WM_MOUSEMOVE */
817 {
818 UINT pos;
819
820 if (!SCROLL_PtInRectEx( &rect, pt, vertical )) pos = lastClickPos;
821 else
822 {
823 pt = SCROLL_ClipPos( &rect, pt );
824 pos = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
825 }
826 if ( (pos != lastMousePos) || (!SCROLL_MovingThumb) )
827 {
828 if (SCROLL_MovingThumb)
829 SCROLL_DrawMovingThumb( hdc, &rect, vertical,
830 arrowSize, thumbSize );
831 lastMousePos = pos;
832 SCROLL_TrackingPos = trackThumbPos + pos - lastClickPos;
833 SCROLL_TrackingVal = SCROLL_GetThumbVal( infoPtr, &rect,
834 vertical,
835 SCROLL_TrackingPos );
836 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
837 MAKEWPARAM( SB_THUMBTRACK, SCROLL_TrackingVal),
838 hwndCtl );
839 if (!SCROLL_MovingThumb)
840 SCROLL_DrawMovingThumb( hdc, &rect, vertical,
841 arrowSize, thumbSize );
842 }
843 }
844 break;
845
846 case SCROLL_BOTTOM_RECT:
847 SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
848 thumbPos, infoPtr->flags, vertical,
849 FALSE, (hittest == SCROLL_trackHitTest) );
850 if (hittest == SCROLL_trackHitTest)
851 {
852 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
853 {
854 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
855 SB_PAGEDOWN, hwndCtl );
856 //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
857 // SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
858 // (TIMERPROC)0 );
859 }
860 }
861 //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
862 break;
863
864 case SCROLL_BOTTOM_ARROW:
865 SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
866 FALSE, (hittest == SCROLL_trackHitTest) );
867 if (hittest == SCROLL_trackHitTest)
868 {
869 if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
870 {
871 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
872 SB_LINEDOWN, hwndCtl );
873 //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
874 // SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
875 // (TIMERPROC)0 );
876 }
877 }
878 //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
879 break;
880 }
881
882 if (msg == WM_LBUTTONUP)
883 {
884 hittest = SCROLL_trackHitTest;
885 SCROLL_trackHitTest = SCROLL_NOWHERE; /* Terminate tracking */
886
887 if (hittest == SCROLL_THUMB)
888 {
889 UINT val = SCROLL_GetThumbVal( infoPtr, &rect, vertical,
890 trackThumbPos + lastMousePos - lastClickPos );
891 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
892 MAKEWPARAM( SB_THUMBPOSITION, val ), hwndCtl );
893 }
894 else
895 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
896 SB_ENDSCROLL, hwndCtl );
897 }
898
899 ReleaseDC( hwnd, hdc );
900}
901
902
903/***********************************************************************
904 * ScrollBarWndProc
905 */
906LRESULT WINAPI ScrollBarWndProc( HWND hwnd, UINT message, WPARAM wParam,
907 LPARAM lParam )
908{
909 switch(message)
910 {
911 case WM_CREATE:
912 {
913 CREATESTRUCTA *lpCreat = (CREATESTRUCTA *)lParam;
914 if (lpCreat->style & SBS_SIZEBOX)
915 {
916 //FIXME("Unimplemented style SBS_SIZEBOX.\n" );
917 return 0;
918 }
919
920 if (lpCreat->style & SBS_VERT)
921 {
922 if (lpCreat->style & SBS_LEFTALIGN)
923 MoveWindow( hwnd, lpCreat->x, lpCreat->y,
924 GetSystemMetrics(SM_CXVSCROLL)+1, lpCreat->cy, FALSE );
925 else if (lpCreat->style & SBS_RIGHTALIGN)
926 MoveWindow( hwnd,
927 lpCreat->x+lpCreat->cx-GetSystemMetrics(SM_CXVSCROLL)-1,
928 lpCreat->y,
929 GetSystemMetrics(SM_CXVSCROLL)+1, lpCreat->cy, FALSE );
930 }
931 else /* SBS_HORZ */
932 {
933 if (lpCreat->style & SBS_TOPALIGN)
934 MoveWindow( hwnd, lpCreat->x, lpCreat->y,
935 lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL)+1, FALSE );
936 else if (lpCreat->style & SBS_BOTTOMALIGN)
937 MoveWindow( hwnd,
938 lpCreat->x,
939 lpCreat->y+lpCreat->cy-GetSystemMetrics(SM_CYHSCROLL)-1,
940 lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL)+1, FALSE );
941 }
942 }
943 if (!hUpArrow) SCROLL_LoadBitmaps();
944 //TRACE("ScrollBar creation, hwnd=%04x\n", hwnd );
945 return 0;
946
947 case WM_LBUTTONDOWN:
948 case WM_LBUTTONUP:
949 case WM_MOUSEMOVE:
950 case WM_SYSTIMER:
951 {
952 POINT pt;
953 CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
954 SCROLL_HandleScrollEvent( hwnd, SB_CTL, message, pt );
955 }
956 break;
957
958 case WM_KEYDOWN:
959 SCROLL_HandleKbdEvent( hwnd, wParam );
960 break;
961
962 case WM_ERASEBKGND:
963 return 1;
964
965 case WM_GETDLGCODE:
966 return DLGC_WANTARROWS; /* Windows returns this value */
967
968 case WM_PAINT:
969 {
970 PAINTSTRUCT ps;
971 HDC hdc = BeginPaint( hwnd, &ps );
972 SCROLL_DrawScrollBar( hwnd, hdc, SB_CTL, TRUE, TRUE );
973 EndPaint( hwnd, &ps );
974 }
975 break;
976
977 case SBM_SETPOS:
978 return SetScrollPos( hwnd, SB_CTL, wParam, (BOOL)lParam );
979
980 case SBM_GETPOS:
981 return GetScrollPos( hwnd, SB_CTL );
982
983 case SBM_SETRANGE:
984 SetScrollRange( hwnd, SB_CTL, wParam, lParam, FALSE );
985 return 0; /* FIXME: return previous position */
986
987 case SBM_GETRANGE:
988 GetScrollRange( hwnd, SB_CTL, (LPINT)wParam, (LPINT)lParam );
989 return 0;
990
991 case SBM_ENABLE_ARROWS:
992 return EnableScrollBar( hwnd, SB_CTL, wParam );
993
994 case SBM_SETRANGEREDRAW:
995 SetScrollRange( hwnd, SB_CTL, wParam, lParam, TRUE );
996 return 0; /* FIXME: return previous position */
997
998 case SBM_SETSCROLLINFO:
999 return SetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam, wParam );
1000
1001 case SBM_GETSCROLLINFO:
1002 return GetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam );
1003
1004 case 0x00e5:
1005 case 0x00e7:
1006 case 0x00e8:
1007 case 0x00eb:
1008 case 0x00ec:
1009 case 0x00ed:
1010 case 0x00ee:
1011 case 0x00ef:
1012 //ERR("unknown Win32 msg %04x wp=%08x lp=%08lx\n",
1013 // message, wParam, lParam );
1014 break;
1015
1016 default:
1017 if (message >= WM_USER)
1018 //WARN("unknown msg %04x wp=%04x lp=%08lx\n",
1019 // message, wParam, lParam );
1020 return DefWindowProcA( hwnd, message, wParam, lParam );
1021 }
1022 return 0;
1023}
1024
1025
1026/*************************************************************************
1027 * SetScrollInfo32 (USER32.501)
1028 * SetScrollInfo32 can be used to set the position, upper bound,
1029 * lower bound, and page size of a scrollbar control.
1030 *
1031 * RETURNS
1032 * Scrollbar position
1033 *
1034 * NOTE
1035 * For 100 lines of text to be displayed in a window of 25 lines,
1036 * one would for instance use info->nMin=0, info->nMax=75
1037 * (corresponding to the 76 different positions of the window on
1038 * the text), and info->nPage=25.
1039 */
1040/* CB:
1041
1042INT WINAPI SetScrollInfo(
1043HWND hwnd / * [I] Handle of window whose scrollbar will be affected * /,
1044INT nBar / * [I] One of SB_HORZ, SB_VERT, or SB_CTL * /,
1045const SCROLLINFO *info / * [I] Specifies what to change and new values * /,
1046BOOL bRedraw / * [I] Should scrollbar be redrawn afterwards ? * /)
1047{
1048 INT action;
1049 INT retVal = SCROLL_SetScrollInfo( hwnd, nBar, info, &action );
1050
1051 if( action & SA_SSI_HIDE )
1052 SCROLL_ShowScrollBar( hwnd, nBar, FALSE, FALSE );
1053 else
1054 {
1055 if( action & SA_SSI_SHOW )
1056 if( SCROLL_ShowScrollBar( hwnd, nBar, TRUE, TRUE ) )
1057 return retVal; / * SetWindowPos() already did the painting * /
1058
1059 if( bRedraw && (action & SA_SSI_REFRESH))
1060 SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
1061 else if( action & SA_SSI_REPAINT_ARROWS )
1062 SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, FALSE );
1063 }
1064 return retVal;
1065} */
1066
1067INT SCROLL_SetScrollInfo( HWND hwnd, INT nBar,
1068 const SCROLLINFO *info, INT *action )
1069{
1070 /* Update the scrollbar state and set action flags according to
1071 * what has to be done graphics wise. */
1072
1073 SCROLLBAR_INFO *infoPtr;
1074 UINT new_flags;
1075
1076 //dbg_decl_str(scroll, 256);
1077
1078 *action = 0;
1079
1080 if (!(infoPtr = SCROLL_GetScrollInfo(hwnd, nBar))) return 0;
1081 if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return 0;
1082 if ((info->cbSize != sizeof(*info)) &&
1083 (info->cbSize != sizeof(*info)-sizeof(info->nTrackPos))) return 0;
1084
1085 /* Set the page size */
1086
1087 if (info->fMask & SIF_PAGE)
1088 {
1089 //dsprintf(scroll, " page=%d", info->nPage );
1090 if( infoPtr->Page != info->nPage )
1091 {
1092 infoPtr->Page = info->nPage;
1093 *action |= SA_SSI_REFRESH;
1094 }
1095 }
1096
1097 /* Set the scroll pos */
1098
1099 if (info->fMask & SIF_POS)
1100 {
1101 //dsprintf(scroll, " pos=%d", info->nPos );
1102 if( infoPtr->CurVal != info->nPos )
1103 {
1104 infoPtr->CurVal = info->nPos;
1105 *action |= SA_SSI_REFRESH;
1106 }
1107 }
1108
1109 /* Set the scroll range */
1110
1111 if (info->fMask & SIF_RANGE)
1112 {
1113 //dsprintf(scroll, " min=%d max=%d", info->nMin, info->nMax );
1114
1115 /* Invalid range -> range is set to (0,0) */
1116 if ((info->nMin > info->nMax) ||
1117 ((UINT)(info->nMax - info->nMin) >= 0x80000000))
1118 {
1119 infoPtr->MinVal = 0;
1120 infoPtr->MaxVal = 0;
1121 }
1122 else
1123 {
1124 if( infoPtr->MinVal != info->nMin ||
1125 infoPtr->MaxVal != info->nMax )
1126 {
1127 *action |= SA_SSI_REFRESH;
1128 infoPtr->MinVal = info->nMin;
1129 infoPtr->MaxVal = info->nMax;
1130 }
1131 }
1132 }
1133
1134 //TRACE("hwnd=%04x bar=%d %s\n",
1135 // hwnd, nBar, dbg_str(scroll));
1136
1137 /* Make sure the page size is valid */
1138
1139 if (infoPtr->Page < 0) infoPtr->Page = 0;
1140 else if (infoPtr->Page > infoPtr->MaxVal - infoPtr->MinVal + 1 )
1141 infoPtr->Page = infoPtr->MaxVal - infoPtr->MinVal + 1;
1142
1143 /* Make sure the pos is inside the range */
1144
1145 if (infoPtr->CurVal < infoPtr->MinVal)
1146 infoPtr->CurVal = infoPtr->MinVal;
1147 else if (infoPtr->CurVal > infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 ))
1148 infoPtr->CurVal = infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 );
1149
1150 //TRACE(" new values: page=%d pos=%d min=%d max=%d\n",
1151 // infoPtr->Page, infoPtr->CurVal,
1152 // infoPtr->MinVal, infoPtr->MaxVal );
1153
1154 /* Check if the scrollbar should be hidden or disabled */
1155
1156 if (info->fMask & (SIF_RANGE | SIF_PAGE | SIF_DISABLENOSCROLL))
1157 {
1158 new_flags = infoPtr->flags;
1159 if (infoPtr->MinVal >= infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 ))
1160 {
1161 /* Hide or disable scroll-bar */
1162 if (info->fMask & SIF_DISABLENOSCROLL)
1163 {
1164 new_flags = ESB_DISABLE_BOTH;
1165 *action |= SA_SSI_REFRESH;
1166 }
1167 else if (nBar != SB_CTL)
1168 {
1169 *action = SA_SSI_HIDE;
1170 goto done;
1171 }
1172 }
1173 else /* Show and enable scroll-bar */
1174 {
1175 new_flags = 0;
1176 if (nBar != SB_CTL)
1177 *action |= SA_SSI_SHOW;
1178 }
1179
1180 if (infoPtr->flags != new_flags) /* check arrow flags */
1181 {
1182 infoPtr->flags = new_flags;
1183 *action |= SA_SSI_REPAINT_ARROWS;
1184 }
1185 }
1186
1187done:
1188 /* Return current position */
1189
1190 return infoPtr->CurVal;
1191}
1192
1193
1194/*************************************************************************
1195 * GetScrollInfo32 (USER32.284)
1196 * GetScrollInfo32 can be used to retrieve the position, upper bound,
1197 * lower bound, and page size of a scrollbar control.
1198 *
1199 * RETURNS STD
1200 */
1201/* CB:
1202BOOL WINAPI GetScrollInfo(
1203 HWND hwnd / * [I] Handle of window * / ,
1204 INT nBar / * [I] One of SB_HORZ, SB_VERT, or SB_CTL * /,
1205 LPSCROLLINFO info / * [IO] (info.fMask [I] specifies which values are to retrieve) * /)
1206{
1207 SCROLLBAR_INFO *infoPtr;
1208
1209 if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return FALSE;
1210 if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return FALSE;
1211 if ((info->cbSize != sizeof(*info)) &&
1212 (info->cbSize != sizeof(*info)-sizeof(info->nTrackPos))) return FALSE;
1213
1214 if (info->fMask & SIF_PAGE) info->nPage = infoPtr->Page;
1215 if (info->fMask & SIF_POS) info->nPos = infoPtr->CurVal;
1216 if ((info->fMask & SIF_TRACKPOS) && (info->cbSize == sizeof(*info)))
1217 info->nTrackPos = (SCROLL_TrackingWin==hwnd) ? SCROLL_TrackingVal : infoPtr->CurVal;
1218 if (info->fMask & SIF_RANGE)
1219 {
1220 info->nMin = infoPtr->MinVal;
1221 info->nMax = infoPtr->MaxVal;
1222 }
1223 return (info->fMask & SIF_ALL) != 0;
1224} */
1225
1226
1227/*************************************************************************
1228 * SetScrollPos32 (USER32.502)
1229 *
1230 * RETURNS
1231 * Success: Scrollbar position
1232 * Failure: 0
1233 *
1234 * REMARKS
1235 * Note the ambiguity when 0 is returned. Use GetLastError
1236 * to make sure there was an error (and to know which one).
1237 */
1238/* CB:
1239INT WINAPI SetScrollPos(
1240HWND hwnd / * [I] Handle of window whose scrollbar will be affected * /,
1241INT nBar / * [I] One of SB_HORZ, SB_VERT, or SB_CTL * /,
1242INT nPos / * [I] New value * /,
1243BOOL bRedraw / * [I] Should scrollbar be redrawn afterwards ? * / )
1244{
1245 SCROLLINFO info;
1246 SCROLLBAR_INFO *infoPtr;
1247 INT oldPos;
1248
1249 if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return 0;
1250 oldPos = infoPtr->CurVal;
1251 info.cbSize = sizeof(info);
1252 info.nPos = nPos;
1253 info.fMask = SIF_POS;
1254 SetScrollInfo( hwnd, nBar, &info, bRedraw );
1255 return oldPos;
1256} */
1257
1258
1259/*************************************************************************
1260 * GetScrollPos32 (USER32.285)
1261 *
1262 * RETURNS
1263 * Success: Current position
1264 * Failure: 0
1265 *
1266 * REMARKS
1267 * Note the ambiguity when 0 is returned. Use GetLastError
1268 * to make sure there was an error (and to know which one).
1269 */
1270/* CB:
1271INT WINAPI GetScrollPos(
1272HWND hwnd, / * [I] Handle of window * /
1273INT nBar / * [I] One of SB_HORZ, SB_VERT, or SB_CTL * /)
1274{
1275 SCROLLBAR_INFO *infoPtr;
1276
1277 if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return 0;
1278 return infoPtr->CurVal;
1279} */
1280
1281
1282/*************************************************************************
1283 * SetScrollRange32 (USER32.503)
1284 *
1285 * RETURNS STD
1286 */
1287/* CB:
1288BOOL WINAPI SetScrollRange(
1289HWND hwnd, / * [I] Handle of window whose scrollbar will be affected * /
1290INT nBar, / * [I] One of SB_HORZ, SB_VERT, or SB_CTL * /
1291INT MinVal, / * [I] New minimum value * /
1292INT MaxVal, / * [I] New maximum value * /
1293BOOL bRedraw / * [I] Should scrollbar be redrawn afterwards ? * /)
1294{
1295 SCROLLINFO info;
1296
1297 info.cbSize = sizeof(info);
1298 info.nMin = MinVal;
1299 info.nMax = MaxVal;
1300 info.fMask = SIF_RANGE;
1301 SetScrollInfo( hwnd, nBar, &info, bRedraw );
1302 return TRUE;
1303} */
1304
1305
1306/*************************************************************************
1307 * SCROLL_SetNCSbState
1308 *
1309 * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
1310 */
1311INT SCROLL_SetNCSbState(HWND hwnd, int vMin, int vMax, int vPos,
1312 int hMin, int hMax, int hPos)
1313{
1314 INT vA, hA;
1315 SCROLLINFO vInfo, hInfo;
1316
1317 vInfo.cbSize = hInfo.cbSize = sizeof(SCROLLINFO);
1318 vInfo.nMin = vMin; hInfo.nMin = hMin;
1319 vInfo.nMax = vMax; hInfo.nMax = hMax;
1320 vInfo.nPos = vPos; hInfo.nPos = hPos;
1321 vInfo.fMask = hInfo.fMask = SIF_RANGE | SIF_POS;
1322
1323 SCROLL_SetScrollInfo( hwnd, SB_VERT, &vInfo, &vA );
1324 SCROLL_SetScrollInfo( hwnd, SB_HORZ, &hInfo, &hA );
1325
1326 if( !SCROLL_ShowScrollBar( hwnd, SB_BOTH,
1327 (hA & SA_SSI_SHOW),(vA & SA_SSI_SHOW) ) )
1328 {
1329 /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
1330 if( vA & SA_SSI_REFRESH )
1331 SCROLL_RefreshScrollBar( hwnd, SB_VERT, FALSE, TRUE );
1332
1333 if( hA & SA_SSI_REFRESH )
1334 SCROLL_RefreshScrollBar( hwnd, SB_HORZ, FALSE, TRUE );
1335 }
1336 return 0;
1337}
1338
1339
1340/*************************************************************************
1341 * GetScrollRange32 (USER32.286)
1342 *
1343 * RETURNS STD
1344 */
1345/* CB:
1346BOOL WINAPI GetScrollRange(
1347HWND hwnd, / * [I] Handle of window * /
1348INT nBar, / * [I] One of SB_HORZ, SB_VERT, or SB_CTL * /
1349LPINT lpMin, / * [O] Where to store minimum value * /
1350LPINT lpMax / * [O] Where to store maximum value * /)
1351{
1352 SCROLLBAR_INFO *infoPtr;
1353
1354 if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar )))
1355 {
1356 if (lpMin) lpMin = 0;
1357 if (lpMax) lpMax = 0;
1358 return FALSE;
1359 }
1360 if (lpMin) *lpMin = infoPtr->MinVal;
1361 if (lpMax) *lpMax = infoPtr->MaxVal;
1362 return TRUE;
1363}*/
1364
1365
1366/*************************************************************************
1367 * SCROLL_ShowScrollBar()
1368 *
1369 * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
1370 * NOTE: fShowV/fShowH must be zero when nBar is SB_HORZ/SB_VERT.
1371 */
1372BOOL SCROLL_ShowScrollBar( HWND hwnd, INT nBar,
1373 BOOL fShowH, BOOL fShowV )
1374{
1375 BOOL retvalue = FALSE;
1376 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
1377
1378 //TRACE("hwnd=%04x bar=%d horz=%d, vert=%d\n",
1379 // hwnd, nBar, fShowH, fShowV );
1380
1381 switch(nBar)
1382 {
1383 case SB_CTL:
1384 ShowWindow( hwnd, fShowH ? SW_SHOW : SW_HIDE );
1385 retvalue = TRUE;
1386 goto END;
1387
1388 case SB_BOTH:
1389 case SB_HORZ:
1390 if (fShowH)
1391 {
1392 fShowH = !(dwStyle & WS_HSCROLL);
1393 dwStyle |= WS_HSCROLL;
1394 }
1395 else /* hide it */
1396 {
1397 fShowH = (dwStyle & WS_HSCROLL);
1398 dwStyle &= ~WS_HSCROLL;
1399 }
1400 SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
1401 if( nBar == SB_HORZ ) {
1402 fShowV = FALSE;
1403 break;
1404 }
1405 /* fall through */
1406
1407 case SB_VERT:
1408 if (fShowV)
1409 {
1410 fShowV = !(dwStyle & WS_VSCROLL);
1411 dwStyle |= WS_VSCROLL;
1412 }
1413 else /* hide it */
1414 {
1415 fShowV = (dwStyle & WS_VSCROLL);
1416 dwStyle &= ~WS_VSCROLL;
1417 }
1418 SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
1419 if ( nBar == SB_VERT )
1420 fShowH = FALSE;
1421 break;
1422
1423 default:
1424 retvalue = FALSE; /* Nothing to do! */
1425 goto END;
1426 }
1427
1428 if( fShowH || fShowV ) /* frame has been changed, let the window redraw itself */
1429 {
1430 SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
1431 | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
1432 retvalue = TRUE;
1433 goto END;
1434 }
1435
1436 retvalue = FALSE; /* no frame changes */
1437END:
1438 return retvalue;
1439}
1440
1441
1442/*************************************************************************
1443 * ShowScrollBar32 (USER32.532)
1444 *
1445 * RETURNS STD
1446 */
1447/* CB:
1448BOOL WINAPI ShowScrollBar(
1449HWND hwnd, / * [I] Handle of window whose scrollbar(s) will be affected * /
1450INT nBar, / * [I] One of SB_HORZ, SB_VERT, SB_BOTH or SB_CTL * /
1451BOOL fShow / * [I] TRUE = show, FALSE = hide * /)
1452{
1453 SCROLL_ShowScrollBar( hwnd, nBar, (nBar == SB_VERT) ? 0 : fShow,
1454 (nBar == SB_HORZ) ? 0 : fShow );
1455 return TRUE;
1456}*/
1457
1458
1459/*************************************************************************
1460 * EnableScrollBar32 (USER32.171)
1461 */
1462/* CB_
1463BOOL WINAPI EnableScrollBar( HWND hwnd, INT nBar, UINT flags )
1464{
1465 BOOL bFineWithMe;
1466 SCROLLBAR_INFO *infoPtr;
1467
1468 //TRACE("%04x %d %d\n", hwnd, nBar, flags );
1469
1470 flags &= ESB_DISABLE_BOTH;
1471
1472 if (nBar == SB_BOTH)
1473 {
1474 if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, SB_VERT ))) return FALSE;
1475 if (!(bFineWithMe = (infoPtr->flags == flags)) )
1476 {
1477 infoPtr->flags = flags;
1478 SCROLL_RefreshScrollBar( hwnd, SB_VERT, TRUE, TRUE );
1479 }
1480 nBar = SB_HORZ;
1481 }
1482 else
1483 bFineWithMe = TRUE;
1484
1485 if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return FALSE;
1486 if (bFineWithMe && infoPtr->flags == flags) return FALSE;
1487 infoPtr->flags = flags;
1488
1489 SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
1490 return TRUE;
1491}*/
1492
1493BOOL SCROLLBAR_Register()
1494{
1495 WNDCLASSA wndClass;
1496
1497 if (GlobalFindAtomA(SCROLLBARCLASSNAME)) return FALSE;
1498
1499 ZeroMemory(&wndClass,sizeof(WNDCLASSA));
1500 wndClass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW | CS_PARENTDC;
1501 wndClass.lpfnWndProc = (WNDPROC)ScrollBarWndProc;
1502 wndClass.cbClsExtra = 0;
1503 wndClass.cbWndExtra = sizeof(SCROLLBAR_INFO);
1504 wndClass.hCursor = LoadCursorA(0,IDC_ARROWA);
1505 wndClass.hbrBackground = (HBRUSH)0;
1506 wndClass.lpszClassName = SCROLLBARCLASSNAME;
1507
1508 return RegisterClassA(&wndClass);
1509}
1510
1511
1512BOOL SCROLLBAR_Unregister()
1513{
1514 if (GlobalFindAtomA(SCROLLBARCLASSNAME))
1515 return UnregisterClassA(SCROLLBARCLASSNAME,(HINSTANCE)NULL);
1516 else return FALSE;
1517}
Note: See TracBrowser for help on using the repository browser.