4 * Copyright 1993 Martin Ayotte
5 * Copyright 1994, 1996 Alexandre Julliard
10 #include <sys/types.h>
13 #include "sysmetrics.h"
21 static HBITMAP32 hUpArrow
= 0;
22 static HBITMAP32 hDnArrow
= 0;
23 static HBITMAP32 hLfArrow
= 0;
24 static HBITMAP32 hRgArrow
= 0;
25 static HBITMAP32 hUpArrowD
= 0;
26 static HBITMAP32 hDnArrowD
= 0;
27 static HBITMAP32 hLfArrowD
= 0;
28 static HBITMAP32 hRgArrowD
= 0;
29 static HBITMAP32 hUpArrowI
= 0;
30 static HBITMAP32 hDnArrowI
= 0;
31 static HBITMAP32 hLfArrowI
= 0;
32 static HBITMAP32 hRgArrowI
= 0;
34 #define TOP_ARROW(flags,pressed) \
35 (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
36 #define BOTTOM_ARROW(flags,pressed) \
37 (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
38 #define LEFT_ARROW(flags,pressed) \
39 (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
40 #define RIGHT_ARROW(flags,pressed) \
41 (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
44 /* Minimum size of the rectangle between the arrows */
45 #define SCROLL_MIN_RECT 4
47 /* Minimum size of the thumb in pixels */
48 #define SCROLL_MIN_THUMB 6
50 /* Delay (in ms) before first repetition when holding the button down */
51 #define SCROLL_FIRST_DELAY 200
53 /* Delay (in ms) between scroll repetitions */
54 #define SCROLL_REPEAT_DELAY 50
57 #define SCROLL_TIMER 0
59 /* Scroll-bar hit testing */
62 SCROLL_NOWHERE
, /* Outside the scroll bar */
63 SCROLL_TOP_ARROW
, /* Top or left arrow */
64 SCROLL_TOP_RECT
, /* Rectangle between the top arrow and the thumb */
65 SCROLL_THUMB
, /* Thumb rectangle */
66 SCROLL_BOTTOM_RECT
, /* Rectangle between the thumb and the bottom arrow */
67 SCROLL_BOTTOM_ARROW
/* Bottom or right arrow */
70 /* Thumb-tracking info */
71 static HWND32 SCROLL_TrackingWin
= 0;
72 static INT32 SCROLL_TrackingBar
= 0;
73 static INT32 SCROLL_TrackingPos
= 0;
74 static INT32 SCROLL_TrackingVal
= 0;
76 /* Is the moving thumb being displayed? */
77 static BOOL32 SCROLL_MovingThumb
= FALSE
;
79 /***********************************************************************
82 static void SCROLL_LoadBitmaps(void)
84 hUpArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_UPARROW
) );
85 hDnArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_DNARROW
) );
86 hLfArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_LFARROW
) );
87 hRgArrow
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_RGARROW
) );
88 hUpArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_UPARROWD
) );
89 hDnArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_DNARROWD
) );
90 hLfArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_LFARROWD
) );
91 hRgArrowD
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_RGARROWD
) );
92 hUpArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_UPARROWI
) );
93 hDnArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_DNARROWI
) );
94 hLfArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_LFARROWI
) );
95 hRgArrowI
= LoadBitmap32A( 0, MAKEINTRESOURCE32A(OBM_RGARROWI
) );
99 /***********************************************************************
100 * SCROLL_GetPtrScrollInfo
102 static SCROLLBAR_INFO
*SCROLL_GetPtrScrollInfo( WND
* wndPtr
, INT32 nBar
)
104 SCROLLBAR_INFO
*infoPtr
;
106 if (!wndPtr
) return NULL
;
109 case SB_HORZ
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pHScroll
; break;
110 case SB_VERT
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->pVScroll
; break;
111 case SB_CTL
: infoPtr
= (SCROLLBAR_INFO
*)wndPtr
->wExtra
; break;
112 default: return NULL
;
115 if (!infoPtr
) /* Create the info structure if needed */
117 if ((infoPtr
= HeapAlloc( SystemHeap
, 0, sizeof(SCROLLBAR_INFO
) )))
119 infoPtr
->MinVal
= infoPtr
->CurVal
= infoPtr
->Page
= 0;
120 infoPtr
->MaxVal
= 100;
121 infoPtr
->flags
= ESB_ENABLE_BOTH
;
122 if (nBar
== SB_HORZ
) wndPtr
->pHScroll
= infoPtr
;
123 else wndPtr
->pVScroll
= infoPtr
;
125 if (!hUpArrow
) SCROLL_LoadBitmaps();
131 /***********************************************************************
132 * SCROLL_GetScrollInfo
134 static SCROLLBAR_INFO
*SCROLL_GetScrollInfo( HWND32 hwnd
, INT32 nBar
)
136 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
137 return SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
141 /***********************************************************************
142 * SCROLL_GetScrollBarRect
144 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
145 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
146 * 'arrowSize' returns the width or height of an arrow (depending on
147 * the orientation of the scrollbar), 'thumbSize' returns the size of
148 * the thumb, and 'thumbPos' returns the position of the thumb
149 * relative to the left or to the top.
150 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
152 static BOOL32
SCROLL_GetScrollBarRect( HWND32 hwnd
, INT32 nBar
, RECT32
*lprect
,
153 INT32
*arrowSize
, INT32
*thumbSize
,
158 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
163 lprect
->left
= wndPtr
->rectClient
.left
- wndPtr
->rectWindow
.left
- 1;
164 lprect
->top
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
;
165 lprect
->right
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
+1;
166 lprect
->bottom
= lprect
->top
+ SYSMETRICS_CYHSCROLL
+ 1;
171 lprect
->left
= wndPtr
->rectClient
.right
- wndPtr
->rectWindow
.left
;
172 lprect
->top
= wndPtr
->rectClient
.top
- wndPtr
->rectWindow
.top
- 1;
173 lprect
->right
= lprect
->left
+ SYSMETRICS_CXVSCROLL
+ 1;
174 lprect
->bottom
= wndPtr
->rectClient
.bottom
- wndPtr
->rectWindow
.top
+1;
179 GetClientRect32( hwnd
, lprect
);
180 vertical
= ((wndPtr
->dwStyle
& SBS_VERT
) != 0);
187 if (vertical
) pixels
= lprect
->bottom
- lprect
->top
;
188 else pixels
= lprect
->right
- lprect
->left
;
190 if (pixels
<= 2*SYSMETRICS_CXVSCROLL
+ SCROLL_MIN_RECT
)
192 if (pixels
> SCROLL_MIN_RECT
)
193 *arrowSize
= (pixels
- SCROLL_MIN_RECT
) / 2;
196 *thumbPos
= *thumbSize
= 0;
200 SCROLLBAR_INFO
*info
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
202 *arrowSize
= SYSMETRICS_CXVSCROLL
;
203 pixels
-= 2 * SYSMETRICS_CXVSCROLL
;
207 *thumbSize
= pixels
* info
->Page
/ (info
->MaxVal
-info
->MinVal
+1);
208 if (*thumbSize
< SCROLL_MIN_THUMB
) *thumbSize
= SCROLL_MIN_THUMB
;
210 else *thumbSize
= SYSMETRICS_CXVSCROLL
;
212 if (((pixels
-= *thumbSize
+ 1) < 0) ||
213 ((info
->flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
))
215 /* Rectangle too small or scrollbar disabled -> no thumb */
216 *thumbPos
= *thumbSize
= 0;
220 INT32 max
= info
->MaxVal
- MAX( info
->Page
-1, 0 );
221 if (info
->MinVal
>= max
)
222 *thumbPos
= *arrowSize
;
224 *thumbPos
= *arrowSize
+ pixels
* (info
->CurVal
-info
->MinVal
) /
225 (max
- info
->MinVal
);
232 /***********************************************************************
235 * Compute the current scroll position based on the thumb position in pixels
236 * from the top of the scroll-bar.
238 static UINT32
SCROLL_GetThumbVal( SCROLLBAR_INFO
*infoPtr
, RECT32
*rect
,
239 BOOL32 vertical
, INT32 pos
)
242 INT32 pixels
= vertical
? rect
->bottom
-rect
->top
: rect
->right
-rect
->left
;
244 if ((pixels
-= 2*SYSMETRICS_CXVSCROLL
) <= 0) return infoPtr
->MinVal
;
248 thumbSize
= pixels
* infoPtr
->Page
/(infoPtr
->MaxVal
-infoPtr
->MinVal
+1);
249 if (thumbSize
< SCROLL_MIN_THUMB
) thumbSize
= SCROLL_MIN_THUMB
;
251 else thumbSize
= SYSMETRICS_CXVSCROLL
;
253 if ((pixels
-= thumbSize
+ 1) <= 0) return infoPtr
->MinVal
;
255 pos
= MAX( 0, pos
- SYSMETRICS_CXVSCROLL
);
256 if (pos
> pixels
) pos
= pixels
;
258 if (!infoPtr
->Page
) pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
;
259 else pos
*= infoPtr
->MaxVal
- infoPtr
->MinVal
- infoPtr
->Page
+ 1;
260 return infoPtr
->MinVal
+ ((pos
+ pixels
/ 2) / pixels
);
264 /***********************************************************************
267 * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
269 static enum SCROLL_HITTEST
SCROLL_HitTest( HWND32 hwnd
, INT32 nBar
,
272 INT32 arrowSize
, thumbSize
, thumbPos
;
275 BOOL32 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
276 &arrowSize
, &thumbSize
, &thumbPos
);
277 if (!PtInRect32( &rect
, pt
)) return SCROLL_NOWHERE
;
281 if (pt
.y
<= rect
.top
+ arrowSize
+ 1) return SCROLL_TOP_ARROW
;
282 if (pt
.y
>= rect
.bottom
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
283 if (!thumbPos
) return SCROLL_TOP_RECT
;
285 if (pt
.y
< thumbPos
) return SCROLL_TOP_RECT
;
286 if (pt
.y
> thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
289 else /* horizontal */
291 if (pt
.x
<= rect
.left
+ arrowSize
) return SCROLL_TOP_ARROW
;
292 if (pt
.x
>= rect
.right
- arrowSize
) return SCROLL_BOTTOM_ARROW
;
293 if (!thumbPos
) return SCROLL_TOP_RECT
;
295 if (pt
.x
< thumbPos
) return SCROLL_TOP_RECT
;
296 if (pt
.x
> thumbPos
+ thumbSize
) return SCROLL_BOTTOM_RECT
;
302 /***********************************************************************
305 * Draw the scroll bar arrows.
307 static void SCROLL_DrawArrows( HDC32 hdc
, SCROLLBAR_INFO
*infoPtr
,
308 RECT32
*rect
, INT32 arrowSize
, BOOL32 vertical
,
309 BOOL32 top_pressed
, BOOL32 bottom_pressed
)
311 HDC32 hdcMem
= CreateCompatibleDC32( hdc
);
312 HBITMAP32 hbmpPrev
= SelectObject32( hdcMem
, vertical
?
313 TOP_ARROW(infoPtr
->flags
, top_pressed
)
314 : LEFT_ARROW(infoPtr
->flags
, top_pressed
));
315 SetStretchBltMode32( hdc
, STRETCH_DELETESCANS
);
316 StretchBlt32( hdc
, rect
->left
, rect
->top
,
317 vertical
? rect
->right
-rect
->left
: arrowSize
+1,
318 vertical
? arrowSize
+1 : rect
->bottom
-rect
->top
,
320 SYSMETRICS_CXVSCROLL
+ 1, SYSMETRICS_CYHSCROLL
+ 1,
323 SelectObject32( hdcMem
, vertical
?
324 BOTTOM_ARROW( infoPtr
->flags
, bottom_pressed
)
325 : RIGHT_ARROW( infoPtr
->flags
, bottom_pressed
) );
327 StretchBlt32( hdc
, rect
->left
, rect
->bottom
- arrowSize
- 1,
328 rect
->right
- rect
->left
, arrowSize
+ 1,
330 SYSMETRICS_CXVSCROLL
+ 1, SYSMETRICS_CYHSCROLL
+ 1,
333 StretchBlt32( hdc
, rect
->right
- arrowSize
- 1, rect
->top
,
334 arrowSize
+ 1, rect
->bottom
- rect
->top
,
336 SYSMETRICS_CXVSCROLL
+ 1, SYSMETRICS_CYHSCROLL
+ 1,
338 SelectObject32( hdcMem
, hbmpPrev
);
339 DeleteDC32( hdcMem
);
343 /***********************************************************************
344 * SCROLL_DrawMovingThumb
346 * Draw the moving thumb rectangle.
348 static void SCROLL_DrawMovingThumb( HDC32 hdc
, RECT32
*rect
, BOOL32 vertical
,
349 INT32 arrowSize
, INT32 thumbSize
)
354 r
.top
+= SCROLL_TrackingPos
;
355 if (r
.top
< rect
->top
+ arrowSize
) r
.top
= rect
->top
+ arrowSize
;
356 if (r
.top
+ thumbSize
>= rect
->bottom
- arrowSize
)
357 r
.top
= rect
->bottom
- arrowSize
- thumbSize
- 1;
358 r
.bottom
= r
.top
+ thumbSize
+ 1;
362 r
.left
+= SCROLL_TrackingPos
;
363 if (r
.left
< rect
->left
+ arrowSize
) r
.left
= rect
->left
+ arrowSize
;
364 if (r
.left
+ thumbSize
>= rect
->right
- arrowSize
)
365 r
.left
= rect
->right
- arrowSize
- thumbSize
- 1;
366 r
.right
= r
.left
+ thumbSize
+ 1;
368 InflateRect32( &r
, -1, -1 );
369 DrawFocusRect32( hdc
, &r
);
370 SCROLL_MovingThumb
= !SCROLL_MovingThumb
;
374 /***********************************************************************
375 * SCROLL_DrawInterior
377 * Draw the scroll bar interior (everything except the arrows).
379 static void SCROLL_DrawInterior( HWND32 hwnd
, HDC32 hdc
, INT32 nBar
,
380 RECT32
*rect
, INT32 arrowSize
,
381 INT32 thumbSize
, INT32 thumbPos
,
382 UINT32 flags
, BOOL32 vertical
,
383 BOOL32 top_selected
, BOOL32 bottom_selected
)
387 /* Select the correct brush and pen */
389 SelectObject32( hdc
, GetSysColorPen32(COLOR_WINDOWFRAME
) );
390 if ((flags
& ESB_DISABLE_BOTH
) == ESB_DISABLE_BOTH
)
392 /* This ought to be the color of the parent window */
393 SelectObject32( hdc
, GetSysColorBrush32(COLOR_WINDOW
) );
397 if (nBar
== SB_CTL
) /* Only scrollbar controls send WM_CTLCOLOR */
399 HBRUSH32 hbrush
= SendMessage32A(GetParent32(hwnd
),
400 WM_CTLCOLORSCROLLBAR
, hdc
, hwnd
);
401 SelectObject32( hdc
, hbrush
);
403 else SelectObject32( hdc
, GetSysColorBrush32(COLOR_SCROLLBAR
) );
406 /* Calculate the scroll rectangle */
411 r
.top
+= arrowSize
- 1;
412 r
.bottom
-= arrowSize
;
417 r
.left
+= arrowSize
- 1;
418 r
.right
-= arrowSize
;
422 /* Draw the scroll bar frame */
424 GRAPH_DrawRectangle( hdc
, r
.left
, r
.top
, r
.right
- r
.left
, r
.bottom
- r
.top
, 0);
426 /* Draw the scroll rectangles and thumb */
428 if (!thumbPos
) /* No thumb to draw */
430 PatBlt32( hdc
, r
.left
+1, r
.top
+1, r
.right
- r
.left
- 2,
431 r
.bottom
- r
.top
- 2, PATCOPY
);
437 PatBlt32( hdc
, r
.left
+ 1, r
.top
+ 1,
438 r
.right
- r
.left
- 2,
439 thumbPos
- arrowSize
,
440 top_selected
? 0x0f0000 : PATCOPY
);
441 r
.top
+= thumbPos
- arrowSize
;
442 PatBlt32( hdc
, r
.left
+ 1, r
.top
+ thumbSize
+ 1,
443 r
.right
- r
.left
- 2,
444 r
.bottom
- r
.top
- thumbSize
- 2,
445 bottom_selected
? 0x0f0000 : PATCOPY
);
446 r
.bottom
= r
.top
+ thumbSize
+ 2;
448 else /* horizontal */
450 PatBlt32( hdc
, r
.left
+ 1, r
.top
+ 1,
451 thumbPos
- arrowSize
,
452 r
.bottom
- r
.top
- 2,
453 top_selected
? 0x0f0000 : PATCOPY
);
454 r
.left
+= thumbPos
- arrowSize
;
455 PatBlt32( hdc
, r
.left
+ thumbSize
+ 1, r
.top
+ 1,
456 r
.right
- r
.left
- thumbSize
- 2,
457 r
.bottom
- r
.top
- 2,
458 bottom_selected
? 0x0f0000 : PATCOPY
);
459 r
.right
= r
.left
+ thumbSize
+ 2;
464 SelectObject32( hdc
, GetSysColorBrush32(COLOR_BTNFACE
) );
465 Rectangle32( hdc
, r
.left
, r
.top
, r
.right
, r
.bottom
);
466 InflateRect32( &r
, -1, -1 );
467 GRAPH_DrawReliefRect( hdc
, &r
, 1, 2, FALSE
);
468 if (SCROLL_MovingThumb
&&
469 (SCROLL_TrackingWin
== hwnd
) &&
470 (SCROLL_TrackingBar
== nBar
))
472 SCROLL_DrawMovingThumb( hdc
, rect
, vertical
, arrowSize
, thumbSize
);
473 SCROLL_MovingThumb
= TRUE
;
478 /***********************************************************************
479 * SCROLL_DrawScrollBar
481 * Redraw the whole scrollbar.
483 void SCROLL_DrawScrollBar( HWND32 hwnd
, HDC32 hdc
, INT32 nBar
, BOOL32 arrows
)
485 INT32 arrowSize
, thumbSize
, thumbPos
;
488 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
489 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetPtrScrollInfo( wndPtr
, nBar
);
491 if (!wndPtr
|| !infoPtr
||
492 ((nBar
== SB_VERT
) && !(wndPtr
->dwStyle
& WS_VSCROLL
)) ||
493 ((nBar
== SB_HORZ
) && !(wndPtr
->dwStyle
& WS_HSCROLL
))) return;
495 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
496 &arrowSize
, &thumbSize
, &thumbPos
);
497 /* Draw the arrows */
499 if (arrows
&& arrowSize
) SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
,
500 vertical
, FALSE
, FALSE
);
502 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
503 thumbPos
, infoPtr
->flags
, vertical
, FALSE
, FALSE
);
507 /***********************************************************************
508 * SCROLL_RefreshScrollBar
510 * Repaint the scroll bar interior after a SetScrollRange() or
511 * SetScrollPos() call.
513 static void SCROLL_RefreshScrollBar( HWND32 hwnd
, INT32 nBar
, BOOL32 arrows
)
515 HDC32 hdc
= GetDCEx32( hwnd
, 0,
516 DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
) );
518 SCROLL_DrawScrollBar( hwnd
, hdc
, nBar
, arrows
);
519 ReleaseDC32( hwnd
, hdc
);
523 /***********************************************************************
524 * SCROLL_HandleKbdEvent
526 * Handle a keyboard event (only for SB_CTL scrollbars).
528 static void SCROLL_HandleKbdEvent( HWND32 hwnd
, WPARAM32 wParam
)
530 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
535 case VK_PRIOR
: msg
= SB_PAGEUP
; break;
536 case VK_NEXT
: msg
= SB_PAGEDOWN
; break;
537 case VK_HOME
: msg
= SB_TOP
; break;
538 case VK_END
: msg
= SB_BOTTOM
; break;
539 case VK_UP
: msg
= SB_LINEUP
; break;
540 case VK_DOWN
: msg
= SB_LINEDOWN
; break;
544 SendMessage32A( GetParent32(hwnd
),
545 (wndPtr
->dwStyle
& SBS_VERT
) ? WM_VSCROLL
: WM_HSCROLL
,
550 /***********************************************************************
551 * SCROLL_HandleScrollEvent
553 * Handle a mouse or timer event for the scrollbar.
554 * 'pt' is the location of the mouse event in client (for SB_CTL) or
555 * windows coordinates.
557 void SCROLL_HandleScrollEvent( HWND32 hwnd
, INT32 nBar
, UINT32 msg
, POINT32 pt
)
559 /* Previous mouse position for timer events */
560 static POINT32 prevPt
;
561 /* Hit test code of the last button-down event */
562 static enum SCROLL_HITTEST trackHitTest
;
563 /* Thumb position when tracking started. */
564 static UINT32 trackThumbPos
;
565 /* Position in the scroll-bar of the last button-down event. */
566 static INT32 lastClickPos
;
567 /* Position in the scroll-bar of the last mouse event. */
568 static INT32 lastMousePos
;
570 enum SCROLL_HITTEST hittest
;
571 HWND32 hwndOwner
, hwndCtl
;
573 INT32 arrowSize
, thumbSize
, thumbPos
;
577 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
);
578 if (!infoPtr
) return;
579 if ((trackHitTest
== SCROLL_NOWHERE
) && (msg
!= WM_LBUTTONDOWN
)) return;
581 hdc
= GetDCEx32( hwnd
, 0, DCX_CACHE
| ((nBar
== SB_CTL
) ? 0 : DCX_WINDOW
));
582 vertical
= SCROLL_GetScrollBarRect( hwnd
, nBar
, &rect
,
583 &arrowSize
, &thumbSize
, &thumbPos
);
584 hwndOwner
= (nBar
== SB_CTL
) ? GetParent32(hwnd
) : hwnd
;
585 hwndCtl
= (nBar
== SB_CTL
) ? hwnd
: 0;
589 case WM_LBUTTONDOWN
: /* Initialise mouse tracking */
590 trackHitTest
= hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
);
591 lastClickPos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
592 lastMousePos
= lastClickPos
;
593 trackThumbPos
= thumbPos
;
595 SetCapture32( hwnd
);
596 if (nBar
== SB_CTL
) SetFocus32( hwnd
);
600 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
);
605 hittest
= SCROLL_NOWHERE
;
611 hittest
= SCROLL_HitTest( hwnd
, nBar
, pt
);
615 return; /* Should never happen */
618 TRACE(scroll
, "Event: hwnd=%04x bar=%d msg=%x pt=%d,%d hit=%d\n",
619 hwnd
, nBar
, msg
, pt
.x
, pt
.y
, hittest
);
623 case SCROLL_NOWHERE
: /* No tracking in progress */
626 case SCROLL_TOP_ARROW
:
627 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
628 (hittest
== trackHitTest
), FALSE
);
629 if (hittest
== trackHitTest
)
631 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
633 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
634 SB_LINEUP
, hwndCtl
);
635 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
636 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
640 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
643 case SCROLL_TOP_RECT
:
644 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
645 thumbPos
, infoPtr
->flags
, vertical
,
646 (hittest
== trackHitTest
), FALSE
);
647 if (hittest
== trackHitTest
)
649 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
651 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
652 SB_PAGEUP
, hwndCtl
);
653 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
654 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
658 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
662 if (msg
== WM_LBUTTONDOWN
)
664 SCROLL_TrackingWin
= hwnd
;
665 SCROLL_TrackingBar
= nBar
;
666 SCROLL_TrackingPos
= trackThumbPos
+ lastMousePos
- lastClickPos
;
667 SCROLL_DrawMovingThumb(hdc
, &rect
, vertical
, arrowSize
, thumbSize
);
669 else if (msg
== WM_LBUTTONUP
)
671 SCROLL_TrackingWin
= 0;
672 SCROLL_MovingThumb
= FALSE
;
673 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
674 thumbPos
, infoPtr
->flags
, vertical
,
677 else /* WM_MOUSEMOVE */
681 if (!PtInRect32( &rect
, pt
)) pos
= lastClickPos
;
682 else pos
= vertical
? (pt
.y
- rect
.top
) : (pt
.x
- rect
.left
);
683 if (pos
!= lastMousePos
)
685 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
686 arrowSize
, thumbSize
);
688 SCROLL_TrackingPos
= trackThumbPos
+ pos
- lastClickPos
;
689 SCROLL_TrackingVal
= SCROLL_GetThumbVal( infoPtr
, &rect
,
691 SCROLL_TrackingPos
);
692 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
693 MAKEWPARAM( SB_THUMBTRACK
, SCROLL_TrackingVal
),
695 SCROLL_DrawMovingThumb( hdc
, &rect
, vertical
,
696 arrowSize
, thumbSize
);
701 case SCROLL_BOTTOM_RECT
:
702 SCROLL_DrawInterior( hwnd
, hdc
, nBar
, &rect
, arrowSize
, thumbSize
,
703 thumbPos
, infoPtr
->flags
, vertical
,
704 FALSE
, (hittest
== trackHitTest
) );
705 if (hittest
== trackHitTest
)
707 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
709 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
710 SB_PAGEDOWN
, hwndCtl
);
711 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
712 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
716 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
719 case SCROLL_BOTTOM_ARROW
:
720 SCROLL_DrawArrows( hdc
, infoPtr
, &rect
, arrowSize
, vertical
,
721 FALSE
, (hittest
== trackHitTest
) );
722 if (hittest
== trackHitTest
)
724 if ((msg
== WM_LBUTTONDOWN
) || (msg
== WM_SYSTIMER
))
726 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
727 SB_LINEDOWN
, hwndCtl
);
728 SetSystemTimer32( hwnd
, SCROLL_TIMER
, (msg
== WM_LBUTTONDOWN
) ?
729 SCROLL_FIRST_DELAY
: SCROLL_REPEAT_DELAY
,
733 else KillSystemTimer32( hwnd
, SCROLL_TIMER
);
737 if (msg
== WM_LBUTTONUP
)
739 if (trackHitTest
== SCROLL_THUMB
)
741 UINT32 val
= SCROLL_GetThumbVal( infoPtr
, &rect
, vertical
,
742 trackThumbPos
+ lastMousePos
- lastClickPos
);
743 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
744 MAKEWPARAM( SB_THUMBPOSITION
, val
), hwndCtl
);
747 SendMessage32A( hwndOwner
, vertical
? WM_VSCROLL
: WM_HSCROLL
,
748 SB_ENDSCROLL
, hwndCtl
);
749 trackHitTest
= SCROLL_NOWHERE
; /* Terminate tracking */
752 ReleaseDC32( hwnd
, hdc
);
756 /***********************************************************************
759 LRESULT WINAPI
ScrollBarWndProc( HWND32 hwnd
, UINT32 message
, WPARAM32 wParam
,
766 CREATESTRUCT32A
*lpCreat
= (CREATESTRUCT32A
*)lParam
;
767 if (lpCreat
->style
& SBS_SIZEBOX
)
769 FIXME(scroll
, "Unimplemented style SBS_SIZEBOX.\n" );
773 if (lpCreat
->style
& SBS_VERT
)
775 if (lpCreat
->style
& SBS_LEFTALIGN
)
776 MoveWindow32( hwnd
, lpCreat
->x
, lpCreat
->y
,
777 SYSMETRICS_CXVSCROLL
+1, lpCreat
->cy
, FALSE
);
778 else if (lpCreat
->style
& SBS_RIGHTALIGN
)
780 lpCreat
->x
+lpCreat
->cx
-SYSMETRICS_CXVSCROLL
-1,
782 SYSMETRICS_CXVSCROLL
+1, lpCreat
->cy
, FALSE
);
786 if (lpCreat
->style
& SBS_TOPALIGN
)
787 MoveWindow32( hwnd
, lpCreat
->x
, lpCreat
->y
,
788 lpCreat
->cx
, SYSMETRICS_CYHSCROLL
+1, FALSE
);
789 else if (lpCreat
->style
& SBS_BOTTOMALIGN
)
792 lpCreat
->y
+lpCreat
->cy
-SYSMETRICS_CYHSCROLL
-1,
793 lpCreat
->cx
, SYSMETRICS_CYHSCROLL
+1, FALSE
);
796 if (!hUpArrow
) SCROLL_LoadBitmaps();
797 TRACE(scroll
, "ScrollBar creation, hwnd=%04x\n", hwnd
);
806 CONV_POINT16TO32( (POINT16
*)&lParam
, &pt
);
807 SCROLL_HandleScrollEvent( hwnd
, SB_CTL
, message
, pt
);
812 SCROLL_HandleKbdEvent( hwnd
, wParam
);
819 return DLGC_WANTARROWS
; /* Windows returns this value */
824 HDC32 hdc
= BeginPaint32( hwnd
, &ps
);
825 SCROLL_DrawScrollBar( hwnd
, hdc
, SB_CTL
, TRUE
);
826 EndPaint32( hwnd
, &ps
);
832 return SetScrollPos32( hwnd
, SB_CTL
, wParam
, (BOOL32
)lParam
);
836 return GetScrollPos32( hwnd
, SB_CTL
);
839 SetScrollRange32( hwnd
, SB_CTL
, LOWORD(lParam
), HIWORD(lParam
),
840 wParam
/* FIXME: Is this correct? */ );
844 SetScrollRange32( hwnd
, SB_CTL
, wParam
, lParam
, FALSE
);
845 return 0; /* FIXME: return previous position */
848 FIXME(scroll
, "don't know how to handle SBM_GETRANGE16 (wp=%04x,lp=%08lx)\n", wParam
, lParam
);
852 GetScrollRange32( hwnd
, SB_CTL
, (LPINT32
)wParam
, (LPINT32
)lParam
);
855 case SBM_ENABLE_ARROWS16
:
856 case SBM_ENABLE_ARROWS32
:
857 return EnableScrollBar32( hwnd
, SB_CTL
, wParam
);
859 case SBM_SETRANGEREDRAW32
:
860 SetScrollRange32( hwnd
, SB_CTL
, wParam
, lParam
, TRUE
);
861 return 0; /* FIXME: return previous position */
863 case SBM_SETSCROLLINFO32
:
864 return SetScrollInfo32( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
, wParam
);
866 case SBM_GETSCROLLINFO32
:
867 return GetScrollInfo32( hwnd
, SB_CTL
, (SCROLLINFO
*)lParam
);
877 ERR(scroll
, "unknown Win32 msg %04x wp=%08x lp=%08lx\n",
878 message
, wParam
, lParam
);
882 if (message
>= WM_USER
)
883 WARN(scroll
, "unknown msg %04x wp=%04x lp=%08lx\n",
884 message
, wParam
, lParam
);
885 return DefWindowProc32A( hwnd
, message
, wParam
, lParam
);
891 /*************************************************************************
892 * SetScrollInfo16 (USER.475)
894 INT16 WINAPI
SetScrollInfo16( HWND16 hwnd
, INT16 nBar
, const SCROLLINFO
*info
,
897 return (INT16
)SetScrollInfo32( hwnd
, nBar
, info
, bRedraw
);
901 /*************************************************************************
902 * SetScrollInfo32 (USER32.501)
904 INT32 WINAPI
SetScrollInfo32( HWND32 hwnd
, INT32 nBar
, const SCROLLINFO
*info
,
907 SCROLLBAR_INFO
*infoPtr
;
909 BOOL32 repaint_arrows
= FALSE
;
910 dbg_decl_str(scroll
, 256);
912 if (!(infoPtr
= SCROLL_GetScrollInfo(hwnd
, nBar
))) return 0;
913 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return 0;
914 if ((info
->cbSize
!= sizeof(*info
)) &&
915 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return 0;
917 /* Set the page size */
919 if (info
->fMask
& SIF_PAGE
)
921 dsprintf(scroll
, " page=%d", info
->nPage
);
922 infoPtr
->Page
= info
->nPage
;
925 /* Set the scroll pos */
927 if (info
->fMask
& SIF_POS
)
929 dsprintf(scroll
, " pos=%d", info
->nPos
);
930 infoPtr
->CurVal
= info
->nPos
;
933 /* Set the scroll range */
935 if (info
->fMask
& SIF_RANGE
)
937 dsprintf(scroll
, " min=%d max=%d", info
->nMin
, info
->nMax
);
939 /* Invalid range -> range is set to (0,0) */
940 if ((info
->nMin
> info
->nMax
) ||
941 ((UINT32
)(info
->nMax
- info
->nMin
) >= 0x80000000))
948 infoPtr
->MinVal
= info
->nMin
;
949 infoPtr
->MaxVal
= info
->nMax
;
953 TRACE(scroll
, "hwnd=%04x bar=%d %s\n",
954 hwnd
, nBar
, dbg_str(scroll
));
956 /* Make sure the page size is valid */
958 if (infoPtr
->Page
< 0) infoPtr
->Page
= 0;
959 else if (infoPtr
->Page
> infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1 )
960 infoPtr
->Page
= infoPtr
->MaxVal
- infoPtr
->MinVal
+ 1;
962 /* Make sure the pos is inside the range */
964 if (infoPtr
->CurVal
< infoPtr
->MinVal
)
965 infoPtr
->CurVal
= infoPtr
->MinVal
;
966 else if (infoPtr
->CurVal
> infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
967 infoPtr
->CurVal
= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 );
969 TRACE(scroll
, " new values: page=%d pos=%d min=%d max=%d\n",
970 infoPtr
->Page
, infoPtr
->CurVal
,
971 infoPtr
->MinVal
, infoPtr
->MaxVal
);
973 /* Check if the scrollbar should be hidden or disabled */
975 if (info
->fMask
& (SIF_RANGE
| SIF_PAGE
| SIF_DISABLENOSCROLL
))
977 new_flags
= infoPtr
->flags
;
978 if (infoPtr
->MinVal
>= infoPtr
->MaxVal
- MAX( infoPtr
->Page
-1, 0 ))
980 /* Hide or disable scroll-bar */
981 if (info
->fMask
& SIF_DISABLENOSCROLL
)
982 new_flags
= ESB_DISABLE_BOTH
;
983 else if (nBar
!= SB_CTL
)
985 ShowScrollBar32( hwnd
, nBar
, FALSE
);
986 bRedraw
= FALSE
; /* No need to repaint anything */
989 else /* Show and enable scroll-bar */
992 if (nBar
!= SB_CTL
) ShowScrollBar32( hwnd
, nBar
, TRUE
);
995 if (infoPtr
->flags
!= new_flags
)
997 infoPtr
->flags
= new_flags
;
998 repaint_arrows
= TRUE
;
1002 if (bRedraw
|| repaint_arrows
)
1003 SCROLL_RefreshScrollBar( hwnd
, nBar
, repaint_arrows
);
1005 /* Return current position */
1007 return infoPtr
->CurVal
;
1011 /*************************************************************************
1012 * GetScrollInfo16 (USER.476)
1014 BOOL16 WINAPI
GetScrollInfo16( HWND16 hwnd
, INT16 nBar
, LPSCROLLINFO info
)
1016 return GetScrollInfo32( hwnd
, nBar
, info
);
1020 /*************************************************************************
1021 * GetScrollInfo32 (USER32.284)
1023 BOOL32 WINAPI
GetScrollInfo32( HWND32 hwnd
, INT32 nBar
, LPSCROLLINFO info
)
1025 SCROLLBAR_INFO
*infoPtr
;
1027 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1028 if (info
->fMask
& ~(SIF_ALL
| SIF_DISABLENOSCROLL
)) return FALSE
;
1029 if ((info
->cbSize
!= sizeof(*info
)) &&
1030 (info
->cbSize
!= sizeof(*info
)-sizeof(info
->nTrackPos
))) return FALSE
;
1032 if (info
->fMask
& SIF_PAGE
) info
->nPage
= infoPtr
->Page
;
1033 if (info
->fMask
& SIF_POS
) info
->nPos
= infoPtr
->CurVal
;
1034 if ((info
->fMask
& SIF_TRACKPOS
) && (info
->cbSize
== sizeof(*info
)))
1035 info
->nTrackPos
= (SCROLL_TrackingWin
==hwnd
) ? SCROLL_TrackingVal
: 0;
1036 if (info
->fMask
& SIF_RANGE
)
1038 info
->nMin
= infoPtr
->MinVal
;
1039 info
->nMax
= infoPtr
->MaxVal
;
1041 return (info
->fMask
& SIF_ALL
) != 0;
1045 /*************************************************************************
1046 * SetScrollPos16 (USER.62)
1048 INT16 WINAPI
SetScrollPos16( HWND16 hwnd
, INT16 nBar
, INT16 nPos
,
1051 return (INT16
)SetScrollPos32( hwnd
, nBar
, nPos
, bRedraw
);
1055 /*************************************************************************
1056 * SetScrollPos32 (USER32.502)
1058 INT32 WINAPI
SetScrollPos32( HWND32 hwnd
, INT32 nBar
, INT32 nPos
,
1062 SCROLLBAR_INFO
*infoPtr
;
1065 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1066 oldPos
= infoPtr
->CurVal
;
1067 info
.cbSize
= sizeof(info
);
1069 info
.fMask
= SIF_POS
;
1070 SetScrollInfo32( hwnd
, nBar
, &info
, bRedraw
);
1075 /*************************************************************************
1076 * GetScrollPos16 (USER.63)
1078 INT16 WINAPI
GetScrollPos16( HWND16 hwnd
, INT16 nBar
)
1080 return (INT16
)GetScrollPos32( hwnd
, nBar
);
1084 /*************************************************************************
1085 * GetScrollPos32 (USER32.285)
1087 INT32 WINAPI
GetScrollPos32( HWND32 hwnd
, INT32 nBar
)
1089 SCROLLBAR_INFO
*infoPtr
;
1091 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return 0;
1092 return infoPtr
->CurVal
;
1096 /*************************************************************************
1097 * SetScrollRange16 (USER.64)
1099 void WINAPI
SetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1100 INT16 MinVal
, INT16 MaxVal
, BOOL16 bRedraw
)
1102 /* Invalid range -> range is set to (0,0) */
1103 if ((INT32
)MaxVal
- (INT32
)MinVal
> 0x7fff) MinVal
= MaxVal
= 0;
1104 SetScrollRange32( hwnd
, nBar
, MinVal
, MaxVal
, bRedraw
);
1108 /*************************************************************************
1109 * SetScrollRange32 (USER32.503)
1111 BOOL32 WINAPI
SetScrollRange32( HWND32 hwnd
, INT32 nBar
,
1112 INT32 MinVal
, INT32 MaxVal
, BOOL32 bRedraw
)
1116 info
.cbSize
= sizeof(info
);
1119 info
.fMask
= SIF_RANGE
;
1120 SetScrollInfo32( hwnd
, nBar
, &info
, bRedraw
);
1125 /*************************************************************************
1126 * SCROLL_SetNCSbState
1128 * This is for CalcChildScroll in windows/mdi.c
1130 DWORD
SCROLL_SetNCSbState(WND
* wndPtr
, int vMin
, int vMax
, int vPos
,
1131 int hMin
, int hMax
, int hPos
)
1133 SCROLLBAR_INFO
*infoPtr
= SCROLL_GetPtrScrollInfo(wndPtr
, SB_VERT
);
1135 wndPtr
->dwStyle
|= (WS_VSCROLL
| WS_HSCROLL
);
1139 wndPtr
->dwStyle
&= ~WS_VSCROLL
; }
1140 if( vPos
> vMax
) vPos
= vMax
; else if( vPos
< vMin
) vPos
= vMin
;
1141 infoPtr
->MinVal
= vMin
;
1142 infoPtr
->MaxVal
= vMax
;
1143 infoPtr
->CurVal
= vPos
;
1145 infoPtr
= SCROLL_GetPtrScrollInfo(wndPtr
, SB_HORZ
);
1149 wndPtr
->dwStyle
&= ~WS_HSCROLL
; }
1150 if( hPos
> hMax
) hPos
= hMax
; else if( hPos
< hMin
) hPos
= hMin
;
1151 infoPtr
->MinVal
= hMin
;
1152 infoPtr
->MaxVal
= hMax
;
1153 infoPtr
->CurVal
= hPos
;
1155 return wndPtr
->dwStyle
& (WS_VSCROLL
| WS_HSCROLL
);
1159 /*************************************************************************
1160 * GetScrollRange16 (USER.65)
1162 BOOL16 WINAPI
GetScrollRange16( HWND16 hwnd
, INT16 nBar
,
1163 LPINT16 lpMin
, LPINT16 lpMax
)
1166 BOOL16 ret
= GetScrollRange32( hwnd
, nBar
, &min
, &max
);
1167 if (lpMin
) *lpMin
= min
;
1168 if (lpMax
) *lpMax
= max
;
1173 /*************************************************************************
1174 * GetScrollRange32 (USER32.286)
1176 BOOL32 WINAPI
GetScrollRange32( HWND32 hwnd
, INT32 nBar
,
1177 LPINT32 lpMin
, LPINT32 lpMax
)
1179 SCROLLBAR_INFO
*infoPtr
;
1181 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
)))
1183 if (lpMin
) lpMin
= 0;
1184 if (lpMax
) lpMax
= 0;
1187 if (lpMin
) *lpMin
= infoPtr
->MinVal
;
1188 if (lpMax
) *lpMax
= infoPtr
->MaxVal
;
1193 /*************************************************************************
1194 * ShowScrollBar16 (USER.267)
1196 void WINAPI
ShowScrollBar16( HWND16 hwnd
, INT16 nBar
, BOOL16 fShow
)
1198 ShowScrollBar32( hwnd
, nBar
, fShow
);
1202 /*************************************************************************
1203 * ShowScrollBar32 (USER32.532)
1205 BOOL32 WINAPI
ShowScrollBar32( HWND32 hwnd
, INT32 nBar
, BOOL32 fShow
)
1207 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
1209 if (!wndPtr
) return FALSE
;
1210 TRACE(scroll
, "hwnd=%04x bar=%d on=%d\n",
1211 hwnd
, nBar
, fShow
);
1216 ShowWindow32( hwnd
, fShow
? SW_SHOW
: SW_HIDE
);
1222 if (wndPtr
->dwStyle
& WS_HSCROLL
) return TRUE
;
1223 wndPtr
->dwStyle
|= WS_HSCROLL
;
1227 if (!(wndPtr
->dwStyle
& WS_HSCROLL
)) return TRUE
;
1228 wndPtr
->dwStyle
&= ~WS_HSCROLL
;
1235 if (wndPtr
->dwStyle
& WS_VSCROLL
) return TRUE
;
1236 wndPtr
->dwStyle
|= WS_VSCROLL
;
1240 if (!(wndPtr
->dwStyle
& WS_VSCROLL
)) return TRUE
;
1241 wndPtr
->dwStyle
&= ~WS_VSCROLL
;
1248 if ((wndPtr
->dwStyle
& WS_HSCROLL
)
1249 && (wndPtr
->dwStyle
& WS_VSCROLL
)) return TRUE
;
1250 wndPtr
->dwStyle
|= WS_HSCROLL
| WS_VSCROLL
;
1254 if (!(wndPtr
->dwStyle
& WS_HSCROLL
)
1255 && !(wndPtr
->dwStyle
& WS_VSCROLL
)) return TRUE
;
1256 wndPtr
->dwStyle
&= ~(WS_HSCROLL
| WS_VSCROLL
);
1261 return TRUE
; /* Nothing to do! */
1263 SetWindowPos32( hwnd
, 0, 0, 0, 0, 0, SWP_NOSIZE
| SWP_NOMOVE
1264 | SWP_NOACTIVATE
| SWP_NOZORDER
| SWP_FRAMECHANGED
);
1269 /*************************************************************************
1270 * EnableScrollBar16 (USER.482)
1272 BOOL16 WINAPI
EnableScrollBar16( HWND16 hwnd
, INT16 nBar
, UINT16 flags
)
1274 return EnableScrollBar32( hwnd
, nBar
, flags
);
1278 /*************************************************************************
1279 * EnableScrollBar32 (USER32.171)
1281 BOOL32 WINAPI
EnableScrollBar32( HWND32 hwnd
, INT32 nBar
, UINT32 flags
)
1283 SCROLLBAR_INFO
*infoPtr
;
1285 if (!(infoPtr
= SCROLL_GetScrollInfo( hwnd
, nBar
))) return FALSE
;
1286 TRACE(scroll
, "%04x %d %d\n",
1287 hwnd
, nBar
, flags
);
1288 flags
&= ESB_DISABLE_BOTH
;
1289 if (infoPtr
->flags
== flags
) return FALSE
;
1290 infoPtr
->flags
= flags
;
1292 /* Redraw the whole scroll bar */
1293 SCROLL_RefreshScrollBar( hwnd
, nBar
, TRUE
);