4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994, 1996 Alexandre Julliard
8 #include "wine/winuser16.h"
12 #include "debugtools.h"
16 DEFAULT_DEBUG_CHANNEL(scroll
)
19 static HBITMAP hUpArrow
= 0;
20 static HBITMAP hDnArrow
= 0;
21 static HBITMAP hLfArrow
= 0;
22 static HBITMAP hRgArrow
= 0;
23 static HBITMAP hUpArrowD
= 0;
24 static HBITMAP hDnArrowD
= 0;
25 static HBITMAP hLfArrowD
= 0;
26 static HBITMAP hRgArrowD
= 0;
27 static HBITMAP hUpArrowI
= 0;
28 static HBITMAP hDnArrowI
= 0;
29 static HBITMAP hLfArrowI
= 0;
30 static HBITMAP hRgArrowI
= 0;
32 #define TOP_ARROW(flags,pressed) \
33 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
34 #define BOTTOM_ARROW(flags,pressed) \
35 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
36 #define LEFT_ARROW(flags,pressed) \
37 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
38 #define RIGHT_ARROW(flags,pressed) \
39 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
42 /* Minimum size of the rectangle between the arrows */
43 #define SCROLL_MIN_RECT 4
45 /* Minimum size of the thumb in pixels */
46 #define SCROLL_MIN_THUMB 6
48 /* Overlap between arrows and thumb */
49 #define SCROLL_ARROW_THUMB_OVERLAP ((TWEAK_WineLook == WIN31_LOOK) ? 1 : 0)
51 /* Delay (in ms) before first repetition when holding the button down */
52 #define SCROLL_FIRST_DELAY 200
54 /* Delay (in ms) between scroll repetitions */
55 #define SCROLL_REPEAT_DELAY 50
58 #define SCROLL_TIMER 0
60 /* Scroll-bar hit testing */
63 SCROLL_NOWHERE
, /* Outside the scroll bar */
64 SCROLL_TOP_ARROW
, /* Top or left arrow */
65 SCROLL_TOP_RECT
, /* Rectangle between the top arrow and the thumb */
66 SCROLL_THUMB
, /* Thumb rectangle */
67 SCROLL_BOTTOM_RECT
, /* Rectangle between the thumb and the bottom arrow */
68 SCROLL_BOTTOM_ARROW
/* Bottom or right arrow */
71 /* What to do after SCROLL_SetScrollInfo() */
72 #define SA_SSI_HIDE 0x0001
73 #define SA_SSI_SHOW 0x0002
74 #define SA_SSI_REFRESH 0x0004
75 #define SA_SSI_REPAINT_ARROWS 0x0008
77 /* Thumb-tracking info */
78 static HWND SCROLL_TrackingWin
= 0;
79 static INT SCROLL_TrackingBar
= 0;
80 static INT SCROLL_TrackingPos
= 0;
81 static INT SCROLL_TrackingVal
= 0;
82 /* Hit test code of the last button-down event */
83 static enum SCROLL_HITTEST SCROLL_trackHitTest
;
84 static BOOL SCROLL_trackVertical
;
86 /* Is the moving thumb being displayed? */
87 static BOOL SCROLL_MovingThumb
= FALSE
;
90 static BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
91 BOOL fShowH
, BOOL fShowV
);
92 static INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
93 const SCROLLINFO
*info
, INT
*action
);
94 static void SCROLL_DrawInterior_9x( HWND hwnd
, HDC hdc
, INT nBar
,
95 RECT
*rect
, INT arrowSize
,
96 INT thumbSize
, INT thumbPos
,
97 UINT flags
, BOOL vertical
,
98 BOOL top_selected
, BOOL bottom_selected
);
101 /***********************************************************************
104 static void SCROLL_LoadBitmaps(void)
106 hUpArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROW
) );
107 hDnArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROW
) );
108 hLfArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROW
) );
109 hRgArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROW
) );
110 hUpArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWD
) );
111 hDnArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWD
) );
112 hLfArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWD
) );
113 hRgArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWD
) );
114 hUpArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWI
) );
115 hDnArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWI
) );
116 hLfArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWI
) );
117 hRgArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWI
) );
121 /***********************************************************************
122 * SCROLL_GetPtrScrollInfo
124 static SCROLLBAR_INFO
*SCROLL_GetPtrScrollInfo( WND
* wndPtr
, INT nBar
)
126 SCROLLBAR_INFO
*infoPtr
;
128 if (!wndPtr
) return NULL
;
131 case SB_HORZ
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pHScroll
; break;
132 case SB_VERT
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pVScroll
; break;
133 case SB_CTL
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->wExtra
; break;
134 default: return NULL
;
137 if (!infoPtr
) /* Create the info structure if needed */
139 if ((infoPtr
= HeapAlloc( SystemHeap
, 0, sizeof(SCROLLBAR_INFO
) )))
141 infoPtr
->MinVal
= infoPtr
->CurVal
= infoPtr
->Page
= 0;
142 infoPtr
->MaxVal
= 100;
143 infoPtr
->flags
= ESB_ENABLE_BOTH
;
144 if (nBar
== SB_HORZ
) wndPtr
->pHScroll
= infoPtr
;
145 else wndPtr
->pVScroll
= infoPtr
;
147 if (!hUpArrow
) SCROLL_LoadBitmaps();
153 /***********************************************************************
154 * SCROLL_GetScrollInfo
156 static SCROLLBAR_INFO
*SCROLL_GetScrollInfo( HWND hwnd
, INT nBar
)
158 SCROLLBAR_INFO
*retvalue
;
159 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
160 retvalue
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
161 WIN_ReleaseWndPtr(wndPtr
);
166 /***********************************************************************
167 * SCROLL_GetScrollBarRect
169 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
170 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
171 * 'arrowSize' returns the width or height of an arrow (depending on
172 * the orientation of the scrollbar), 'thumbSize' returns the size of
173 * the thumb, and 'thumbPos' returns the position of the thumb
174 * relative to the left or to the top.
175 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
177 static BOOL
SCROLL_GetScrollBarRect( HWND hwnd
, INT nBar
, RECT
*lprect
,
178 INT
*arrowSize
, INT
*thumbSize
,
183 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
188 lprect
->left
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
;
189 lprect
->top
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
190 lprect
->right
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
191 lprect
->bottom
= lprect
->top
+ GetSystemMetrics(SM_CYHSCROLL
);
192 if(wndPtr
->dwStyle
& WS_BORDER
) {
195 } else if(wndPtr
->dwStyle
& WS_VSCROLL
)
201 lprect
->left
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
202 lprect
->top
= wndPtr
->rectClient
.top
- wndPtr
->rectWindow
.top
;
203 lprect
->right
= lprect
->left
+ GetSystemMetrics(SM_CXVSCROLL
);
204 lprect
->bottom
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
205 if(wndPtr
->dwStyle
& WS_BORDER
) {
208 } else if(wndPtr
->dwStyle
& WS_HSCROLL
)
214 GetClientRect( hwnd
, lprect
);
215 vertical
= ((wndPtr
->dwStyle
& SBS_VERT
) != 0);
219 WIN_ReleaseWndPtr(wndPtr
);
223 if (vertical
) pixels
= lprect
->bottom
- lprect
->top
;
224 else pixels
= lprect
->right
- lprect
->left
;
226 if (pixels
<= 2*GetSystemMetrics(SM_CXVSCROLL
) + SCROLL_MIN_RECT
)
228 if (pixels
> SCROLL_MIN_RECT
)
229 *arrowSize
= (pixels
- SCROLL_MIN_RECT
) / 2;
232 *thumbPos
= *thumbSize
= 0;
236 SCROLLBAR_INFO
*info
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
238 *arrowSize
= GetSystemMetrics(SM_CXVSCROLL
);
239 pixels
-= (2 * (GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
));
243 *thumbSize
= pixels
* info
->Page
/ (info
->MaxVal
-info
->MinVal
+1);
244 if (*thumbSize
< SCROLL_MIN_THUMB
) *thumbSize
= SCROLL_MIN_THUMB
;
246 else *thumbSize
= GetSystemMetrics(SM_CXVSCROLL
);
248 if (((pixels
-= *thumbSize
) < 0) ||
249 ((info
->flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
))
251 /* Rectangle too small or scrollbar disabled -> no thumb */
252 *thumbPos
= *thumbSize
= 0;
256 INT max
= info
->MaxVal
- MAX( info
->Page
-1, 0 );
257 if (info
->MinVal
>= max
)
258 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
260 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
261 + pixels
* (info
->CurVal
-info
->MinVal
) / (max
- info
->MinVal
);
264 WIN_ReleaseWndPtr(wndPtr
);
269 /***********************************************************************
272 * Compute the current scroll position based on the thumb position in pixels
273 * from the top of the scroll-bar.
275 static UINT
SCROLL_GetThumbVal( SCROLLBAR_INFO
*infoPtr
, RECT
*rect
,
276 BOOL vertical
, INT pos
)
279 INT pixels
= vertical
? rect
->bottom
-rect
->top
: rect
->right
-rect
->left
;
281 if ((pixels
-= 2*(GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
)) <= 0)
282 return infoPtr
->MinVal
;
286 thumbSize
= pixels
* infoPtr
->Page
/(infoPtr
->MaxVal
-infoPtr
->MinVal
+1);
287 if (thumbSize
< SCROLL_MIN_THUMB
) thumbSize
= SCROLL_MIN_THUMB
;
289 else thumbSize
= GetSystemMetrics(SM_CXVSCROLL
);
291 if ((pixels
-= thumbSize
) <= 0) return infoPtr
->MinVal
;
293 pos
= MAX( 0, pos
- (GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
) );
294 if (pos
> pixels
) pos
= pixels
;
296 if (!infoPtr
->Page
) pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
;
297 else pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
- infoPtr
->Page
+ 1;
298 return infoPtr
->MinVal
+ ((pos
+ pixels
/ 2) / pixels
);
301 /***********************************************************************
304 static BOOL
SCROLL_PtInRectEx( LPRECT lpRect
, POINT pt
, BOOL vertical
)
310 rect
.left
-= lpRect
->right
- lpRect
->left
;
311 rect
.right
+= lpRect
->right
- lpRect
->left
;
315 rect
.top
-= lpRect
->bottom
- lpRect
->top
;
316 rect
.bottom
+= lpRect
->bottom
- lpRect
->top
;
318 return PtInRect( &rect
, pt
);
321 /***********************************************************************
324 static POINT
SCROLL_ClipPos( LPRECT lpRect
, POINT pt
)
326 if( pt
.x
< lpRect
->left
)
329 if( pt
.x
> lpRect
->right
)
330 pt
.x
= lpRect
->right
;
332 if( pt
.y
< lpRect
->top
)
335 if( pt
.y
> lpRect
->bottom
)
336 pt
.y
= lpRect
->bottom
;
342 /***********************************************************************
345 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
347 static enum SCROLL_HITTEST
SCROLL_HitTest( HWND hwnd
, INT nBar
,
348 POINT pt
, BOOL bDragging
)
350 INT arrowSize
, thumbSize
, thumbPos
;
353 BOOL vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
354 &arrowSize
, &thumbSize
, &thumbPos
);
356 if ( (bDragging
&& !SCROLL_PtInRectEx( &rect
, pt
, vertical
)) ||
357 (!PtInRect( &rect
, pt
)) ) return SCROLL_NOWHERE
;
361 if (pt
.y
< rect
.top
+ arrowSize
) return SCROLL_TOP_ARROW
;
362 if (pt
.y
>= rect
.bottom
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
363 if (!thumbPos
) return SCROLL_TOP_RECT
;
365 if (pt
.y
< thumbPos
) return SCROLL_TOP_RECT
;
366 if (pt
.y
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
368 else /* horizontal */
370 if (pt
.x
< rect
.left
+ arrowSize
) return SCROLL_TOP_ARROW
;
371 if (pt
.x
>= rect
.right
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
372 if (!thumbPos
) return SCROLL_TOP_RECT
;
374 if (pt
.x
< thumbPos
) return SCROLL_TOP_RECT
;
375 if (pt
.x
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
381 /***********************************************************************
384 * Draw the scroll bar arrows.
386 static void SCROLL_DrawArrows_9x( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
387 RECT
*rect
, INT arrowSize
, BOOL vertical
,
388 BOOL top_pressed
, BOOL bottom_pressed
)
394 r
.bottom
= r
.top
+ arrowSize
;
396 r
.right
= r
.left
+ arrowSize
;
398 DrawFrameControl( hdc
, &r
, DFC_SCROLL
,
399 (vertical
? DFCS_SCROLLUP
: DFCS_SCROLLLEFT
)
400 | (top_pressed
? (DFCS_PUSHED
| DFCS_FLAT
) : 0 )
401 | (infoPtr
->flags
&ESB_DISABLE_LTUP
? DFCS_INACTIVE
: 0 ) );
405 r
.top
= r
.bottom
-arrowSize
;
407 r
.left
= r
.right
-arrowSize
;
409 DrawFrameControl( hdc
, &r
, DFC_SCROLL
,
410 (vertical
? DFCS_SCROLLDOWN
: DFCS_SCROLLRIGHT
)
411 | (bottom_pressed
? (DFCS_PUSHED
| DFCS_FLAT
) : 0 )
412 | (infoPtr
->flags
&ESB_DISABLE_RTDN
? DFCS_INACTIVE
: 0) );
415 static void SCROLL_DrawArrows_31( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
416 RECT
*rect
, INT arrowSize
, BOOL vertical
,
417 BOOL top_pressed
, BOOL bottom_pressed
)
419 HDC hdcMem
= CreateCompatibleDC( hdc
);
420 HBITMAP hbmpPrev
= SelectObject( hdcMem
, vertical
?
421 TOP_ARROW(infoPtr
->flags
, top_pressed
)
422 : LEFT_ARROW(infoPtr
->flags
, top_pressed
));
424 SetStretchBltMode( hdc
, STRETCH_DELETESCANS
);
425 StretchBlt( hdc
, rect
->left
, rect
->top
,
426 vertical
? rect
->right
-rect
->left
: arrowSize
,
427 vertical
? arrowSize
: rect
->bottom
-rect
->top
,
429 GetSystemMetrics(SM_CXVSCROLL
),GetSystemMetrics(SM_CYHSCROLL
),
432 SelectObject( hdcMem
, vertical
?
433 BOTTOM_ARROW( infoPtr
->flags
, bottom_pressed
)
434 : RIGHT_ARROW( infoPtr
->flags
, bottom_pressed
) );
436 StretchBlt( hdc
, rect
->left
, rect
->bottom
- arrowSize
,
437 rect
->right
- rect
->left
, arrowSize
,
439 GetSystemMetrics(SM_CXVSCROLL
),GetSystemMetrics(SM_CYHSCROLL
),
442 StretchBlt( hdc
, rect
->right
- arrowSize
, rect
->top
,
443 arrowSize
, rect
->bottom
- rect
->top
,
445 GetSystemMetrics(SM_CXVSCROLL
), GetSystemMetrics(SM_CYHSCROLL
),
447 SelectObject( hdcMem
, hbmpPrev
);
451 static void SCROLL_DrawArrows( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
452 RECT
*rect
, INT arrowSize
, BOOL vertical
,
453 BOOL top_pressed
, BOOL bottom_pressed
)
455 if( TWEAK_WineLook
== WIN31_LOOK
)
456 SCROLL_DrawArrows_31( hdc
, infoPtr
, rect
, arrowSize
,
457 vertical
, top_pressed
,bottom_pressed
);
459 SCROLL_DrawArrows_9x( hdc
, infoPtr
, rect
, arrowSize
,
460 vertical
, top_pressed
,bottom_pressed
);
464 /***********************************************************************
465 * SCROLL_DrawMovingThumb
467 * Draw the moving thumb rectangle.
469 static void SCROLL_DrawMovingThumb_31( HDC hdc
, RECT
*rect
, BOOL vertical
,
470 INT arrowSize
, INT thumbSize
)
475 r
.top
+= SCROLL_TrackingPos
;
476 if (r
.top
< rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
477 r
.top
= rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
478 if (r
.top
+ thumbSize
>
479 rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
480 r
.top
= rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
482 r
.bottom
= r
.top
+ thumbSize
;
486 r
.left
+= SCROLL_TrackingPos
;
487 if (r
.left
< rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
488 r
.left
= rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
489 if (r
.left
+ thumbSize
>
490 rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
491 r
.left
= rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
493 r
.right
= r
.left
+ thumbSize
;
496 DrawFocusRect( hdc
, &r
);
497 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
500 static void SCROLL_DrawMovingThumb_9x( HDC hdc
, RECT
*rect
, BOOL vertical
,
501 INT arrowSize
, INT thumbSize
)
503 INT pos
= SCROLL_TrackingPos
;
507 max_size
= rect
->bottom
- rect
->top
;
509 max_size
= rect
->right
- rect
->left
;
511 max_size
-= (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
) + thumbSize
;
513 if( pos
< (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
) )
514 pos
= (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
);
515 else if( pos
> max_size
)
518 SCROLL_DrawInterior_9x( SCROLL_TrackingWin
, hdc
, SCROLL_TrackingBar
,
519 rect
, arrowSize
, thumbSize
, pos
,
520 0, vertical
, FALSE
, FALSE
);
522 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
525 static void SCROLL_DrawMovingThumb( HDC hdc
, RECT
*rect
, BOOL vertical
,
526 INT arrowSize
, INT thumbSize
)
528 if( TWEAK_WineLook
== WIN31_LOOK
)
529 SCROLL_DrawMovingThumb_31( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
531 SCROLL_DrawMovingThumb_9x( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
534 /***********************************************************************
535 * SCROLL_DrawInterior
537 * Draw the scroll bar interior (everything except the arrows).
539 static void SCROLL_DrawInterior_9x( HWND hwnd
, HDC hdc
, INT nBar
,
540 RECT
*rect
, INT arrowSize
,
541 INT thumbSize
, INT thumbPos
,
542 UINT flags
, BOOL vertical
,
543 BOOL top_selected
, BOOL bottom_selected
)
547 HBRUSH hSaveBrush
,hBrush
;
549 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
550 * The window-owned scrollbars need to call DEFWND_ControlColor
551 * to correctly setup default scrollbar colors
555 hBrush
= (HBRUSH
)SendMessageA( GetParent(hwnd
), WM_CTLCOLORSCROLLBAR
,
556 (WPARAM
)hdc
,(LPARAM
)hwnd
);
560 hBrush
= DEFWND_ControlColor( hdc
, CTLCOLOR_SCROLLBAR
);
563 hSavePen
= SelectObject( hdc
, GetSysColorPen(COLOR_WINDOWFRAME
) );
564 hSaveBrush
= SelectObject( hdc
, hBrush
);
566 /* Calculate the scroll rectangle */
570 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
571 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
575 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
576 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
579 /* Draw the scroll rectangles and thumb */
580 if (!thumbPos
) /* No thumb to draw */
582 PatBlt( hdc
, r
.left
, r
.top
,
583 r
.right
- r
.left
, r
.bottom
- r
.top
,
586 /* cleanup and return */
587 SelectObject( hdc
, hSavePen
);
588 SelectObject( hdc
, hSaveBrush
);
594 PatBlt( hdc
, r
.left
, r
.top
,
596 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
597 top_selected
? 0x0f0000 : PATCOPY
);
598 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
599 PatBlt( hdc
, r
.left
, r
.top
+ thumbSize
,
601 r
.bottom
- r
.top
- thumbSize
,
602 bottom_selected
? 0x0f0000 : PATCOPY
);
603 r
.bottom
= r
.top
+ thumbSize
;
605 else /* horizontal */
607 PatBlt( hdc
, r
.left
, r
.top
,
608 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
610 top_selected
? 0x0f0000 : PATCOPY
);
611 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
612 PatBlt( hdc
, r
.left
+ thumbSize
, r
.top
,
613 r
.right
- r
.left
- thumbSize
,
615 bottom_selected
? 0x0f0000 : PATCOPY
);
616 r
.right
= r
.left
+ thumbSize
;
620 DrawEdge( hdc
, &r
, EDGE_RAISED
, BF_RECT
| BF_MIDDLE
);
623 SelectObject( hdc
, hSavePen
);
624 SelectObject( hdc
, hSaveBrush
);
628 static void SCROLL_DrawInterior( HWND hwnd
, HDC hdc
, INT nBar
,
629 RECT
*rect
, INT arrowSize
,
630 INT thumbSize
, INT thumbPos
,
631 UINT flags
, BOOL vertical
,
632 BOOL top_selected
, BOOL bottom_selected
)
636 HBRUSH hSaveBrush
,hBrush
;
637 BOOL Save_SCROLL_MovingThumb
= SCROLL_MovingThumb
;
639 if (Save_SCROLL_MovingThumb
&&
640 (SCROLL_TrackingWin
== hwnd
) &&
641 (SCROLL_TrackingBar
== nBar
))
642 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
644 /* Select the correct brush and pen */
646 if (TWEAK_WineLook
== WIN31_LOOK
&& (flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
)
648 /* This ought to be the color of the parent window */
649 if (TWEAK_WineLook
== WIN31_LOOK
) {
650 hBrush
= GetSysColorBrush(COLOR_WINDOW
);
652 /* Under Win9x look & feel, scrollbars don't have a solid border.
653 * To make scrollbar's background different from the window
654 * background, we need to apply a gray 0x55aa pattern brush.
655 * Otherwise it won't look good.
657 hBrush
= CACHE_GetPattern55AABrush();
662 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
663 * The window-owned scrollbars need to call DEFWND_ControlColor
664 * to correctly setup default scrollbar colors
666 if (nBar
== SB_CTL
) {
667 hBrush
= (HBRUSH
)SendMessageA( GetParent(hwnd
), WM_CTLCOLORSCROLLBAR
,
668 (WPARAM
)hdc
,(LPARAM
)hwnd
);
670 hBrush
= DEFWND_ControlColor( hdc
, CTLCOLOR_SCROLLBAR
);
673 hSavePen
= SelectObject( hdc
, GetSysColorPen(COLOR_WINDOWFRAME
) );
674 hSaveBrush
= SelectObject( hdc
, hBrush
);
676 /* Calculate the scroll rectangle */
681 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
682 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
686 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
687 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
690 /* Draw the scroll bar frame */
692 /* Only draw outline if Win 3.1. Mar 24, 1999 - Ronald B. Cemer */
693 if (TWEAK_WineLook
== WIN31_LOOK
)
694 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
696 /* Draw the scroll rectangles and thumb */
698 if (!thumbPos
) /* No thumb to draw */
700 INT offset
= (TWEAK_WineLook
> WIN31_LOOK
) ? 0 : 1;
702 PatBlt( hdc
, r
.left
+offset
, r
.top
+offset
,
703 r
.right
- r
.left
- 2*offset
, r
.bottom
- r
.top
- 2*offset
,
706 /* cleanup and return */
707 SelectObject( hdc
, hSavePen
);
708 SelectObject( hdc
, hSaveBrush
);
714 INT offset
= (TWEAK_WineLook
== WIN31_LOOK
) ? 1 : 0;
716 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ offset
,
717 r
.right
- r
.left
- offset
*2,
718 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
) - offset
,
719 top_selected
? 0x0f0000 : PATCOPY
);
720 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
721 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ thumbSize
,
722 r
.right
- r
.left
- offset
*2,
723 r
.bottom
- r
.top
- thumbSize
- offset
,
724 bottom_selected
? 0x0f0000 : PATCOPY
);
725 r
.bottom
= r
.top
+ thumbSize
;
727 else /* horizontal */
729 INT offset
= (TWEAK_WineLook
== WIN31_LOOK
) ? 1 : 0;
731 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ offset
,
732 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
733 r
.bottom
- r
.top
- offset
*2,
734 top_selected
? 0x0f0000 : PATCOPY
);
735 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
736 PatBlt( hdc
, r
.left
+ thumbSize
, r
.top
+ offset
,
737 r
.right
- r
.left
- thumbSize
- offset
,
738 r
.bottom
- r
.top
- offset
*2,
739 bottom_selected
? 0x0f0000 : PATCOPY
);
740 r
.right
= r
.left
+ thumbSize
;
745 SelectObject( hdc
, GetSysColorBrush(COLOR_BTNFACE
) );
746 if (TWEAK_WineLook
== WIN31_LOOK
)
748 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
753 Rectangle( hdc
, r
.left
+1, r
.top
+1, r
.right
-1, r
.bottom
-1 );
755 DrawEdge( hdc
, &r
, EDGE_RAISED
, BF_RECT
);
757 if (Save_SCROLL_MovingThumb
&&
758 (SCROLL_TrackingWin
== hwnd
) &&
759 (SCROLL_TrackingBar
== nBar
))
760 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
763 SelectObject( hdc
, hSavePen
);
764 SelectObject( hdc
, hSaveBrush
);
768 /***********************************************************************
769 * SCROLL_DrawScrollBar
771 * Redraw the whole scrollbar.
773 void SCROLL_DrawScrollBar( HWND hwnd
, HDC hdc
, INT nBar
,
774 BOOL arrows
, BOOL interior
)
776 INT arrowSize
, thumbSize
, thumbPos
;
779 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
780 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
781 BOOL Save_SCROLL_MovingThumb
= SCROLL_MovingThumb
;
783 if (!wndPtr
|| !infoPtr
||
784 ((nBar
== SB_VERT
) && !(wndPtr
->dwStyle
& WS_VSCROLL
)) ||
785 ((nBar
== SB_HORZ
) && !(wndPtr
->dwStyle
& WS_HSCROLL
))) goto END
;
786 if (!WIN_IsWindowDrawable( wndPtr
, FALSE
)) goto END
;
788 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
789 &arrowSize
, &thumbSize
, &thumbPos
);
791 if (Save_SCROLL_MovingThumb
&&
792 (SCROLL_TrackingWin
== hwnd
) &&
793 (SCROLL_TrackingBar
== nBar
))
794 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
796 /* Draw the arrows */
798 if (arrows
&& arrowSize
)
800 if( vertical
== SCROLL_trackVertical
&& GetCapture() == hwnd
)
801 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
802 (SCROLL_trackHitTest
== SCROLL_TOP_ARROW
),
803 (SCROLL_trackHitTest
== SCROLL_BOTTOM_ARROW
) );
805 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
809 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
810 thumbPos
, infoPtr
->flags
, vertical
, FALSE
, FALSE
);
812 if (Save_SCROLL_MovingThumb
&&
813 (SCROLL_TrackingWin
== hwnd
) &&
814 (SCROLL_TrackingBar
== nBar
))
815 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
818 WIN_ReleaseWndPtr(wndPtr
);
822 /***********************************************************************
823 * SCROLL_RefreshScrollBar
825 * Repaint the scroll bar interior after a SetScrollRange() or
826 * SetScrollPos() call.
828 static void SCROLL_RefreshScrollBar( HWND hwnd
, INT nBar
,
829 BOOL arrows
, BOOL interior
)
831 HDC hdc
= GetDCEx( hwnd
, 0,
832 DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
) );
835 SCROLL_DrawScrollBar( hwnd
, hdc
, nBar
, arrows
, interior
);
836 ReleaseDC( hwnd
, hdc
);
840 /***********************************************************************
841 * SCROLL_HandleKbdEvent
843 * Handle a keyboard event (only for SB_CTL scrollbars).
845 static void SCROLL_HandleKbdEvent( HWND hwnd
, WPARAM wParam
)
847 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
852 case VK_PRIOR
: msg
= SB_PAGEUP
; break;
853 case VK_NEXT
: msg
= SB_PAGEDOWN
; break;
854 case VK_HOME
: msg
= SB_TOP
; break;
855 case VK_END
: msg
= SB_BOTTOM
; break;
856 case VK_UP
: msg
= SB_LINEUP
; break;
857 case VK_DOWN
: msg
= SB_LINEDOWN
; break;
859 WIN_ReleaseWndPtr(wndPtr
);
862 SendMessageA( GetParent(hwnd
),
863 (wndPtr
->dwStyle
& SBS_VERT
) ? WM_VSCROLL
: WM_HSCROLL
,
865 WIN_ReleaseWndPtr(wndPtr
);
869 /***********************************************************************
870 * SCROLL_HandleScrollEvent
872 * Handle a mouse or timer event for the scrollbar.
873 * 'pt' is the location of the mouse event in client (for SB_CTL) or
874 * windows coordinates.
876 void SCROLL_HandleScrollEvent( HWND hwnd
, INT nBar
, UINT msg
, POINT pt
)
878 /* Previous mouse position for timer events */
880 /* Thumb position when tracking started. */
881 static UINT trackThumbPos
;
882 /* Position in the scroll-bar of the last button-down event. */
883 static INT lastClickPos
;
884 /* Position in the scroll-bar of the last mouse event. */
885 static INT lastMousePos
;
887 enum SCROLL_HITTEST hittest
;
888 HWND hwndOwner
, hwndCtl
;
890 INT arrowSize
, thumbSize
, thumbPos
;
894 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
);
895 if (!infoPtr
) return;
896 if ((SCROLL_trackHitTest
== SCROLL_NOWHERE
) && (msg
!= WM_LBUTTONDOWN
))
899 hdc
= GetDCEx( hwnd
, 0, DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
));
900 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
901 &arrowSize
, &thumbSize
, &thumbPos
);
902 hwndOwner
= (nBar
== SB_CTL
) ? GetParent(hwnd
) : hwnd
;
903 hwndCtl
= (nBar
== SB_CTL
) ? hwnd
: 0;
907 case WM_LBUTTONDOWN
: /* Initialise mouse tracking */
908 SCROLL_trackVertical
= vertical
;
909 SCROLL_trackHitTest
= hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
910 lastClickPos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
911 lastMousePos
= lastClickPos
;
912 trackThumbPos
= thumbPos
;
915 if (nBar
== SB_CTL
) SetFocus( hwnd
);
919 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, TRUE
);
924 hittest
= SCROLL_NOWHERE
;
930 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
934 return; /* Should never happen */
937 TRACE("Event: hwnd=%04x bar=%d msg=%x pt=%ld,%ld hit=%d\n",
938 hwnd
, nBar
, msg
, pt
.x
, pt
.y
, hittest
);
940 switch(SCROLL_trackHitTest
)
942 case SCROLL_NOWHERE
: /* No tracking in progress */
945 case SCROLL_TOP_ARROW
:
946 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
947 (hittest
== SCROLL_trackHitTest
), FALSE
);
948 if (hittest
== SCROLL_trackHitTest
)
950 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
952 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
953 SB_LINEUP
, hwndCtl
);
956 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
957 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
960 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
963 case SCROLL_TOP_RECT
:
964 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
965 thumbPos
, infoPtr
->flags
, vertical
,
966 (hittest
== SCROLL_trackHitTest
), FALSE
);
967 if (hittest
== SCROLL_trackHitTest
)
969 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
971 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
972 SB_PAGEUP
, hwndCtl
);
973 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
974 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
978 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
982 if (msg
== WM_LBUTTONDOWN
)
984 SCROLL_TrackingWin
= hwnd
;
985 SCROLL_TrackingBar
= nBar
;
986 SCROLL_TrackingPos
= trackThumbPos
+ lastMousePos
- lastClickPos
;
987 if (!SCROLL_MovingThumb
)
988 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
990 else if (msg
== WM_LBUTTONUP
)
992 if (SCROLL_MovingThumb
)
993 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
994 SCROLL_TrackingWin
= 0;
995 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
996 thumbPos
, infoPtr
->flags
, vertical
,
999 else /* WM_MOUSEMOVE */
1003 if (!SCROLL_PtInRectEx( &rect
, pt
, vertical
)) pos
= lastClickPos
;
1006 pt
= SCROLL_ClipPos( &rect
, pt
);
1007 pos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
1009 if ( (pos
!= lastMousePos
) || (!SCROLL_MovingThumb
) )
1011 if (SCROLL_MovingThumb
)
1012 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
1013 arrowSize
, thumbSize
);
1015 SCROLL_TrackingPos
= trackThumbPos
+ pos
- lastClickPos
;
1016 SCROLL_TrackingVal
= SCROLL_GetThumbVal( infoPtr
, &rect
,
1018 SCROLL_TrackingPos
);
1019 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1020 MAKEWPARAM( SB_THUMBTRACK
, SCROLL_TrackingVal
),
1022 if (!SCROLL_MovingThumb
)
1023 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
1024 arrowSize
, thumbSize
);
1029 case SCROLL_BOTTOM_RECT
:
1030 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
1031 thumbPos
, infoPtr
->flags
, vertical
,
1032 FALSE
, (hittest
== SCROLL_trackHitTest
) );
1033 if (hittest
== SCROLL_trackHitTest
)
1035 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
1037 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1038 SB_PAGEDOWN
, hwndCtl
);
1039 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
1040 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1044 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1047 case SCROLL_BOTTOM_ARROW
:
1048 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
1049 FALSE
, (hittest
== SCROLL_trackHitTest
) );
1050 if (hittest
== SCROLL_trackHitTest
)
1052 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
1054 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1055 SB_LINEDOWN
, hwndCtl
);
1058 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
1059 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1062 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1066 if (msg
== WM_LBUTTONUP
)
1068 hittest
= SCROLL_trackHitTest
;
1069 SCROLL_trackHitTest
= SCROLL_NOWHERE
; /* Terminate tracking */
1071 if (hittest
== SCROLL_THUMB
)
1073 UINT val
= SCROLL_GetThumbVal( infoPtr
, &rect
, vertical
,
1074 trackThumbPos
+ lastMousePos
- lastClickPos
);
1075 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1076 MAKEWPARAM( SB_THUMBPOSITION
, val
), hwndCtl
);
1079 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1080 SB_ENDSCROLL
, hwndCtl
);
1083 ReleaseDC( hwnd
, hdc
);
1087 /***********************************************************************
1090 LRESULT WINAPI
ScrollBarWndProc( HWND hwnd
, UINT message
, WPARAM wParam
,
1097 CREATESTRUCTA
*lpCreat
= (CREATESTRUCTA
*)lParam
;
1098 if (lpCreat
->style
& SBS_SIZEBOX
)
1100 FIXME("Unimplemented style SBS_SIZEBOX.\n" );
1104 if (lpCreat
->style
& SBS_VERT
)
1106 if (lpCreat
->style
& SBS_LEFTALIGN
)
1107 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
1108 GetSystemMetrics(SM_CXVSCROLL
)+1, lpCreat
->cy
, FALSE
);
1109 else if (lpCreat
->style
& SBS_RIGHTALIGN
)
1111 lpCreat
->x
+lpCreat
->cx
-GetSystemMetrics(SM_CXVSCROLL
)-1,
1113 GetSystemMetrics(SM_CXVSCROLL
)+1, lpCreat
->cy
, FALSE
);
1117 if (lpCreat
->style
& SBS_TOPALIGN
)
1118 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
1119 lpCreat
->cx
, GetSystemMetrics(SM_CYHSCROLL
)+1, FALSE
);
1120 else if (lpCreat
->style
& SBS_BOTTOMALIGN
)
1123 lpCreat
->y
+lpCreat
->cy
-GetSystemMetrics(SM_CYHSCROLL
)-1,
1124 lpCreat
->cx
, GetSystemMetrics(SM_CYHSCROLL
)+1, FALSE
);
1127 if (!hUpArrow
) SCROLL_LoadBitmaps();
1128 TRACE("ScrollBar creation, hwnd=%04x\n", hwnd
);
1131 case WM_LBUTTONDOWN
:
1137 CONV_POINT16TO32( (POINT16
*)&lParam
, &pt
);
1138 SCROLL_HandleScrollEvent( hwnd
, SB_CTL
, message
, pt
);
1143 SCROLL_HandleKbdEvent( hwnd
, wParam
);
1150 return DLGC_WANTARROWS
; /* Windows returns this value */
1155 HDC hdc
= BeginPaint( hwnd
, &ps
);
1156 SCROLL_DrawScrollBar( hwnd
, hdc
, SB_CTL
, TRUE
, TRUE
);
1157 EndPaint( hwnd
, &ps
);
1163 return SetScrollPos( hwnd
, SB_CTL
, wParam
, (BOOL
)lParam
);
1167 return GetScrollPos( hwnd
, SB_CTL
);
1169 case SBM_SETRANGE16
:
1170 SetScrollRange( hwnd
, SB_CTL
, LOWORD(lParam
), HIWORD(lParam
),
1171 wParam
/* FIXME: Is this correct? */ );
1175 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, FALSE
);
1176 return 0; /* FIXME: return previous position */
1178 case SBM_GETRANGE16
:
1179 FIXME("don't know how to handle SBM_GETRANGE16 (wp=%04x,lp=%08lx)\n", wParam
, lParam
);
1183 GetScrollRange( hwnd
, SB_CTL
, (LPINT
)wParam
, (LPINT
)lParam
);
1186 case SBM_ENABLE_ARROWS16
:
1187 case SBM_ENABLE_ARROWS
:
1188 return EnableScrollBar( hwnd
, SB_CTL
, wParam
);
1190 case SBM_SETRANGEREDRAW
:
1191 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, TRUE
);
1192 return 0; /* FIXME: return previous position */
1194 case SBM_SETSCROLLINFO
:
1195 return SetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
, wParam
);
1197 case SBM_GETSCROLLINFO
:
1198 return GetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
);
1208 ERR("unknown Win32 msg %04x wp=%08x lp=%08lx\n",
1209 message
, wParam
, lParam
);
1213 if (message
>= WM_USER
)
1214 WARN("unknown msg %04x wp=%04x lp=%08lx\n",
1215 message
, wParam
, lParam
);
1216 return DefWindowProcA( hwnd
, message
, wParam
, lParam
);
1222 /*************************************************************************
1223 * SetScrollInfo16 (USER.475)
1225 INT16 WINAPI
SetScrollInfo16( HWND16 hwnd
, INT16 nBar
, const SCROLLINFO
*info
,
1228 return (INT16
)SetScrollInfo( hwnd
, nBar
, info
, bRedraw
);
1232 /*************************************************************************
1233 * SetScrollInfo32 (USER32.501)
1234 * SetScrollInfo32 can be used to set the position, upper bound,
1235 * lower bound, and page size of a scrollbar control.
1238 * Scrollbar position
1241 * For 100 lines of text to be displayed in a window of 25 lines,
1242 * one would for instance use info->nMin=0, info->nMax=75
1243 * (corresponding to the 76 different positions of the window on
1244 * the text), and info->nPage=25.
1246 INT WINAPI
SetScrollInfo(
1247 HWND hwnd
/* [I] Handle of window whose scrollbar will be affected */,
1248 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1249 const SCROLLINFO
*info
/* [I] Specifies what to change and new values */,
1250 BOOL bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */)
1253 INT retVal
= SCROLL_SetScrollInfo( hwnd
, nBar
, info
, &action
);
1255 if( action
& SA_SSI_HIDE
)
1256 SCROLL_ShowScrollBar( hwnd
, nBar
, FALSE
, FALSE
);
1259 if( action
& SA_SSI_SHOW
)
1260 if( SCROLL_ShowScrollBar( hwnd
, nBar
, TRUE
, TRUE
) )
1261 return retVal
; /* SetWindowPos() already did the painting */
1263 if( bRedraw
&& (action
& SA_SSI_REFRESH
))
1264 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);
1265 else if( action
& SA_SSI_REPAINT_ARROWS
)
1266 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, FALSE
);
1271 INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
1272 const SCROLLINFO
*info
, INT
*action
)
1274 /* Update the scrollbar state and set action flags according to
1275 * what has to be done graphics wise. */
1277 SCROLLBAR_INFO
*infoPtr
;
1282 if (!(infoPtr
= SCROLL_GetScrollInfo(hwnd
, nBar
))) return 0;
1283 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return 0;
1284 if ((info
->cbSize
!= sizeof(*info
)) &&
1285 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return 0;
1287 if (TRACE_ON(scroll
))
1289 DPRINTF( "hwnd=%04x bar=%d", hwnd
, nBar
);
1290 if (info
->fMask
& SIF_PAGE
) DPRINTF( " page=%d", info
->nPage
);
1291 if (info
->fMask
& SIF_POS
) DPRINTF( " pos=%d", info
->nPos
);
1292 if (info
->fMask
& SIF_RANGE
) DPRINTF( " min=%d max=%d", info
->nMin
, info
->nMax
);
1296 /* Set the page size */
1298 if (info
->fMask
& SIF_PAGE
)
1300 if( infoPtr
->Page
!= info
->nPage
)
1302 infoPtr
->Page
= info
->nPage
;
1303 *action
|= SA_SSI_REFRESH
;
1307 /* Set the scroll pos */
1309 if (info
->fMask
& SIF_POS
)
1311 if( infoPtr
->CurVal
!= info
->nPos
)
1313 infoPtr
->CurVal
= info
->nPos
;
1314 *action
|= SA_SSI_REFRESH
;
1318 /* Set the scroll range */
1320 if (info
->fMask
& SIF_RANGE
)
1322 /* Invalid range -> range is set to (0,0) */
1323 if ((info
->nMin
> info
->nMax
) ||
1324 ((UINT
)(info
->nMax
- info
->nMin
) >= 0x80000000))
1326 infoPtr
->MinVal
= 0;
1327 infoPtr
->MaxVal
= 0;
1331 if( infoPtr
->MinVal
!= info
->nMin
||
1332 infoPtr
->MaxVal
!= info
->nMax
)
1334 *action
|= SA_SSI_REFRESH
;
1335 infoPtr
->MinVal
= info
->nMin
;
1336 infoPtr
->MaxVal
= info
->nMax
;
1341 /* Make sure the page size is valid */
1343 if (infoPtr
->Page
< 0) infoPtr
->Page
= 0;
1344 else if (infoPtr
->Page
> infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1 )
1345 infoPtr
->Page
= infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1;
1347 /* Make sure the pos is inside the range */
1349 if (infoPtr
->CurVal
< infoPtr
->MinVal
)
1350 infoPtr
->CurVal
= infoPtr
->MinVal
;
1351 else if (infoPtr
->CurVal
> infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
1352 infoPtr
->CurVal
= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 );
1354 TRACE(" new values: page=%d pos=%d min=%d max=%d\n",
1355 infoPtr
->Page
, infoPtr
->CurVal
,
1356 infoPtr
->MinVal
, infoPtr
->MaxVal
);
1358 /* don't change the scrollbar state if SetScrollInfo
1359 * is just called with SIF_DISABLENOSCROLL
1361 if(!(info
->fMask
& SIF_ALL
)) goto done
;
1363 /* Check if the scrollbar should be hidden or disabled */
1365 if (info
->fMask
& (SIF_RANGE
| SIF_PAGE
| SIF_DISABLENOSCROLL
))
1367 new_flags
= infoPtr
->flags
;
1368 if (infoPtr
->MinVal
>= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
1370 /* Hide or disable scroll-bar */
1371 if (info
->fMask
& SIF_DISABLENOSCROLL
)
1373 new_flags
= ESB_DISABLE_BOTH
;
1374 *action
|= SA_SSI_REFRESH
;
1376 else if (nBar
!= SB_CTL
)
1378 *action
= SA_SSI_HIDE
;
1382 else /* Show and enable scroll-bar */
1386 *action
|= SA_SSI_SHOW
;
1389 if (infoPtr
->flags
!= new_flags
) /* check arrow flags */
1391 infoPtr
->flags
= new_flags
;
1392 *action
|= SA_SSI_REPAINT_ARROWS
;
1397 /* Return current position */
1399 return infoPtr
->CurVal
;
1403 /*************************************************************************
1404 * GetScrollInfo16 (USER.476)
1406 BOOL16 WINAPI
GetScrollInfo16( HWND16 hwnd
, INT16 nBar
, LPSCROLLINFO info
)
1408 return GetScrollInfo( hwnd
, nBar
, info
);
1412 /*************************************************************************
1413 * GetScrollInfo32 (USER32.284)
1414 * GetScrollInfo32 can be used to retrieve the position, upper bound,
1415 * lower bound, and page size of a scrollbar control.
1419 BOOL WINAPI
GetScrollInfo(
1420 HWND hwnd
/* [I] Handle of window */ ,
1421 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1422 LPSCROLLINFO info
/* [IO] (info.fMask [I] specifies which values are to retrieve) */)
1424 SCROLLBAR_INFO
*infoPtr
;
1426 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1427 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return FALSE
;
1428 if ((info
->cbSize
!= sizeof(*info
)) &&
1429 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return FALSE
;
1431 if (info
->fMask
& SIF_PAGE
) info
->nPage
= infoPtr
->Page
;
1432 if (info
->fMask
& SIF_POS
) info
->nPos
= infoPtr
->CurVal
;
1433 if ((info
->fMask
& SIF_TRACKPOS
) && (info
->cbSize
== sizeof(*info
)))
1434 info
->nTrackPos
= (SCROLL_TrackingWin
==hwnd
) ? SCROLL_TrackingVal
: infoPtr
->CurVal
;
1435 if (info
->fMask
& SIF_RANGE
)
1437 info
->nMin
= infoPtr
->MinVal
;
1438 info
->nMax
= infoPtr
->MaxVal
;
1440 return (info
->fMask
& SIF_ALL
) != 0;
1444 /*************************************************************************
1445 * SetScrollPos16 (USER.62)
1447 INT16 WINAPI
SetScrollPos16( HWND16 hwnd
, INT16 nBar
, INT16 nPos
,
1450 return (INT16
)SetScrollPos( hwnd
, nBar
, nPos
, bRedraw
);
1454 /*************************************************************************
1455 * SetScrollPos32 (USER32.502)
1458 * Success: Scrollbar position
1462 * Note the ambiguity when 0 is returned. Use GetLastError
1463 * to make sure there was an error (and to know which one).
1465 INT WINAPI
SetScrollPos(
1466 HWND hwnd
/* [I] Handle of window whose scrollbar will be affected */,
1467 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1468 INT nPos
/* [I] New value */,
1469 BOOL bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */ )
1472 SCROLLBAR_INFO
*infoPtr
;
1475 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1476 oldPos
= infoPtr
->CurVal
;
1477 info
.cbSize
= sizeof(info
);
1479 info
.fMask
= SIF_POS
;
1480 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1485 /*************************************************************************
1486 * GetScrollPos16 (USER.63)
1488 INT16 WINAPI
GetScrollPos16( HWND16 hwnd
, INT16 nBar
)
1490 return (INT16
)GetScrollPos( hwnd
, nBar
);
1494 /*************************************************************************
1495 * GetScrollPos32 (USER32.285)
1498 * Success: Current position
1502 * Note the ambiguity when 0 is returned. Use GetLastError
1503 * to make sure there was an error (and to know which one).
1505 INT WINAPI
GetScrollPos(
1506 HWND hwnd
, /* [I] Handle of window */
1507 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */)
1509 SCROLLBAR_INFO
*infoPtr
;
1511 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1512 return infoPtr
->CurVal
;
1516 /*************************************************************************
1517 * SetScrollRange16 (USER.64)
1519 void WINAPI
SetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1520 INT16 MinVal
, INT16 MaxVal
, BOOL16 bRedraw
)
1522 /* Invalid range -> range is set to (0,0) */
1523 if ((INT
)MaxVal
- (INT
)MinVal
> 0x7fff) MinVal
= MaxVal
= 0;
1524 SetScrollRange( hwnd
, nBar
, MinVal
, MaxVal
, bRedraw
);
1528 /*************************************************************************
1529 * SetScrollRange32 (USER32.503)
1533 BOOL WINAPI
SetScrollRange(
1534 HWND hwnd
, /* [I] Handle of window whose scrollbar will be affected */
1535 INT nBar
, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1536 INT MinVal
, /* [I] New minimum value */
1537 INT MaxVal
, /* [I] New maximum value */
1538 BOOL bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */)
1542 info
.cbSize
= sizeof(info
);
1545 info
.fMask
= SIF_RANGE
;
1546 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1551 /*************************************************************************
1552 * SCROLL_SetNCSbState
1554 * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
1556 INT
SCROLL_SetNCSbState(WND
* wndPtr
, int vMin
, int vMax
, int vPos
,
1557 int hMin
, int hMax
, int hPos
)
1560 SCROLLINFO vInfo
, hInfo
;
1562 vInfo
.cbSize
= hInfo
.cbSize
= sizeof(SCROLLINFO
);
1563 vInfo
.nMin
= vMin
; hInfo
.nMin
= hMin
;
1564 vInfo
.nMax
= vMax
; hInfo
.nMax
= hMax
;
1565 vInfo
.nPos
= vPos
; hInfo
.nPos
= hPos
;
1566 vInfo
.fMask
= hInfo
.fMask
= SIF_RANGE
| SIF_POS
;
1568 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_VERT
, &vInfo
, &vA
);
1569 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_HORZ
, &hInfo
, &hA
);
1571 if( !SCROLL_ShowScrollBar( wndPtr
->hwndSelf
, SB_BOTH
,
1572 (hA
& SA_SSI_SHOW
),(vA
& SA_SSI_SHOW
) ) )
1574 /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
1575 if( vA
& SA_SSI_REFRESH
)
1576 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_VERT
, FALSE
, TRUE
);
1578 if( hA
& SA_SSI_REFRESH
)
1579 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_HORZ
, FALSE
, TRUE
);
1585 /*************************************************************************
1586 * GetScrollRange16 (USER.65)
1588 BOOL16 WINAPI
GetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1589 LPINT16 lpMin
, LPINT16 lpMax
)
1592 BOOL16 ret
= GetScrollRange( hwnd
, nBar
, &min
, &max
);
1593 if (lpMin
) *lpMin
= min
;
1594 if (lpMax
) *lpMax
= max
;
1599 /*************************************************************************
1600 * GetScrollRange32 (USER32.286)
1604 BOOL WINAPI
GetScrollRange(
1605 HWND hwnd
, /* [I] Handle of window */
1606 INT nBar
, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1607 LPINT lpMin
, /* [O] Where to store minimum value */
1608 LPINT lpMax
/* [O] Where to store maximum value */)
1610 SCROLLBAR_INFO
*infoPtr
;
1612 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
)))
1614 if (lpMin
) lpMin
= 0;
1615 if (lpMax
) lpMax
= 0;
1618 if (lpMin
) *lpMin
= infoPtr
->MinVal
;
1619 if (lpMax
) *lpMax
= infoPtr
->MaxVal
;
1624 /*************************************************************************
1625 * SCROLL_ShowScrollBar()
1627 * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
1628 * NOTE: fShowV/fShowH must be zero when nBar is SB_HORZ/SB_VERT.
1630 BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
1631 BOOL fShowH
, BOOL fShowV
)
1633 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
1634 BOOL retvalue
= FALSE
;
1636 if (!wndPtr
) return FALSE
;
1637 TRACE("hwnd=%04x bar=%d horz=%d, vert=%d\n",
1638 hwnd
, nBar
, fShowH
, fShowV
);
1643 ShowWindow( hwnd
, fShowH
? SW_SHOW
: SW_HIDE
);
1651 fShowH
= !(wndPtr
->dwStyle
& WS_HSCROLL
);
1652 wndPtr
->dwStyle
|= WS_HSCROLL
;
1656 fShowH
= (wndPtr
->dwStyle
& WS_HSCROLL
);
1657 wndPtr
->dwStyle
&= ~WS_HSCROLL
;
1659 if( nBar
== SB_HORZ
) {
1668 fShowV
= !(wndPtr
->dwStyle
& WS_VSCROLL
);
1669 wndPtr
->dwStyle
|= WS_VSCROLL
;
1673 fShowV
= (wndPtr
->dwStyle
& WS_VSCROLL
);
1674 wndPtr
->dwStyle
&= ~WS_VSCROLL
;
1676 if ( nBar
== SB_VERT
)
1681 retvalue
= FALSE
; /* Nothing to do! */
1685 if( fShowH
|| fShowV
) /* frame has been changed, let the window redraw itself */
1687 SetWindowPos( hwnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
1688 | SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
1693 retvalue
= FALSE
; /* no frame changes */
1695 WIN_ReleaseWndPtr(wndPtr
);
1700 /*************************************************************************
1701 * ShowScrollBar16 (USER.267)
1703 void WINAPI
ShowScrollBar16( HWND16 hwnd
, INT16 nBar
, BOOL16 fShow
)
1705 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1706 (nBar
== SB_HORZ
) ? 0 : fShow
);
1710 /*************************************************************************
1711 * ShowScrollBar32 (USER32.532)
1715 BOOL WINAPI
ShowScrollBar(
1716 HWND hwnd
, /* [I] Handle of window whose scrollbar(s) will be affected */
1717 INT nBar
, /* [I] One of SB_HORZ, SB_VERT, SB_BOTH or SB_CTL */
1718 BOOL fShow
/* [I] TRUE = show, FALSE = hide */)
1720 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1721 (nBar
== SB_HORZ
) ? 0 : fShow
);
1726 /*************************************************************************
1727 * EnableScrollBar16 (USER.482)
1729 BOOL16 WINAPI
EnableScrollBar16( HWND16 hwnd
, INT16 nBar
, UINT16 flags
)
1731 return EnableScrollBar( hwnd
, nBar
, flags
);
1735 /*************************************************************************
1736 * EnableScrollBar32 (USER32.171)
1738 BOOL WINAPI
EnableScrollBar( HWND hwnd
, INT nBar
, UINT flags
)
1741 SCROLLBAR_INFO
*infoPtr
;
1743 TRACE("%04x %d %d\n", hwnd
, nBar
, flags
);
1745 flags
&= ESB_DISABLE_BOTH
;
1747 if (nBar
== SB_BOTH
)
1749 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, SB_VERT
))) return FALSE
;
1750 if (!(bFineWithMe
= (infoPtr
->flags
== flags
)) )
1752 infoPtr
->flags
= flags
;
1753 SCROLL_RefreshScrollBar( hwnd
, SB_VERT
, TRUE
, TRUE
);
1760 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1761 if (bFineWithMe
&& infoPtr
->flags
== flags
) return FALSE
;
1762 infoPtr
->flags
= flags
;
1764 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);