4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994, 1996 Alexandre Julliard
8 #include "wine/winuser16.h"
9 #include "sysmetrics.h"
16 static HBITMAP hUpArrow
= 0;
17 static HBITMAP hDnArrow
= 0;
18 static HBITMAP hLfArrow
= 0;
19 static HBITMAP hRgArrow
= 0;
20 static HBITMAP hUpArrowD
= 0;
21 static HBITMAP hDnArrowD
= 0;
22 static HBITMAP hLfArrowD
= 0;
23 static HBITMAP hRgArrowD
= 0;
24 static HBITMAP hUpArrowI
= 0;
25 static HBITMAP hDnArrowI
= 0;
26 static HBITMAP hLfArrowI
= 0;
27 static HBITMAP hRgArrowI
= 0;
29 #define TOP_ARROW(flags,pressed) \
30 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
31 #define BOTTOM_ARROW(flags,pressed) \
32 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
33 #define LEFT_ARROW(flags,pressed) \
34 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
35 #define RIGHT_ARROW(flags,pressed) \
36 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
39 /* Minimum size of the rectangle between the arrows */
40 #define SCROLL_MIN_RECT 4
42 /* Minimum size of the thumb in pixels */
43 #define SCROLL_MIN_THUMB 6
45 /* Overlap between arrows and thumb */
46 #define SCROLL_ARROW_THUMB_OVERLAP 1
48 /* Delay (in ms) before first repetition when holding the button down */
49 #define SCROLL_FIRST_DELAY 200
51 /* Delay (in ms) between scroll repetitions */
52 #define SCROLL_REPEAT_DELAY 50
55 #define SCROLL_TIMER 0
57 /* Scroll-bar hit testing */
60 SCROLL_NOWHERE
, /* Outside the scroll bar */
61 SCROLL_TOP_ARROW
, /* Top or left arrow */
62 SCROLL_TOP_RECT
, /* Rectangle between the top arrow and the thumb */
63 SCROLL_THUMB
, /* Thumb rectangle */
64 SCROLL_BOTTOM_RECT
, /* Rectangle between the thumb and the bottom arrow */
65 SCROLL_BOTTOM_ARROW
/* Bottom or right arrow */
68 /* What to do after SCROLL_SetScrollInfo() */
69 #define SA_SSI_HIDE 0x0001
70 #define SA_SSI_SHOW 0x0002
71 #define SA_SSI_REFRESH 0x0004
72 #define SA_SSI_REPAINT_ARROWS 0x0008
74 /* Thumb-tracking info */
75 static HWND SCROLL_TrackingWin
= 0;
76 static INT SCROLL_TrackingBar
= 0;
77 static INT SCROLL_TrackingPos
= 0;
78 static INT SCROLL_TrackingVal
= 0;
79 /* Hit test code of the last button-down event */
80 static enum SCROLL_HITTEST SCROLL_trackHitTest
;
81 static BOOL SCROLL_trackVertical
;
83 /* Is the moving thumb being displayed? */
84 static BOOL SCROLL_MovingThumb
= FALSE
;
87 static BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
88 BOOL fShowH
, BOOL fShowV
);
89 static INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
90 const SCROLLINFO
*info
, INT
*action
);
92 /***********************************************************************
95 static void SCROLL_LoadBitmaps(void)
97 hUpArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROW
) );
98 hDnArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROW
) );
99 hLfArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROW
) );
100 hRgArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROW
) );
101 hUpArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWD
) );
102 hDnArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWD
) );
103 hLfArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWD
) );
104 hRgArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWD
) );
105 hUpArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWI
) );
106 hDnArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWI
) );
107 hLfArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWI
) );
108 hRgArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWI
) );
112 /***********************************************************************
113 * SCROLL_GetPtrScrollInfo
115 static SCROLLBAR_INFO
*SCROLL_GetPtrScrollInfo( WND
* wndPtr
, INT nBar
)
117 SCROLLBAR_INFO
*infoPtr
;
119 if (!wndPtr
) return NULL
;
122 case SB_HORZ
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pHScroll
; break;
123 case SB_VERT
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pVScroll
; break;
124 case SB_CTL
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->wExtra
; break;
125 default: return NULL
;
128 if (!infoPtr
) /* Create the info structure if needed */
130 if ((infoPtr
= HeapAlloc( SystemHeap
, 0, sizeof(SCROLLBAR_INFO
) )))
132 infoPtr
->MinVal
= infoPtr
->CurVal
= infoPtr
->Page
= 0;
133 infoPtr
->MaxVal
= 100;
134 infoPtr
->flags
= ESB_ENABLE_BOTH
;
135 if (nBar
== SB_HORZ
) wndPtr
->pHScroll
= infoPtr
;
136 else wndPtr
->pVScroll
= infoPtr
;
138 if (!hUpArrow
) SCROLL_LoadBitmaps();
144 /***********************************************************************
145 * SCROLL_GetScrollInfo
147 static SCROLLBAR_INFO
*SCROLL_GetScrollInfo( HWND hwnd
, INT nBar
)
149 SCROLLBAR_INFO
*retvalue
;
150 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
151 retvalue
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
152 WIN_ReleaseWndPtr(wndPtr
);
157 /***********************************************************************
158 * SCROLL_GetScrollBarRect
160 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
161 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
162 * 'arrowSize' returns the width or height of an arrow (depending on
163 * the orientation of the scrollbar), 'thumbSize' returns the size of
164 * the thumb, and 'thumbPos' returns the position of the thumb
165 * relative to the left or to the top.
166 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
168 static BOOL
SCROLL_GetScrollBarRect( HWND hwnd
, INT nBar
, RECT
*lprect
,
169 INT
*arrowSize
, INT
*thumbSize
,
174 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
179 lprect
->left
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
;
180 lprect
->top
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
181 lprect
->right
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
182 lprect
->bottom
= lprect
->top
+ SYSMETRICS_CYHSCROLL
;
183 if(wndPtr
->dwStyle
& WS_BORDER
) {
186 } else if(wndPtr
->dwStyle
& WS_VSCROLL
)
192 lprect
->left
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
193 lprect
->top
= wndPtr
->rectClient
.top
- wndPtr
->rectWindow
.top
;
194 lprect
->right
= lprect
->left
+ SYSMETRICS_CXVSCROLL
;
195 lprect
->bottom
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
196 if(wndPtr
->dwStyle
& WS_BORDER
) {
199 } else if(wndPtr
->dwStyle
& WS_HSCROLL
)
205 GetClientRect( hwnd
, lprect
);
206 vertical
= ((wndPtr
->dwStyle
& SBS_VERT
) != 0);
210 WIN_ReleaseWndPtr(wndPtr
);
214 if (vertical
) pixels
= lprect
->bottom
- lprect
->top
;
215 else pixels
= lprect
->right
- lprect
->left
;
217 if (pixels
<= 2*SYSMETRICS_CXVSCROLL
+ SCROLL_MIN_RECT
)
219 if (pixels
> SCROLL_MIN_RECT
)
220 *arrowSize
= (pixels
- SCROLL_MIN_RECT
) / 2;
223 *thumbPos
= *thumbSize
= 0;
227 SCROLLBAR_INFO
*info
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
229 *arrowSize
= SYSMETRICS_CXVSCROLL
;
230 pixels
-= (2 * (SYSMETRICS_CXVSCROLL
- SCROLL_ARROW_THUMB_OVERLAP
));
234 *thumbSize
= pixels
* info
->Page
/ (info
->MaxVal
-info
->MinVal
+1);
235 if (*thumbSize
< SCROLL_MIN_THUMB
) *thumbSize
= SCROLL_MIN_THUMB
;
237 else *thumbSize
= SYSMETRICS_CXVSCROLL
;
239 if (((pixels
-= *thumbSize
) < 0) ||
240 ((info
->flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
))
242 /* Rectangle too small or scrollbar disabled -> no thumb */
243 *thumbPos
= *thumbSize
= 0;
247 INT max
= info
->MaxVal
- MAX( info
->Page
-1, 0 );
248 if (info
->MinVal
>= max
)
249 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
251 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
252 + pixels
* (info
->CurVal
-info
->MinVal
) / (max
- info
->MinVal
);
255 WIN_ReleaseWndPtr(wndPtr
);
260 /***********************************************************************
263 * Compute the current scroll position based on the thumb position in pixels
264 * from the top of the scroll-bar.
266 static UINT
SCROLL_GetThumbVal( SCROLLBAR_INFO
*infoPtr
, RECT
*rect
,
267 BOOL vertical
, INT pos
)
270 INT pixels
= vertical
? rect
->bottom
-rect
->top
: rect
->right
-rect
->left
;
272 if ((pixels
-= 2*(SYSMETRICS_CXVSCROLL
- SCROLL_ARROW_THUMB_OVERLAP
)) <= 0)
273 return infoPtr
->MinVal
;
277 thumbSize
= pixels
* infoPtr
->Page
/(infoPtr
->MaxVal
-infoPtr
->MinVal
+1);
278 if (thumbSize
< SCROLL_MIN_THUMB
) thumbSize
= SCROLL_MIN_THUMB
;
280 else thumbSize
= SYSMETRICS_CXVSCROLL
;
282 if ((pixels
-= thumbSize
) <= 0) return infoPtr
->MinVal
;
284 pos
= MAX( 0, pos
- (SYSMETRICS_CXVSCROLL
- SCROLL_ARROW_THUMB_OVERLAP
) );
285 if (pos
> pixels
) pos
= pixels
;
287 if (!infoPtr
->Page
) pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
;
288 else pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
- infoPtr
->Page
+ 1;
289 return infoPtr
->MinVal
+ ((pos
+ pixels
/ 2) / pixels
);
292 /***********************************************************************
295 static BOOL
SCROLL_PtInRectEx( LPRECT lpRect
, POINT pt
, BOOL vertical
)
301 rect
.left
-= lpRect
->right
- lpRect
->left
;
302 rect
.right
+= lpRect
->right
- lpRect
->left
;
306 rect
.top
-= lpRect
->bottom
- lpRect
->top
;
307 rect
.bottom
+= lpRect
->bottom
- lpRect
->top
;
309 return PtInRect( &rect
, pt
);
312 /***********************************************************************
315 static POINT
SCROLL_ClipPos( LPRECT lpRect
, POINT pt
)
317 if( pt
.x
< lpRect
->left
)
320 if( pt
.x
> lpRect
->right
)
321 pt
.x
= lpRect
->right
;
323 if( pt
.y
< lpRect
->top
)
326 if( pt
.y
> lpRect
->bottom
)
327 pt
.y
= lpRect
->bottom
;
333 /***********************************************************************
336 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
338 static enum SCROLL_HITTEST
SCROLL_HitTest( HWND hwnd
, INT nBar
,
339 POINT pt
, BOOL bDragging
)
341 INT arrowSize
, thumbSize
, thumbPos
;
344 BOOL vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
345 &arrowSize
, &thumbSize
, &thumbPos
);
347 if ( (bDragging
&& !SCROLL_PtInRectEx( &rect
, pt
, vertical
)) ||
348 (!PtInRect( &rect
, pt
)) ) return SCROLL_NOWHERE
;
352 if (pt
.y
< rect
.top
+ arrowSize
) return SCROLL_TOP_ARROW
;
353 if (pt
.y
>= rect
.bottom
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
354 if (!thumbPos
) return SCROLL_TOP_RECT
;
356 if (pt
.y
< thumbPos
) return SCROLL_TOP_RECT
;
357 if (pt
.y
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
359 else /* horizontal */
361 if (pt
.x
< rect
.left
+ arrowSize
) return SCROLL_TOP_ARROW
;
362 if (pt
.x
>= rect
.right
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
363 if (!thumbPos
) return SCROLL_TOP_RECT
;
365 if (pt
.x
< thumbPos
) return SCROLL_TOP_RECT
;
366 if (pt
.x
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
372 /***********************************************************************
375 * Draw the scroll bar arrows.
377 static void SCROLL_DrawArrows( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
378 RECT
*rect
, INT arrowSize
, BOOL vertical
,
379 BOOL top_pressed
, BOOL bottom_pressed
)
381 HDC hdcMem
= CreateCompatibleDC( hdc
);
382 HBITMAP hbmpPrev
= SelectObject( hdcMem
, vertical
?
383 TOP_ARROW(infoPtr
->flags
, top_pressed
)
384 : LEFT_ARROW(infoPtr
->flags
, top_pressed
));
386 SetStretchBltMode( hdc
, STRETCH_DELETESCANS
);
387 StretchBlt( hdc
, rect
->left
, rect
->top
,
388 vertical
? rect
->right
-rect
->left
: arrowSize
,
389 vertical
? arrowSize
: rect
->bottom
-rect
->top
,
391 SYSMETRICS_CXVSCROLL
, SYSMETRICS_CYHSCROLL
,
394 SelectObject( hdcMem
, vertical
?
395 BOTTOM_ARROW( infoPtr
->flags
, bottom_pressed
)
396 : RIGHT_ARROW( infoPtr
->flags
, bottom_pressed
) );
398 StretchBlt( hdc
, rect
->left
, rect
->bottom
- arrowSize
,
399 rect
->right
- rect
->left
, arrowSize
,
401 SYSMETRICS_CXVSCROLL
, SYSMETRICS_CYHSCROLL
,
404 StretchBlt( hdc
, rect
->right
- arrowSize
, rect
->top
,
405 arrowSize
, rect
->bottom
- rect
->top
,
407 SYSMETRICS_CXVSCROLL
, SYSMETRICS_CYHSCROLL
,
409 SelectObject( hdcMem
, hbmpPrev
);
414 /***********************************************************************
415 * SCROLL_DrawMovingThumb
417 * Draw the moving thumb rectangle.
419 static void SCROLL_DrawMovingThumb( HDC hdc
, RECT
*rect
, BOOL vertical
,
420 INT arrowSize
, INT thumbSize
)
425 r
.top
+= SCROLL_TrackingPos
;
426 if (r
.top
< rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
427 r
.top
= rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
428 if (r
.top
+ thumbSize
>
429 rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
430 r
.top
= rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
432 r
.bottom
= r
.top
+ thumbSize
;
436 r
.left
+= SCROLL_TrackingPos
;
437 if (r
.left
< rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
438 r
.left
= rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
439 if (r
.left
+ thumbSize
>
440 rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
441 r
.left
= rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
443 r
.right
= r
.left
+ thumbSize
;
445 DrawFocusRect( hdc
, &r
);
446 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
450 /***********************************************************************
451 * SCROLL_DrawInterior
453 * Draw the scroll bar interior (everything except the arrows).
455 static void SCROLL_DrawInterior( HWND hwnd
, HDC hdc
, INT nBar
,
456 RECT
*rect
, INT arrowSize
,
457 INT thumbSize
, INT thumbPos
,
458 UINT flags
, BOOL vertical
,
459 BOOL top_selected
, BOOL bottom_selected
)
463 /* Select the correct brush and pen */
465 SelectObject( hdc
, GetSysColorPen(COLOR_WINDOWFRAME
) );
466 if ((flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
)
468 /* This ought to be the color of the parent window */
469 SelectObject( hdc
, GetSysColorBrush(COLOR_WINDOW
) );
473 if (nBar
== SB_CTL
) /* Only scrollbar controls send WM_CTLCOLOR */
475 HBRUSH hbrush
= SendMessageA(GetParent(hwnd
),
476 WM_CTLCOLORSCROLLBAR
, hdc
, hwnd
);
477 SelectObject( hdc
, hbrush
);
479 else SelectObject( hdc
, GetSysColorBrush(COLOR_SCROLLBAR
) );
482 /* Calculate the scroll rectangle */
487 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
488 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
492 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
493 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
496 /* Draw the scroll bar frame */
498 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
500 /* Draw the scroll rectangles and thumb */
502 if (!thumbPos
) /* No thumb to draw */
504 PatBlt( hdc
, r
.left
+1, r
.top
+1, r
.right
- r
.left
- 2,
505 r
.bottom
- r
.top
- 2, PATCOPY
);
511 PatBlt( hdc
, r
.left
+ 1, r
.top
+ 1,
512 r
.right
- r
.left
- 2,
513 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
) - 1,
514 top_selected
? 0x0f0000 : PATCOPY
);
515 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
516 PatBlt( hdc
, r
.left
+ 1, r
.top
+ thumbSize
,
517 r
.right
- r
.left
- 2,
518 r
.bottom
- r
.top
- thumbSize
- 1,
519 bottom_selected
? 0x0f0000 : PATCOPY
);
520 r
.bottom
= r
.top
+ thumbSize
;
522 else /* horizontal */
524 PatBlt( hdc
, r
.left
+ 1, r
.top
+ 1,
525 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
) - 1,
526 r
.bottom
- r
.top
- 2,
527 top_selected
? 0x0f0000 : PATCOPY
);
528 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
529 PatBlt( hdc
, r
.left
+ thumbSize
, r
.top
+ 1,
530 r
.right
- r
.left
- thumbSize
- 1,
531 r
.bottom
- r
.top
- 2,
532 bottom_selected
? 0x0f0000 : PATCOPY
);
533 r
.right
= r
.left
+ thumbSize
;
538 SelectObject( hdc
, GetSysColorBrush(COLOR_BTNFACE
) );
539 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
541 DrawEdge( hdc
, &r
, EDGE_RAISED
, BF_RECT
);
542 if (SCROLL_MovingThumb
&&
543 (SCROLL_TrackingWin
== hwnd
) &&
544 (SCROLL_TrackingBar
== nBar
))
546 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
547 SCROLL_MovingThumb
= TRUE
;
552 /***********************************************************************
553 * SCROLL_DrawScrollBar
555 * Redraw the whole scrollbar.
557 void SCROLL_DrawScrollBar( HWND hwnd
, HDC hdc
, INT nBar
,
558 BOOL arrows
, BOOL interior
)
560 INT arrowSize
, thumbSize
, thumbPos
;
563 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
564 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
566 if (!wndPtr
|| !infoPtr
||
567 ((nBar
== SB_VERT
) && !(wndPtr
->dwStyle
& WS_VSCROLL
)) ||
568 ((nBar
== SB_HORZ
) && !(wndPtr
->dwStyle
& WS_HSCROLL
))) goto END
;
569 if (!WIN_IsWindowDrawable( wndPtr
, FALSE
)) goto END
;
571 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
572 &arrowSize
, &thumbSize
, &thumbPos
);
574 /* Draw the arrows */
576 if (arrows
&& arrowSize
)
578 if( vertical
== SCROLL_trackVertical
&& GetCapture() == hwnd
)
579 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
580 (SCROLL_trackHitTest
== SCROLL_TOP_ARROW
),
581 (SCROLL_trackHitTest
== SCROLL_BOTTOM_ARROW
) );
583 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
587 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
588 thumbPos
, infoPtr
->flags
, vertical
, FALSE
, FALSE
);
590 WIN_ReleaseWndPtr(wndPtr
);
594 /***********************************************************************
595 * SCROLL_RefreshScrollBar
597 * Repaint the scroll bar interior after a SetScrollRange() or
598 * SetScrollPos() call.
600 static void SCROLL_RefreshScrollBar( HWND hwnd
, INT nBar
,
601 BOOL arrows
, BOOL interior
)
603 HDC hdc
= GetDCEx( hwnd
, 0,
604 DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
) );
607 SCROLL_DrawScrollBar( hwnd
, hdc
, nBar
, arrows
, interior
);
608 ReleaseDC( hwnd
, hdc
);
612 /***********************************************************************
613 * SCROLL_HandleKbdEvent
615 * Handle a keyboard event (only for SB_CTL scrollbars).
617 static void SCROLL_HandleKbdEvent( HWND hwnd
, WPARAM wParam
)
619 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
624 case VK_PRIOR
: msg
= SB_PAGEUP
; break;
625 case VK_NEXT
: msg
= SB_PAGEDOWN
; break;
626 case VK_HOME
: msg
= SB_TOP
; break;
627 case VK_END
: msg
= SB_BOTTOM
; break;
628 case VK_UP
: msg
= SB_LINEUP
; break;
629 case VK_DOWN
: msg
= SB_LINEDOWN
; break;
631 WIN_ReleaseWndPtr(wndPtr
);
634 SendMessageA( GetParent(hwnd
),
635 (wndPtr
->dwStyle
& SBS_VERT
) ? WM_VSCROLL
: WM_HSCROLL
,
637 WIN_ReleaseWndPtr(wndPtr
);
641 /***********************************************************************
642 * SCROLL_HandleScrollEvent
644 * Handle a mouse or timer event for the scrollbar.
645 * 'pt' is the location of the mouse event in client (for SB_CTL) or
646 * windows coordinates.
648 void SCROLL_HandleScrollEvent( HWND hwnd
, INT nBar
, UINT msg
, POINT pt
)
650 /* Previous mouse position for timer events */
652 /* Thumb position when tracking started. */
653 static UINT trackThumbPos
;
654 /* Position in the scroll-bar of the last button-down event. */
655 static INT lastClickPos
;
656 /* Position in the scroll-bar of the last mouse event. */
657 static INT lastMousePos
;
659 enum SCROLL_HITTEST hittest
;
660 HWND hwndOwner
, hwndCtl
;
662 INT arrowSize
, thumbSize
, thumbPos
;
666 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
);
667 if (!infoPtr
) return;
668 if ((SCROLL_trackHitTest
== SCROLL_NOWHERE
) && (msg
!= WM_LBUTTONDOWN
))
671 hdc
= GetDCEx( hwnd
, 0, DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
));
672 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
673 &arrowSize
, &thumbSize
, &thumbPos
);
674 hwndOwner
= (nBar
== SB_CTL
) ? GetParent(hwnd
) : hwnd
;
675 hwndCtl
= (nBar
== SB_CTL
) ? hwnd
: 0;
679 case WM_LBUTTONDOWN
: /* Initialise mouse tracking */
680 SCROLL_trackVertical
= vertical
;
681 SCROLL_trackHitTest
= hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
682 lastClickPos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
683 lastMousePos
= lastClickPos
;
684 trackThumbPos
= thumbPos
;
687 if (nBar
== SB_CTL
) SetFocus( hwnd
);
691 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, TRUE
);
696 hittest
= SCROLL_NOWHERE
;
702 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
706 return; /* Should never happen */
709 TRACE(scroll
, "Event: hwnd=%04x bar=%d msg=%x pt=%ld,%ld hit=%d\n",
710 hwnd
, nBar
, msg
, pt
.x
, pt
.y
, hittest
);
712 switch(SCROLL_trackHitTest
)
714 case SCROLL_NOWHERE
: /* No tracking in progress */
717 case SCROLL_TOP_ARROW
:
718 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
719 (hittest
== SCROLL_trackHitTest
), FALSE
);
720 if (hittest
== SCROLL_trackHitTest
)
722 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
724 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
725 SB_LINEUP
, hwndCtl
);
726 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
727 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
731 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
734 case SCROLL_TOP_RECT
:
735 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
736 thumbPos
, infoPtr
->flags
, vertical
,
737 (hittest
== SCROLL_trackHitTest
), FALSE
);
738 if (hittest
== SCROLL_trackHitTest
)
740 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
742 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
743 SB_PAGEUP
, hwndCtl
);
744 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
745 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
749 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
753 if (msg
== WM_LBUTTONDOWN
)
755 SCROLL_TrackingWin
= hwnd
;
756 SCROLL_TrackingBar
= nBar
;
757 SCROLL_TrackingPos
= trackThumbPos
+ lastMousePos
- lastClickPos
;
758 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
760 else if (msg
== WM_LBUTTONUP
)
762 SCROLL_TrackingWin
= 0;
763 SCROLL_MovingThumb
= FALSE
;
764 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
765 thumbPos
, infoPtr
->flags
, vertical
,
768 else /* WM_MOUSEMOVE */
772 if (!SCROLL_PtInRectEx( &rect
, pt
, vertical
)) pos
= lastClickPos
;
775 pt
= SCROLL_ClipPos( &rect
, pt
);
776 pos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
778 if (pos
!= lastMousePos
)
780 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
781 arrowSize
, thumbSize
);
783 SCROLL_TrackingPos
= trackThumbPos
+ pos
- lastClickPos
;
784 SCROLL_TrackingVal
= SCROLL_GetThumbVal( infoPtr
, &rect
,
786 SCROLL_TrackingPos
);
787 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
788 MAKEWPARAM( SB_THUMBTRACK
, SCROLL_TrackingVal
),
790 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
791 arrowSize
, thumbSize
);
796 case SCROLL_BOTTOM_RECT
:
797 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
798 thumbPos
, infoPtr
->flags
, vertical
,
799 FALSE
, (hittest
== SCROLL_trackHitTest
) );
800 if (hittest
== SCROLL_trackHitTest
)
802 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
804 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
805 SB_PAGEDOWN
, hwndCtl
);
806 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
807 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
811 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
814 case SCROLL_BOTTOM_ARROW
:
815 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
816 FALSE
, (hittest
== SCROLL_trackHitTest
) );
817 if (hittest
== SCROLL_trackHitTest
)
819 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
821 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
822 SB_LINEDOWN
, hwndCtl
);
823 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
824 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
828 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
832 if (msg
== WM_LBUTTONUP
)
834 hittest
= SCROLL_trackHitTest
;
835 SCROLL_trackHitTest
= SCROLL_NOWHERE
; /* Terminate tracking */
837 if (hittest
== SCROLL_THUMB
)
839 UINT val
= SCROLL_GetThumbVal( infoPtr
, &rect
, vertical
,
840 trackThumbPos
+ lastMousePos
- lastClickPos
);
841 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
842 MAKEWPARAM( SB_THUMBPOSITION
, val
), hwndCtl
);
845 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
846 SB_ENDSCROLL
, hwndCtl
);
849 ReleaseDC( hwnd
, hdc
);
853 /***********************************************************************
856 LRESULT WINAPI
ScrollBarWndProc( HWND hwnd
, UINT message
, WPARAM wParam
,
863 CREATESTRUCTA
*lpCreat
= (CREATESTRUCTA
*)lParam
;
864 if (lpCreat
->style
& SBS_SIZEBOX
)
866 FIXME(scroll
, "Unimplemented style SBS_SIZEBOX.\n" );
870 if (lpCreat
->style
& SBS_VERT
)
872 if (lpCreat
->style
& SBS_LEFTALIGN
)
873 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
874 SYSMETRICS_CXVSCROLL
+1, lpCreat
->cy
, FALSE
);
875 else if (lpCreat
->style
& SBS_RIGHTALIGN
)
877 lpCreat
->x
+lpCreat
->cx
-SYSMETRICS_CXVSCROLL
-1,
879 SYSMETRICS_CXVSCROLL
+1, lpCreat
->cy
, FALSE
);
883 if (lpCreat
->style
& SBS_TOPALIGN
)
884 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
885 lpCreat
->cx
, SYSMETRICS_CYHSCROLL
+1, FALSE
);
886 else if (lpCreat
->style
& SBS_BOTTOMALIGN
)
889 lpCreat
->y
+lpCreat
->cy
-SYSMETRICS_CYHSCROLL
-1,
890 lpCreat
->cx
, SYSMETRICS_CYHSCROLL
+1, FALSE
);
893 if (!hUpArrow
) SCROLL_LoadBitmaps();
894 TRACE(scroll
, "ScrollBar creation, hwnd=%04x\n", hwnd
);
903 CONV_POINT16TO32( (POINT16
*)&lParam
, &pt
);
904 SCROLL_HandleScrollEvent( hwnd
, SB_CTL
, message
, pt
);
909 SCROLL_HandleKbdEvent( hwnd
, wParam
);
916 return DLGC_WANTARROWS
; /* Windows returns this value */
921 HDC hdc
= BeginPaint( hwnd
, &ps
);
922 SCROLL_DrawScrollBar( hwnd
, hdc
, SB_CTL
, TRUE
, TRUE
);
923 EndPaint( hwnd
, &ps
);
929 return SetScrollPos( hwnd
, SB_CTL
, wParam
, (BOOL
)lParam
);
933 return GetScrollPos( hwnd
, SB_CTL
);
936 SetScrollRange( hwnd
, SB_CTL
, LOWORD(lParam
), HIWORD(lParam
),
937 wParam
/* FIXME: Is this correct? */ );
941 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, FALSE
);
942 return 0; /* FIXME: return previous position */
945 FIXME(scroll
, "don't know how to handle SBM_GETRANGE16 (wp=%04x,lp=%08lx)\n", wParam
, lParam
);
949 GetScrollRange( hwnd
, SB_CTL
, (LPINT
)wParam
, (LPINT
)lParam
);
952 case SBM_ENABLE_ARROWS16
:
953 case SBM_ENABLE_ARROWS
:
954 return EnableScrollBar( hwnd
, SB_CTL
, wParam
);
956 case SBM_SETRANGEREDRAW
:
957 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, TRUE
);
958 return 0; /* FIXME: return previous position */
960 case SBM_SETSCROLLINFO
:
961 return SetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
, wParam
);
963 case SBM_GETSCROLLINFO
:
964 return GetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
);
974 ERR(scroll
, "unknown Win32 msg %04x wp=%08x lp=%08lx\n",
975 message
, wParam
, lParam
);
979 if (message
>= WM_USER
)
980 WARN(scroll
, "unknown msg %04x wp=%04x lp=%08lx\n",
981 message
, wParam
, lParam
);
982 return DefWindowProcA( hwnd
, message
, wParam
, lParam
);
988 /*************************************************************************
989 * SetScrollInfo16 (USER.475)
991 INT16 WINAPI
SetScrollInfo16( HWND16 hwnd
, INT16 nBar
, const SCROLLINFO
*info
,
994 return (INT16
)SetScrollInfo( hwnd
, nBar
, info
, bRedraw
);
998 /*************************************************************************
999 * SetScrollInfo32 (USER32.501)
1000 * SetScrollInfo32 can be used to set the position, upper bound,
1001 * lower bound, and page size of a scrollbar control.
1004 * Scrollbar position
1007 * For 100 lines of text to be displayed in a window of 25 lines,
1008 * one would for instance use info->nMin=0, info->nMax=75
1009 * (corresponding to the 76 different positions of the window on
1010 * the text), and info->nPage=25.
1012 INT WINAPI
SetScrollInfo(
1013 HWND hwnd
/* [I] Handle of window whose scrollbar will be affected */,
1014 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1015 const SCROLLINFO
*info
/* [I] Specifies what to change and new values */,
1016 BOOL bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */)
1019 INT retVal
= SCROLL_SetScrollInfo( hwnd
, nBar
, info
, &action
);
1021 if( action
& SA_SSI_HIDE
)
1022 SCROLL_ShowScrollBar( hwnd
, nBar
, FALSE
, FALSE
);
1025 if( action
& SA_SSI_SHOW
)
1026 if( SCROLL_ShowScrollBar( hwnd
, nBar
, TRUE
, TRUE
) )
1027 return retVal
; /* SetWindowPos() already did the painting */
1029 if( bRedraw
&& (action
& SA_SSI_REFRESH
))
1030 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);
1031 else if( action
& SA_SSI_REPAINT_ARROWS
)
1032 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, FALSE
);
1037 INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
1038 const SCROLLINFO
*info
, INT
*action
)
1040 /* Update the scrollbar state and set action flags according to
1041 * what has to be done graphics wise. */
1043 SCROLLBAR_INFO
*infoPtr
;
1046 dbg_decl_str(scroll
, 256);
1050 if (!(infoPtr
= SCROLL_GetScrollInfo(hwnd
, nBar
))) return 0;
1051 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return 0;
1052 if ((info
->cbSize
!= sizeof(*info
)) &&
1053 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return 0;
1055 /* Set the page size */
1057 if (info
->fMask
& SIF_PAGE
)
1059 dsprintf(scroll
, " page=%d", info
->nPage
);
1060 if( infoPtr
->Page
!= info
->nPage
)
1062 infoPtr
->Page
= info
->nPage
;
1063 *action
|= SA_SSI_REFRESH
;
1067 /* Set the scroll pos */
1069 if (info
->fMask
& SIF_POS
)
1071 dsprintf(scroll
, " pos=%d", info
->nPos
);
1072 if( infoPtr
->CurVal
!= info
->nPos
)
1074 infoPtr
->CurVal
= info
->nPos
;
1075 *action
|= SA_SSI_REFRESH
;
1079 /* Set the scroll range */
1081 if (info
->fMask
& SIF_RANGE
)
1083 dsprintf(scroll
, " min=%d max=%d", info
->nMin
, info
->nMax
);
1085 /* Invalid range -> range is set to (0,0) */
1086 if ((info
->nMin
> info
->nMax
) ||
1087 ((UINT
)(info
->nMax
- info
->nMin
) >= 0x80000000))
1089 infoPtr
->MinVal
= 0;
1090 infoPtr
->MaxVal
= 0;
1094 if( infoPtr
->MinVal
!= info
->nMin
||
1095 infoPtr
->MaxVal
!= info
->nMax
)
1097 *action
|= SA_SSI_REFRESH
;
1098 infoPtr
->MinVal
= info
->nMin
;
1099 infoPtr
->MaxVal
= info
->nMax
;
1104 TRACE(scroll
, "hwnd=%04x bar=%d %s\n",
1105 hwnd
, nBar
, dbg_str(scroll
));
1107 /* Make sure the page size is valid */
1109 if (infoPtr
->Page
< 0) infoPtr
->Page
= 0;
1110 else if (infoPtr
->Page
> infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1 )
1111 infoPtr
->Page
= infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1;
1113 /* Make sure the pos is inside the range */
1115 if (infoPtr
->CurVal
< infoPtr
->MinVal
)
1116 infoPtr
->CurVal
= infoPtr
->MinVal
;
1117 else if (infoPtr
->CurVal
> infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
1118 infoPtr
->CurVal
= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 );
1120 TRACE(scroll
, " new values: page=%d pos=%d min=%d max=%d\n",
1121 infoPtr
->Page
, infoPtr
->CurVal
,
1122 infoPtr
->MinVal
, infoPtr
->MaxVal
);
1124 /* Check if the scrollbar should be hidden or disabled */
1126 if (info
->fMask
& (SIF_RANGE
| SIF_PAGE
| SIF_DISABLENOSCROLL
))
1128 new_flags
= infoPtr
->flags
;
1129 if (infoPtr
->MinVal
>= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
1131 /* Hide or disable scroll-bar */
1132 if (info
->fMask
& SIF_DISABLENOSCROLL
)
1134 new_flags
= ESB_DISABLE_BOTH
;
1135 *action
|= SA_SSI_REFRESH
;
1137 else if (nBar
!= SB_CTL
)
1139 *action
= SA_SSI_HIDE
;
1143 else /* Show and enable scroll-bar */
1147 *action
|= SA_SSI_SHOW
;
1150 if (infoPtr
->flags
!= new_flags
) /* check arrow flags */
1152 infoPtr
->flags
= new_flags
;
1153 *action
|= SA_SSI_REPAINT_ARROWS
;
1158 /* Return current position */
1160 return infoPtr
->CurVal
;
1164 /*************************************************************************
1165 * GetScrollInfo16 (USER.476)
1167 BOOL16 WINAPI
GetScrollInfo16( HWND16 hwnd
, INT16 nBar
, LPSCROLLINFO info
)
1169 return GetScrollInfo( hwnd
, nBar
, info
);
1173 /*************************************************************************
1174 * GetScrollInfo32 (USER32.284)
1175 * GetScrollInfo32 can be used to retrieve the position, upper bound,
1176 * lower bound, and page size of a scrollbar control.
1180 BOOL WINAPI
GetScrollInfo(
1181 HWND hwnd
/* [I] Handle of window */ ,
1182 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1183 LPSCROLLINFO info
/* [IO] (info.fMask [I] specifies which values are to retrieve) */)
1185 SCROLLBAR_INFO
*infoPtr
;
1187 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1188 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return FALSE
;
1189 if ((info
->cbSize
!= sizeof(*info
)) &&
1190 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return FALSE
;
1192 if (info
->fMask
& SIF_PAGE
) info
->nPage
= infoPtr
->Page
;
1193 if (info
->fMask
& SIF_POS
) info
->nPos
= infoPtr
->CurVal
;
1194 if ((info
->fMask
& SIF_TRACKPOS
) && (info
->cbSize
== sizeof(*info
)))
1195 info
->nTrackPos
= (SCROLL_TrackingWin
==hwnd
) ? SCROLL_TrackingVal
: 0;
1196 if (info
->fMask
& SIF_RANGE
)
1198 info
->nMin
= infoPtr
->MinVal
;
1199 info
->nMax
= infoPtr
->MaxVal
;
1201 return (info
->fMask
& SIF_ALL
) != 0;
1205 /*************************************************************************
1206 * SetScrollPos16 (USER.62)
1208 INT16 WINAPI
SetScrollPos16( HWND16 hwnd
, INT16 nBar
, INT16 nPos
,
1211 return (INT16
)SetScrollPos( hwnd
, nBar
, nPos
, bRedraw
);
1215 /*************************************************************************
1216 * SetScrollPos32 (USER32.502)
1219 * Success: Scrollbar position
1223 * Note the ambiguity when 0 is returned. Use GetLastError
1224 * to make sure there was an error (and to know which one).
1226 INT WINAPI
SetScrollPos(
1227 HWND hwnd
/* [I] Handle of window whose scrollbar will be affected */,
1228 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
1229 INT nPos
/* [I] New value */,
1230 BOOL bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */ )
1233 SCROLLBAR_INFO
*infoPtr
;
1236 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1237 oldPos
= infoPtr
->CurVal
;
1238 info
.cbSize
= sizeof(info
);
1240 info
.fMask
= SIF_POS
;
1241 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1246 /*************************************************************************
1247 * GetScrollPos16 (USER.63)
1249 INT16 WINAPI
GetScrollPos16( HWND16 hwnd
, INT16 nBar
)
1251 return (INT16
)GetScrollPos( hwnd
, nBar
);
1255 /*************************************************************************
1256 * GetScrollPos32 (USER32.285)
1259 * Success: Current position
1263 * Note the ambiguity when 0 is returned. Use GetLastError
1264 * to make sure there was an error (and to know which one).
1266 INT WINAPI
GetScrollPos(
1267 HWND hwnd
, /* [I] Handle of window */
1268 INT nBar
/* [I] One of SB_HORZ, SB_VERT, or SB_CTL */)
1270 SCROLLBAR_INFO
*infoPtr
;
1272 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1273 return infoPtr
->CurVal
;
1277 /*************************************************************************
1278 * SetScrollRange16 (USER.64)
1280 void WINAPI
SetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1281 INT16 MinVal
, INT16 MaxVal
, BOOL16 bRedraw
)
1283 /* Invalid range -> range is set to (0,0) */
1284 if ((INT
)MaxVal
- (INT
)MinVal
> 0x7fff) MinVal
= MaxVal
= 0;
1285 SetScrollRange( hwnd
, nBar
, MinVal
, MaxVal
, bRedraw
);
1289 /*************************************************************************
1290 * SetScrollRange32 (USER32.503)
1294 BOOL WINAPI
SetScrollRange(
1295 HWND hwnd
, /* [I] Handle of window whose scrollbar will be affected */
1296 INT nBar
, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1297 INT MinVal
, /* [I] New minimum value */
1298 INT MaxVal
, /* [I] New maximum value */
1299 BOOL bRedraw
/* [I] Should scrollbar be redrawn afterwards ? */)
1303 info
.cbSize
= sizeof(info
);
1306 info
.fMask
= SIF_RANGE
;
1307 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1312 /*************************************************************************
1313 * SCROLL_SetNCSbState
1315 * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
1317 INT
SCROLL_SetNCSbState(WND
* wndPtr
, int vMin
, int vMax
, int vPos
,
1318 int hMin
, int hMax
, int hPos
)
1321 SCROLLINFO vInfo
, hInfo
;
1323 vInfo
.cbSize
= hInfo
.cbSize
= sizeof(SCROLLINFO
);
1324 vInfo
.nMin
= vMin
; hInfo
.nMin
= hMin
;
1325 vInfo
.nMax
= vMax
; hInfo
.nMax
= hMax
;
1326 vInfo
.nPos
= vPos
; hInfo
.nPos
= hPos
;
1327 vInfo
.fMask
= hInfo
.fMask
= SIF_RANGE
| SIF_POS
;
1329 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_VERT
, &vInfo
, &vA
);
1330 SCROLL_SetScrollInfo( wndPtr
->hwndSelf
, SB_HORZ
, &hInfo
, &hA
);
1332 if( !SCROLL_ShowScrollBar( wndPtr
->hwndSelf
, SB_BOTH
,
1333 (hA
& SA_SSI_SHOW
),(vA
& SA_SSI_SHOW
) ) )
1335 /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
1336 if( vA
& SA_SSI_REFRESH
)
1337 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_VERT
, FALSE
, TRUE
);
1339 if( hA
& SA_SSI_REFRESH
)
1340 SCROLL_RefreshScrollBar( wndPtr
->hwndSelf
, SB_HORZ
, FALSE
, TRUE
);
1346 /*************************************************************************
1347 * GetScrollRange16 (USER.65)
1349 BOOL16 WINAPI
GetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1350 LPINT16 lpMin
, LPINT16 lpMax
)
1353 BOOL16 ret
= GetScrollRange( hwnd
, nBar
, &min
, &max
);
1354 if (lpMin
) *lpMin
= min
;
1355 if (lpMax
) *lpMax
= max
;
1360 /*************************************************************************
1361 * GetScrollRange32 (USER32.286)
1365 BOOL WINAPI
GetScrollRange(
1366 HWND hwnd
, /* [I] Handle of window */
1367 INT nBar
, /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */
1368 LPINT lpMin
, /* [O] Where to store minimum value */
1369 LPINT lpMax
/* [O] Where to store maximum value */)
1371 SCROLLBAR_INFO
*infoPtr
;
1373 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
)))
1375 if (lpMin
) lpMin
= 0;
1376 if (lpMax
) lpMax
= 0;
1379 if (lpMin
) *lpMin
= infoPtr
->MinVal
;
1380 if (lpMax
) *lpMax
= infoPtr
->MaxVal
;
1385 /*************************************************************************
1386 * SCROLL_ShowScrollBar()
1388 * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
1389 * NOTE: fShowV/fShowH must be zero when nBar is SB_HORZ/SB_VERT.
1391 BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
1392 BOOL fShowH
, BOOL fShowV
)
1394 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
1395 BOOL retvalue
= FALSE
;
1397 if (!wndPtr
) return FALSE
;
1398 TRACE(scroll
, "hwnd=%04x bar=%d horz=%d, vert=%d\n",
1399 hwnd
, nBar
, fShowH
, fShowV
);
1404 ShowWindow( hwnd
, fShowH
? SW_SHOW
: SW_HIDE
);
1412 fShowH
= !(wndPtr
->dwStyle
& WS_HSCROLL
);
1413 wndPtr
->dwStyle
|= WS_HSCROLL
;
1417 fShowH
= (wndPtr
->dwStyle
& WS_HSCROLL
);
1418 wndPtr
->dwStyle
&= ~WS_HSCROLL
;
1420 if( nBar
== SB_HORZ
) break;
1426 fShowV
= !(wndPtr
->dwStyle
& WS_VSCROLL
);
1427 wndPtr
->dwStyle
|= WS_VSCROLL
;
1431 fShowV
= (wndPtr
->dwStyle
& WS_VSCROLL
);
1432 wndPtr
->dwStyle
&= ~WS_VSCROLL
;
1437 retvalue
= FALSE
; /* Nothing to do! */
1441 if( fShowH
|| fShowV
) /* frame has been changed, let the window redraw itself */
1443 SetWindowPos( hwnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
1444 | SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
1449 retvalue
= FALSE
; /* no frame changes */
1451 WIN_ReleaseWndPtr(wndPtr
);
1456 /*************************************************************************
1457 * ShowScrollBar16 (USER.267)
1459 void WINAPI
ShowScrollBar16( HWND16 hwnd
, INT16 nBar
, BOOL16 fShow
)
1461 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1462 (nBar
== SB_HORZ
) ? 0 : fShow
);
1466 /*************************************************************************
1467 * ShowScrollBar32 (USER32.532)
1471 BOOL WINAPI
ShowScrollBar(
1472 HWND hwnd
, /* [I] Handle of window whose scrollbar(s) will be affected */
1473 INT nBar
, /* [I] One of SB_HORZ, SB_VERT, SB_BOTH or SB_CTL */
1474 BOOL fShow
/* [I] TRUE = show, FALSE = hide */)
1476 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1477 (nBar
== SB_HORZ
) ? 0 : fShow
);
1482 /*************************************************************************
1483 * EnableScrollBar16 (USER.482)
1485 BOOL16 WINAPI
EnableScrollBar16( HWND16 hwnd
, INT16 nBar
, UINT16 flags
)
1487 return EnableScrollBar( hwnd
, nBar
, flags
);
1491 /*************************************************************************
1492 * EnableScrollBar32 (USER32.171)
1494 BOOL WINAPI
EnableScrollBar( HWND hwnd
, INT nBar
, UINT flags
)
1497 SCROLLBAR_INFO
*infoPtr
;
1499 TRACE(scroll
, "%04x %d %d\n", hwnd
, nBar
, flags
);
1501 flags
&= ESB_DISABLE_BOTH
;
1503 if (nBar
== SB_BOTH
)
1505 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, SB_VERT
))) return FALSE
;
1506 if (!(bFineWithMe
= (infoPtr
->flags
== flags
)) )
1508 infoPtr
->flags
= flags
;
1509 SCROLL_RefreshScrollBar( hwnd
, SB_VERT
, TRUE
, TRUE
);
1516 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1517 if (bFineWithMe
&& infoPtr
->flags
== flags
) return FALSE
;
1518 infoPtr
->flags
= flags
;
1520 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);