4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994, 1996 Alexandre Julliard
9 #include "wine/winuser16.h"
10 #include "sysmetrics.h"
17 static HBITMAP32 hUpArrow
= 0;
18 static HBITMAP32 hDnArrow
= 0;
19 static HBITMAP32 hLfArrow
= 0;
20 static HBITMAP32 hRgArrow
= 0;
21 static HBITMAP32 hUpArrowD
= 0;
22 static HBITMAP32 hDnArrowD
= 0;
23 static HBITMAP32 hLfArrowD
= 0;
24 static HBITMAP32 hRgArrowD
= 0;
25 static HBITMAP32 hUpArrowI
= 0;
26 static HBITMAP32 hDnArrowI
= 0;
27 static HBITMAP32 hLfArrowI
= 0;
28 static HBITMAP32 hRgArrowI
= 0;
30 #define TOP_ARROW(flags,pressed) \
31 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
32 #define BOTTOM_ARROW(flags,pressed) \
33 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
34 #define LEFT_ARROW(flags,pressed) \
35 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
36 #define RIGHT_ARROW(flags,pressed) \
37 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
40 /* Minimum size of the rectangle between the arrows */
41 #define SCROLL_MIN_RECT 4
43 /* Minimum size of the thumb in pixels */
44 #define SCROLL_MIN_THUMB 6
46 /* Overlap between arrows and thumb */
47 #define SCROLL_ARROW_THUMB_OVERLAP 1
49 /* Delay (in ms) before first repetition when holding the button down */
50 #define SCROLL_FIRST_DELAY 200
52 /* Delay (in ms) between scroll repetitions */
53 #define SCROLL_REPEAT_DELAY 50
56 #define SCROLL_TIMER 0
58 /* Scroll-bar hit testing */
61 SCROLL_NOWHERE
, /* Outside the scroll bar */
62 SCROLL_TOP_ARROW
, /* Top or left arrow */
63 SCROLL_TOP_RECT
, /* Rectangle between the top arrow and the thumb */
64 SCROLL_THUMB
, /* Thumb rectangle */
65 SCROLL_BOTTOM_RECT
, /* Rectangle between the thumb and the bottom arrow */
66 SCROLL_BOTTOM_ARROW
/* Bottom or right arrow */
69 /* What to do after SCROLL_SetScrollInfo() */
70 #define SA_SSI_HIDE 0x0001
71 #define SA_SSI_SHOW 0x0002
72 #define SA_SSI_REFRESH 0x0004
73 #define SA_SSI_REPAINT_ARROWS 0x0008
75 /* Thumb-tracking info */
76 static HWND32 SCROLL_TrackingWin
= 0;
77 static INT32 SCROLL_TrackingBar
= 0;
78 static INT32 SCROLL_TrackingPos
= 0;
79 static INT32 SCROLL_TrackingVal
= 0;
80 /* Hit test code of the last button-down event */
81 static enum SCROLL_HITTEST SCROLL_trackHitTest
;
82 static BOOL32 SCROLL_trackVertical
;
84 /* Is the moving thumb being displayed? */
85 static BOOL32 SCROLL_MovingThumb
= FALSE
;
88 static BOOL32
SCROLL_ShowScrollBar( HWND32 hwnd
, INT32 nBar
,
89 BOOL32 fShowH
, BOOL32 fShowV
);
90 static INT32
SCROLL_SetScrollInfo( HWND32 hwnd
, INT32 nBar
,
91 const SCROLLINFO
*info
, INT32
*action
);
93 /***********************************************************************
96 static void SCROLL_LoadBitmaps(void)
98 hUpArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_UPARROW
) );
99 hDnArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_DNARROW
) );
100 hLfArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_LFARROW
) );
101 hRgArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_RGARROW
) );
102 hUpArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_UPARROWD
) );
103 hDnArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_DNARROWD
) );
104 hLfArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_LFARROWD
) );
105 hRgArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_RGARROWD
) );
106 hUpArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_UPARROWI
) );
107 hDnArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_DNARROWI
) );
108 hLfArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_LFARROWI
) );
109 hRgArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_RGARROWI
) );
113 /***********************************************************************
114 * SCROLL_GetPtrScrollInfo
116 static SCROLLBAR_INFO
*SCROLL_GetPtrScrollInfo( WND
* wndPtr
, INT32 nBar
)
118 SCROLLBAR_INFO
*infoPtr
;
120 if (!wndPtr
) return NULL
;
123 case SB_HORZ
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pHScroll
; break;
124 case SB_VERT
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pVScroll
; break;
125 case SB_CTL
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->wExtra
; break;
126 default: return NULL
;
129 if (!infoPtr
) /* Create the info structure if needed */
131 if ((infoPtr
= HeapAlloc( SystemHeap
, 0, sizeof(SCROLLBAR_INFO
) )))
133 infoPtr
->MinVal
= infoPtr
->CurVal
= infoPtr
->Page
= 0;
134 infoPtr
->MaxVal
= 100;
135 infoPtr
->flags
= ESB_ENABLE_BOTH
;
136 if (nBar
== SB_HORZ
) wndPtr
->pHScroll
= infoPtr
;
137 else wndPtr
->pVScroll
= infoPtr
;
139 if (!hUpArrow
) SCROLL_LoadBitmaps();
145 /***********************************************************************
146 * SCROLL_GetScrollInfo
148 static SCROLLBAR_INFO
*SCROLL_GetScrollInfo( HWND32 hwnd
, INT32 nBar
)
150 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
151 return SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
155 /***********************************************************************
156 * SCROLL_GetScrollBarRect
158 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
159 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
160 * 'arrowSize' returns the width or height of an arrow (depending on
161 * the orientation of the scrollbar), 'thumbSize' returns the size of
162 * the thumb, and 'thumbPos' returns the position of the thumb
163 * relative to the left or to the top.
164 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
166 static BOOL32
SCROLL_GetScrollBarRect( HWND32 hwnd
, INT32 nBar
, RECT32
*lprect
,
167 INT32
*arrowSize
, INT32
*thumbSize
,
172 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
177 lprect
->left
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
;
178 lprect
->top
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
179 lprect
->right
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
180 lprect
->bottom
= lprect
->top
+ SYSMETRICS_CYHSCROLL
;
181 if(wndPtr
->dwStyle
& WS_BORDER
) {
184 } else if(wndPtr
->dwStyle
& WS_VSCROLL
)
190 lprect
->left
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
191 lprect
->top
= wndPtr
->rectClient
.top
- wndPtr
->rectWindow
.top
;
192 lprect
->right
= lprect
->left
+ SYSMETRICS_CXVSCROLL
;
193 lprect
->bottom
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
194 if(wndPtr
->dwStyle
& WS_BORDER
) {
197 } else if(wndPtr
->dwStyle
& WS_HSCROLL
)
203 GetClientRect32( hwnd
, lprect
);
204 vertical
= ((wndPtr
->dwStyle
& SBS_VERT
) != 0);
211 if (vertical
) pixels
= lprect
->bottom
- lprect
->top
;
212 else pixels
= lprect
->right
- lprect
->left
;
214 if (pixels
<= 2*SYSMETRICS_CXVSCROLL
+ SCROLL_MIN_RECT
)
216 if (pixels
> SCROLL_MIN_RECT
)
217 *arrowSize
= (pixels
- SCROLL_MIN_RECT
) / 2;
220 *thumbPos
= *thumbSize
= 0;
224 SCROLLBAR_INFO
*info
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
226 *arrowSize
= SYSMETRICS_CXVSCROLL
;
227 pixels
-= (2 * (SYSMETRICS_CXVSCROLL
- SCROLL_ARROW_THUMB_OVERLAP
));
231 *thumbSize
= pixels
* info
->Page
/ (info
->MaxVal
-info
->MinVal
+1);
232 if (*thumbSize
< SCROLL_MIN_THUMB
) *thumbSize
= SCROLL_MIN_THUMB
;
234 else *thumbSize
= SYSMETRICS_CXVSCROLL
;
236 if (((pixels
-= *thumbSize
) < 0) ||
237 ((info
->flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
))
239 /* Rectangle too small or scrollbar disabled -> no thumb */
240 *thumbPos
= *thumbSize
= 0;
244 INT32 max
= info
->MaxVal
- MAX( info
->Page
-1, 0 );
245 if (info
->MinVal
>= max
)
246 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
248 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
249 + pixels
* (info
->CurVal
-info
->MinVal
) / (max
- info
->MinVal
);
256 /***********************************************************************
259 * Compute the current scroll position based on the thumb position in pixels
260 * from the top of the scroll-bar.
262 static UINT32
SCROLL_GetThumbVal( SCROLLBAR_INFO
*infoPtr
, RECT32
*rect
,
263 BOOL32 vertical
, INT32 pos
)
266 INT32 pixels
= vertical
? rect
->bottom
-rect
->top
: rect
->right
-rect
->left
;
268 if ((pixels
-= 2*(SYSMETRICS_CXVSCROLL
- SCROLL_ARROW_THUMB_OVERLAP
)) <= 0)
269 return infoPtr
->MinVal
;
273 thumbSize
= pixels
* infoPtr
->Page
/(infoPtr
->MaxVal
-infoPtr
->MinVal
+1);
274 if (thumbSize
< SCROLL_MIN_THUMB
) thumbSize
= SCROLL_MIN_THUMB
;
276 else thumbSize
= SYSMETRICS_CXVSCROLL
;
278 if ((pixels
-= thumbSize
) <= 0) return infoPtr
->MinVal
;
280 pos
= MAX( 0, pos
- (SYSMETRICS_CXVSCROLL
- SCROLL_ARROW_THUMB_OVERLAP
) );
281 if (pos
> pixels
) pos
= pixels
;
283 if (!infoPtr
->Page
) pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
;
284 else pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
- infoPtr
->Page
+ 1;
285 return infoPtr
->MinVal
+ ((pos
+ pixels
/ 2) / pixels
);
288 /***********************************************************************
291 static BOOL32
SCROLL_PtInRectEx( LPRECT32 lpRect
, POINT32 pt
, BOOL32 vertical
)
293 RECT32 rect
= *lpRect
;
297 rect
.left
-= lpRect
->right
- lpRect
->left
;
298 rect
.right
+= lpRect
->right
- lpRect
->left
;
302 rect
.top
-= lpRect
->bottom
- lpRect
->top
;
303 rect
.bottom
+= lpRect
->bottom
- lpRect
->top
;
305 return PtInRect32( &rect
, pt
);
308 /***********************************************************************
311 static POINT32
SCROLL_ClipPos( LPRECT32 lpRect
, POINT32 pt
)
313 if( pt
.x
< lpRect
->left
)
316 if( pt
.x
> lpRect
->right
)
317 pt
.x
= lpRect
->right
;
319 if( pt
.y
< lpRect
->top
)
322 if( pt
.y
> lpRect
->bottom
)
323 pt
.y
= lpRect
->bottom
;
329 /***********************************************************************
332 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
334 static enum SCROLL_HITTEST
SCROLL_HitTest( HWND32 hwnd
, INT32 nBar
,
335 POINT32 pt
, BOOL32 bDragging
)
337 INT32 arrowSize
, thumbSize
, thumbPos
;
340 BOOL32 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
341 &arrowSize
, &thumbSize
, &thumbPos
);
343 if ( (bDragging
&& !SCROLL_PtInRectEx( &rect
, pt
, vertical
)) ||
344 (!PtInRect32( &rect
, pt
)) ) return SCROLL_NOWHERE
;
348 if (pt
.y
< rect
.top
+ arrowSize
) return SCROLL_TOP_ARROW
;
349 if (pt
.y
>= rect
.bottom
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
350 if (!thumbPos
) return SCROLL_TOP_RECT
;
352 if (pt
.y
< thumbPos
) return SCROLL_TOP_RECT
;
353 if (pt
.y
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
355 else /* horizontal */
357 if (pt
.x
< rect
.left
+ arrowSize
) return SCROLL_TOP_ARROW
;
358 if (pt
.x
>= rect
.right
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
359 if (!thumbPos
) return SCROLL_TOP_RECT
;
361 if (pt
.x
< thumbPos
) return SCROLL_TOP_RECT
;
362 if (pt
.x
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
368 /***********************************************************************
371 * Draw the scroll bar arrows.
373 static void SCROLL_DrawArrows( HDC32 hdc
, SCROLLBAR_INFO
*infoPtr
,
374 RECT32
*rect
, INT32 arrowSize
, BOOL32 vertical
,
375 BOOL32 top_pressed
, BOOL32 bottom_pressed
)
377 HDC32 hdcMem
= CreateCompatibleDC32( hdc
);
378 HBITMAP32 hbmpPrev
= SelectObject32( hdcMem
, vertical
?
379 TOP_ARROW(infoPtr
->flags
, top_pressed
)
380 : LEFT_ARROW(infoPtr
->flags
, top_pressed
));
382 SetStretchBltMode32( hdc
, STRETCH_DELETESCANS
);
383 StretchBlt32( hdc
, rect
->left
, rect
->top
,
384 vertical
? rect
->right
-rect
->left
: arrowSize
,
385 vertical
? arrowSize
: rect
->bottom
-rect
->top
,
387 SYSMETRICS_CXVSCROLL
, SYSMETRICS_CYHSCROLL
,
390 SelectObject32( hdcMem
, vertical
?
391 BOTTOM_ARROW( infoPtr
->flags
, bottom_pressed
)
392 : RIGHT_ARROW( infoPtr
->flags
, bottom_pressed
) );
394 StretchBlt32( hdc
, rect
->left
, rect
->bottom
- arrowSize
,
395 rect
->right
- rect
->left
, arrowSize
,
397 SYSMETRICS_CXVSCROLL
, SYSMETRICS_CYHSCROLL
,
400 StretchBlt32( hdc
, rect
->right
- arrowSize
, rect
->top
,
401 arrowSize
, rect
->bottom
- rect
->top
,
403 SYSMETRICS_CXVSCROLL
, SYSMETRICS_CYHSCROLL
,
405 SelectObject32( hdcMem
, hbmpPrev
);
406 DeleteDC32( hdcMem
);
410 /***********************************************************************
411 * SCROLL_DrawMovingThumb
413 * Draw the moving thumb rectangle.
415 static void SCROLL_DrawMovingThumb( HDC32 hdc
, RECT32
*rect
, BOOL32 vertical
,
416 INT32 arrowSize
, INT32 thumbSize
)
421 r
.top
+= SCROLL_TrackingPos
;
422 if (r
.top
< rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
423 r
.top
= rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
424 if (r
.top
+ thumbSize
>
425 rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
426 r
.top
= rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
428 r
.bottom
= r
.top
+ thumbSize
;
432 r
.left
+= SCROLL_TrackingPos
;
433 if (r
.left
< rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
434 r
.left
= rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
435 if (r
.left
+ thumbSize
>
436 rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
437 r
.left
= rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
439 r
.right
= r
.left
+ thumbSize
;
441 DrawFocusRect32( hdc
, &r
);
442 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
446 /***********************************************************************
447 * SCROLL_DrawInterior
449 * Draw the scroll bar interior (everything except the arrows).
451 static void SCROLL_DrawInterior( HWND32 hwnd
, HDC32 hdc
, INT32 nBar
,
452 RECT32
*rect
, INT32 arrowSize
,
453 INT32 thumbSize
, INT32 thumbPos
,
454 UINT32 flags
, BOOL32 vertical
,
455 BOOL32 top_selected
, BOOL32 bottom_selected
)
459 /* Select the correct brush and pen */
461 SelectObject32( hdc
, GetSysColorPen32(COLOR_WINDOWFRAME
) );
462 if ((flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
)
464 /* This ought to be the color of the parent window */
465 SelectObject32( hdc
, GetSysColorBrush32(COLOR_WINDOW
) );
469 if (nBar
== SB_CTL
) /* Only scrollbar controls send WM_CTLCOLOR */
471 HBRUSH32 hbrush
= SendMessage32A(GetParent32(hwnd
),
472 WM_CTLCOLORSCROLLBAR
, hdc
, hwnd
);
473 SelectObject32( hdc
, hbrush
);
475 else SelectObject32( hdc
, GetSysColorBrush32(COLOR_SCROLLBAR
) );
478 /* Calculate the scroll rectangle */
483 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
484 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
488 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
489 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
492 /* Draw the scroll bar frame */
494 Rectangle32( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
496 /* Draw the scroll rectangles and thumb */
498 if (!thumbPos
) /* No thumb to draw */
500 PatBlt32( hdc
, r
.left
+1, r
.top
+1, r
.right
- r
.left
- 2,
501 r
.bottom
- r
.top
- 2, PATCOPY
);
507 PatBlt32( hdc
, r
.left
+ 1, r
.top
+ 1,
508 r
.right
- r
.left
- 2,
509 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
) - 1,
510 top_selected
? 0x0f0000 : PATCOPY
);
511 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
512 PatBlt32( hdc
, r
.left
+ 1, r
.top
+ thumbSize
,
513 r
.right
- r
.left
- 2,
514 r
.bottom
- r
.top
- thumbSize
- 1,
515 bottom_selected
? 0x0f0000 : PATCOPY
);
516 r
.bottom
= r
.top
+ thumbSize
;
518 else /* horizontal */
520 PatBlt32( hdc
, r
.left
+ 1, r
.top
+ 1,
521 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
) - 1,
522 r
.bottom
- r
.top
- 2,
523 top_selected
? 0x0f0000 : PATCOPY
);
524 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
525 PatBlt32( hdc
, r
.left
+ thumbSize
, r
.top
+ 1,
526 r
.right
- r
.left
- thumbSize
- 1,
527 r
.bottom
- r
.top
- 2,
528 bottom_selected
? 0x0f0000 : PATCOPY
);
529 r
.right
= r
.left
+ thumbSize
;
534 SelectObject32( hdc
, GetSysColorBrush32(COLOR_BTNFACE
) );
535 Rectangle32( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
537 DrawEdge32( hdc
, &r
, EDGE_RAISED
, BF_RECT
);
538 if (SCROLL_MovingThumb
&&
539 (SCROLL_TrackingWin
== hwnd
) &&
540 (SCROLL_TrackingBar
== nBar
))
542 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
543 SCROLL_MovingThumb
= TRUE
;
548 /***********************************************************************
549 * SCROLL_DrawScrollBar
551 * Redraw the whole scrollbar.
553 void SCROLL_DrawScrollBar( HWND32 hwnd
, HDC32 hdc
, INT32 nBar
,
554 BOOL32 arrows
, BOOL32 interior
)
556 INT32 arrowSize
, thumbSize
, thumbPos
;
559 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
560 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
562 if (!wndPtr
|| !infoPtr
||
563 ((nBar
== SB_VERT
) && !(wndPtr
->dwStyle
& WS_VSCROLL
)) ||
564 ((nBar
== SB_HORZ
) && !(wndPtr
->dwStyle
& WS_HSCROLL
))) return;
565 if (!WIN_IsWindowDrawable( wndPtr
, FALSE
)) return;
567 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
568 &arrowSize
, &thumbSize
, &thumbPos
);
570 /* Draw the arrows */
572 if (arrows
&& arrowSize
)
574 if( vertical
== SCROLL_trackVertical
&& GetCapture32() == hwnd
)
575 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
576 (SCROLL_trackHitTest
== SCROLL_TOP_ARROW
),
577 (SCROLL_trackHitTest
== SCROLL_BOTTOM_ARROW
) );
579 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
583 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
584 thumbPos
, infoPtr
->flags
, vertical
, FALSE
, FALSE
);
588 /***********************************************************************
589 * SCROLL_RefreshScrollBar
591 * Repaint the scroll bar interior after a SetScrollRange() or
592 * SetScrollPos() call.
594 static void SCROLL_RefreshScrollBar( HWND32 hwnd
, INT32 nBar
,
595 BOOL32 arrows
, BOOL32 interior
)
597 HDC32 hdc
= GetDCEx32( hwnd
, 0,
598 DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
) );
601 SCROLL_DrawScrollBar( hwnd
, hdc
, nBar
, arrows
, interior
);
602 ReleaseDC32( hwnd
, hdc
);
606 /***********************************************************************
607 * SCROLL_HandleKbdEvent
609 * Handle a keyboard event (only for SB_CTL scrollbars).
611 static void SCROLL_HandleKbdEvent( HWND32 hwnd
, WPARAM32 wParam
)
613 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
618 case VK_PRIOR
: msg
= SB_PAGEUP
; break;
619 case VK_NEXT
: msg
= SB_PAGEDOWN
; break;
620 case VK_HOME
: msg
= SB_TOP
; break;
621 case VK_END
: msg
= SB_BOTTOM
; break;
622 case VK_UP
: msg
= SB_LINEUP
; break;
623 case VK_DOWN
: msg
= SB_LINEDOWN
; break;
627 SendMessage32A( GetParent32(hwnd
),
628 (wndPtr
->dwStyle
& SBS_VERT
) ? WM_VSCROLL
: WM_HSCROLL
,
633 /***********************************************************************
634 * SCROLL_HandleScrollEvent
636 * Handle a mouse or timer event for the scrollbar.
637 * 'pt' is the location of the mouse event in client (for SB_CTL) or
638 * windows coordinates.
640 void SCROLL_HandleScrollEvent( HWND32 hwnd
, INT32 nBar
, UINT32 msg
, POINT32 pt
)
642 /* Previous mouse position for timer events */
643 static POINT32 prevPt
;
644 /* Thumb position when tracking started. */
645 static UINT32 trackThumbPos
;
646 /* Position in the scroll-bar of the last button-down event. */
647 static INT32 lastClickPos
;
648 /* Position in the scroll-bar of the last mouse event. */
649 static INT32 lastMousePos
;
651 enum SCROLL_HITTEST hittest
;
652 HWND32 hwndOwner
, hwndCtl
;
654 INT32 arrowSize
, thumbSize
, thumbPos
;
658 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
);
659 if (!infoPtr
) return;
660 if ((SCROLL_trackHitTest
== SCROLL_NOWHERE
) && (msg
!= WM_LBUTTONDOWN
))
663 hdc
= GetDCEx32( hwnd
, 0, DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
));
664 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
665 &arrowSize
, &thumbSize
, &thumbPos
);
666 hwndOwner
= (nBar
== SB_CTL
) ? GetParent32(hwnd
) : hwnd
;
667 hwndCtl
= (nBar
== SB_CTL
) ? hwnd
: 0;
671 case WM_LBUTTONDOWN
: /* Initialise mouse tracking */
672 SCROLL_trackVertical
= vertical
;
673 SCROLL_trackHitTest
= hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
674 lastClickPos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
675 lastMousePos
= lastClickPos
;
676 trackThumbPos
= thumbPos
;
678 SetCapture32( hwnd
);
679 if (nBar
== SB_CTL
) SetFocus32( hwnd
);
683 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, TRUE
);
688 hittest
= SCROLL_NOWHERE
;
694 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
698 return; /* Should never happen */
701 TRACE(scroll
, "Event: hwnd=%04x bar=%d msg=%x pt=%d,%d hit=%d\n",
702 hwnd
, nBar
, msg
, pt
.x
, pt
.y
, hittest
);
704 switch(SCROLL_trackHitTest
)
706 case SCROLL_NOWHERE
: /* No tracking in progress */
709 case SCROLL_TOP_ARROW
:
710 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
711 (hittest
== SCROLL_trackHitTest
), FALSE
);
712 if (hittest
== SCROLL_trackHitTest
)
714 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
716 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
717 SB_LINEUP
, hwndCtl
);
718 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
719 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
723 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
726 case SCROLL_TOP_RECT
:
727 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
728 thumbPos
, infoPtr
->flags
, vertical
,
729 (hittest
== SCROLL_trackHitTest
), FALSE
);
730 if (hittest
== SCROLL_trackHitTest
)
732 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
734 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
735 SB_PAGEUP
, hwndCtl
);
736 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
737 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
741 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
745 if (msg
== WM_LBUTTONDOWN
)
747 SCROLL_TrackingWin
= hwnd
;
748 SCROLL_TrackingBar
= nBar
;
749 SCROLL_TrackingPos
= trackThumbPos
+ lastMousePos
- lastClickPos
;
750 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
752 else if (msg
== WM_LBUTTONUP
)
754 SCROLL_TrackingWin
= 0;
755 SCROLL_MovingThumb
= FALSE
;
756 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
757 thumbPos
, infoPtr
->flags
, vertical
,
760 else /* WM_MOUSEMOVE */
764 if (!SCROLL_PtInRectEx( &rect
, pt
, vertical
)) pos
= lastClickPos
;
767 pt
= SCROLL_ClipPos( &rect
, pt
);
768 pos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
770 if (pos
!= lastMousePos
)
772 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
773 arrowSize
, thumbSize
);
775 SCROLL_TrackingPos
= trackThumbPos
+ pos
- lastClickPos
;
776 SCROLL_TrackingVal
= SCROLL_GetThumbVal( infoPtr
, &rect
,
778 SCROLL_TrackingPos
);
779 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
780 MAKEWPARAM( SB_THUMBTRACK
, SCROLL_TrackingVal
),
782 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
783 arrowSize
, thumbSize
);
788 case SCROLL_BOTTOM_RECT
:
789 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
790 thumbPos
, infoPtr
->flags
, vertical
,
791 FALSE
, (hittest
== SCROLL_trackHitTest
) );
792 if (hittest
== SCROLL_trackHitTest
)
794 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
796 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
797 SB_PAGEDOWN
, hwndCtl
);
798 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
799 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
803 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
806 case SCROLL_BOTTOM_ARROW
:
807 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
808 FALSE
, (hittest
== SCROLL_trackHitTest
) );
809 if (hittest
== SCROLL_trackHitTest
)
811 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
813 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
814 SB_LINEDOWN
, hwndCtl
);
815 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
816 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
820 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
824 if (msg
== WM_LBUTTONUP
)
826 hittest
= SCROLL_trackHitTest
;
827 SCROLL_trackHitTest
= SCROLL_NOWHERE
; /* Terminate tracking */
829 if (hittest
== SCROLL_THUMB
)
831 UINT32 val
= SCROLL_GetThumbVal( infoPtr
, &rect
, vertical
,
832 trackThumbPos
+ lastMousePos
- lastClickPos
);
833 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
834 MAKEWPARAM( SB_THUMBPOSITION
, val
), hwndCtl
);
837 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
838 SB_ENDSCROLL
, hwndCtl
);
841 ReleaseDC32( hwnd
, hdc
);
845 /***********************************************************************
848 LRESULT WINAPI
ScrollBarWndProc( HWND32 hwnd
, UINT32 message
, WPARAM32 wParam
,
855 CREATESTRUCT32A
*lpCreat
= (CREATESTRUCT32A
*)lParam
;
856 if (lpCreat
->style
& SBS_SIZEBOX
)
858 FIXME(scroll
, "Unimplemented style SBS_SIZEBOX.\n" );
862 if (lpCreat
->style
& SBS_VERT
)
864 if (lpCreat
->style
& SBS_LEFTALIGN
)
865 MoveWindow32( hwnd
, lpCreat
->x
, lpCreat
->y
,
866 SYSMETRICS_CXVSCROLL
+1, lpCreat
->cy
, FALSE
);
867 else if (lpCreat
->style
& SBS_RIGHTALIGN
)
869 lpCreat
->x
+lpCreat
->cx
-SYSMETRICS_CXVSCROLL
-1,
871 SYSMETRICS_CXVSCROLL
+1, lpCreat
->cy
, FALSE
);
875 if (lpCreat
->style
& SBS_TOPALIGN
)
876 MoveWindow32( hwnd
, lpCreat
->x
, lpCreat
->y
,
877 lpCreat
->cx
, SYSMETRICS_CYHSCROLL
+1, FALSE
);
878 else if (lpCreat
->style
& SBS_BOTTOMALIGN
)
881 lpCreat
->y
+lpCreat
->cy
-SYSMETRICS_CYHSCROLL
-1,
882 lpCreat
->cx
, SYSMETRICS_CYHSCROLL
+1, FALSE
);
885 if (!hUpArrow
) SCROLL_LoadBitmaps();
886 TRACE(scroll
, "ScrollBar creation, hwnd=%04x\n", hwnd
);
895 CONV_POINT16TO32( (POINT16
*)&lParam
, &pt
);
896 SCROLL_HandleScrollEvent( hwnd
, SB_CTL
, message
, pt
);
901 SCROLL_HandleKbdEvent( hwnd
, wParam
);
908 return DLGC_WANTARROWS
; /* Windows returns this value */
913 HDC32 hdc
= BeginPaint32( hwnd
, &ps
);
914 SCROLL_DrawScrollBar( hwnd
, hdc
, SB_CTL
, TRUE
, TRUE
);
915 EndPaint32( hwnd
, &ps
);
921 return SetScrollPos32( hwnd
, SB_CTL
, wParam
, (BOOL32
)lParam
);
925 return GetScrollPos32( hwnd
, SB_CTL
);
928 SetScrollRange32( hwnd
, SB_CTL
, LOWORD(lParam
), HIWORD(lParam
),
929 wParam
/* FIXME: Is this correct? */ );
933 SetScrollRange32( hwnd
, SB_CTL
, wParam
, lParam
, FALSE
);
934 return 0; /* FIXME: return previous position */
937 FIXME(scroll
, "don't know how to handle SBM_GETRANGE16 (wp=%04x,lp=%08lx)\n", wParam
, lParam
);
941 GetScrollRange32( hwnd
, SB_CTL
, (LPINT32
)wParam
, (LPINT32
)lParam
);
944 case SBM_ENABLE_ARROWS16
:
945 case SBM_ENABLE_ARROWS32
:
946 return EnableScrollBar32( hwnd
, SB_CTL
, wParam
);
948 case SBM_SETRANGEREDRAW32
:
949 SetScrollRange32( hwnd
, SB_CTL
, wParam
, lParam
, TRUE
);
950 return 0; /* FIXME: return previous position */
952 case SBM_SETSCROLLINFO32
:
953 return SetScrollInfo32( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
, wParam
);
955 case SBM_GETSCROLLINFO32
:
956 return GetScrollInfo32( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
);
966 ERR(scroll
, "unknown Win32 msg %04x wp=%08x lp=%08lx\n",
967 message
, wParam
, lParam
);
971 if (message
>= WM_USER
)
972 WARN(scroll
, "unknown msg %04x wp=%04x lp=%08lx\n",
973 message
, wParam
, lParam
);
974 return DefWindowProc32A( hwnd
, message
, wParam
, lParam
);
980 /*************************************************************************
981 * SetScrollInfo16 (USER.475)
983 INT16 WINAPI
SetScrollInfo16( HWND16 hwnd
, INT16 nBar
, const SCROLLINFO
*info
,
986 return (INT16
)SetScrollInfo32( hwnd
, nBar
, info
, bRedraw
);
990 /*************************************************************************
991 * SetScrollInfo32 (USER32.501)
992 * SetScrollInfo32 can be used to set the position, upper bound,
993 * lower bound, and page size of a scrollbar control.
999 * For 100 lines of text to be displayed in a window of 25 lines,
1000 * one would for instance use info->nMin=0, info->nMax=75
1001 * (corresponding to the 76 different positions of the window on
1002 * the text), and info->nPage=25.
1004 INT32 WINAPI
SetScrollInfo32(
1005 HWND32 hwnd
/* [I] Handle of window whose scrollbar will be affected */,
1006 INT32 nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1007 const SCROLLINFO
*info
/* [I] Specifies what to change and new values */,
1008 BOOL32 bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */)
1011 INT32 retVal
= SCROLL_SetScrollInfo( hwnd
, nBar
, info
, &action
);
1013 if( action
& SA_SSI_HIDE
)
1014 SCROLL_ShowScrollBar( hwnd
, nBar
, FALSE
, FALSE
);
1017 if( action
& SA_SSI_SHOW
)
1018 if( SCROLL_ShowScrollBar( hwnd
, nBar
, TRUE
, TRUE
) )
1019 return retVal
; /* SetWindowPos() already did the painting */
1021 if( bRedraw
&& (action
& SA_SSI_REFRESH
))
1022 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);
1023 else if( action
& SA_SSI_REPAINT_ARROWS
)
1024 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, FALSE
);
1029 INT32
SCROLL_SetScrollInfo( HWND32 hwnd
, INT32 nBar
,
1030 const SCROLLINFO
*info
, INT32
*action
)
1032 /* Update the scrollbar state and set action flags according to
1033 * what has to be done graphics wise. */
1035 SCROLLBAR_INFO
*infoPtr
;
1038 dbg_decl_str(scroll
, 256);
1042 if (!(infoPtr
= SCROLL_GetScrollInfo(hwnd
, nBar
))) return 0;
1043 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return 0;
1044 if ((info
->cbSize
!= sizeof(*info
)) &&
1045 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return 0;
1047 /* Set the page size */
1049 if (info
->fMask
& SIF_PAGE
)
1051 dsprintf(scroll
, " page=%d", info
->nPage
);
1052 if( infoPtr
->Page
!= info
->nPage
)
1054 infoPtr
->Page
= info
->nPage
;
1055 *action
|= SA_SSI_REFRESH
;
1059 /* Set the scroll pos */
1061 if (info
->fMask
& SIF_POS
)
1063 dsprintf(scroll
, " pos=%d", info
->nPos
);
1064 if( infoPtr
->CurVal
!= info
->nPos
)
1066 infoPtr
->CurVal
= info
->nPos
;
1067 *action
|= SA_SSI_REFRESH
;
1071 /* Set the scroll range */
1073 if (info
->fMask
& SIF_RANGE
)
1075 dsprintf(scroll
, " min=%d max=%d", info
->nMin
, info
->nMax
);
1077 /* Invalid range -> range is set to (0,0) */
1078 if ((info
->nMin
> info
->nMax
) ||
1079 ((UINT32
)(info
->nMax
- info
->nMin
) >= 0x80000000))
1081 infoPtr
->MinVal
= 0;
1082 infoPtr
->MaxVal
= 0;
1086 if( infoPtr
->MinVal
!= info
->nMin
||
1087 infoPtr
->MaxVal
!= info
->nMax
)
1089 *action
|= SA_SSI_REFRESH
;
1090 infoPtr
->MinVal
= info
->nMin
;
1091 infoPtr
->MaxVal
= info
->nMax
;
1096 TRACE(scroll
, "hwnd=%04x bar=%d %s\n",
1097 hwnd
, nBar
, dbg_str(scroll
));
1099 /* Make sure the page size is valid */
1101 if (infoPtr
->Page
< 0) infoPtr
->Page
= 0;
1102 else if (infoPtr
->Page
> infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1 )
1103 infoPtr
->Page
= infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1;
1105 /* Make sure the pos is inside the range */
1107 if (infoPtr
->CurVal
< infoPtr
->MinVal
)
1108 infoPtr
->CurVal
= infoPtr
->MinVal
;
1109 else if (infoPtr
->CurVal
> infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
1110 infoPtr
->CurVal
= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 );
1112 TRACE(scroll
, " new values: page=%d pos=%d min=%d max=%d\n",
1113 infoPtr
->Page
, infoPtr
->CurVal
,
1114 infoPtr
->MinVal
, infoPtr
->MaxVal
);
1116 /* Check if the scrollbar should be hidden or disabled */
1118 if (info
->fMask
& (SIF_RANGE
| SIF_PAGE
| SIF_DISABLENOSCROLL
))
1120 new_flags
= infoPtr
->flags
;
1121 if (infoPtr
->MinVal
>= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
1123 /* Hide or disable scroll-bar */
1124 if (info
->fMask
& SIF_DISABLENOSCROLL
)
1126 new_flags
= ESB_DISABLE_BOTH
;
1127 *action
|= SA_SSI_REFRESH
;
1129 else if (nBar
!= SB_CTL
)
1131 *action
= SA_SSI_HIDE
;
1135 else /* Show and enable scroll-bar */
1139 *action
|= SA_SSI_SHOW
;
1142 if (infoPtr
->flags
!= new_flags
) /* check arrow flags */
1144 infoPtr
->flags
= new_flags
;
1145 *action
|= SA_SSI_REPAINT_ARROWS
;
1150 /* Return current position */
1152 return infoPtr
->CurVal
;
1156 /*************************************************************************
1157 * GetScrollInfo16 (USER.476)
1159 BOOL16 WINAPI
GetScrollInfo16( HWND16 hwnd
, INT16 nBar
, LPSCROLLINFO info
)
1161 return GetScrollInfo32( hwnd
, nBar
, info
);
1165 /*************************************************************************
1166 * GetScrollInfo32 (USER32.284)
1167 * GetScrollInfo32 can be used to retrieve the position, upper bound,
1168 * lower bound, and page size of a scrollbar control.
1172 BOOL32 WINAPI
GetScrollInfo32(
1173 HWND32 hwnd
/* [I] Handle of window */ ,
1174 INT32 nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1175 LPSCROLLINFO info
/* [IO] (info.fMask [I] specifies which values are to retrieve) */)
1177 SCROLLBAR_INFO
*infoPtr
;
1179 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1180 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return FALSE
;
1181 if ((info
->cbSize
!= sizeof(*info
)) &&
1182 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return FALSE
;
1184 if (info
->fMask
& SIF_PAGE
) info
->nPage
= infoPtr
->Page
;
1185 if (info
->fMask
& SIF_POS
) info
->nPos
= infoPtr
->CurVal
;
1186 if ((info
->fMask
& SIF_TRACKPOS
) && (info
->cbSize
== sizeof(*info
)))
1187 info
->nTrackPos
= (SCROLL_TrackingWin
==hwnd
) ? SCROLL_TrackingVal
: 0;
1188 if (info
->fMask
& SIF_RANGE
)
1190 info
->nMin
= infoPtr
->MinVal
;
1191 info
->nMax
= infoPtr
->MaxVal
;
1193 return (info
->fMask
& SIF_ALL
) != 0;
1197 /*************************************************************************
1198 * SetScrollPos16 (USER.62)
1200 INT16 WINAPI
SetScrollPos16( HWND16 hwnd
, INT16 nBar
, INT16 nPos
,
1203 return (INT16
)SetScrollPos32( hwnd
, nBar
, nPos
, bRedraw
);
1207 /*************************************************************************
1208 * SetScrollPos32 (USER32.502)
1211 * Success: Scrollbar position
1215 * Note the ambiguity when 0 is returned. Use GetLastError
1216 * to make sure there was an error (and to know which one).
1218 INT32 WINAPI
SetScrollPos32(
1219 HWND32 hwnd
/* [I] Handle of window whose scrollbar will be affected */,
1220 INT32 nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1221 INT32 nPos
/* [I] New value */,
1222 BOOL32 bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */ )
1225 SCROLLBAR_INFO
*infoPtr
;
1228 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1229 oldPos
= infoPtr
->CurVal
;
1230 info
.cbSize
= sizeof(info
);
1232 info
.fMask
= SIF_POS
;
1233 SetScrollInfo32( hwnd
, nBar
, &info
, bRedraw
);
1238 /*************************************************************************
1239 * GetScrollPos16 (USER.63)
1241 INT16 WINAPI
GetScrollPos16( HWND16 hwnd
, INT16 nBar
)
1243 return (INT16
)GetScrollPos32( hwnd
, nBar
);
1247 /*************************************************************************
1248 * GetScrollPos32 (USER32.285)
1251 * Success: Current position
1255 * Note the ambiguity when 0 is returned. Use GetLastError
1256 * to make sure there was an error (and to know which one).
1258 INT32 WINAPI
GetScrollPos32(
1259 HWND32 hwnd
, /* [I] Handle of window */
1260 INT32 nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */)
1262 SCROLLBAR_INFO
*infoPtr
;
1264 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1265 return infoPtr
->CurVal
;
1269 /*************************************************************************
1270 * SetScrollRange16 (USER.64)
1272 void WINAPI
SetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1273 INT16 MinVal
, INT16 MaxVal
, BOOL16 bRedraw
)
1275 /* Invalid range -> range is set to (0,0) */
1276 if ((INT32
)MaxVal
- (INT32
)MinVal
> 0x7fff) MinVal
= MaxVal
= 0;
1277 SetScrollRange32( hwnd
, nBar
, MinVal
, MaxVal
, bRedraw
);
1281 /*************************************************************************
1282 * SetScrollRange32 (USER32.503)
1286 BOOL32 WINAPI
SetScrollRange32(
1287 HWND32 hwnd
, /* [I] Handle of window whose scrollbar will be affected */
1288 INT32 nBar
, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1289 INT32 MinVal
, /* [I] New minimum value */
1290 INT32 MaxVal
, /* [I] New maximum value */
1291 BOOL32 bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */)
1295 info
.cbSize
= sizeof(info
);
1298 info
.fMask
= SIF_RANGE
;
1299 SetScrollInfo32( hwnd
, nBar
, &info
, bRedraw
);
1304 /*************************************************************************
1305 * SCROLL_SetNCSbState
1307 * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
1309 INT32
SCROLL_SetNCSbState(WND
* wndPtr
, int vMin
, int vMax
, int vPos
,
1310 int hMin
, int hMax
, int hPos
)
1313 SCROLLINFO vInfo
, hInfo
;
1315 vInfo
.cbSize
= hInfo
.cbSize
= sizeof(SCROLLINFO
);
1316 vInfo
.nMin
= vMin
; hInfo
.nMin
= hMin
;
1317 vInfo
.nMax
= vMax
; hInfo
.nMax
= hMax
;
1318 vInfo
.nPos
= vPos
; hInfo
.nPos
= hPos
;
1319 vInfo
.fMask
= hInfo
.fMask
= SIF_RANGE
| SIF_POS
;
1321 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_VERT
, &vInfo
, &vA
);
1322 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_HORZ
, &hInfo
, &hA
);
1324 if( !SCROLL_ShowScrollBar( wndPtr
->hwndSelf
, SB_BOTH
,
1325 (hA
& SA_SSI_SHOW
),(vA
& SA_SSI_SHOW
) ) )
1327 /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
1328 if( vA
& SA_SSI_REFRESH
)
1329 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_VERT
, FALSE
, TRUE
);
1331 if( hA
& SA_SSI_REFRESH
)
1332 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_HORZ
, FALSE
, TRUE
);
1338 /*************************************************************************
1339 * GetScrollRange16 (USER.65)
1341 BOOL16 WINAPI
GetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1342 LPINT16 lpMin
, LPINT16 lpMax
)
1345 BOOL16 ret
= GetScrollRange32( hwnd
, nBar
, &min
, &max
);
1346 if (lpMin
) *lpMin
= min
;
1347 if (lpMax
) *lpMax
= max
;
1352 /*************************************************************************
1353 * GetScrollRange32 (USER32.286)
1357 BOOL32 WINAPI
GetScrollRange32(
1358 HWND32 hwnd
, /* [I] Handle of window */
1359 INT32 nBar
, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1360 LPINT32 lpMin
, /* [O] Where to store minimum value */
1361 LPINT32 lpMax
/* [O] Where to store maximum value */)
1363 SCROLLBAR_INFO
*infoPtr
;
1365 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
)))
1367 if (lpMin
) lpMin
= 0;
1368 if (lpMax
) lpMax
= 0;
1371 if (lpMin
) *lpMin
= infoPtr
->MinVal
;
1372 if (lpMax
) *lpMax
= infoPtr
->MaxVal
;
1377 /*************************************************************************
1378 * SCROLL_ShowScrollBar()
1380 * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
1381 * NOTE: fShowV/fShowH must be zero when nBar is SB_HORZ/SB_VERT.
1383 BOOL32
SCROLL_ShowScrollBar( HWND32 hwnd
, INT32 nBar
,
1384 BOOL32 fShowH
, BOOL32 fShowV
)
1386 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
1388 if (!wndPtr
) return FALSE
;
1389 TRACE(scroll
, "hwnd=%04x bar=%d horz=%d, vert=%d\n",
1390 hwnd
, nBar
, fShowH
, fShowV
);
1395 ShowWindow32( hwnd
, fShowH
? SW_SHOW
: SW_HIDE
);
1402 fShowH
= !(wndPtr
->dwStyle
& WS_HSCROLL
);
1403 wndPtr
->dwStyle
|= WS_HSCROLL
;
1407 fShowH
= (wndPtr
->dwStyle
& WS_HSCROLL
);
1408 wndPtr
->dwStyle
&= ~WS_HSCROLL
;
1410 if( nBar
== SB_HORZ
) break;
1416 fShowV
= !(wndPtr
->dwStyle
& WS_VSCROLL
);
1417 wndPtr
->dwStyle
|= WS_VSCROLL
;
1421 fShowV
= (wndPtr
->dwStyle
& WS_VSCROLL
);
1422 wndPtr
->dwStyle
&= ~WS_VSCROLL
;
1427 return FALSE
; /* Nothing to do! */
1430 if( fShowH
|| fShowV
) /* frame has been changed, let the window redraw itself */
1432 SetWindowPos32( hwnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
1433 | SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
1437 return FALSE
; /* no frame changes */
1441 /*************************************************************************
1442 * ShowScrollBar16 (USER.267)
1444 void WINAPI
ShowScrollBar16( HWND16 hwnd
, INT16 nBar
, BOOL16 fShow
)
1446 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1447 (nBar
== SB_HORZ
) ? 0 : fShow
);
1451 /*************************************************************************
1452 * ShowScrollBar32 (USER32.532)
1456 BOOL32 WINAPI
ShowScrollBar32(
1457 HWND32 hwnd
, /* [I] Handle of window whose scrollbar(s) will be affected */
1458 INT32 nBar
, /* [I] One of SB_HORZ, SB_VERT, SB_BOTH or SB_CTL */
1459 BOOL32 fShow
/* [I] TRUE = show, FALSE = hide */)
1461 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1462 (nBar
== SB_HORZ
) ? 0 : fShow
);
1467 /*************************************************************************
1468 * EnableScrollBar16 (USER.482)
1470 BOOL16 WINAPI
EnableScrollBar16( HWND16 hwnd
, INT16 nBar
, UINT16 flags
)
1472 return EnableScrollBar32( hwnd
, nBar
, flags
);
1476 /*************************************************************************
1477 * EnableScrollBar32 (USER32.171)
1479 BOOL32 WINAPI
EnableScrollBar32( HWND32 hwnd
, INT32 nBar
, UINT32 flags
)
1482 SCROLLBAR_INFO
*infoPtr
;
1484 TRACE(scroll
, "%04x %d %d\n", hwnd
, nBar
, flags
);
1486 flags
&= ESB_DISABLE_BOTH
;
1488 if (nBar
== SB_BOTH
)
1490 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, SB_VERT
))) return FALSE
;
1491 if (!(bFineWithMe
= (infoPtr
->flags
== flags
)) )
1493 infoPtr
->flags
= flags
;
1494 SCROLL_RefreshScrollBar( hwnd
, SB_VERT
, TRUE
, TRUE
);
1501 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1502 if (bFineWithMe
&& infoPtr
->flags
== flags
) return FALSE
;
1503 infoPtr
->flags
= flags
;
1505 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);