4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994, 1996 Alexandre Julliard
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "wine/winuser16.h"
27 #include "wine/debug.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(scroll
);
35 INT curVal
; /* Current scroll-bar value */
36 INT minVal
; /* Minimum scroll-bar value */
37 INT maxVal
; /* Maximum scroll-bar value */
38 INT page
; /* Page size of scroll bar (Win32) */
39 UINT flags
; /* EnableScrollBar flags */
43 static HBITMAP hUpArrow
;
44 static HBITMAP hDnArrow
;
45 static HBITMAP hLfArrow
;
46 static HBITMAP hRgArrow
;
47 static HBITMAP hUpArrowD
;
48 static HBITMAP hDnArrowD
;
49 static HBITMAP hLfArrowD
;
50 static HBITMAP hRgArrowD
;
51 static HBITMAP hUpArrowI
;
52 static HBITMAP hDnArrowI
;
53 static HBITMAP hLfArrowI
;
54 static HBITMAP hRgArrowI
;
56 #define TOP_ARROW(flags,pressed) \
57 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
58 #define BOTTOM_ARROW(flags,pressed) \
59 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
60 #define LEFT_ARROW(flags,pressed) \
61 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
62 #define RIGHT_ARROW(flags,pressed) \
63 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
66 /* Minimum size of the rectangle between the arrows */
67 #define SCROLL_MIN_RECT 4
69 /* Minimum size of the thumb in pixels */
70 #define SCROLL_MIN_THUMB 6
72 /* Overlap between arrows and thumb */
73 #define SCROLL_ARROW_THUMB_OVERLAP ((TWEAK_WineLook == WIN31_LOOK) ? 1 : 0)
75 /* Delay (in ms) before first repetition when holding the button down */
76 #define SCROLL_FIRST_DELAY 200
78 /* Delay (in ms) between scroll repetitions */
79 #define SCROLL_REPEAT_DELAY 50
82 #define SCROLL_TIMER 0
84 /* Scroll-bar hit testing */
87 SCROLL_NOWHERE
, /* Outside the scroll bar */
88 SCROLL_TOP_ARROW
, /* Top or left arrow */
89 SCROLL_TOP_RECT
, /* Rectangle between the top arrow and the thumb */
90 SCROLL_THUMB
, /* Thumb rectangle */
91 SCROLL_BOTTOM_RECT
, /* Rectangle between the thumb and the bottom arrow */
92 SCROLL_BOTTOM_ARROW
/* Bottom or right arrow */
95 /* What to do after SCROLL_SetScrollInfo() */
96 #define SA_SSI_HIDE 0x0001
97 #define SA_SSI_SHOW 0x0002
98 #define SA_SSI_REFRESH 0x0004
99 #define SA_SSI_REPAINT_ARROWS 0x0008
101 /* Thumb-tracking info */
102 static HWND SCROLL_TrackingWin
= 0;
103 static INT SCROLL_TrackingBar
= 0;
104 static INT SCROLL_TrackingPos
= 0;
105 static INT SCROLL_TrackingVal
= 0;
106 /* Hit test code of the last button-down event */
107 static enum SCROLL_HITTEST SCROLL_trackHitTest
;
108 static BOOL SCROLL_trackVertical
;
110 /* Is the moving thumb being displayed? */
111 static BOOL SCROLL_MovingThumb
= FALSE
;
113 /* Local functions */
114 static BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
115 BOOL fShowH
, BOOL fShowV
);
116 static INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
117 const SCROLLINFO
*info
, INT
*action
);
118 static void SCROLL_DrawInterior_9x( HWND hwnd
, HDC hdc
, INT nBar
,
119 RECT
*rect
, INT arrowSize
,
120 INT thumbSize
, INT thumbPos
,
121 UINT flags
, BOOL vertical
,
122 BOOL top_selected
, BOOL bottom_selected
);
123 static LRESULT WINAPI
ScrollBarWndProc( HWND hwnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
);
126 /*********************************************************************
127 * scrollbar class descriptor
129 const struct builtin_class_descr SCROLL_builtin_class
=
131 "ScrollBar", /* name */
132 CS_GLOBALCLASS
| CS_DBLCLKS
| CS_VREDRAW
| CS_HREDRAW
| CS_PARENTDC
, /* style */
133 NULL
, /* procA (winproc is Unicode only) */
134 ScrollBarWndProc
, /* procW */
135 sizeof(SCROLLBAR_INFO
), /* extra */
136 IDC_ARROWA
, /* cursor */
141 /***********************************************************************
144 static void SCROLL_LoadBitmaps(void)
146 hUpArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROW
) );
147 hDnArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROW
) );
148 hLfArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROW
) );
149 hRgArrow
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROW
) );
150 hUpArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWD
) );
151 hDnArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWD
) );
152 hLfArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWD
) );
153 hRgArrowD
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWD
) );
154 hUpArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_UPARROWI
) );
155 hDnArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_DNARROWI
) );
156 hLfArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_LFARROWI
) );
157 hRgArrowI
= LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RGARROWI
) );
161 /***********************************************************************
162 * SCROLL_GetScrollInfo
164 static SCROLLBAR_INFO
*SCROLL_GetScrollInfo( HWND hwnd
, INT nBar
)
166 SCROLLBAR_INFO
*infoPtr
;
167 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
169 if (!wndPtr
) return NULL
;
172 case SB_HORZ
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pHScroll
; break;
173 case SB_VERT
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pVScroll
; break;
174 case SB_CTL
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->wExtra
; break;
176 WIN_ReleaseWndPtr( wndPtr
);
180 if (!infoPtr
) /* Create the info structure if needed */
182 if ((infoPtr
= HeapAlloc( GetProcessHeap(), 0, sizeof(SCROLLBAR_INFO
) )))
184 infoPtr
->minVal
= infoPtr
->curVal
= infoPtr
->page
= 0;
185 infoPtr
->maxVal
= 100;
186 infoPtr
->flags
= ESB_ENABLE_BOTH
;
187 if (nBar
== SB_HORZ
) wndPtr
->pHScroll
= infoPtr
;
188 else wndPtr
->pVScroll
= infoPtr
;
190 if (!hUpArrow
) SCROLL_LoadBitmaps();
192 WIN_ReleaseWndPtr( wndPtr
);
197 /***********************************************************************
198 * SCROLL_GetScrollBarRect
200 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
201 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
202 * 'arrowSize' returns the width or height of an arrow (depending on
203 * the orientation of the scrollbar), 'thumbSize' returns the size of
204 * the thumb, and 'thumbPos' returns the position of the thumb
205 * relative to the left or to the top.
206 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
208 static BOOL
SCROLL_GetScrollBarRect( HWND hwnd
, INT nBar
, RECT
*lprect
,
209 INT
*arrowSize
, INT
*thumbSize
,
214 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
219 lprect
->left
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
;
220 lprect
->top
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
221 lprect
->right
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
222 lprect
->bottom
= lprect
->top
+ GetSystemMetrics(SM_CYHSCROLL
);
223 if(wndPtr
->dwStyle
& WS_BORDER
) {
226 } else if(wndPtr
->dwStyle
& WS_VSCROLL
)
232 if((wndPtr
->dwExStyle
& WS_EX_LEFTSCROLLBAR
) != 0)
233 lprect
->left
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
- GetSystemMetrics(SM_CXVSCROLL
);
235 lprect
->left
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
236 lprect
->top
= wndPtr
->rectClient
.top
- wndPtr
->rectWindow
.top
;
237 lprect
->right
= lprect
->left
+ GetSystemMetrics(SM_CXVSCROLL
);
238 lprect
->bottom
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
239 if(wndPtr
->dwStyle
& WS_BORDER
) {
242 } else if(wndPtr
->dwStyle
& WS_HSCROLL
)
248 GetClientRect( hwnd
, lprect
);
249 vertical
= ((wndPtr
->dwStyle
& SBS_VERT
) != 0);
253 WIN_ReleaseWndPtr(wndPtr
);
257 if (vertical
) pixels
= lprect
->bottom
- lprect
->top
;
258 else pixels
= lprect
->right
- lprect
->left
;
260 if (pixels
<= 2*GetSystemMetrics(SM_CXVSCROLL
) + SCROLL_MIN_RECT
)
262 if (pixels
> SCROLL_MIN_RECT
)
263 *arrowSize
= (pixels
- SCROLL_MIN_RECT
) / 2;
266 *thumbPos
= *thumbSize
= 0;
270 SCROLLBAR_INFO
*info
= SCROLL_GetScrollInfo( hwnd
, nBar
);
272 *arrowSize
= GetSystemMetrics(SM_CXVSCROLL
);
273 pixels
-= (2 * (GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
));
277 *thumbSize
= MulDiv(pixels
,info
->page
,(info
->maxVal
-info
->minVal
+1));
278 if (*thumbSize
< SCROLL_MIN_THUMB
) *thumbSize
= SCROLL_MIN_THUMB
;
280 else *thumbSize
= GetSystemMetrics(SM_CXVSCROLL
);
282 if (((pixels
-= *thumbSize
) < 0) ||
283 ((info
->flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
))
285 /* Rectangle too small or scrollbar disabled -> no thumb */
286 *thumbPos
= *thumbSize
= 0;
290 INT max
= info
->maxVal
- max( info
->page
-1, 0 );
291 if (info
->minVal
>= max
)
292 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
294 *thumbPos
= *arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
295 + MulDiv(pixels
, (info
->curVal
-info
->minVal
),(max
- info
->minVal
));
298 WIN_ReleaseWndPtr(wndPtr
);
303 /***********************************************************************
306 * Compute the current scroll position based on the thumb position in pixels
307 * from the top of the scroll-bar.
309 static UINT
SCROLL_GetThumbVal( SCROLLBAR_INFO
*infoPtr
, RECT
*rect
,
310 BOOL vertical
, INT pos
)
313 INT pixels
= vertical
? rect
->bottom
-rect
->top
: rect
->right
-rect
->left
;
315 if ((pixels
-= 2*(GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
)) <= 0)
316 return infoPtr
->minVal
;
320 thumbSize
= MulDiv(pixels
,infoPtr
->page
,(infoPtr
->maxVal
-infoPtr
->minVal
+1));
321 if (thumbSize
< SCROLL_MIN_THUMB
) thumbSize
= SCROLL_MIN_THUMB
;
323 else thumbSize
= GetSystemMetrics(SM_CXVSCROLL
);
325 if ((pixels
-= thumbSize
) <= 0) return infoPtr
->minVal
;
327 pos
= max( 0, pos
- (GetSystemMetrics(SM_CXVSCROLL
) - SCROLL_ARROW_THUMB_OVERLAP
) );
328 if (pos
> pixels
) pos
= pixels
;
330 if (!infoPtr
->page
) pos
*= infoPtr
->maxVal
- infoPtr
->minVal
;
331 else pos
*= infoPtr
->maxVal
- infoPtr
->minVal
- infoPtr
->page
+ 1;
332 return infoPtr
->minVal
+ ((pos
+ pixels
/ 2) / pixels
);
335 /***********************************************************************
338 static BOOL
SCROLL_PtInRectEx( LPRECT lpRect
, POINT pt
, BOOL vertical
)
344 rect
.left
-= lpRect
->right
- lpRect
->left
;
345 rect
.right
+= lpRect
->right
- lpRect
->left
;
349 rect
.top
-= lpRect
->bottom
- lpRect
->top
;
350 rect
.bottom
+= lpRect
->bottom
- lpRect
->top
;
352 return PtInRect( &rect
, pt
);
355 /***********************************************************************
358 static POINT
SCROLL_ClipPos( LPRECT lpRect
, POINT pt
)
360 if( pt
.x
< lpRect
->left
)
363 if( pt
.x
> lpRect
->right
)
364 pt
.x
= lpRect
->right
;
366 if( pt
.y
< lpRect
->top
)
369 if( pt
.y
> lpRect
->bottom
)
370 pt
.y
= lpRect
->bottom
;
376 /***********************************************************************
379 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
381 static enum SCROLL_HITTEST
SCROLL_HitTest( HWND hwnd
, INT nBar
,
382 POINT pt
, BOOL bDragging
)
384 INT arrowSize
, thumbSize
, thumbPos
;
387 BOOL vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
388 &arrowSize
, &thumbSize
, &thumbPos
);
390 if ( (bDragging
&& !SCROLL_PtInRectEx( &rect
, pt
, vertical
)) ||
391 (!PtInRect( &rect
, pt
)) ) return SCROLL_NOWHERE
;
395 if (pt
.y
< rect
.top
+ arrowSize
) return SCROLL_TOP_ARROW
;
396 if (pt
.y
>= rect
.bottom
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
397 if (!thumbPos
) return SCROLL_TOP_RECT
;
399 if (pt
.y
< thumbPos
) return SCROLL_TOP_RECT
;
400 if (pt
.y
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
402 else /* horizontal */
404 if (pt
.x
< rect
.left
+ arrowSize
) return SCROLL_TOP_ARROW
;
405 if (pt
.x
>= rect
.right
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
406 if (!thumbPos
) return SCROLL_TOP_RECT
;
408 if (pt
.x
< thumbPos
) return SCROLL_TOP_RECT
;
409 if (pt
.x
>= thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
415 /***********************************************************************
418 * Draw the scroll bar arrows.
420 static void SCROLL_DrawArrows_9x( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
421 RECT
*rect
, INT arrowSize
, BOOL vertical
,
422 BOOL top_pressed
, BOOL bottom_pressed
)
428 r
.bottom
= r
.top
+ arrowSize
;
430 r
.right
= r
.left
+ arrowSize
;
432 DrawFrameControl( hdc
, &r
, DFC_SCROLL
,
433 (vertical
? DFCS_SCROLLUP
: DFCS_SCROLLLEFT
)
434 | (top_pressed
? (DFCS_PUSHED
| DFCS_FLAT
) : 0 )
435 | (infoPtr
->flags
&ESB_DISABLE_LTUP
? DFCS_INACTIVE
: 0 ) );
439 r
.top
= r
.bottom
-arrowSize
;
441 r
.left
= r
.right
-arrowSize
;
443 DrawFrameControl( hdc
, &r
, DFC_SCROLL
,
444 (vertical
? DFCS_SCROLLDOWN
: DFCS_SCROLLRIGHT
)
445 | (bottom_pressed
? (DFCS_PUSHED
| DFCS_FLAT
) : 0 )
446 | (infoPtr
->flags
&ESB_DISABLE_RTDN
? DFCS_INACTIVE
: 0) );
449 static void SCROLL_DrawArrows_31( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
450 RECT
*rect
, INT arrowSize
, BOOL vertical
,
451 BOOL top_pressed
, BOOL bottom_pressed
)
453 HDC hdcMem
= CreateCompatibleDC( hdc
);
454 HBITMAP hbmpPrev
= SelectObject( hdcMem
, vertical
?
455 TOP_ARROW(infoPtr
->flags
, top_pressed
)
456 : LEFT_ARROW(infoPtr
->flags
, top_pressed
));
458 SetStretchBltMode( hdc
, STRETCH_DELETESCANS
);
459 StretchBlt( hdc
, rect
->left
, rect
->top
,
460 vertical
? rect
->right
-rect
->left
: arrowSize
,
461 vertical
? arrowSize
: rect
->bottom
-rect
->top
,
463 GetSystemMetrics(SM_CXVSCROLL
),GetSystemMetrics(SM_CYHSCROLL
),
466 SelectObject( hdcMem
, vertical
?
467 BOTTOM_ARROW( infoPtr
->flags
, bottom_pressed
)
468 : RIGHT_ARROW( infoPtr
->flags
, bottom_pressed
) );
470 StretchBlt( hdc
, rect
->left
, rect
->bottom
- arrowSize
,
471 rect
->right
- rect
->left
, arrowSize
,
473 GetSystemMetrics(SM_CXVSCROLL
),GetSystemMetrics(SM_CYHSCROLL
),
476 StretchBlt( hdc
, rect
->right
- arrowSize
, rect
->top
,
477 arrowSize
, rect
->bottom
- rect
->top
,
479 GetSystemMetrics(SM_CXVSCROLL
), GetSystemMetrics(SM_CYHSCROLL
),
481 SelectObject( hdcMem
, hbmpPrev
);
485 static void SCROLL_DrawArrows( HDC hdc
, SCROLLBAR_INFO
*infoPtr
,
486 RECT
*rect
, INT arrowSize
, BOOL vertical
,
487 BOOL top_pressed
, BOOL bottom_pressed
)
489 if( TWEAK_WineLook
== WIN31_LOOK
)
490 SCROLL_DrawArrows_31( hdc
, infoPtr
, rect
, arrowSize
,
491 vertical
, top_pressed
,bottom_pressed
);
493 SCROLL_DrawArrows_9x( hdc
, infoPtr
, rect
, arrowSize
,
494 vertical
, top_pressed
,bottom_pressed
);
498 /***********************************************************************
499 * SCROLL_DrawMovingThumb
501 * Draw the moving thumb rectangle.
503 static void SCROLL_DrawMovingThumb_31( HDC hdc
, RECT
*rect
, BOOL vertical
,
504 INT arrowSize
, INT thumbSize
)
509 r
.top
+= SCROLL_TrackingPos
;
510 if (r
.top
< rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
511 r
.top
= rect
->top
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
512 if (r
.top
+ thumbSize
>
513 rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
514 r
.top
= rect
->bottom
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
516 r
.bottom
= r
.top
+ thumbSize
;
520 r
.left
+= SCROLL_TrackingPos
;
521 if (r
.left
< rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
522 r
.left
= rect
->left
+ arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
523 if (r
.left
+ thumbSize
>
524 rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
))
525 r
.left
= rect
->right
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
)
527 r
.right
= r
.left
+ thumbSize
;
530 DrawFocusRect( hdc
, &r
);
531 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
534 static void SCROLL_DrawMovingThumb_9x( HDC hdc
, RECT
*rect
, BOOL vertical
,
535 INT arrowSize
, INT thumbSize
)
537 INT pos
= SCROLL_TrackingPos
;
541 max_size
= rect
->bottom
- rect
->top
;
543 max_size
= rect
->right
- rect
->left
;
545 max_size
-= (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
) + thumbSize
;
547 if( pos
< (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
) )
548 pos
= (arrowSize
-SCROLL_ARROW_THUMB_OVERLAP
);
549 else if( pos
> max_size
)
552 SCROLL_DrawInterior_9x( SCROLL_TrackingWin
, hdc
, SCROLL_TrackingBar
,
553 rect
, arrowSize
, thumbSize
, pos
,
554 0, vertical
, FALSE
, FALSE
);
556 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
559 static void SCROLL_DrawMovingThumb( HDC hdc
, RECT
*rect
, BOOL vertical
,
560 INT arrowSize
, INT thumbSize
)
562 if( TWEAK_WineLook
== WIN31_LOOK
)
563 SCROLL_DrawMovingThumb_31( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
565 SCROLL_DrawMovingThumb_9x( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
568 /***********************************************************************
569 * SCROLL_DrawInterior
571 * Draw the scroll bar interior (everything except the arrows).
573 static void SCROLL_DrawInterior_9x( HWND hwnd
, HDC hdc
, INT nBar
,
574 RECT
*rect
, INT arrowSize
,
575 INT thumbSize
, INT thumbPos
,
576 UINT flags
, BOOL vertical
,
577 BOOL top_selected
, BOOL bottom_selected
)
581 HBRUSH hSaveBrush
,hBrush
;
583 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
584 * The window-owned scrollbars need to call DEFWND_ControlColor
585 * to correctly setup default scrollbar colors
589 hBrush
= (HBRUSH
)SendMessageA( GetParent(hwnd
), WM_CTLCOLORSCROLLBAR
,
590 (WPARAM
)hdc
,(LPARAM
)hwnd
);
594 hBrush
= DEFWND_ControlColor( hdc
, CTLCOLOR_SCROLLBAR
);
597 hSavePen
= SelectObject( hdc
, SYSCOLOR_GetPen(COLOR_WINDOWFRAME
) );
598 hSaveBrush
= SelectObject( hdc
, hBrush
);
600 /* Calculate the scroll rectangle */
604 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
605 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
609 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
610 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
613 /* Draw the scroll rectangles and thumb */
614 if (!thumbPos
) /* No thumb to draw */
616 PatBlt( hdc
, r
.left
, r
.top
,
617 r
.right
- r
.left
, r
.bottom
- r
.top
,
620 /* cleanup and return */
621 SelectObject( hdc
, hSavePen
);
622 SelectObject( hdc
, hSaveBrush
);
628 PatBlt( hdc
, r
.left
, r
.top
,
630 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
631 top_selected
? 0x0f0000 : PATCOPY
);
632 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
633 PatBlt( hdc
, r
.left
, r
.top
+ thumbSize
,
635 r
.bottom
- r
.top
- thumbSize
,
636 bottom_selected
? 0x0f0000 : PATCOPY
);
637 r
.bottom
= r
.top
+ thumbSize
;
639 else /* horizontal */
641 PatBlt( hdc
, r
.left
, r
.top
,
642 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
644 top_selected
? 0x0f0000 : PATCOPY
);
645 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
646 PatBlt( hdc
, r
.left
+ thumbSize
, r
.top
,
647 r
.right
- r
.left
- thumbSize
,
649 bottom_selected
? 0x0f0000 : PATCOPY
);
650 r
.right
= r
.left
+ thumbSize
;
654 DrawEdge( hdc
, &r
, EDGE_RAISED
, BF_RECT
| BF_MIDDLE
);
657 SelectObject( hdc
, hSavePen
);
658 SelectObject( hdc
, hSaveBrush
);
662 static void SCROLL_DrawInterior( HWND hwnd
, HDC hdc
, INT nBar
,
663 RECT
*rect
, INT arrowSize
,
664 INT thumbSize
, INT thumbPos
,
665 UINT flags
, BOOL vertical
,
666 BOOL top_selected
, BOOL bottom_selected
)
670 HBRUSH hSaveBrush
,hBrush
;
671 BOOL Save_SCROLL_MovingThumb
= SCROLL_MovingThumb
;
673 if (Save_SCROLL_MovingThumb
&&
674 (SCROLL_TrackingWin
== hwnd
) &&
675 (SCROLL_TrackingBar
== nBar
))
676 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
678 /* Select the correct brush and pen */
680 if (TWEAK_WineLook
== WIN31_LOOK
&& (flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
)
682 /* This ought to be the color of the parent window */
683 hBrush
= GetSysColorBrush(COLOR_WINDOW
);
687 /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
688 * The window-owned scrollbars need to call DEFWND_ControlColor
689 * to correctly setup default scrollbar colors
691 if (nBar
== SB_CTL
) {
692 hBrush
= (HBRUSH
)SendMessageA( GetParent(hwnd
), WM_CTLCOLORSCROLLBAR
,
693 (WPARAM
)hdc
,(LPARAM
)hwnd
);
695 hBrush
= DEFWND_ControlColor( hdc
, CTLCOLOR_SCROLLBAR
);
698 hSavePen
= SelectObject( hdc
, SYSCOLOR_GetPen(COLOR_WINDOWFRAME
) );
699 hSaveBrush
= SelectObject( hdc
, hBrush
);
701 /* Calculate the scroll rectangle */
706 r
.top
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
707 r
.bottom
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
711 r
.left
+= arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
;
712 r
.right
-= (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
715 /* Draw the scroll bar frame */
717 /* Only draw outline if Win 3.1. Mar 24, 1999 - Ronald B. Cemer */
718 if (TWEAK_WineLook
== WIN31_LOOK
)
719 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
721 /* Draw the scroll rectangles and thumb */
723 if (!thumbPos
) /* No thumb to draw */
725 INT offset
= (TWEAK_WineLook
> WIN31_LOOK
) ? 0 : 1;
727 PatBlt( hdc
, r
.left
+offset
, r
.top
+offset
,
728 r
.right
- r
.left
- 2*offset
, r
.bottom
- r
.top
- 2*offset
,
731 /* cleanup and return */
732 SelectObject( hdc
, hSavePen
);
733 SelectObject( hdc
, hSaveBrush
);
739 INT offset
= (TWEAK_WineLook
== WIN31_LOOK
) ? 1 : 0;
741 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ offset
,
742 r
.right
- r
.left
- offset
*2,
743 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
) - offset
,
744 top_selected
? 0x0f0000 : PATCOPY
);
745 r
.top
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
746 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ thumbSize
,
747 r
.right
- r
.left
- offset
*2,
748 r
.bottom
- r
.top
- thumbSize
- offset
,
749 bottom_selected
? 0x0f0000 : PATCOPY
);
750 r
.bottom
= r
.top
+ thumbSize
;
752 else /* horizontal */
754 INT offset
= (TWEAK_WineLook
== WIN31_LOOK
) ? 1 : 0;
756 PatBlt( hdc
, r
.left
+ offset
, r
.top
+ offset
,
757 thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
),
758 r
.bottom
- r
.top
- offset
*2,
759 top_selected
? 0x0f0000 : PATCOPY
);
760 r
.left
+= thumbPos
- (arrowSize
- SCROLL_ARROW_THUMB_OVERLAP
);
761 PatBlt( hdc
, r
.left
+ thumbSize
, r
.top
+ offset
,
762 r
.right
- r
.left
- thumbSize
- offset
,
763 r
.bottom
- r
.top
- offset
*2,
764 bottom_selected
? 0x0f0000 : PATCOPY
);
765 r
.right
= r
.left
+ thumbSize
;
770 SelectObject( hdc
, GetSysColorBrush(COLOR_BTNFACE
) );
771 if (TWEAK_WineLook
== WIN31_LOOK
)
773 Rectangle( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
778 Rectangle( hdc
, r
.left
+1, r
.top
+1, r
.right
-1, r
.bottom
-1 );
780 DrawEdge( hdc
, &r
, EDGE_RAISED
, BF_RECT
);
782 if (Save_SCROLL_MovingThumb
&&
783 (SCROLL_TrackingWin
== hwnd
) &&
784 (SCROLL_TrackingBar
== nBar
))
785 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
788 SelectObject( hdc
, hSavePen
);
789 SelectObject( hdc
, hSaveBrush
);
793 /***********************************************************************
794 * SCROLL_DrawScrollBar
796 * Redraw the whole scrollbar.
798 void SCROLL_DrawScrollBar( HWND hwnd
, HDC hdc
, INT nBar
,
799 BOOL arrows
, BOOL interior
)
801 INT arrowSize
, thumbSize
, thumbPos
;
804 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
805 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
);
806 BOOL Save_SCROLL_MovingThumb
= SCROLL_MovingThumb
;
808 if (!wndPtr
|| !infoPtr
||
809 ((nBar
== SB_VERT
) && !(wndPtr
->dwStyle
& WS_VSCROLL
)) ||
810 ((nBar
== SB_HORZ
) && !(wndPtr
->dwStyle
& WS_HSCROLL
))) goto END
;
811 if (!WIN_IsWindowDrawable( hwnd
, FALSE
)) goto END
;
812 hwnd
= wndPtr
->hwndSelf
; /* make it a full handle */
814 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
815 &arrowSize
, &thumbSize
, &thumbPos
);
817 /* do not draw if the scrollbar rectangle is empty */
818 if(IsRectEmpty(&rect
))
821 if (Save_SCROLL_MovingThumb
&&
822 (SCROLL_TrackingWin
== hwnd
) &&
823 (SCROLL_TrackingBar
== nBar
))
824 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
826 /* Draw the arrows */
828 if (arrows
&& arrowSize
)
830 if( vertical
== SCROLL_trackVertical
&& GetCapture() == hwnd
)
831 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
832 (SCROLL_trackHitTest
== SCROLL_TOP_ARROW
),
833 (SCROLL_trackHitTest
== SCROLL_BOTTOM_ARROW
) );
835 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
839 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
840 thumbPos
, infoPtr
->flags
, vertical
, FALSE
, FALSE
);
842 if (Save_SCROLL_MovingThumb
&&
843 (SCROLL_TrackingWin
== hwnd
) &&
844 (SCROLL_TrackingBar
== nBar
))
845 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
847 /* if scroll bar has focus, reposition the caret */
848 if(hwnd
==GetFocus() && (nBar
==SB_CTL
))
852 SetCaretPos(thumbPos
+1, rect
.top
+1);
856 SetCaretPos(rect
.top
+1, thumbPos
+1);
861 WIN_ReleaseWndPtr(wndPtr
);
865 /***********************************************************************
866 * SCROLL_RefreshScrollBar
868 * Repaint the scroll bar interior after a SetScrollRange() or
869 * SetScrollPos() call.
871 static void SCROLL_RefreshScrollBar( HWND hwnd
, INT nBar
,
872 BOOL arrows
, BOOL interior
)
874 HDC hdc
= GetDCEx( hwnd
, 0,
875 DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
) );
878 SCROLL_DrawScrollBar( hwnd
, hdc
, nBar
, arrows
, interior
);
879 ReleaseDC( hwnd
, hdc
);
883 /***********************************************************************
884 * SCROLL_HandleKbdEvent
886 * Handle a keyboard event (only for SB_CTL scrollbars).
888 static void SCROLL_HandleKbdEvent( HWND hwnd
, WPARAM wParam
)
894 case VK_PRIOR
: msg
= SB_PAGEUP
; break;
895 case VK_NEXT
: msg
= SB_PAGEDOWN
; break;
896 case VK_HOME
: msg
= SB_TOP
; break;
897 case VK_END
: msg
= SB_BOTTOM
; break;
898 case VK_UP
: msg
= SB_LINEUP
; break;
899 case VK_DOWN
: msg
= SB_LINEDOWN
; break;
902 SendMessageW( GetParent(hwnd
),
903 (GetWindowLongA( hwnd
, GWL_STYLE
) & SBS_VERT
) ? WM_VSCROLL
: WM_HSCROLL
,
908 /***********************************************************************
909 * SCROLL_HandleScrollEvent
911 * Handle a mouse or timer event for the scrollbar.
912 * 'pt' is the location of the mouse event in client (for SB_CTL) or
913 * windows coordinates.
915 static void SCROLL_HandleScrollEvent( HWND hwnd
, INT nBar
, UINT msg
, POINT pt
)
917 /* Previous mouse position for timer events */
919 /* Thumb position when tracking started. */
920 static UINT trackThumbPos
;
921 /* Position in the scroll-bar of the last button-down event. */
922 static INT lastClickPos
;
923 /* Position in the scroll-bar of the last mouse event. */
924 static INT lastMousePos
;
926 enum SCROLL_HITTEST hittest
;
927 HWND hwndOwner
, hwndCtl
;
929 INT arrowSize
, thumbSize
, thumbPos
;
933 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
);
934 if (!infoPtr
) return;
935 if ((SCROLL_trackHitTest
== SCROLL_NOWHERE
) && (msg
!= WM_LBUTTONDOWN
))
938 hdc
= GetDCEx( hwnd
, 0, DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
));
939 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
940 &arrowSize
, &thumbSize
, &thumbPos
);
941 hwndOwner
= (nBar
== SB_CTL
) ? GetParent(hwnd
) : hwnd
;
942 hwndCtl
= (nBar
== SB_CTL
) ? hwnd
: 0;
946 case WM_LBUTTONDOWN
: /* Initialise mouse tracking */
947 HideCaret(hwnd
); /* hide caret while holding down LBUTTON */
948 SCROLL_trackVertical
= vertical
;
949 SCROLL_trackHitTest
= hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
950 lastClickPos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
951 lastMousePos
= lastClickPos
;
952 trackThumbPos
= thumbPos
;
954 if (nBar
== SB_CTL
&& (GetWindowLongA(hwnd
, GWL_STYLE
) & WS_TABSTOP
)) SetFocus( hwnd
);
959 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, TRUE
);
964 hittest
= SCROLL_NOWHERE
;
966 /* if scrollbar has focus, show back caret */
967 if (hwnd
==GetFocus()) ShowCaret(hwnd
);
972 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
, FALSE
);
976 return; /* Should never happen */
979 TRACE("Event: hwnd=%p bar=%d msg=%s pt=%ld,%ld hit=%d\n",
980 hwnd
, nBar
, SPY_GetMsgName(msg
,hwnd
), pt
.x
, pt
.y
, hittest
);
982 switch(SCROLL_trackHitTest
)
984 case SCROLL_NOWHERE
: /* No tracking in progress */
987 case SCROLL_TOP_ARROW
:
988 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
989 (hittest
== SCROLL_trackHitTest
), FALSE
);
990 if (hittest
== SCROLL_trackHitTest
)
992 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
994 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
995 SB_LINEUP
, (LPARAM
)hwndCtl
);
998 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
999 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1002 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1005 case SCROLL_TOP_RECT
:
1006 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
1007 thumbPos
, infoPtr
->flags
, vertical
,
1008 (hittest
== SCROLL_trackHitTest
), FALSE
);
1009 if (hittest
== SCROLL_trackHitTest
)
1011 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
1013 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1014 SB_PAGEUP
, (LPARAM
)hwndCtl
);
1016 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
1017 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1020 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1024 if (msg
== WM_LBUTTONDOWN
)
1026 SCROLL_TrackingWin
= hwnd
;
1027 SCROLL_TrackingBar
= nBar
;
1028 SCROLL_TrackingPos
= trackThumbPos
+ lastMousePos
- lastClickPos
;
1029 SCROLL_TrackingVal
= SCROLL_GetThumbVal( infoPtr
, &rect
,
1031 SCROLL_TrackingPos
);
1032 if (!SCROLL_MovingThumb
)
1033 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
1035 else if (msg
== WM_LBUTTONUP
)
1037 if (SCROLL_MovingThumb
)
1038 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
1039 SCROLL_TrackingWin
= 0;
1040 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
1041 thumbPos
, infoPtr
->flags
, vertical
,
1044 else /* WM_MOUSEMOVE */
1048 if (!SCROLL_PtInRectEx( &rect
, pt
, vertical
)) pos
= lastClickPos
;
1051 pt
= SCROLL_ClipPos( &rect
, pt
);
1052 pos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
1054 if ( (pos
!= lastMousePos
) || (!SCROLL_MovingThumb
) )
1056 if (SCROLL_MovingThumb
)
1057 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
1058 arrowSize
, thumbSize
);
1060 SCROLL_TrackingPos
= trackThumbPos
+ pos
- lastClickPos
;
1061 SCROLL_TrackingVal
= SCROLL_GetThumbVal( infoPtr
, &rect
,
1063 SCROLL_TrackingPos
);
1064 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1065 MAKEWPARAM( SB_THUMBTRACK
, SCROLL_TrackingVal
),
1067 if (!SCROLL_MovingThumb
)
1068 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
1069 arrowSize
, thumbSize
);
1074 case SCROLL_BOTTOM_RECT
:
1075 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
1076 thumbPos
, infoPtr
->flags
, vertical
,
1077 FALSE
, (hittest
== SCROLL_trackHitTest
) );
1078 if (hittest
== SCROLL_trackHitTest
)
1080 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
1082 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1083 SB_PAGEDOWN
, (LPARAM
)hwndCtl
);
1085 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
1086 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1089 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1092 case SCROLL_BOTTOM_ARROW
:
1093 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
1094 FALSE
, (hittest
== SCROLL_trackHitTest
) );
1095 if (hittest
== SCROLL_trackHitTest
)
1097 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
1099 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1100 SB_LINEDOWN
, (LPARAM
)hwndCtl
);
1103 SetSystemTimer( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
1104 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
1107 else KillSystemTimer( hwnd
, SCROLL_TIMER
);
1111 if (msg
== WM_LBUTTONDOWN
)
1114 if (hittest
== SCROLL_THUMB
)
1116 UINT val
= SCROLL_GetThumbVal( infoPtr
, &rect
, vertical
,
1117 trackThumbPos
+ lastMousePos
- lastClickPos
);
1118 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1119 MAKEWPARAM( SB_THUMBTRACK
, val
), (LPARAM
)hwndCtl
);
1123 if (msg
== WM_LBUTTONUP
)
1125 hittest
= SCROLL_trackHitTest
;
1126 SCROLL_trackHitTest
= SCROLL_NOWHERE
; /* Terminate tracking */
1128 if (hittest
== SCROLL_THUMB
)
1130 UINT val
= SCROLL_GetThumbVal( infoPtr
, &rect
, vertical
,
1131 trackThumbPos
+ lastMousePos
- lastClickPos
);
1132 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1133 MAKEWPARAM( SB_THUMBPOSITION
, val
), (LPARAM
)hwndCtl
);
1135 SendMessageA( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
1136 SB_ENDSCROLL
, (LPARAM
)hwndCtl
);
1139 ReleaseDC( hwnd
, hdc
);
1143 /***********************************************************************
1144 * SCROLL_TrackScrollBar
1146 * Track a mouse button press on a scroll-bar.
1147 * pt is in screen-coordinates for non-client scroll bars.
1149 void SCROLL_TrackScrollBar( HWND hwnd
, INT scrollbar
, POINT pt
)
1152 INT xoffset
= 0, yoffset
= 0;
1154 if (scrollbar
!= SB_CTL
)
1156 WND
*wndPtr
= WIN_GetPtr( hwnd
);
1157 if (!wndPtr
|| wndPtr
== WND_OTHER_PROCESS
) return;
1158 xoffset
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
;
1159 yoffset
= wndPtr
->rectClient
.top
- wndPtr
->rectWindow
.top
;
1160 WIN_ReleasePtr( wndPtr
);
1161 ScreenToClient( hwnd
, &pt
);
1166 SCROLL_HandleScrollEvent( hwnd
, scrollbar
, WM_LBUTTONDOWN
, pt
);
1170 if (!GetMessageW( &msg
, 0, 0, 0 )) break;
1171 if (CallMsgFilterW( &msg
, MSGF_SCROLLBAR
)) continue;
1177 pt
.x
= LOWORD(msg
.lParam
) + xoffset
;
1178 pt
.y
= HIWORD(msg
.lParam
) + yoffset
;
1179 SCROLL_HandleScrollEvent( hwnd
, scrollbar
, msg
.message
, pt
);
1182 TranslateMessage( &msg
);
1183 DispatchMessageW( &msg
);
1186 if (!IsWindow( hwnd
))
1191 } while (msg
.message
!= WM_LBUTTONUP
);
1195 /***********************************************************************
1198 static LRESULT WINAPI
ScrollBarWndProc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
1200 if (!IsWindow( hwnd
)) return 0;
1206 SCROLLBAR_INFO
*infoPtr
;
1207 CREATESTRUCTW
*lpCreat
= (CREATESTRUCTW
*)lParam
;
1209 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, SB_CTL
))) return -1;
1210 if (lpCreat
->style
& WS_DISABLED
)
1212 TRACE("Created WS_DISABLED scrollbar\n");
1213 infoPtr
->flags
= ESB_DISABLE_BOTH
;
1216 if (lpCreat
->style
& SBS_VERT
)
1218 if (lpCreat
->style
& SBS_LEFTALIGN
)
1219 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
1220 GetSystemMetrics(SM_CXVSCROLL
)+1, lpCreat
->cy
, FALSE
);
1221 else if (lpCreat
->style
& SBS_RIGHTALIGN
)
1223 lpCreat
->x
+lpCreat
->cx
-GetSystemMetrics(SM_CXVSCROLL
)-1,
1225 GetSystemMetrics(SM_CXVSCROLL
)+1, lpCreat
->cy
, FALSE
);
1229 if (lpCreat
->style
& SBS_TOPALIGN
)
1230 MoveWindow( hwnd
, lpCreat
->x
, lpCreat
->y
,
1231 lpCreat
->cx
, GetSystemMetrics(SM_CYHSCROLL
)+1, FALSE
);
1232 else if (lpCreat
->style
& SBS_BOTTOMALIGN
)
1235 lpCreat
->y
+lpCreat
->cy
-GetSystemMetrics(SM_CYHSCROLL
)-1,
1236 lpCreat
->cx
, GetSystemMetrics(SM_CYHSCROLL
)+1, FALSE
);
1239 if (!hUpArrow
) SCROLL_LoadBitmaps();
1240 TRACE("ScrollBar creation, hwnd=%p\n", hwnd
);
1245 SCROLLBAR_INFO
*infoPtr
;
1246 if ((infoPtr
= SCROLL_GetScrollInfo( hwnd
, SB_CTL
)))
1248 infoPtr
->flags
= wParam
? ESB_ENABLE_BOTH
: ESB_DISABLE_BOTH
;
1249 SCROLL_RefreshScrollBar(hwnd
, SB_CTL
, TRUE
, TRUE
);
1254 case WM_LBUTTONDOWN
:
1257 pt
.x
= SLOWORD(lParam
);
1258 pt
.y
= SHIWORD(lParam
);
1259 SCROLL_TrackScrollBar( hwnd
, SB_CTL
, pt
);
1267 pt
.x
= SLOWORD(lParam
);
1268 pt
.y
= SHIWORD(lParam
);
1269 SCROLL_HandleScrollEvent( hwnd
, SB_CTL
, message
, pt
);
1273 /* if key event is received, the scrollbar has the focus */
1275 /* hide caret on first KEYDOWN to prevent flicker */
1276 if ((lParam
& 0x40000000)==0)
1278 SCROLL_HandleKbdEvent( hwnd
, wParam
);
1287 /* Create a caret when a ScrollBar get focus */
1289 int arrowSize
, thumbSize
, thumbPos
, vertical
;
1290 vertical
= SCROLL_GetScrollBarRect( hwnd
, SB_CTL
, &rect
,
1291 &arrowSize
, &thumbSize
, &thumbPos
);
1294 CreateCaret(hwnd
, (HBITMAP
)1, thumbSize
-2, rect
.bottom
-rect
.top
-2);
1295 SetCaretPos(thumbPos
+1, rect
.top
+1);
1299 CreateCaret(hwnd
, (HBITMAP
)1, rect
.right
-rect
.left
-2,thumbSize
-2);
1300 SetCaretPos(rect
.top
+1, thumbPos
+1);
1309 int arrowSize
, thumbSize
, thumbPos
, vertical
;
1310 vertical
= SCROLL_GetScrollBarRect( hwnd
, SB_CTL
, &rect
,&arrowSize
, &thumbSize
, &thumbPos
);
1312 rect
.left
=thumbPos
+1;
1313 rect
.right
=rect
.left
+thumbSize
;
1317 rect
.top
=thumbPos
+1;
1318 rect
.bottom
=rect
.top
+thumbSize
;
1321 InvalidateRect(hwnd
,&rect
,0);
1330 return DLGC_WANTARROWS
; /* Windows returns this value */
1335 HDC hdc
= BeginPaint( hwnd
, &ps
);
1336 if (GetWindowLongW( hwnd
, GWL_STYLE
) & SBS_SIZEBOX
)
1337 FillRect( hdc
, &ps
.rcPaint
, GetSysColorBrush(COLOR_SCROLLBAR
) );
1339 SCROLL_DrawScrollBar( hwnd
, hdc
, SB_CTL
, TRUE
, TRUE
);
1340 EndPaint( hwnd
, &ps
);
1346 return SetScrollPos( hwnd
, SB_CTL
, wParam
, (BOOL
)lParam
);
1350 return GetScrollPos( hwnd
, SB_CTL
);
1352 case SBM_SETRANGE16
:
1353 SetScrollRange( hwnd
, SB_CTL
, LOWORD(lParam
), HIWORD(lParam
),
1354 wParam
/* FIXME: Is this correct? */ );
1359 INT oldPos
= GetScrollPos( hwnd
, SB_CTL
);
1360 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, FALSE
);
1361 if (oldPos
!= GetScrollPos( hwnd
, SB_CTL
)) return oldPos
;
1365 case SBM_GETRANGE16
:
1366 FIXME("don't know how to handle SBM_GETRANGE16 (wp=%04x,lp=%08lx)\n", wParam
, lParam
);
1370 GetScrollRange( hwnd
, SB_CTL
, (LPINT
)wParam
, (LPINT
)lParam
);
1373 case SBM_ENABLE_ARROWS16
:
1374 case SBM_ENABLE_ARROWS
:
1375 return EnableScrollBar( hwnd
, SB_CTL
, wParam
);
1377 case SBM_SETRANGEREDRAW
:
1379 INT oldPos
= GetScrollPos( hwnd
, SB_CTL
);
1380 SetScrollRange( hwnd
, SB_CTL
, wParam
, lParam
, TRUE
);
1381 if (oldPos
!= GetScrollPos( hwnd
, SB_CTL
)) return oldPos
;
1385 case SBM_SETSCROLLINFO
:
1386 return SetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
, wParam
);
1388 case SBM_GETSCROLLINFO
:
1389 return GetScrollInfo( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
);
1399 ERR("unknown Win32 msg %04x wp=%08x lp=%08lx\n",
1400 message
, wParam
, lParam
);
1404 if (message
>= WM_USER
)
1405 WARN("unknown msg %04x wp=%04x lp=%08lx\n",
1406 message
, wParam
, lParam
);
1407 return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
1413 /*************************************************************************
1414 * SetScrollInfo (USER32.@)
1415 * SetScrollInfo can be used to set the position, upper bound,
1416 * lower bound, and page size of a scrollbar control.
1419 * Scrollbar position
1422 * For 100 lines of text to be displayed in a window of 25 lines,
1423 * one would for instance use info->nMin=0, info->nMax=75
1424 * (corresponding to the 76 different positions of the window on
1425 * the text), and info->nPage=25.
1427 INT WINAPI
SetScrollInfo(
1428 HWND hwnd
/* [in] Handle of window whose scrollbar will be affected */,
1429 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */,
1430 const SCROLLINFO
*info
/* [in] Specifies what to change and new values */,
1431 BOOL bRedraw
/* [in] Should scrollbar be redrawn afterwards ? */)
1434 INT retVal
= SCROLL_SetScrollInfo( hwnd
, nBar
, info
, &action
);
1436 if( action
& SA_SSI_HIDE
)
1437 SCROLL_ShowScrollBar( hwnd
, nBar
, FALSE
, FALSE
);
1440 if( action
& SA_SSI_SHOW
)
1441 if( SCROLL_ShowScrollBar( hwnd
, nBar
, TRUE
, TRUE
) )
1442 return retVal
; /* SetWindowPos() already did the painting */
1444 if( bRedraw
&& (action
& SA_SSI_REFRESH
))
1445 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);
1446 else if( action
& SA_SSI_REPAINT_ARROWS
)
1447 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, FALSE
);
1452 INT
SCROLL_SetScrollInfo( HWND hwnd
, INT nBar
,
1453 const SCROLLINFO
*info
, INT
*action
)
1455 /* Update the scrollbar state and set action flags according to
1456 * what has to be done graphics wise. */
1458 SCROLLBAR_INFO
*infoPtr
;
1460 BOOL bChangeParams
= FALSE
; /* don't show/hide scrollbar if params don't change */
1464 if (!(infoPtr
= SCROLL_GetScrollInfo(hwnd
, nBar
))) return 0;
1465 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return 0;
1466 if ((info
->cbSize
!= sizeof(*info
)) &&
1467 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return 0;
1469 if (TRACE_ON(scroll
))
1471 TRACE("hwnd=%p bar=%d", hwnd
, nBar
);
1472 if (info
->fMask
& SIF_PAGE
) DPRINTF( " page=%d", info
->nPage
);
1473 if (info
->fMask
& SIF_POS
) DPRINTF( " pos=%d", info
->nPos
);
1474 if (info
->fMask
& SIF_RANGE
) DPRINTF( " min=%d max=%d", info
->nMin
, info
->nMax
);
1478 /* Set the page size */
1480 if (info
->fMask
& SIF_PAGE
)
1482 if( infoPtr
->page
!= info
->nPage
)
1484 infoPtr
->page
= info
->nPage
;
1485 *action
|= SA_SSI_REFRESH
;
1486 bChangeParams
= TRUE
;
1490 /* Set the scroll pos */
1492 if (info
->fMask
& SIF_POS
)
1494 if( infoPtr
->curVal
!= info
->nPos
)
1496 infoPtr
->curVal
= info
->nPos
;
1497 *action
|= SA_SSI_REFRESH
;
1501 /* Set the scroll range */
1503 if (info
->fMask
& SIF_RANGE
)
1505 /* Invalid range -> range is set to (0,0) */
1506 if ((info
->nMin
> info
->nMax
) ||
1507 ((UINT
)(info
->nMax
- info
->nMin
) >= 0x80000000))
1509 infoPtr
->minVal
= 0;
1510 infoPtr
->maxVal
= 0;
1511 bChangeParams
= TRUE
;
1515 if( infoPtr
->minVal
!= info
->nMin
||
1516 infoPtr
->maxVal
!= info
->nMax
)
1518 *action
|= SA_SSI_REFRESH
;
1519 infoPtr
->minVal
= info
->nMin
;
1520 infoPtr
->maxVal
= info
->nMax
;
1521 bChangeParams
= TRUE
;
1526 /* Make sure the page size is valid */
1528 if (infoPtr
->page
< 0) infoPtr
->page
= 0;
1529 else if (infoPtr
->page
> infoPtr
->maxVal
- infoPtr
->minVal
+ 1 )
1530 infoPtr
->page
= infoPtr
->maxVal
- infoPtr
->minVal
+ 1;
1532 /* Make sure the pos is inside the range */
1534 if (infoPtr
->curVal
< infoPtr
->minVal
)
1535 infoPtr
->curVal
= infoPtr
->minVal
;
1536 else if (infoPtr
->curVal
> infoPtr
->maxVal
- max( infoPtr
->page
-1, 0 ))
1537 infoPtr
->curVal
= infoPtr
->maxVal
- max( infoPtr
->page
-1, 0 );
1539 TRACE(" new values: page=%d pos=%d min=%d max=%d\n",
1540 infoPtr
->page
, infoPtr
->curVal
,
1541 infoPtr
->minVal
, infoPtr
->maxVal
);
1543 /* don't change the scrollbar state if SetScrollInfo
1544 * is just called with SIF_DISABLENOSCROLL
1546 if(!(info
->fMask
& SIF_ALL
)) goto done
;
1548 /* Check if the scrollbar should be hidden or disabled */
1550 if (info
->fMask
& (SIF_RANGE
| SIF_PAGE
| SIF_DISABLENOSCROLL
))
1552 new_flags
= infoPtr
->flags
;
1553 if (infoPtr
->minVal
>= infoPtr
->maxVal
- max( infoPtr
->page
-1, 0 ))
1555 /* Hide or disable scroll-bar */
1556 if (info
->fMask
& SIF_DISABLENOSCROLL
)
1558 new_flags
= ESB_DISABLE_BOTH
;
1559 *action
|= SA_SSI_REFRESH
;
1561 else if ((nBar
!= SB_CTL
) && bChangeParams
)
1563 *action
= SA_SSI_HIDE
;
1567 else /* Show and enable scroll-bar */
1570 if ((nBar
!= SB_CTL
) && bChangeParams
)
1571 *action
|= SA_SSI_SHOW
;
1574 if (infoPtr
->flags
!= new_flags
) /* check arrow flags */
1576 infoPtr
->flags
= new_flags
;
1577 *action
|= SA_SSI_REPAINT_ARROWS
;
1582 /* Return current position */
1584 return infoPtr
->curVal
;
1588 /*************************************************************************
1589 * GetScrollInfo (USER32.@)
1590 * GetScrollInfo can be used to retrieve the position, upper bound,
1591 * lower bound, and page size of a scrollbar control.
1595 BOOL WINAPI
GetScrollInfo(
1596 HWND hwnd
/* [in] Handle of window */ ,
1597 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */,
1598 LPSCROLLINFO info
/* [in/out] (info.fMask [in] specifies which values are to retrieve) */)
1600 SCROLLBAR_INFO
*infoPtr
;
1602 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1603 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return FALSE
;
1604 if ((info
->cbSize
!= sizeof(*info
)) &&
1605 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return FALSE
;
1607 if (info
->fMask
& SIF_PAGE
) info
->nPage
= infoPtr
->page
;
1608 if (info
->fMask
& SIF_POS
) info
->nPos
= infoPtr
->curVal
;
1609 if ((info
->fMask
& SIF_TRACKPOS
) && (info
->cbSize
== sizeof(*info
)))
1610 info
->nTrackPos
= (SCROLL_TrackingWin
== WIN_GetFullHandle(hwnd
)) ? SCROLL_TrackingVal
: infoPtr
->curVal
;
1611 if (info
->fMask
& SIF_RANGE
)
1613 info
->nMin
= infoPtr
->minVal
;
1614 info
->nMax
= infoPtr
->maxVal
;
1616 return (info
->fMask
& SIF_ALL
) != 0;
1620 /*************************************************************************
1621 * SetScrollPos (USER32.@)
1624 * Success: Scrollbar position
1628 * Note the ambiguity when 0 is returned. Use GetLastError
1629 * to make sure there was an error (and to know which one).
1631 INT WINAPI
SetScrollPos(
1632 HWND hwnd
/* [in] Handle of window whose scrollbar will be affected */,
1633 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */,
1634 INT nPos
/* [in] New value */,
1635 BOOL bRedraw
/* [in] Should scrollbar be redrawn afterwards ? */ )
1638 SCROLLBAR_INFO
*infoPtr
;
1641 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1642 oldPos
= infoPtr
->curVal
;
1643 info
.cbSize
= sizeof(info
);
1645 info
.fMask
= SIF_POS
;
1646 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1651 /*************************************************************************
1652 * GetScrollPos (USER32.@)
1655 * Success: Current position
1659 * Note the ambiguity when 0 is returned. Use GetLastError
1660 * to make sure there was an error (and to know which one).
1662 INT WINAPI
GetScrollPos(
1663 HWND hwnd
, /* [in] Handle of window */
1664 INT nBar
/* [in] One of SB_HORZ, SB_VERT, or SB_CTL */)
1666 SCROLLBAR_INFO
*infoPtr
;
1668 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1669 return infoPtr
->curVal
;
1673 /*************************************************************************
1674 * SetScrollRange (USER32.@)
1678 BOOL WINAPI
SetScrollRange(
1679 HWND hwnd
, /* [in] Handle of window whose scrollbar will be affected */
1680 INT nBar
, /* [in] One of SB_HORZ, SB_VERT, or SB_CTL */
1681 INT minVal
, /* [in] New minimum value */
1682 INT maxVal
, /* [in] New maximum value */
1683 BOOL bRedraw
/* [in] Should scrollbar be redrawn afterwards ? */)
1687 info
.cbSize
= sizeof(info
);
1690 info
.fMask
= SIF_RANGE
;
1691 SetScrollInfo( hwnd
, nBar
, &info
, bRedraw
);
1696 /*************************************************************************
1697 * SCROLL_SetNCSbState
1699 * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
1701 INT
SCROLL_SetNCSbState(HWND hwnd
, int vMin
, int vMax
, int vPos
,
1702 int hMin
, int hMax
, int hPos
)
1705 SCROLLINFO vInfo
, hInfo
;
1707 vInfo
.cbSize
= hInfo
.cbSize
= sizeof(SCROLLINFO
);
1714 vInfo
.fMask
= hInfo
.fMask
= SIF_RANGE
| SIF_POS
;
1716 SCROLL_SetScrollInfo( hwnd
, SB_VERT
, &vInfo
, &vA
);
1717 SCROLL_SetScrollInfo( hwnd
, SB_HORZ
, &hInfo
, &hA
);
1719 if( !SCROLL_ShowScrollBar( hwnd
, SB_BOTH
,
1720 (hA
& SA_SSI_SHOW
),(vA
& SA_SSI_SHOW
) ) )
1722 /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
1723 if( vA
& SA_SSI_REFRESH
)
1724 SCROLL_RefreshScrollBar( hwnd
, SB_VERT
, FALSE
, TRUE
);
1726 if( hA
& SA_SSI_REFRESH
)
1727 SCROLL_RefreshScrollBar( hwnd
, SB_HORZ
, FALSE
, TRUE
);
1733 /*************************************************************************
1734 * GetScrollRange (USER32.@)
1738 BOOL WINAPI
GetScrollRange(
1739 HWND hwnd
, /* [in] Handle of window */
1740 INT nBar
, /* [in] One of SB_HORZ, SB_VERT, or SB_CTL */
1741 LPINT lpMin
, /* [out] Where to store minimum value */
1742 LPINT lpMax
/* [out] Where to store maximum value */)
1744 SCROLLBAR_INFO
*infoPtr
;
1746 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
)))
1748 if (lpMin
) lpMin
= 0;
1749 if (lpMax
) lpMax
= 0;
1752 if (lpMin
) *lpMin
= infoPtr
->minVal
;
1753 if (lpMax
) *lpMax
= infoPtr
->maxVal
;
1758 /*************************************************************************
1759 * SCROLL_ShowScrollBar()
1761 * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
1763 BOOL
SCROLL_ShowScrollBar( HWND hwnd
, INT nBar
,
1764 BOOL fShowH
, BOOL fShowV
)
1766 LONG style
= GetWindowLongW( hwnd
, GWL_STYLE
);
1768 TRACE("hwnd=%p bar=%d horz=%d, vert=%d\n", hwnd
, nBar
, fShowH
, fShowV
);
1773 ShowWindow( hwnd
, fShowH
? SW_SHOW
: SW_HIDE
);
1780 fShowH
= !(style
& WS_HSCROLL
);
1781 style
|= WS_HSCROLL
;
1785 fShowH
= (style
& WS_HSCROLL
);
1786 style
&= ~WS_HSCROLL
;
1788 if( nBar
== SB_HORZ
) {
1797 fShowV
= !(style
& WS_VSCROLL
);
1798 style
|= WS_VSCROLL
;
1802 fShowV
= (style
& WS_VSCROLL
);
1803 style
&= ~WS_VSCROLL
;
1805 if ( nBar
== SB_VERT
)
1810 return FALSE
; /* Nothing to do! */
1813 if( fShowH
|| fShowV
) /* frame has been changed, let the window redraw itself */
1815 WIN_SetStyle( hwnd
, style
);
1816 SetWindowPos( hwnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
1817 | SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
1820 return FALSE
; /* no frame changes */
1824 /*************************************************************************
1825 * ShowScrollBar (USER32.@)
1829 BOOL WINAPI
ShowScrollBar(
1830 HWND hwnd
, /* [in] Handle of window whose scrollbar(s) will be affected */
1831 INT nBar
, /* [in] One of SB_HORZ, SB_VERT, SB_BOTH or SB_CTL */
1832 BOOL fShow
/* [in] TRUE = show, FALSE = hide */)
1834 SCROLL_ShowScrollBar( hwnd
, nBar
, (nBar
== SB_VERT
) ? 0 : fShow
,
1835 (nBar
== SB_HORZ
) ? 0 : fShow
);
1840 /*************************************************************************
1841 * EnableScrollBar (USER32.@)
1843 BOOL WINAPI
EnableScrollBar( HWND hwnd
, INT nBar
, UINT flags
)
1846 SCROLLBAR_INFO
*infoPtr
;
1848 TRACE("%p %d %d\n", hwnd
, nBar
, flags
);
1850 flags
&= ESB_DISABLE_BOTH
;
1852 if (nBar
== SB_BOTH
)
1854 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, SB_VERT
))) return FALSE
;
1855 if (!(bFineWithMe
= (infoPtr
->flags
== flags
)) )
1857 infoPtr
->flags
= flags
;
1858 SCROLL_RefreshScrollBar( hwnd
, SB_VERT
, TRUE
, TRUE
);
1865 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1866 if (bFineWithMe
&& infoPtr
->flags
== flags
) return FALSE
;
1867 infoPtr
->flags
= flags
;
1869 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
, TRUE
);