4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994, 1996 Alexandre Julliard
10 #include "wine/winuser16.h"
14 #include "debugtools.h"
18 DEFAULT_DEBUG_CHANNEL(scroll
);
21 static HBITMAP hUpArrow
= 0;
22 static HBITMAP hDnArrow
= 0;
23 static HBITMAP hLfArrow
= 0;
24 static HBITMAP hRgArrow
= 0;
25 static HBITMAP hUpArrowD
= 0;
26 static HBITMAP hDnArrowD
= 0;
27 static HBITMAP hLfArrowD
= 0;
28 static HBITMAP hRgArrowD
= 0;
29 static HBITMAP hUpArrowI
= 0;
30 static HBITMAP hDnArrowI
= 0;
31 static HBITMAP hLfArrowI
= 0;
32 static HBITMAP hRgArrowI
= 0;
34 #define TOP_ARROW(flags,pressed) \
35 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
36 #define BOTTOM_ARROW(flags,pressed) \
37 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
38 #define LEFT_ARROW(flags,pressed) \
39 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
40 #define RIGHT_ARROW(flags,pressed) \
41 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
44 /* Minimum size of the rectangle between the arrows */
45 #define SCROLL_MIN_RECT 4
47 /* Minimum size of the thumb in pixels */
48 #define SCROLL_MIN_THUMB 6
50 /* Overlap between arrows and thumb */
51 #define SCROLL_ARROW_THUMB_OVERLAP ((TWEAK_WineLook == WIN31_LOOK) ? 1 : 0)
53 /* Delay (in ms) before first repetition when holding the button down */
54 #define SCROLL_FIRST_DELAY 200
56 /* Delay (in ms) between scroll repetitions */
57 #define SCROLL_REPEAT_DELAY 50
60 #define SCROLL_TIMER 0
62 /* Scroll-bar hit testing */
65 SCROLL_NOWHERE
, /* Outside the scroll bar */
66 SCROLL_TOP_ARROW
, /* Top or left arrow */
67 SCROLL_TOP_RECT
, /* Rectangle between the top arrow and the thumb */
68 SCROLL_THUMB
, /* Thumb rectangle */
69 SCROLL_BOTTOM_RECT
, /* Rectangle between the thumb and the bottom arrow */
70 SCROLL_BOTTOM_ARROW
/* Bottom or right arrow */
73 /* What to do after SCROLL_SetScrollInfo() */
74 #define SA_SSI_HIDE 0x0001
75 #define SA_SSI_SHOW 0x0002
76 #define SA_SSI_REFRESH 0x0004
77 #define SA_SSI_REPAINT_ARROWS 0x0008
79 /* Thumb-tracking info */
80 static HWND SCROLL_TrackingWin
= 0;
81 static INT SCROLL_TrackingBar
= 0;
82 static INT SCROLL_TrackingPos
= 0;
83 static INT SCROLL_TrackingVal
= 0;
84 /* Hit test code of the last button-down event */
85 static enum SCROLL_HITTEST SCROLL_trackHitTest
;
86 static BOOL SCROLL_trackVertical
;
88 /* Is the moving thumb being displayed? */
89 static BOOL SCROLL_MovingThumb
= FALSE
;
92 static BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
93 BOOL fShowH
, BOOL fShowV
);
94 static INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
95 const SCROLLINFO
*info
, INT
*action
);
96 static void SCROLL_DrawInterior_9x( HWND hwnd
, HDC hdc
, INT nBar
,
97 RECT
*rect
, INT arrowSize
,
98 INT thumbSize
, INT thumbPos
,
99 UINT flags
, BOOL vertical
,
100 BOOL top_selected
, BOOL bottom_selected
);
103 /***********************************************************************
106 static void SCROLL_LoadBitmaps(void)
108 hUpArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROW
) );
109 hDnArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROW
) );
110 hLfArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROW
) );
111 hRgArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROW
) );
112 hUpArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWD
) );
113 hDnArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWD
) );
114 hLfArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWD
) );
115 hRgArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWD
) );
116 hUpArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWI
) );
117 hDnArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWI
) );
118 hLfArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWI
) );
119 hRgArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWI
) );
123 /***********************************************************************
124 * SCROLL_GetPtrScrollInfo
126 static SCROLLBAR_INFO
*SCROLL_GetPtrScrollInfo( WND
* wndPtr
, INT nBar
)
128 SCROLLBAR_INFO
*infoPtr
;
130 if (!wndPtr
) return NULL
;
133 case SB_HORZ
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pHScroll
; break;
134 case SB_VERT
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pVScroll
; break;
135 case SB_CTL
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->wExtra
; break;
136 default: return NULL
;
139 if (!infoPtr
) /* Create the info structure if needed */
141 if ((infoPtr
= HeapAlloc( SystemHeap
, 0, sizeof(SCROLLBAR_INFO
) )))
143 infoPtr
->MinVal
= infoPtr
->CurVal
= infoPtr
->Page
= 0;
144 infoPtr
->MaxVal
= 100;
145 infoPtr
->flags
= ESB_ENABLE_BOTH
;
146 if (nBar
== SB_HORZ
) wndPtr
->pHScroll
= infoPtr
;
147 else wndPtr
->pVScroll
= infoPtr
;
149 if (!hUpArrow
) SCROLL_LoadBitmaps();
155 /***********************************************************************
156 * SCROLL_GetScrollInfo
158 static SCROLLBAR_INFO
*SCROLL_GetScrollInfo( HWND hwnd
, INT nBar
)
160 SCROLLBAR_INFO
*retvalue
;
161 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
162 retvalue
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
163 WIN_ReleaseWndPtr(wndPtr
);
168 /***********************************************************************
169 * SCROLL_GetScrollBarRect
171 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
172 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
173 * 'arrowSize' returns the width or height of an arrow (depending on
174 * the orientation of the scrollbar), 'thumbSize' returns the size of
175 * the thumb, and 'thumbPos' returns the position of the thumb
176 * relative to the left or to the top.
177 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
179 static BOOL
SCROLL_GetScrollBarRect( HWND hwnd
, INT nBar
, RECT
*lprect
,
180 INT
*arrowSize
, INT
*thumbSize
,
185 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
190 lprect
->left
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
;
191 lprect
->top
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
192 lprect
->right
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
193 lprect
->bottom
= lprect
->top
+ GetSystemMetrics(SM_CYHSCROLL
);
194 if(wndPtr
->dwStyle
& WS_BORDER
) {
197 } else if(wndPtr
->dwStyle
& WS_VSCROLL
)
203 lprect
->left
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
204 lprect
->top
= wndPtr
->rectClient
.top
- wndPtr
->rectWindow
.top
;
205 lprect
->right
= lprect
->left
+ GetSystemMetrics(SM_CXVSCROLL
);
206 lprect
->bottom
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
207 if(wndPtr
->dwStyle
& WS_BORDER
) {
210 } else if(wndPtr
->dwStyle
& WS_HSCROLL
)
216 GetClientRect( hwnd
, lprect
);
217 vertical
= ((wndPtr
->dwStyle
& SBS_VERT
) != 0);
221 WIN_ReleaseWndPtr(wndPtr
);
225 if (vertical
) pixels
= lprect
->bottom
- lprect
->top
;
226 else pixels
= lprect
->right
- lprect
->left
;
228 if (pixels
<= 2*GetSystemMetrics(SM_CXVSCROLL
) + SCROLL_MIN_RECT
)
230 if (pixels
> SCROLL_MIN_RECT
)
231 *arrowSize
= (pixels
- SCROLL_MIN_RECT
) / 2;
234 *thumbPos
= *thumbSize
= 0;
238 SCROLLBAR_INFO
*info
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
240 *arrowSize
= GetSystemMetrics(SM_CXVSCROLL
);
241 pixels
-= (2 * (GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
));
245 *thumbSize
= pixels
* info
->Page
/ (info
->MaxVal
-info
->MinVal
+1);
246 if (*thumbSize
< SCROLL_MIN_THUMB
) *thumbSize
= SCROLL_MIN_THUMB
;
248 else *thumbSize
= GetSystemMetrics(SM_CXVSCROLL
);
250 if (((pixels
-= *thumbSize
) < 0) ||
251 ((info
->flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
))
253 /* Rectangle too small or scrollbar disabled -> no thumb */
254 *thumbPos
= *thumbSize
= 0;
258 INT max
= info
->MaxVal
- max( info
->Page
-1, 0 );
259 if (info
->MinVal
>= max
)
260 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
262 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
263 + pixels
* (info
->CurVal
-info
->MinVal
) / (max
- info
->MinVal
);
266 WIN_ReleaseWndPtr(wndPtr
);
271 /***********************************************************************
274 * Compute the current scroll position based on the thumb position in pixels
275 * from the top of the scroll-bar.
277 static UINT
SCROLL_GetThumbVal( SCROLLBAR_INFO
*infoPtr
, RECT
*rect
,
278 BOOL vertical
, INT pos
)
281 INT pixels
= vertical
? rect
->bottom
-rect
->top
: rect
->right
-rect
->left
;
283 if ((pixels
-= 2*(GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
)) <= 0)
284 return infoPtr
->MinVal
;
288 thumbSize
= pixels
* infoPtr
->Page
/(infoPtr
->MaxVal
-infoPtr
->MinVal
+1);
289 if (thumbSize
< SCROLL_MIN_THUMB
) thumbSize
= SCROLL_MIN_THUMB
;
291 else thumbSize
= GetSystemMetrics(SM_CXVSCROLL
);
293 if ((pixels
-= thumbSize
) <= 0) return infoPtr
->MinVal
;
295 pos
= max( 0, pos
- (GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
) );
296 if (pos
> pixels
) pos
= pixels
;
298 if (!infoPtr
->Page
) pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
;
299 else pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
- infoPtr
->Page
+ 1;
300 return infoPtr
->MinVal
+ ((pos
+ pixels
/ 2) / pixels
);
303 /***********************************************************************
306 static BOOL
SCROLL_PtInRectEx( LPRECT lpRect
, POINT pt
, BOOL vertical
)
312 rect
.left
-= lpRect
->right
- lpRect
->left
;
313 rect
.right
+= lpRect
->right
- lpRect
->left
;
317 rect
.top
-= lpRect
->bottom
- lpRect
->top
;
318 rect
.bottom
+= lpRect
->bottom
- lpRect
->top
;
320 return PtInRect( &rect
, pt
);
323 /***********************************************************************
326 static POINT
SCROLL_ClipPos( LPRECT lpRect
, POINT pt
)
328 if( pt
.x
< lpRect
->left
)
331 if( pt
.x
> lpRect
->right
)
332 pt
.x
= lpRect
->right
;
334 if( pt
.y
< lpRect
->top
)
337 if( pt
.y
> lpRect
->bottom
)
338 pt
.y
= lpRect
->bottom
;
344 /***********************************************************************
347 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
349 static enum SCROLL_HITTEST
SCROLL_HitTest( HWND hwnd
, INT nBar
,
350 POINT pt
, BOOL bDragging
)
352 INT arrowSize
, thumbSize
, thumbPos
;
355 BOOL vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
356 &arrowSize
, &thumbSize
, &thumbPos
);
358 if ( (bDragging
&& !SCROLL_PtInRectEx( &rect
, pt
, vertical
)) ||
359 (!PtInRect( &rect
, pt
)) ) return SCROLL_NOWHERE
;
363 if (pt
.y
< rect
.top
+ arrowSize
) return SCROLL_TOP_ARROW
;
364 if (pt
.y
>= rect
.bottom
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
365 if (!thumbPos
) return SCROLL_TOP_RECT
;
367 if (pt
.y
< thumbPos
) return SCROLL_TOP_RECT
;
368 if (pt
.y
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
370 else /* horizontal */
372 if (pt
.x
< rect
.left
+ arrowSize
) return SCROLL_TOP_ARROW
;
373 if (pt
.x
>= rect
.right
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
374 if (!thumbPos
) return SCROLL_TOP_RECT
;
376 if (pt
.x
< thumbPos
) return SCROLL_TOP_RECT
;
377 if (pt
.x
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
383 /***********************************************************************
386 * Draw the scroll bar arrows.
388 static void SCROLL_DrawArrows_9x( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
389 RECT
*rect
, INT arrowSize
, BOOL vertical
,
390 BOOL top_pressed
, BOOL bottom_pressed
)
396 r
.bottom
= r
.top
+ arrowSize
;
398 r
.right
= r
.left
+ arrowSize
;
400 DrawFrameControl( hdc
, &r
, DFC_SCROLL
,
401 (vertical
? DFCS_SCROLLUP
: DFCS_SCROLLLEFT
)
402 | (top_pressed
? (DFCS_PUSHED
| DFCS_FLAT
) : 0 )
403 | (infoPtr
->flags
&ESB_DISABLE_LTUP
? DFCS_INACTIVE
: 0 ) );
407 r
.top
= r
.bottom
-arrowSize
;
409 r
.left
= r
.right
-arrowSize
;
411 DrawFrameControl( hdc
, &r
, DFC_SCROLL
,
412 (vertical
? DFCS_SCROLLDOWN
: DFCS_SCROLLRIGHT
)
413 | (bottom_pressed
? (DFCS_PUSHED
| DFCS_FLAT
) : 0 )
414 | (infoPtr
->flags
&ESB_DISABLE_RTDN
? DFCS_INACTIVE
: 0) );
417 static void SCROLL_DrawArrows_31( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
418 RECT
*rect
, INT arrowSize
, BOOL vertical
,
419 BOOL top_pressed
, BOOL bottom_pressed
)
421 HDC hdcMem
= CreateCompatibleDC( hdc
);
422 HBITMAP hbmpPrev
= SelectObject( hdcMem
, vertical
?
423 TOP_ARROW(infoPtr
->flags
, top_pressed
)
424 : LEFT_ARROW(infoPtr
->flags
, top_pressed
));
426 SetStretchBltMode( hdc
, STRETCH_DELETESCANS
);
427 StretchBlt( hdc
, rect
->left
, rect
->top
,
428 vertical
? rect
->right
-rect
->left
: arrowSize
,
429 vertical
? arrowSize
: rect
->bottom
-rect
->top
,
431 GetSystemMetrics(SM_CXVSCROLL
),GetSystemMetrics(SM_CYHSCROLL
),
434 SelectObject( hdcMem
, vertical
?
435 BOTTOM_ARROW( infoPtr
->flags
, bottom_pressed
)
436 : RIGHT_ARROW( infoPtr
->flags
, bottom_pressed
) );
438 StretchBlt( hdc
, rect
->left
, rect
->bottom
- arrowSize
,
439 rect
->right
- rect
->left
, arrowSize
,
441 GetSystemMetrics(SM_CXVSCROLL
),GetSystemMetrics(SM_CYHSCROLL
),
444 StretchBlt( hdc
, rect
->right
- arrowSize
, rect
->top
,
445 arrowSize
, rect
->bottom
- rect
->top
,
447 GetSystemMetrics(SM_CXVSCROLL
), GetSystemMetrics(SM_CYHSCROLL
),
449 SelectObject( hdcMem
, hbmpPrev
);
453 static void SCROLL_DrawArrows( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
454 RECT
*rect
, INT arrowSize
, BOOL vertical
,
455 BOOL top_pressed
, BOOL bottom_pressed
)
457 if( TWEAK_WineLook
== WIN31_LOOK
)
458 SCROLL_DrawArrows_31( hdc
, infoPtr
, rect
, arrowSize
,
459 vertical
, top_pressed
,bottom_pressed
);
461 SCROLL_DrawArrows_9x( hdc
, infoPtr
, rect
, arrowSize
,
462 vertical
, top_pressed
,bottom_pressed
);
466 /***********************************************************************
467 * SCROLL_DrawMovingThumb
469 * Draw the moving thumb rectangle.
471 static void SCROLL_DrawMovingThumb_31( HDC hdc
, RECT
*rect
, BOOL vertical
,
472 INT arrowSize
, INT thumbSize
)
477 r
.top
+= SCROLL_TrackingPos
;
478 if (r
.top
< rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
479 r
.top
= rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
480 if (r
.top
+ thumbSize
>
481 rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
482 r
.top
= rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
484 r
.bottom
= r
.top
+ thumbSize
;
488 r
.left
+= SCROLL_TrackingPos
;
489 if (r
.left
< rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
490 r
.left
= rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
491 if (r
.left
+ thumbSize
>
492 rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
493 r
.left
= rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
495 r
.right
= r
.left
+ thumbSize
;
498 DrawFocusRect( hdc
, &r
);
499 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
502 static void SCROLL_DrawMovingThumb_9x( HDC hdc
, RECT
*rect
, BOOL vertical
,
503 INT arrowSize
, INT thumbSize
)
505 INT pos
= SCROLL_TrackingPos
;
509 max_size
= rect
->bottom
- rect
->top
;
511 max_size
= rect
->right
- rect
->left
;
513 max_size
-= (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
) + thumbSize
;
515 if( pos
< (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
) )
516 pos
= (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
);
517 else if( pos
> max_size
)
520 SCROLL_DrawInterior_9x( SCROLL_TrackingWin
, hdc
, SCROLL_TrackingBar
,
521 rect
, arrowSize
, thumbSize
, pos
,
522 0, vertical
, FALSE
, FALSE
);
524 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
527 static void SCROLL_DrawMovingThumb( HDC hdc
, RECT
*rect
, BOOL vertical
,
528 INT arrowSize
, INT thumbSize
)
530 if( TWEAK_WineLook
== WIN31_LOOK
)
531 SCROLL_DrawMovingThumb_31( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
533 SCROLL_DrawMovingThumb_9x( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
536 /***********************************************************************
537 * SCROLL_DrawInterior
539 * Draw the scroll bar interior (everything except the arrows).
541 static void SCROLL_DrawInterior_9x( HWND hwnd
, HDC hdc
, INT nBar
,
542 RECT
*rect
, INT arrowSize
,
543 INT thumbSize
, INT thumbPos
,
544 UINT flags
, BOOL vertical
,
545 BOOL top_selected
, BOOL bottom_selected
)
549 HBRUSH hSaveBrush
,hBrush
;
551 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
552 * The window-owned scrollbars need to call DEFWND_ControlColor
553 * to correctly setup default scrollbar colors
557 hBrush
= (HBRUSH
)SendMessageA( GetParent(hwnd
), WM_CTLCOLORSCROLLBAR
,
558 (WPARAM
)hdc
,(LPARAM
)hwnd
);
562 hBrush
= DEFWND_ControlColor( hdc
, CTLCOLOR_SCROLLBAR
);
565 hSavePen
= SelectObject( hdc
, GetSysColorPen(COLOR_WINDOWFRAME
) );
566 hSaveBrush
= SelectObject( hdc
, hBrush
);
568 /* Calculate the scroll rectangle */
572 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
573 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
577 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
578 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
581 /* Draw the scroll rectangles and thumb */
582 if (!thumbPos
) /* No thumb to draw */
584 PatBlt( hdc
, r
.left
, r
.top
,
585 r
.right
- r
.left
, r
.bottom
- r
.top
,
588 /* cleanup and return */
589 SelectObject( hdc
, hSavePen
);
590 SelectObject( hdc
, hSaveBrush
);
596 PatBlt( hdc
, r
.left
, r
.top
,
598 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
599 top_selected
? 0x0f0000 : PATCOPY
);
600 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
601 PatBlt( hdc
, r
.left
, r
.top
+ thumbSize
,
603 r
.bottom
- r
.top
- thumbSize
,
604 bottom_selected
? 0x0f0000 : PATCOPY
);
605 r
.bottom
= r
.top
+ thumbSize
;
607 else /* horizontal */
609 PatBlt( hdc
, r
.left
, r
.top
,
610 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
612 top_selected
? 0x0f0000 : PATCOPY
);
613 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
614 PatBlt( hdc
, r
.left
+ thumbSize
, r
.top
,
615 r
.right
- r
.left
- thumbSize
,
617 bottom_selected
? 0x0f0000 : PATCOPY
);
618 r
.right
= r
.left
+ thumbSize
;
622 DrawEdge( hdc
, &r
, EDGE_RAISED
, BF_RECT
| BF_MIDDLE
);
625 SelectObject( hdc
, hSavePen
);
626 SelectObject( hdc
, hSaveBrush
);
630 static void SCROLL_DrawInterior( HWND hwnd
, HDC hdc
, INT nBar
,
631 RECT
*rect
, INT arrowSize
,
632 INT thumbSize
, INT thumbPos
,
633 UINT flags
, BOOL vertical
,
634 BOOL top_selected
, BOOL bottom_selected
)
638 HBRUSH hSaveBrush
,hBrush
;
639 BOOL Save_SCROLL_MovingThumb
= SCROLL_MovingThumb
;
641 if (Save_SCROLL_MovingThumb
&&
642 (SCROLL_TrackingWin
== hwnd
) &&
643 (SCROLL_TrackingBar
== nBar
))
644 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
646 /* Select the correct brush and pen */
648 if (TWEAK_WineLook
== WIN31_LOOK
&& (flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
)
650 /* This ought to be the color of the parent window */
651 if (TWEAK_WineLook
== WIN31_LOOK
) {
652 hBrush
= GetSysColorBrush(COLOR_WINDOW
);
654 /* Under Win9x look & feel, scrollbars don't have a solid border.
655 * To make scrollbar's background different from the window
656 * background, we need to apply a gray 0x55aa pattern brush.
657 * Otherwise it won't look good.
659 hBrush
= CACHE_GetPattern55AABrush();
664 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
665 * The window-owned scrollbars need to call DEFWND_ControlColor
666 * to correctly setup default scrollbar colors
668 if (nBar
== SB_CTL
) {
669 hBrush
= (HBRUSH
)SendMessageA( GetParent(hwnd
), WM_CTLCOLORSCROLLBAR
,
670 (WPARAM
)hdc
,(LPARAM
)hwnd
);
672 hBrush
= DEFWND_ControlColor( hdc
, CTLCOLOR_SCROLLBAR
);
675 hSavePen
= SelectObject( hdc
, GetSysColorPen(COLOR_WINDOWFRAME
) );
676 hSaveBrush
= SelectObject( hdc
, hBrush
);
678 /* Calculate the scroll rectangle */
683 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
684 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
688 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
689 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
692 /* Draw the scroll bar frame */
694 /* Only draw outline if Win 3.1. Mar 24, 1999 - Ronald B. Cemer */
695 if (TWEAK_WineLook
== WIN31_LOOK
)
696 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
698 /* Draw the scroll rectangles and thumb */
700 if (!thumbPos
) /* No thumb to draw */
702 INT offset
= (TWEAK_WineLook
> WIN31_LOOK
) ? 0 : 1;
704 PatBlt( hdc
, r
.left
+offset
, r
.top
+offset
,
705 r
.right
- r
.left
- 2*offset
, r
.bottom
- r
.top
- 2*offset
,
708 /* cleanup and return */
709 SelectObject( hdc
, hSavePen
);
710 SelectObject( hdc
, hSaveBrush
);
716 INT offset
= (TWEAK_WineLook
== WIN31_LOOK
) ? 1 : 0;
718 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ offset
,
719 r
.right
- r
.left
- offset
*2,
720 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
) - offset
,
721 top_selected
? 0x0f0000 : PATCOPY
);
722 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
723 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ thumbSize
,
724 r
.right
- r
.left
- offset
*2,
725 r
.bottom
- r
.top
- thumbSize
- offset
,
726 bottom_selected
? 0x0f0000 : PATCOPY
);
727 r
.bottom
= r
.top
+ thumbSize
;
729 else /* horizontal */
731 INT offset
= (TWEAK_WineLook
== WIN31_LOOK
) ? 1 : 0;
733 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ offset
,
734 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
735 r
.bottom
- r
.top
- offset
*2,
736 top_selected
? 0x0f0000 : PATCOPY
);
737 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
738 PatBlt( hdc
, r
.left
+ thumbSize
, r
.top
+ offset
,
739 r
.right
- r
.left
- thumbSize
- offset
,
740 r
.bottom
- r
.top
- offset
*2,
741 bottom_selected
? 0x0f0000 : PATCOPY
);
742 r
.right
= r
.left
+ thumbSize
;
747 SelectObject( hdc
, GetSysColorBrush(COLOR_BTNFACE
) );
748 if (TWEAK_WineLook
== WIN31_LOOK
)
750 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
755 Rectangle( hdc
, r
.left
+1, r
.top
+1, r
.right
-1, r
.bottom
-1 );
757 DrawEdge( hdc
, &r
, EDGE_RAISED
, BF_RECT
);
759 if (Save_SCROLL_MovingThumb
&&
760 (SCROLL_TrackingWin
== hwnd
) &&
761 (SCROLL_TrackingBar
== nBar
))
762 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
765 SelectObject( hdc
, hSavePen
);
766 SelectObject( hdc
, hSaveBrush
);
770 /***********************************************************************
771 * SCROLL_DrawScrollBar
773 * Redraw the whole scrollbar.
775 void SCROLL_DrawScrollBar( HWND hwnd
, HDC hdc
, INT nBar
,
776 BOOL arrows
, BOOL interior
)
778 INT arrowSize
, thumbSize
, thumbPos
;
781 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
782 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
783 BOOL Save_SCROLL_MovingThumb
= SCROLL_MovingThumb
;
785 if (!wndPtr
|| !infoPtr
||
786 ((nBar
== SB_VERT
) && !(wndPtr
->dwStyle
& WS_VSCROLL
)) ||
787 ((nBar
== SB_HORZ
) && !(wndPtr
->dwStyle
& WS_HSCROLL
))) goto END
;
788 if (!WIN_IsWindowDrawable( wndPtr
, FALSE
)) goto END
;
790 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
791 &arrowSize
, &thumbSize
, &thumbPos
);
793 /* do not draw if the scrollbar rectangle is empty */
794 if(IsRectEmpty(&rect
))
797 if (Save_SCROLL_MovingThumb
&&
798 (SCROLL_TrackingWin
== hwnd
) &&
799 (SCROLL_TrackingBar
== nBar
))
800 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
802 /* Draw the arrows */
804 if (arrows
&& arrowSize
)
806 if( vertical
== SCROLL_trackVertical
&& GetCapture() == hwnd
)
807 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
808 (SCROLL_trackHitTest
== SCROLL_TOP_ARROW
),
809 (SCROLL_trackHitTest
== SCROLL_BOTTOM_ARROW
) );
811 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
815 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
816 thumbPos
, infoPtr
->flags
, vertical
, FALSE
, FALSE
);
818 if (Save_SCROLL_MovingThumb
&&
819 (SCROLL_TrackingWin
== hwnd
) &&
820 (SCROLL_TrackingBar
== nBar
))
821 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
823 /* if scroll bar has focus, reposition the caret*/
824 if(hwnd
==GetFocus() && (nBar
==SB_CTL
))
828 SetCaretPos(thumbPos
+1, rect
.top
+1);
832 SetCaretPos(rect
.top
+1, thumbPos
+1);
837 WIN_ReleaseWndPtr(wndPtr
);
841 /***********************************************************************
842 * SCROLL_RefreshScrollBar
844 * Repaint the scroll bar interior after a SetScrollRange() or
845 * SetScrollPos() call.
847 static void SCROLL_RefreshScrollBar( HWND hwnd
, INT nBar
,
848 BOOL arrows
, BOOL interior
)
850 HDC hdc
= GetDCEx( hwnd
, 0,
851 DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
) );
854 SCROLL_DrawScrollBar( hwnd
, hdc
, nBar
, arrows
, interior
);
855 ReleaseDC( hwnd
, hdc
);
859 /***********************************************************************
860 * SCROLL_HandleKbdEvent
862 * Handle a keyboard event (only for SB_CTL scrollbars).
864 static void SCROLL_HandleKbdEvent( HWND hwnd
, WPARAM wParam
)
866 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
871 case VK_PRIOR
: msg
= SB_PAGEUP
; break;
872 case VK_NEXT
: msg
= SB_PAGEDOWN
; break;
873 case VK_HOME
: msg
= SB_TOP
; break;
874 case VK_END
: msg
= SB_BOTTOM
; break;
875 case VK_UP
: msg
= SB_LINEUP
; break;
876 case VK_DOWN
: msg
= SB_LINEDOWN
; break;
878 WIN_ReleaseWndPtr(wndPtr
);
881 SendMessageA( GetParent(hwnd
),
882 (wndPtr
->dwStyle
& SBS_VERT
) ? WM_VSCROLL
: WM_HSCROLL
,
884 WIN_ReleaseWndPtr(wndPtr
);
888 /***********************************************************************
889 * SCROLL_HandleScrollEvent
891 * Handle a mouse or timer event for the scrollbar.
892 * 'pt' is the location of the mouse event in client (for SB_CTL) or
893 * windows coordinates.
895 void SCROLL_HandleScrollEvent( HWND hwnd
, INT nBar
, UINT msg
, POINT pt
)
897 /* Previous mouse position for timer events */
899 /* Thumb position when tracking started. */
900 static UINT trackThumbPos
;
901 /* Position in the scroll-bar of the last button-down event. */
902 static INT lastClickPos
;
903 /* Position in the scroll-bar of the last mouse event. */
904 static INT lastMousePos
;
906 enum SCROLL_HITTEST hittest
;
907 HWND hwndOwner
, hwndCtl
;
909 INT arrowSize
, thumbSize
, thumbPos
;
913 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
);
914 if (!infoPtr
) return;
915 if ((SCROLL_trackHitTest
== SCROLL_NOWHERE
) && (msg
!= WM_LBUTTONDOWN
))
918 hdc
= GetDCEx( hwnd
, 0, DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
));
919 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
920 &arrowSize
, &thumbSize
, &thumbPos
);
921 hwndOwner
= (nBar
== SB_CTL
) ? GetParent(hwnd
) : hwnd
;
922 hwndCtl
= (nBar
== SB_CTL
) ? hwnd
: 0;
926 case WM_LBUTTONDOWN
: /* Initialise mouse tracking */
927 HideCaret(hwnd
); /* hide caret while holding down LBUTTON*/
928 SCROLL_trackVertical
= vertical
;
929 SCROLL_trackHitTest
= hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
930 lastClickPos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
931 lastMousePos
= lastClickPos
;
932 trackThumbPos
= thumbPos
;
935 if (nBar
== SB_CTL
&& (GetWindowLongA(hwnd
, GWL_STYLE
) & WS_TABSTOP
)) SetFocus( hwnd
);
939 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, TRUE
);
944 hittest
= SCROLL_NOWHERE
;
946 /* if scrollbar has focus, show back caret */
947 if (hwnd
==GetFocus()) ShowCaret(hwnd
);
952 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
956 return; /* Should never happen */
959 TRACE("Event: hwnd=%04x bar=%d msg=%x pt=%ld,%ld hit=%d\n",
960 hwnd
, nBar
, msg
, pt
.x
, pt
.y
, hittest
);
962 switch(SCROLL_trackHitTest
)
964 case SCROLL_NOWHERE
: /* No tracking in progress */
967 case SCROLL_TOP_ARROW
:
968 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
969 (hittest
== SCROLL_trackHitTest
), FALSE
);
970 if (hittest
== SCROLL_trackHitTest
)
972 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
974 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
975 SB_LINEUP
, hwndCtl
);
978 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
979 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
982 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
985 case SCROLL_TOP_RECT
:
986 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
987 thumbPos
, infoPtr
->flags
, vertical
,
988 (hittest
== SCROLL_trackHitTest
), FALSE
);
989 if (hittest
== SCROLL_trackHitTest
)
991 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
993 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
994 SB_PAGEUP
, hwndCtl
);
995 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
996 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1000 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1004 if (msg
== WM_LBUTTONDOWN
)
1006 SCROLL_TrackingWin
= hwnd
;
1007 SCROLL_TrackingBar
= nBar
;
1008 SCROLL_TrackingPos
= trackThumbPos
+ lastMousePos
- lastClickPos
;
1009 if (!SCROLL_MovingThumb
)
1010 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
1012 else if (msg
== WM_LBUTTONUP
)
1014 if (SCROLL_MovingThumb
)
1015 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
1016 SCROLL_TrackingWin
= 0;
1017 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
1018 thumbPos
, infoPtr
->flags
, vertical
,
1021 else /* WM_MOUSEMOVE */
1025 if (!SCROLL_PtInRectEx( &rect
, pt
, vertical
)) pos
= lastClickPos
;
1028 pt
= SCROLL_ClipPos( &rect
, pt
);
1029 pos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
1031 if ( (pos
!= lastMousePos
) || (!SCROLL_MovingThumb
) )
1033 if (SCROLL_MovingThumb
)
1034 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
1035 arrowSize
, thumbSize
);
1037 SCROLL_TrackingPos
= trackThumbPos
+ pos
- lastClickPos
;
1038 SCROLL_TrackingVal
= SCROLL_GetThumbVal( infoPtr
, &rect
,
1040 SCROLL_TrackingPos
);
1041 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1042 MAKEWPARAM( SB_THUMBTRACK
, SCROLL_TrackingVal
),
1044 if (!SCROLL_MovingThumb
)
1045 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
1046 arrowSize
, thumbSize
);
1051 case SCROLL_BOTTOM_RECT
:
1052 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
1053 thumbPos
, infoPtr
->flags
, vertical
,
1054 FALSE
, (hittest
== SCROLL_trackHitTest
) );
1055 if (hittest
== SCROLL_trackHitTest
)
1057 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
1059 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1060 SB_PAGEDOWN
, hwndCtl
);
1061 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
1062 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1066 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1069 case SCROLL_BOTTOM_ARROW
:
1070 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
1071 FALSE
, (hittest
== SCROLL_trackHitTest
) );
1072 if (hittest
== SCROLL_trackHitTest
)
1074 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
1076 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1077 SB_LINEDOWN
, hwndCtl
);
1080 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
1081 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1084 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1088 if (msg
== WM_LBUTTONUP
)
1090 hittest
= SCROLL_trackHitTest
;
1091 SCROLL_trackHitTest
= SCROLL_NOWHERE
; /* Terminate tracking */
1093 if (hittest
== SCROLL_THUMB
)
1095 UINT val
= SCROLL_GetThumbVal( infoPtr
, &rect
, vertical
,
1096 trackThumbPos
+ lastMousePos
- lastClickPos
);
1097 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1098 MAKEWPARAM( SB_THUMBPOSITION
, val
), hwndCtl
);
1101 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1102 SB_ENDSCROLL
, hwndCtl
);
1105 ReleaseDC( hwnd
, hdc
);
1109 /***********************************************************************
1112 LRESULT WINAPI
ScrollBarWndProc( HWND hwnd
, UINT message
, WPARAM wParam
,
1119 CREATESTRUCTA
*lpCreat
= (CREATESTRUCTA
*)lParam
;
1120 if (lpCreat
->style
& SBS_SIZEBOX
)
1122 FIXME("Unimplemented style SBS_SIZEBOX.\n" );
1126 if (lpCreat
->style
& SBS_VERT
)
1128 if (lpCreat
->style
& SBS_LEFTALIGN
)
1129 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
1130 GetSystemMetrics(SM_CXVSCROLL
)+1, lpCreat
->cy
, FALSE
);
1131 else if (lpCreat
->style
& SBS_RIGHTALIGN
)
1133 lpCreat
->x
+lpCreat
->cx
-GetSystemMetrics(SM_CXVSCROLL
)-1,
1135 GetSystemMetrics(SM_CXVSCROLL
)+1, lpCreat
->cy
, FALSE
);
1139 if (lpCreat
->style
& SBS_TOPALIGN
)
1140 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
1141 lpCreat
->cx
, GetSystemMetrics(SM_CYHSCROLL
)+1, FALSE
);
1142 else if (lpCreat
->style
& SBS_BOTTOMALIGN
)
1145 lpCreat
->y
+lpCreat
->cy
-GetSystemMetrics(SM_CYHSCROLL
)-1,
1146 lpCreat
->cx
, GetSystemMetrics(SM_CYHSCROLL
)+1, FALSE
);
1149 if (!hUpArrow
) SCROLL_LoadBitmaps();
1150 TRACE("ScrollBar creation, hwnd=%04x\n", hwnd
);
1153 case WM_LBUTTONDOWN
:
1159 pt
.x
= SLOWORD(lParam
);
1160 pt
.y
= SHIWORD(lParam
);
1161 SCROLL_HandleScrollEvent( hwnd
, SB_CTL
, message
, pt
);
1165 /* if key event is received, the scrollbar has the focus*/
1167 /* hide caret on first KEYDOWN to prevent flicker */
1168 if ((lParam
& 0x40000000)==0)
1170 SCROLL_HandleKbdEvent( hwnd
, wParam
);
1179 /* Create a caret when a ScrollBar get focus*/
1181 int arrowSize
, thumbSize
, thumbPos
, vertical
;
1182 vertical
= SCROLL_GetScrollBarRect( hwnd
, SB_CTL
, &rect
,
1183 &arrowSize
, &thumbSize
, &thumbPos
);
1186 CreateCaret(hwnd
,1, thumbSize
-2, rect
.bottom
-rect
.top
-2);
1187 SetCaretPos(thumbPos
+1, rect
.top
+1);
1191 CreateCaret(hwnd
,1, rect
.right
-rect
.left
-2,thumbSize
-2);
1192 SetCaretPos(rect
.top
+1, thumbPos
+1);
1201 int arrowSize
, thumbSize
, thumbPos
, vertical
;
1202 vertical
= SCROLL_GetScrollBarRect( hwnd
, SB_CTL
, &rect
,&arrowSize
, &thumbSize
, &thumbPos
);
1204 rect
.left
=thumbPos
+1;
1205 rect
.right
=rect
.left
+thumbSize
;
1209 rect
.top
=thumbPos
+1;
1210 rect
.bottom
=rect
.top
+thumbSize
;
1213 InvalidateRect(hwnd
,&rect
,0);
1222 return DLGC_WANTARROWS
; /* Windows returns this value */
1227 HDC hdc
= BeginPaint( hwnd
, &ps
);
1228 SCROLL_DrawScrollBar( hwnd
, hdc
, SB_CTL
, TRUE
, TRUE
);
1229 EndPaint( hwnd
, &ps
);
1235 return SetScrollPos( hwnd
, SB_CTL
, wParam
, (BOOL
)lParam
);
1239 return GetScrollPos( hwnd
, SB_CTL
);
1241 case SBM_SETRANGE16
:
1242 SetScrollRange( hwnd
, SB_CTL
, LOWORD(lParam
), HIWORD(lParam
),
1243 wParam
/* FIXME: Is this correct? */ );
1247 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, FALSE
);
1248 return 0; /* FIXME: return previous position */
1250 case SBM_GETRANGE16
:
1251 FIXME("don't know how to handle SBM_GETRANGE16 (wp=%04x,lp=%08lx)\n", wParam
, lParam
);
1255 GetScrollRange( hwnd
, SB_CTL
, (LPINT
)wParam
, (LPINT
)lParam
);
1258 case SBM_ENABLE_ARROWS16
:
1259 case SBM_ENABLE_ARROWS
:
1260 return EnableScrollBar( hwnd
, SB_CTL
, wParam
);
1262 case SBM_SETRANGEREDRAW
:
1263 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, TRUE
);
1264 return 0; /* FIXME: return previous position */
1266 case SBM_SETSCROLLINFO
:
1267 return SetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
, wParam
);
1269 case SBM_GETSCROLLINFO
:
1270 return GetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
);
1280 ERR("unknown Win32 msg %04x wp=%08x lp=%08lx\n",
1281 message
, wParam
, lParam
);
1285 if (message
>= WM_USER
)
1286 WARN("unknown msg %04x wp=%04x lp=%08lx\n",
1287 message
, wParam
, lParam
);
1288 return DefWindowProcA( hwnd
, message
, wParam
, lParam
);
1294 /*************************************************************************
1295 * SetScrollInfo16 (USER.475)
1297 INT16 WINAPI
SetScrollInfo16( HWND16 hwnd
, INT16 nBar
, const SCROLLINFO
*info
,
1300 return (INT16
)SetScrollInfo( hwnd
, nBar
, info
, bRedraw
);
1304 /*************************************************************************
1305 * SetScrollInfo (USER32.501)
1306 * SetScrollInfo can be used to set the position, upper bound,
1307 * lower bound, and page size of a scrollbar control.
1310 * Scrollbar position
1313 * For 100 lines of text to be displayed in a window of 25 lines,
1314 * one would for instance use info->nMin=0, info->nMax=75
1315 * (corresponding to the 76 different positions of the window on
1316 * the text), and info->nPage=25.
1318 INT WINAPI
SetScrollInfo(
1319 HWND hwnd
/* [in] Handle of window whose scrollbar will be affected */,
1320 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */,
1321 const SCROLLINFO
*info
/* [in] Specifies what to change and new values */,
1322 BOOL bRedraw
/* [in] Should scrollbar be redrawn afterwards ? */)
1325 INT retVal
= SCROLL_SetScrollInfo( hwnd
, nBar
, info
, &action
);
1327 if( action
& SA_SSI_HIDE
)
1328 SCROLL_ShowScrollBar( hwnd
, nBar
, FALSE
, FALSE
);
1331 if( action
& SA_SSI_SHOW
)
1332 if( SCROLL_ShowScrollBar( hwnd
, nBar
, TRUE
, TRUE
) )
1333 return retVal
; /* SetWindowPos() already did the painting */
1335 if( bRedraw
&& (action
& SA_SSI_REFRESH
))
1336 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);
1337 else if( action
& SA_SSI_REPAINT_ARROWS
)
1338 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, FALSE
);
1343 INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
1344 const SCROLLINFO
*info
, INT
*action
)
1346 /* Update the scrollbar state and set action flags according to
1347 * what has to be done graphics wise. */
1349 SCROLLBAR_INFO
*infoPtr
;
1351 BOOL bChangeParams
= FALSE
; /* don't show/hide scrollbar if params don't change */
1355 if (!(infoPtr
= SCROLL_GetScrollInfo(hwnd
, nBar
))) return 0;
1356 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return 0;
1357 if ((info
->cbSize
!= sizeof(*info
)) &&
1358 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return 0;
1360 if (TRACE_ON(scroll
))
1362 DPRINTF( "hwnd=%04x bar=%d", hwnd
, nBar
);
1363 if (info
->fMask
& SIF_PAGE
) DPRINTF( " page=%d", info
->nPage
);
1364 if (info
->fMask
& SIF_POS
) DPRINTF( " pos=%d", info
->nPos
);
1365 if (info
->fMask
& SIF_RANGE
) DPRINTF( " min=%d max=%d", info
->nMin
, info
->nMax
);
1369 /* Set the page size */
1371 if (info
->fMask
& SIF_PAGE
)
1373 if( infoPtr
->Page
!= info
->nPage
)
1375 infoPtr
->Page
= info
->nPage
;
1376 *action
|= SA_SSI_REFRESH
;
1377 bChangeParams
= TRUE
;
1381 /* Set the scroll pos */
1383 if (info
->fMask
& SIF_POS
)
1385 if( infoPtr
->CurVal
!= info
->nPos
)
1387 infoPtr
->CurVal
= info
->nPos
;
1388 *action
|= SA_SSI_REFRESH
;
1392 /* Set the scroll range */
1394 if (info
->fMask
& SIF_RANGE
)
1396 /* Invalid range -> range is set to (0,0) */
1397 if ((info
->nMin
> info
->nMax
) ||
1398 ((UINT
)(info
->nMax
- info
->nMin
) >= 0x80000000))
1400 infoPtr
->MinVal
= 0;
1401 infoPtr
->MaxVal
= 0;
1402 bChangeParams
= TRUE
;
1406 if( infoPtr
->MinVal
!= info
->nMin
||
1407 infoPtr
->MaxVal
!= info
->nMax
)
1409 *action
|= SA_SSI_REFRESH
;
1410 infoPtr
->MinVal
= info
->nMin
;
1411 infoPtr
->MaxVal
= info
->nMax
;
1412 bChangeParams
= TRUE
;
1417 /* Make sure the page size is valid */
1419 if (infoPtr
->Page
< 0) infoPtr
->Page
= 0;
1420 else if (infoPtr
->Page
> infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1 )
1421 infoPtr
->Page
= infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1;
1423 /* Make sure the pos is inside the range */
1425 if (infoPtr
->CurVal
< infoPtr
->MinVal
)
1426 infoPtr
->CurVal
= infoPtr
->MinVal
;
1427 else if (infoPtr
->CurVal
> infoPtr
->MaxVal
- max( infoPtr
->Page
-1, 0 ))
1428 infoPtr
->CurVal
= infoPtr
->MaxVal
- max( infoPtr
->Page
-1, 0 );
1430 TRACE(" new values: page=%d pos=%d min=%d max=%d\n",
1431 infoPtr
->Page
, infoPtr
->CurVal
,
1432 infoPtr
->MinVal
, infoPtr
->MaxVal
);
1434 /* don't change the scrollbar state if SetScrollInfo
1435 * is just called with SIF_DISABLENOSCROLL
1437 if(!(info
->fMask
& SIF_ALL
)) goto done
;
1439 /* Check if the scrollbar should be hidden or disabled */
1441 if (info
->fMask
& (SIF_RANGE
| SIF_PAGE
| SIF_DISABLENOSCROLL
))
1443 new_flags
= infoPtr
->flags
;
1444 if (infoPtr
->MinVal
>= infoPtr
->MaxVal
- max( infoPtr
->Page
-1, 0 ))
1446 /* Hide or disable scroll-bar */
1447 if (info
->fMask
& SIF_DISABLENOSCROLL
)
1449 new_flags
= ESB_DISABLE_BOTH
;
1450 *action
|= SA_SSI_REFRESH
;
1452 else if ((nBar
!= SB_CTL
) && bChangeParams
)
1454 *action
= SA_SSI_HIDE
;
1458 else /* Show and enable scroll-bar */
1461 if ((nBar
!= SB_CTL
) && bChangeParams
)
1462 *action
|= SA_SSI_SHOW
;
1465 if (infoPtr
->flags
!= new_flags
) /* check arrow flags */
1467 infoPtr
->flags
= new_flags
;
1468 *action
|= SA_SSI_REPAINT_ARROWS
;
1473 /* Return current position */
1475 return infoPtr
->CurVal
;
1479 /*************************************************************************
1480 * GetScrollInfo16 (USER.476)
1482 BOOL16 WINAPI
GetScrollInfo16( HWND16 hwnd
, INT16 nBar
, LPSCROLLINFO info
)
1484 return GetScrollInfo( hwnd
, nBar
, info
);
1488 /*************************************************************************
1489 * GetScrollInfo (USER32.284)
1490 * GetScrollInfo can be used to retrieve the position, upper bound,
1491 * lower bound, and page size of a scrollbar control.
1495 BOOL WINAPI
GetScrollInfo(
1496 HWND hwnd
/* [in] Handle of window */ ,
1497 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */,
1498 LPSCROLLINFO info
/* [in/out] (info.fMask [in] specifies which values are to retrieve) */)
1500 SCROLLBAR_INFO
*infoPtr
;
1502 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1503 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return FALSE
;
1504 if ((info
->cbSize
!= sizeof(*info
)) &&
1505 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return FALSE
;
1507 if (info
->fMask
& SIF_PAGE
) info
->nPage
= infoPtr
->Page
;
1508 if (info
->fMask
& SIF_POS
) info
->nPos
= infoPtr
->CurVal
;
1509 if ((info
->fMask
& SIF_TRACKPOS
) && (info
->cbSize
== sizeof(*info
)))
1510 info
->nTrackPos
= (SCROLL_TrackingWin
==hwnd
) ? SCROLL_TrackingVal
: infoPtr
->CurVal
;
1511 if (info
->fMask
& SIF_RANGE
)
1513 info
->nMin
= infoPtr
->MinVal
;
1514 info
->nMax
= infoPtr
->MaxVal
;
1516 return (info
->fMask
& SIF_ALL
) != 0;
1520 /*************************************************************************
1521 * SetScrollPos16 (USER.62)
1523 INT16 WINAPI
SetScrollPos16( HWND16 hwnd
, INT16 nBar
, INT16 nPos
,
1526 return (INT16
)SetScrollPos( hwnd
, nBar
, nPos
, bRedraw
);
1530 /*************************************************************************
1531 * SetScrollPos (USER32.502)
1534 * Success: Scrollbar position
1538 * Note the ambiguity when 0 is returned. Use GetLastError
1539 * to make sure there was an error (and to know which one).
1541 INT WINAPI
SetScrollPos(
1542 HWND hwnd
/* [in] Handle of window whose scrollbar will be affected */,
1543 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */,
1544 INT nPos
/* [in] New value */,
1545 BOOL bRedraw
/* [in] Should scrollbar be redrawn afterwards ? */ )
1548 SCROLLBAR_INFO
*infoPtr
;
1551 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1552 oldPos
= infoPtr
->CurVal
;
1553 info
.cbSize
= sizeof(info
);
1555 info
.fMask
= SIF_POS
;
1556 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1561 /*************************************************************************
1562 * GetScrollPos16 (USER.63)
1564 INT16 WINAPI
GetScrollPos16( HWND16 hwnd
, INT16 nBar
)
1566 return (INT16
)GetScrollPos( hwnd
, nBar
);
1570 /*************************************************************************
1571 * GetScrollPos (USER32.285)
1574 * Success: Current position
1578 * Note the ambiguity when 0 is returned. Use GetLastError
1579 * to make sure there was an error (and to know which one).
1581 INT WINAPI
GetScrollPos(
1582 HWND hwnd
, /* [in] Handle of window */
1583 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */)
1585 SCROLLBAR_INFO
*infoPtr
;
1587 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1588 return infoPtr
->CurVal
;
1592 /*************************************************************************
1593 * SetScrollRange16 (USER.64)
1595 void WINAPI
SetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1596 INT16 MinVal
, INT16 MaxVal
, BOOL16 bRedraw
)
1598 /* Invalid range -> range is set to (0,0) */
1599 if ((INT
)MaxVal
- (INT
)MinVal
> 0x7fff) MinVal
= MaxVal
= 0;
1600 SetScrollRange( hwnd
, nBar
, MinVal
, MaxVal
, bRedraw
);
1604 /*************************************************************************
1605 * SetScrollRange (USER32.503)
1609 BOOL WINAPI
SetScrollRange(
1610 HWND hwnd
, /* [in] Handle of window whose scrollbar will be affected */
1611 INT nBar
, /* [in] One of SB_HORZ, SB_VERT, or SB_CTL */
1612 INT MinVal
, /* [in] New minimum value */
1613 INT MaxVal
, /* [in] New maximum value */
1614 BOOL bRedraw
/* [in] Should scrollbar be redrawn afterwards ? */)
1618 info
.cbSize
= sizeof(info
);
1621 info
.fMask
= SIF_RANGE
;
1622 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1627 /*************************************************************************
1628 * SCROLL_SetNCSbState
1630 * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
1632 INT
SCROLL_SetNCSbState(WND
* wndPtr
, int vMin
, int vMax
, int vPos
,
1633 int hMin
, int hMax
, int hPos
)
1636 SCROLLINFO vInfo
, hInfo
;
1638 vInfo
.cbSize
= hInfo
.cbSize
= sizeof(SCROLLINFO
);
1639 vInfo
.nMin
= vMin
; hInfo
.nMin
= hMin
;
1640 vInfo
.nMax
= vMax
; hInfo
.nMax
= hMax
;
1641 vInfo
.nPos
= vPos
; hInfo
.nPos
= hPos
;
1642 vInfo
.fMask
= hInfo
.fMask
= SIF_RANGE
| SIF_POS
;
1644 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_VERT
, &vInfo
, &vA
);
1645 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_HORZ
, &hInfo
, &hA
);
1647 if( !SCROLL_ShowScrollBar( wndPtr
->hwndSelf
, SB_BOTH
,
1648 (hA
& SA_SSI_SHOW
),(vA
& SA_SSI_SHOW
) ) )
1650 /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
1651 if( vA
& SA_SSI_REFRESH
)
1652 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_VERT
, FALSE
, TRUE
);
1654 if( hA
& SA_SSI_REFRESH
)
1655 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_HORZ
, FALSE
, TRUE
);
1661 /*************************************************************************
1662 * GetScrollRange16 (USER.65)
1664 BOOL16 WINAPI
GetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1665 LPINT16 lpMin
, LPINT16 lpMax
)
1668 BOOL16 ret
= GetScrollRange( hwnd
, nBar
, &min
, &max
);
1669 if (lpMin
) *lpMin
= min
;
1670 if (lpMax
) *lpMax
= max
;
1675 /*************************************************************************
1676 * GetScrollRange (USER32.286)
1680 BOOL WINAPI
GetScrollRange(
1681 HWND hwnd
, /* [in] Handle of window */
1682 INT nBar
, /* [in] One of SB_HORZ, SB_VERT, or SB_CTL */
1683 LPINT lpMin
, /* [out] Where to store minimum value */
1684 LPINT lpMax
/* [out] Where to store maximum value */)
1686 SCROLLBAR_INFO
*infoPtr
;
1688 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
)))
1690 if (lpMin
) lpMin
= 0;
1691 if (lpMax
) lpMax
= 0;
1694 if (lpMin
) *lpMin
= infoPtr
->MinVal
;
1695 if (lpMax
) *lpMax
= infoPtr
->MaxVal
;
1700 /*************************************************************************
1701 * SCROLL_ShowScrollBar()
1703 * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
1705 BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
1706 BOOL fShowH
, BOOL fShowV
)
1708 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
1709 BOOL retvalue
= FALSE
;
1711 if (!wndPtr
) return FALSE
;
1712 TRACE("hwnd=%04x bar=%d horz=%d, vert=%d\n",
1713 hwnd
, nBar
, fShowH
, fShowV
);
1718 ShowWindow( hwnd
, fShowH
? SW_SHOW
: SW_HIDE
);
1726 fShowH
= !(wndPtr
->dwStyle
& WS_HSCROLL
);
1727 wndPtr
->dwStyle
|= WS_HSCROLL
;
1731 fShowH
= (wndPtr
->dwStyle
& WS_HSCROLL
);
1732 wndPtr
->dwStyle
&= ~WS_HSCROLL
;
1734 if( nBar
== SB_HORZ
) {
1743 fShowV
= !(wndPtr
->dwStyle
& WS_VSCROLL
);
1744 wndPtr
->dwStyle
|= WS_VSCROLL
;
1748 fShowV
= (wndPtr
->dwStyle
& WS_VSCROLL
);
1749 wndPtr
->dwStyle
&= ~WS_VSCROLL
;
1751 if ( nBar
== SB_VERT
)
1756 retvalue
= FALSE
; /* Nothing to do! */
1760 if( fShowH
|| fShowV
) /* frame has been changed, let the window redraw itself */
1762 SetWindowPos( hwnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
1763 | SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
1768 retvalue
= FALSE
; /* no frame changes */
1770 WIN_ReleaseWndPtr(wndPtr
);
1775 /*************************************************************************
1776 * ShowScrollBar16 (USER.267)
1778 void WINAPI
ShowScrollBar16( HWND16 hwnd
, INT16 nBar
, BOOL16 fShow
)
1780 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1781 (nBar
== SB_HORZ
) ? 0 : fShow
);
1785 /*************************************************************************
1786 * ShowScrollBar (USER32.532)
1790 BOOL WINAPI
ShowScrollBar(
1791 HWND hwnd
, /* [in] Handle of window whose scrollbar(s) will be affected */
1792 INT nBar
, /* [in] One of SB_HORZ, SB_VERT, SB_BOTH or SB_CTL */
1793 BOOL fShow
/* [in] TRUE = show, FALSE = hide */)
1795 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1796 (nBar
== SB_HORZ
) ? 0 : fShow
);
1801 /*************************************************************************
1802 * EnableScrollBar16 (USER.482)
1804 BOOL16 WINAPI
EnableScrollBar16( HWND16 hwnd
, INT16 nBar
, UINT16 flags
)
1806 return EnableScrollBar( hwnd
, nBar
, flags
);
1810 /*************************************************************************
1811 * EnableScrollBar (USER32.171)
1813 BOOL WINAPI
EnableScrollBar( HWND hwnd
, INT nBar
, UINT flags
)
1816 SCROLLBAR_INFO
*infoPtr
;
1818 TRACE("%04x %d %d\n", hwnd
, nBar
, flags
);
1820 flags
&= ESB_DISABLE_BOTH
;
1822 if (nBar
== SB_BOTH
)
1824 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, SB_VERT
))) return FALSE
;
1825 if (!(bFineWithMe
= (infoPtr
->flags
== flags
)) )
1827 infoPtr
->flags
= flags
;
1828 SCROLL_RefreshScrollBar( hwnd
, SB_VERT
, TRUE
, TRUE
);
1835 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1836 if (bFineWithMe
&& infoPtr
->flags
== flags
) return FALSE
;
1837 infoPtr
->flags
= flags
;
1839 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);