- Fix MSVC build?
[reactos.git] / reactos / win32ss / user / user32 / controls / scrollbar.c
1 /*
2 * ReactOS User32 Library
3 * - ScrollBar control
4 *
5 * Copyright 2001 Casper S. Hornstrup
6 * Copyright 2003 Thomas Weidenmueller
7 * Copyright 2003 Filip Navara
8 *
9 * Based on Wine code.
10 *
11 * Copyright 1993 Martin Ayotte
12 * Copyright 1994, 1996 Alexandre Julliard
13 *
14 * This library is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU Lesser General Public
16 * License as published by the Free Software Foundation; either
17 * version 2.1 of the License, or (at your option) any later version.
18 *
19 * This library is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 * Lesser General Public License for more details.
23 *
24 * You should have received a copy of the GNU Lesser General Public
25 * License along with this library; if not, write to the Free Software
26 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 */
28
29 /* INCLUDES *******************************************************************/
30
31 #include <user32.h>
32
33 #include <wine/debug.h>
34 WINE_DEFAULT_DEBUG_CHANNEL(scrollbar);
35
36 /* GLOBAL VARIABLES ***********************************************************/
37
38 /* Definitions for scrollbar hit testing [See SCROLLBARINFO in MSDN] */
39 #define SCROLL_NOWHERE 0x00 /* Outside the scroll bar */
40 #define SCROLL_TOP_ARROW 0x01 /* Top or left arrow */
41 #define SCROLL_TOP_RECT 0x02 /* Rectangle between the top arrow and the thumb */
42 #define SCROLL_THUMB 0x03 /* Thumb rectangle */
43 #define SCROLL_BOTTOM_RECT 0x04 /* Rectangle between the thumb and the bottom arrow */
44 #define SCROLL_BOTTOM_ARROW 0x05 /* Bottom or right arrow */
45
46 #define SCROLL_FIRST_DELAY 200 /* Delay (in ms) before first repetition when
47 holding the button down */
48 #define SCROLL_REPEAT_DELAY 50 /* Delay (in ms) between scroll repetitions */
49
50 #define SCROLL_TIMER 0 /* Scroll timer id */
51
52 /* Minimum size of the rectangle between the arrows */
53 #define SCROLL_MIN_RECT 4
54
55 /* Minimum size of the thumb in pixels */
56 #define SCROLL_MIN_THUMB 6
57
58 /* Overlap between arrows and thumb */
59 #define SCROLL_ARROW_THUMB_OVERLAP 0
60
61 /* Thumb-tracking info */
62 static HWND ScrollTrackingWin = 0;
63 static INT ScrollTrackingBar = 0;
64 static INT ScrollTrackingPos = 0;
65 static INT ScrollTrackingVal = 0;
66 /* Hit test code of the last button-down event */
67 static DWORD ScrollTrackHitTest = SCROLL_NOWHERE;
68 static BOOL ScrollTrackVertical;
69
70 /* Is the moving thumb being displayed? */
71 static BOOL ScrollMovingThumb = FALSE;
72
73 HBRUSH DefWndControlColor(HDC hDC, UINT ctlType);
74
75 UINT_PTR WINAPI SetSystemTimer(HWND,UINT_PTR,UINT,TIMERPROC);
76 BOOL WINAPI KillSystemTimer(HWND,UINT_PTR);
77
78 /*********************************************************************
79 * scrollbar class descriptor
80 */
81 const struct builtin_class_descr SCROLL_builtin_class =
82 {
83 L"ScrollBar", /* name */
84 CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC, /* style */
85 ScrollBarWndProcA, /* procA */
86 ScrollBarWndProcW, /* procW */
87 sizeof(SBWND)-sizeof(WND), /* extra */
88 IDC_ARROW, /* cursor */
89 0 /* brush */
90 };
91
92 /* PRIVATE FUNCTIONS **********************************************************/
93
94 static PSBDATA
95 IntGetSBData(PWND pwnd, INT Bar)
96 {
97 PSBWND pSBWnd;
98 PSBINFO pSBInfo;
99
100 pSBInfo = DesktopPtrToUser(pwnd->pSBInfo);
101 switch (Bar)
102 {
103 case SB_HORZ:
104 return &pSBInfo->Horz;
105 case SB_VERT:
106 return &pSBInfo->Vert;
107 case SB_CTL:
108 if ( pwnd->cbwndExtra != (sizeof(SBWND)-sizeof(WND)) )
109 {
110 ERR("IntGetSBData Wrong Extra bytes for CTL Scrollbar!\n");
111 return 0;
112 }
113 pSBWnd = (PSBWND)pwnd;
114 return (PSBDATA)&pSBWnd->SBCalc;
115 default:
116 ERR("IntGetSBData Bad Bar!\n");
117 }
118 return NULL;
119 }
120
121 static void
122 IntDrawScrollInterior(HWND hWnd, HDC hDC, INT nBar, BOOL Vertical,
123 PSCROLLBARINFO ScrollBarInfo)
124 {
125 INT ThumbSize = ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop;
126 INT ThumbTop = ScrollBarInfo->xyThumbTop;
127 RECT Rect;
128 HBRUSH hSaveBrush, hBrush;
129 BOOL TopSelected = FALSE, BottomSelected = FALSE;
130
131 if (ScrollBarInfo->rgstate[SCROLL_TOP_RECT] & STATE_SYSTEM_PRESSED)
132 TopSelected = TRUE;
133 if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_RECT] & STATE_SYSTEM_PRESSED)
134 BottomSelected = TRUE;
135
136 /*
137 * Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
138 * The window-owned scrollbars need to call DefWndControlColor
139 * to correctly setup default scrollbar colors
140 */
141 if (nBar == SB_CTL)
142 {
143 hBrush = GetControlBrush( hWnd, hDC, WM_CTLCOLORSCROLLBAR);
144 if (!hBrush)
145 hBrush = GetSysColorBrush(COLOR_SCROLLBAR);
146 }
147 else
148 {
149 hBrush = DefWndControlColor(hDC, CTLCOLOR_SCROLLBAR);
150 }
151
152 hSaveBrush = SelectObject(hDC, hBrush);
153
154 /* Calculate the scroll rectangle */
155 if (Vertical)
156 {
157 Rect.top = ScrollBarInfo->rcScrollBar.top + ScrollBarInfo->dxyLineButton;
158 Rect.bottom = ScrollBarInfo->rcScrollBar.bottom - ScrollBarInfo->dxyLineButton;
159 Rect.left = ScrollBarInfo->rcScrollBar.left;
160 Rect.right = ScrollBarInfo->rcScrollBar.right;
161 }
162 else
163 {
164 Rect.top = ScrollBarInfo->rcScrollBar.top;
165 Rect.bottom = ScrollBarInfo->rcScrollBar.bottom;
166 Rect.left = ScrollBarInfo->rcScrollBar.left + ScrollBarInfo->dxyLineButton;
167 Rect.right = ScrollBarInfo->rcScrollBar.right - ScrollBarInfo->dxyLineButton;
168 }
169
170 /* Draw the scroll rectangles and thumb */
171 if (!ScrollBarInfo->xyThumbBottom)
172 {
173 PatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
174 Rect.bottom - Rect.top, PATCOPY);
175
176 /* Cleanup and return */
177 SelectObject(hDC, hSaveBrush);
178 return;
179 }
180
181 ThumbTop -= ScrollBarInfo->dxyLineButton;
182
183 if (ScrollBarInfo->dxyLineButton)
184 {
185 if (Vertical)
186 {
187 if (ThumbSize)
188 {
189 PatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
190 ThumbTop, TopSelected ? BLACKNESS : PATCOPY);
191 Rect.top += ThumbTop;
192 PatBlt(hDC, Rect.left, Rect.top + ThumbSize, Rect.right - Rect.left,
193 Rect.bottom - Rect.top - ThumbSize, BottomSelected ? BLACKNESS : PATCOPY);
194 Rect.bottom = Rect.top + ThumbSize;
195 }
196 else
197 {
198 if (ThumbTop)
199 {
200 PatBlt(hDC, Rect.left, ScrollBarInfo->dxyLineButton,
201 Rect.right - Rect.left, Rect.bottom - Rect.top, PATCOPY);
202 }
203 }
204 }
205 else
206 {
207 if (ThumbSize)
208 {
209 PatBlt(hDC, Rect.left, Rect.top, ThumbTop,
210 Rect.bottom - Rect.top, TopSelected ? BLACKNESS : PATCOPY);
211 Rect.left += ThumbTop;
212 PatBlt(hDC, Rect.left + ThumbSize, Rect.top,
213 Rect.right - Rect.left - ThumbSize, Rect.bottom - Rect.top,
214 BottomSelected ? BLACKNESS : PATCOPY);
215 Rect.right = Rect.left + ThumbSize;
216 }
217 else
218 {
219 if (ThumbTop)
220 {
221 PatBlt(hDC, ScrollBarInfo->dxyLineButton, Rect.top,
222 Rect.right - Rect.left, Rect.bottom - Rect.top, PATCOPY);
223 }
224 }
225 }
226 }
227
228 /* Draw the thumb */
229 if (ThumbSize)
230 DrawEdge(hDC, &Rect, EDGE_RAISED, BF_RECT | BF_MIDDLE);
231
232 /* Cleanup */
233 SelectObject(hDC, hSaveBrush);
234 }
235
236 static VOID FASTCALL
237 IntDrawScrollArrows(HDC hDC, PSCROLLBARINFO ScrollBarInfo, BOOL Vertical)
238 {
239 RECT RectLT, RectRB;
240 INT ScrollDirFlagLT, ScrollDirFlagRB;
241
242 RectLT = RectRB = ScrollBarInfo->rcScrollBar;
243 if (Vertical)
244 {
245 ScrollDirFlagLT = DFCS_SCROLLUP;
246 ScrollDirFlagRB = DFCS_SCROLLDOWN;
247 RectLT.bottom = RectLT.top + ScrollBarInfo->dxyLineButton;
248 RectRB.top = RectRB.bottom - ScrollBarInfo->dxyLineButton;
249 }
250 else
251 {
252 ScrollDirFlagLT = DFCS_SCROLLLEFT;
253 ScrollDirFlagRB = DFCS_SCROLLRIGHT;
254 RectLT.right = RectLT.left + ScrollBarInfo->dxyLineButton;
255 RectRB.left = RectRB.right - ScrollBarInfo->dxyLineButton;
256 }
257
258 if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_PRESSED)
259 {
260 ScrollDirFlagLT |= DFCS_PUSHED | DFCS_FLAT;
261 }
262 if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_UNAVAILABLE)
263 {
264 ScrollDirFlagLT |= DFCS_INACTIVE;
265 }
266 if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_ARROW] & STATE_SYSTEM_PRESSED)
267 {
268 ScrollDirFlagRB |= DFCS_PUSHED | DFCS_FLAT;
269 }
270 if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_ARROW] & STATE_SYSTEM_UNAVAILABLE)
271 {
272 ScrollDirFlagRB |= DFCS_INACTIVE;
273 }
274
275 DrawFrameControl(hDC, &RectLT, DFC_SCROLL, ScrollDirFlagLT);
276 DrawFrameControl(hDC, &RectRB, DFC_SCROLL, ScrollDirFlagRB);
277 }
278
279 static VOID FASTCALL
280 IntScrollDrawMovingThumb(HDC Dc, PSCROLLBARINFO ScrollBarInfo, BOOL Vertical)
281 {
282 INT Pos = ScrollTrackingPos;
283 INT MaxSize;
284 INT OldTop;
285
286 if (Vertical)
287 MaxSize = ScrollBarInfo->rcScrollBar.bottom - ScrollBarInfo->rcScrollBar.top;
288 else
289 MaxSize = ScrollBarInfo->rcScrollBar.right - ScrollBarInfo->rcScrollBar.left;
290
291 MaxSize -= ScrollBarInfo->dxyLineButton + ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop;
292
293 if (Pos < ScrollBarInfo->dxyLineButton)
294 Pos = ScrollBarInfo->dxyLineButton;
295 else if (MaxSize < Pos)
296 Pos = MaxSize;
297
298 OldTop = ScrollBarInfo->xyThumbTop;
299 ScrollBarInfo->xyThumbBottom = Pos + ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop;
300 ScrollBarInfo->xyThumbTop = Pos;
301 IntDrawScrollInterior(ScrollTrackingWin, Dc, ScrollTrackingBar, Vertical, ScrollBarInfo);
302 ScrollBarInfo->xyThumbBottom = OldTop + ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop;
303 ScrollBarInfo->xyThumbTop = OldTop;
304
305 ScrollMovingThumb = !ScrollMovingThumb;
306 }
307
308 static LONG FASTCALL
309 IntScrollGetObjectId(INT SBType)
310 {
311 if (SBType == SB_VERT)
312 return OBJID_VSCROLL;
313 if (SBType == SB_HORZ)
314 return OBJID_HSCROLL;
315 return OBJID_CLIENT;
316 }
317
318 static BOOL FASTCALL
319 IntGetScrollBarInfo(HWND Wnd, INT Bar, PSCROLLBARINFO ScrollBarInfo)
320 {
321 ScrollBarInfo->cbSize = sizeof(SCROLLBARINFO);
322
323 return NtUserGetScrollBarInfo(Wnd, IntScrollGetObjectId(Bar), ScrollBarInfo);
324 }
325
326 void
327 IntDrawScrollBar(HWND Wnd, HDC DC, INT Bar)
328 {
329 //PSBWND pSBWnd;
330 //INT ThumbSize;
331 SCROLLBARINFO Info;
332 BOOL Vertical;
333
334 /*
335 * Get scroll bar info.
336 */
337 switch (Bar)
338 {
339 case SB_HORZ:
340 Vertical = FALSE;
341 break;
342
343 case SB_VERT:
344 Vertical = TRUE;
345 break;
346
347 case SB_CTL:
348 Vertical = (GetWindowLongPtrW(Wnd, GWL_STYLE) & SBS_VERT) != 0;
349 break;
350
351 default:
352 return;
353 }
354 if (!IntGetScrollBarInfo(Wnd, Bar, &Info))
355 {
356 return;
357 }
358
359 if (IsRectEmpty(&Info.rcScrollBar))
360 {
361 return;
362 }
363
364 //ThumbSize = pSBWnd->pSBCalc->pxThumbBottom - pSBWnd->pSBCalc->pxThumbTop;
365
366 /*
367 * Draw the arrows.
368 */
369 if (Info.dxyLineButton)
370 {
371 IntDrawScrollArrows(DC, &Info, Vertical);
372 }
373
374 /*
375 * Draw the interior.
376 */
377 IntDrawScrollInterior(Wnd, DC, Bar, Vertical, &Info);
378
379 /*
380 * If scroll bar has focus, reposition the caret.
381 */
382 if (Wnd == GetFocus() && SB_CTL == Bar)
383 {
384 if (Vertical)
385 {
386 SetCaretPos(Info.rcScrollBar.top + 1, Info.dxyLineButton + 1);
387 }
388 else
389 {
390 SetCaretPos(Info.dxyLineButton + 1, Info.rcScrollBar.top + 1);
391 }
392 }
393 }
394
395 static BOOL FASTCALL
396 IntScrollPtInRectEx(LPRECT Rect, POINT Pt, BOOL Vertical)
397 {
398 RECT TempRect = *Rect;
399 int scrollbarWidth;
400
401 /* Pad hit rect to allow mouse to be dragged outside of scrollbar and
402 * still be considered in the scrollbar. */
403 if (Vertical)
404 {
405 scrollbarWidth = Rect->right - Rect->left;
406 TempRect.left -= scrollbarWidth*8;
407 TempRect.right += scrollbarWidth*8;
408 TempRect.top -= scrollbarWidth*2;
409 TempRect.bottom += scrollbarWidth*2;
410 }
411 else
412 {
413 scrollbarWidth = Rect->bottom - Rect->top;
414 TempRect.left -= scrollbarWidth*2;
415 TempRect.right += scrollbarWidth*2;
416 TempRect.top -= scrollbarWidth*8;
417 TempRect.bottom += scrollbarWidth*8;
418 }
419
420 return PtInRect(&TempRect, Pt);
421 }
422
423 static DWORD FASTCALL
424 IntScrollHitTest(PSCROLLBARINFO ScrollBarInfo, BOOL Vertical, POINT Pt, BOOL Dragging)
425 {
426 INT ArrowSize, ThumbSize, ThumbPos;
427
428 if ((Dragging && ! IntScrollPtInRectEx(&ScrollBarInfo->rcScrollBar, Pt, Vertical)) ||
429 ! PtInRect(&ScrollBarInfo->rcScrollBar, Pt)) return SCROLL_NOWHERE;
430
431 ThumbPos = ScrollBarInfo->xyThumbTop;
432 ThumbSize = ScrollBarInfo->xyThumbBottom - ThumbPos;
433 ArrowSize = ScrollBarInfo->dxyLineButton;
434
435 if (Vertical)
436 {
437 if (Pt.y < ScrollBarInfo->rcScrollBar.top + ArrowSize) return SCROLL_TOP_ARROW;
438 if (Pt.y >= ScrollBarInfo->rcScrollBar.bottom - ArrowSize) return SCROLL_BOTTOM_ARROW;
439 if (!ThumbPos) return SCROLL_TOP_RECT;
440 Pt.y -= ScrollBarInfo->rcScrollBar.top;
441 if (Pt.y < ThumbPos) return SCROLL_TOP_RECT;
442 if (Pt.y >= ThumbPos + ThumbSize) return SCROLL_BOTTOM_RECT;
443 }
444 else
445 {
446 if (Pt.x < ScrollBarInfo->rcScrollBar.left + ArrowSize) return SCROLL_TOP_ARROW;
447 if (Pt.x >= ScrollBarInfo->rcScrollBar.right - ArrowSize) return SCROLL_BOTTOM_ARROW;
448 if (!ThumbPos) return SCROLL_TOP_RECT;
449 Pt.x -= ScrollBarInfo->rcScrollBar.left;
450 if (Pt.x < ThumbPos) return SCROLL_TOP_RECT;
451 if (Pt.x >= ThumbPos + ThumbSize) return SCROLL_BOTTOM_RECT;
452 }
453
454 return SCROLL_THUMB;
455 }
456
457
458 /***********************************************************************
459 * IntScrollGetScrollBarRect
460 *
461 * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
462 * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
463 * 'arrowSize' returns the width or height of an arrow (depending on
464 * the orientation of the scrollbar), 'thumbSize' returns the size of
465 * the thumb, and 'thumbPos' returns the position of the thumb
466 * relative to the left or to the top.
467 * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
468 */
469 static BOOL FASTCALL
470 IntScrollGetScrollBarRect(HWND Wnd, INT Bar, RECT *Rect,
471 INT *ArrowSize, INT *ThumbSize,
472 INT *ThumbPos)
473 {
474 INT Pixels;
475 BOOL Vertical;
476 PWND pWnd;
477 PSBINFO pSBInfo;
478 PSBDATA pSBData;
479 PSBWND pSBWnd;
480
481 pWnd = ValidateHwnd( Wnd );
482 if (!pWnd) return FALSE;
483 pSBInfo = DesktopPtrToUser(pWnd->pSBInfo);
484
485 *Rect = pWnd->rcClient;
486 OffsetRect( Rect, -pWnd->rcWindow.left, -pWnd->rcWindow.top );
487 if (pWnd->ExStyle & WS_EX_LAYOUTRTL)
488 mirror_rect( &pWnd->rcWindow, Rect );
489
490 switch (Bar)
491 {
492 case SB_HORZ:
493 // WIN_GetRectangles( Wnd, COORDS_WINDOW, NULL, Rect );
494 Rect->top = Rect->bottom;
495 Rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
496 if (pWnd->style & WS_BORDER)
497 {
498 Rect->left--;
499 Rect->right++;
500 }
501 else if (pWnd->style & WS_VSCROLL)
502 {
503 Rect->right++;
504 }
505 Vertical = FALSE;
506 pSBData = &pSBInfo->Horz;
507 break;
508
509 case SB_VERT:
510 // WIN_GetRectangles( Wnd, COORDS_WINDOW, NULL, Rect );
511 if (pWnd->ExStyle & WS_EX_LEFTSCROLLBAR)
512 {
513 Rect->right = Rect->left;
514 Rect->left -= GetSystemMetrics(SM_CXVSCROLL);
515 }
516 else
517 {
518 Rect->left = Rect->right;
519 Rect->right += GetSystemMetrics(SM_CXVSCROLL);
520 }
521 if (pWnd->style & WS_BORDER)
522 {
523 Rect->top--;
524 Rect->bottom++;
525 }
526 else if (pWnd->style & WS_HSCROLL)
527 {
528 Rect->bottom++;
529 }
530 Vertical = TRUE;
531 pSBData = &pSBInfo->Vert;
532 break;
533
534 case SB_CTL:
535 GetClientRect( Wnd, Rect );
536 Vertical = (pWnd->style & SBS_VERT);
537 pSBWnd = (PSBWND)pWnd;
538 pSBData = (PSBDATA)&pSBWnd->SBCalc;
539 break;
540
541 default:
542 return FALSE;
543 }
544
545 if (Vertical) Pixels = Rect->bottom - Rect->top;
546 else Pixels = Rect->right - Rect->left;
547
548 if (Pixels <= 2 * GetSystemMetrics(SM_CXVSCROLL) + SCROLL_MIN_RECT)
549 {
550 if (SCROLL_MIN_RECT < Pixels)
551 *ArrowSize = (Pixels - SCROLL_MIN_RECT) / 2;
552 else
553 *ArrowSize = 0;
554 *ThumbPos = *ThumbSize = 0;
555 }
556 else
557 {
558 *ArrowSize = GetSystemMetrics(SM_CXVSCROLL);
559 Pixels -= (2 * (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP));
560 if (pSBData->page)
561 {
562 *ThumbSize = MulDiv(Pixels, pSBData->page, (pSBData->posMax - pSBData->posMin + 1));
563 if (*ThumbSize < SCROLL_MIN_THUMB) *ThumbSize = SCROLL_MIN_THUMB;
564 }
565 else *ThumbSize = GetSystemMetrics(SM_CXVSCROLL);
566
567 if (((Pixels -= *ThumbSize ) < 0) ||
568 (( pSBInfo->WSBflags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH))
569 {
570 /* Rectangle too small or scrollbar disabled -> no thumb */
571 *ThumbPos = *ThumbSize = 0;
572 }
573 else
574 {
575 INT Max = pSBData->posMax - max(pSBData->page - 1, 0);
576 if (pSBData->posMin >= Max)
577 *ThumbPos = *ArrowSize - SCROLL_ARROW_THUMB_OVERLAP;
578 else
579 *ThumbPos = *ArrowSize - SCROLL_ARROW_THUMB_OVERLAP
580 + MulDiv(Pixels, (pSBData->pos - pSBData->posMin),(Max - pSBData->posMin));
581 }
582 }
583 return Vertical;
584 }
585
586 /***********************************************************************
587 * IntScrollGetThumbVal
588 *
589 * Compute the current scroll position based on the thumb position in pixels
590 * from the top of the scroll-bar.
591 */
592 static UINT FASTCALL
593 IntScrollGetThumbVal(HWND Wnd, INT SBType, PSCROLLBARINFO ScrollBarInfo,
594 BOOL Vertical, INT Pos)
595 {
596 PWND pWnd;
597 PSBDATA pSBData;
598 INT Pixels = Vertical ? ScrollBarInfo->rcScrollBar.bottom
599 - ScrollBarInfo->rcScrollBar.top
600 : ScrollBarInfo->rcScrollBar.right
601 - ScrollBarInfo->rcScrollBar.left;
602
603 pWnd = ValidateHwnd( Wnd );
604 if (!pWnd) return FALSE;
605
606 pSBData = IntGetSBData(pWnd, SBType);
607
608 if ((Pixels -= 2 * ScrollBarInfo->dxyLineButton) <= 0)
609 {
610 return pSBData->posMin;
611 }
612
613 if ((Pixels -= (ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop)) <= 0)
614 {
615 return pSBData->posMin;
616 }
617
618 Pos = Pos - ScrollBarInfo->dxyLineButton;
619 if (Pos < 0)
620 {
621 Pos = 0;
622 }
623 if (Pos > Pixels) Pos = Pixels;
624
625 if (!pSBData->page)
626 Pos *= pSBData->posMax - pSBData->posMin;
627 else
628 Pos *= pSBData->posMax - pSBData->posMin - pSBData->page + 1;
629
630 return pSBData->posMin + ((Pos + Pixels / 2) / Pixels);
631 }
632
633 /***********************************************************************
634 * IntScrollClipPos
635 */
636 static POINT IntScrollClipPos(PRECT lpRect, POINT pt)
637 {
638 if( pt.x < lpRect->left )
639 pt.x = lpRect->left;
640 else
641 if( pt.x > lpRect->right )
642 pt.x = lpRect->right;
643
644 if( pt.y < lpRect->top )
645 pt.y = lpRect->top;
646 else
647 if( pt.y > lpRect->bottom )
648 pt.y = lpRect->bottom;
649
650 return pt;
651 }
652
653 /***********************************************************************
654 * IntScrollDrawSizeGrip
655 *
656 * Draw the size grip.
657 */
658 static void FASTCALL
659 IntScrollDrawSizeGrip(HWND Wnd, HDC Dc)
660 {
661 RECT Rect;
662
663 GetClientRect(Wnd, &Rect);
664 FillRect(Dc, &Rect, GetSysColorBrush(COLOR_SCROLLBAR));
665 Rect.left = max(Rect.left, Rect.right - GetSystemMetrics(SM_CXVSCROLL) - 1);
666 Rect.top = max(Rect.top, Rect.bottom - GetSystemMetrics(SM_CYHSCROLL) - 1);
667 DrawFrameControl(Dc, &Rect, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
668 }
669
670 /***********************************************************************
671 * SCROLL_RefreshScrollBar
672 *
673 * Repaint the scroll bar interior after a SetScrollRange() or
674 * SetScrollPos() call.
675 */
676 static void SCROLL_RefreshScrollBar( HWND hwnd, INT nBar,
677 BOOL arrows, BOOL interior )
678 {
679 HDC hdc = GetDCEx( hwnd, 0,
680 DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW) );
681 if (!hdc) return;
682
683 IntDrawScrollBar( hwnd, hdc, nBar);//, arrows, interior );
684 ReleaseDC( hwnd, hdc );
685 }
686
687
688 /***********************************************************************
689 * IntScrollHandleKbdEvent
690 *
691 * Handle a keyboard event (only for SB_CTL scrollbars with focus).
692 */
693 static void FASTCALL
694 IntScrollHandleKbdEvent(
695 HWND Wnd /* [in] Handle of window with scrollbar(s) */,
696 WPARAM wParam /* [in] Variable input including enable state */,
697 LPARAM lParam /* [in] Variable input including input point */)
698 {
699 TRACE("Wnd=%p wParam=%ld lParam=%ld\n", Wnd, wParam, lParam);
700
701 /* hide caret on first KEYDOWN to prevent flicker */
702 if (0 == (lParam & PFD_DOUBLEBUFFER_DONTCARE))
703 {
704 HideCaret(Wnd);
705 }
706
707 switch(wParam)
708 {
709 case VK_PRIOR:
710 wParam = SB_PAGEUP;
711 break;
712
713 case VK_NEXT:
714 wParam = SB_PAGEDOWN;
715 break;
716
717 case VK_HOME:
718 wParam = SB_TOP;
719 break;
720
721 case VK_END:
722 wParam = SB_BOTTOM;
723 break;
724
725 case VK_UP:
726 wParam = SB_LINEUP;
727 break;
728
729 case VK_DOWN:
730 wParam = SB_LINEDOWN;
731 break;
732
733 default:
734 return;
735 }
736
737 SendMessageW(GetParent(Wnd),
738 (0 != (GetWindowLongPtrW(Wnd, GWL_STYLE ) & SBS_VERT) ?
739 WM_VSCROLL : WM_HSCROLL), wParam, (LPARAM) Wnd);
740 }
741
742 /***********************************************************************
743 * IntScrollHandleScrollEvent
744 *
745 * Handle a mouse or timer event for the scrollbar.
746 * 'Pt' is the location of the mouse event in drawing coordinates
747 */
748 static VOID FASTCALL
749 IntScrollHandleScrollEvent(HWND Wnd, INT SBType, UINT Msg, POINT Pt)
750 {
751 static POINT PrevPt; /* Previous mouse position for timer events */
752 static UINT TrackThumbPos; /* Thumb position when tracking started. */
753 static INT LastClickPos; /* Position in the scroll-bar of the last
754 button-down event. */
755 static INT LastMousePos; /* Position in the scroll-bar of the last
756 mouse event. */
757
758 DWORD HitTest;
759 HWND WndOwner, WndCtl;
760 BOOL Vertical;
761 HDC Dc;
762 SCROLLBARINFO ScrollBarInfo;
763 SETSCROLLBARINFO NewInfo;
764
765 if (! IntGetScrollBarInfo(Wnd, SBType, &ScrollBarInfo))
766 {
767 return;
768 }
769 if ((ScrollTrackHitTest == SCROLL_NOWHERE) && (Msg != WM_LBUTTONDOWN))
770 {
771 //// ReactOS : Justin Case something goes wrong.
772 if (Wnd == GetCapture())
773 {
774 ReleaseCapture();
775 }
776 ////
777 return;
778 }
779
780 NewInfo.nTrackPos = ScrollTrackingVal;
781 NewInfo.reserved = ScrollBarInfo.reserved;
782 memcpy(NewInfo.rgstate, ScrollBarInfo.rgstate, (CCHILDREN_SCROLLBAR + 1) * sizeof(DWORD));
783
784 if (SBType == SB_CTL && (GetWindowLongPtrW(Wnd, GWL_STYLE) & (SBS_SIZEGRIP | SBS_SIZEBOX)))
785 {
786 switch(Msg)
787 {
788 case WM_LBUTTONDOWN: /* Initialise mouse tracking */
789 HideCaret(Wnd); /* hide caret while holding down LBUTTON */
790 SetCapture(Wnd);
791 PrevPt = Pt;
792 ScrollTrackHitTest = HitTest = SCROLL_THUMB;
793 break;
794 case WM_MOUSEMOVE:
795 GetClientRect(GetParent(GetParent(Wnd)), &ScrollBarInfo.rcScrollBar);
796 PrevPt = Pt;
797 break;
798 case WM_LBUTTONUP:
799 ReleaseCapture();
800 ScrollTrackHitTest = HitTest = SCROLL_NOWHERE;
801 if (Wnd == GetFocus()) ShowCaret(Wnd);
802 break;
803 case WM_SYSTIMER:
804 Pt = PrevPt;
805 break;
806 }
807 return;
808 }
809
810 Dc = GetDCEx(Wnd, 0, DCX_CACHE | ((SB_CTL == SBType) ? 0 : DCX_WINDOW));
811 if (SB_VERT == SBType)
812 {
813 Vertical = TRUE;
814 }
815 else if (SB_HORZ == SBType)
816 {
817 Vertical = FALSE;
818 }
819 else
820 {
821 Vertical = (0 != (GetWindowLongPtrW(Wnd, GWL_STYLE) & SBS_VERT));
822 }
823 WndOwner = (SB_CTL == SBType) ? GetParent(Wnd) : Wnd;
824 WndCtl = (SB_CTL == SBType) ? Wnd : NULL;
825
826 switch (Msg)
827 {
828 case WM_LBUTTONDOWN: /* Initialise mouse tracking */
829 HideCaret(Wnd); /* hide caret while holding down LBUTTON */
830 ScrollTrackVertical = Vertical;
831 ScrollTrackHitTest = HitTest = IntScrollHitTest(&ScrollBarInfo, Vertical, Pt, FALSE );
832 LastClickPos = Vertical ? (Pt.y - ScrollBarInfo.rcScrollBar.top)
833 : (Pt.x - ScrollBarInfo.rcScrollBar.left);
834 LastMousePos = LastClickPos;
835 TrackThumbPos = ScrollBarInfo.xyThumbTop;
836 PrevPt = Pt;
837 if (SBType == SB_CTL && (GetWindowLongPtrW(Wnd, GWL_STYLE) & WS_TABSTOP)) SetFocus(Wnd);
838 SetCapture(Wnd);
839 ScrollBarInfo.rgstate[ScrollTrackHitTest] |= STATE_SYSTEM_PRESSED;
840 NewInfo.rgstate[ScrollTrackHitTest] = ScrollBarInfo.rgstate[ScrollTrackHitTest];
841 NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
842 break;
843
844 case WM_MOUSEMOVE:
845 HitTest = IntScrollHitTest(&ScrollBarInfo, Vertical, Pt, TRUE);
846 PrevPt = Pt;
847 break;
848
849 case WM_LBUTTONUP:
850 HitTest = SCROLL_NOWHERE;
851 ReleaseCapture();
852 /* if scrollbar has focus, show back caret */
853 if (Wnd == GetFocus()) ShowCaret(Wnd);
854 ScrollBarInfo.rgstate[ScrollTrackHitTest] &= ~STATE_SYSTEM_PRESSED;
855 NewInfo.rgstate[ScrollTrackHitTest] = ScrollBarInfo.rgstate[ScrollTrackHitTest];
856 NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
857
858 IntDrawScrollArrows(Dc, &ScrollBarInfo, Vertical);
859
860 break;
861
862 case WM_SYSTIMER:
863 Pt = PrevPt;
864 HitTest = IntScrollHitTest(&ScrollBarInfo, Vertical, Pt, FALSE);
865 break;
866
867 default:
868 return; /* Should never happen */
869 }
870
871 TRACE("Event: hwnd=%p bar=%d msg=%s pt=%d,%d hit=%d\n",
872 Wnd, SBType, SPY_GetMsgName(Msg,Wnd), Pt.x, Pt.y, HitTest );
873
874 switch (ScrollTrackHitTest)
875 {
876 case SCROLL_NOWHERE: /* No tracking in progress */
877 break;
878
879 case SCROLL_TOP_ARROW:
880 if (HitTest == ScrollTrackHitTest)
881 {
882 if ((WM_LBUTTONDOWN == Msg) || (WM_SYSTIMER == Msg))
883 {
884 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
885 SB_LINEUP, (LPARAM) WndCtl);
886 }
887 SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
888 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
889 (TIMERPROC) NULL);
890 }
891 else
892 {
893 KillSystemTimer(Wnd, SCROLL_TIMER);
894 }
895 break;
896
897 case SCROLL_TOP_RECT:
898 if (HitTest == ScrollTrackHitTest)
899 {
900 if ((WM_LBUTTONDOWN == Msg) || (WM_SYSTIMER == Msg))
901 {
902 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
903 SB_PAGEUP, (LPARAM) WndCtl);
904 }
905 SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
906 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
907 (TIMERPROC) NULL);
908 }
909 else
910 {
911 KillSystemTimer(Wnd, SCROLL_TIMER);
912 }
913 break;
914
915 case SCROLL_THUMB:
916 if (Msg == WM_LBUTTONDOWN)
917 {
918 ScrollTrackingWin = Wnd;
919 ScrollTrackingBar = SBType;
920 ScrollTrackingPos = TrackThumbPos + LastMousePos - LastClickPos;
921 ScrollTrackingVal = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo,
922 Vertical, ScrollTrackingPos);
923 NewInfo.nTrackPos = ScrollTrackingVal;
924 NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
925 IntScrollDrawMovingThumb(Dc, &ScrollBarInfo, Vertical);
926 }
927 else if (Msg == WM_LBUTTONUP)
928 {
929 ScrollTrackingWin = 0;
930 ScrollTrackingVal = 0;
931 IntDrawScrollInterior(Wnd, Dc, SBType, Vertical, &ScrollBarInfo);
932 }
933 else /* WM_MOUSEMOVE */
934 {
935 UINT Pos;
936
937 if (! IntScrollPtInRectEx(&ScrollBarInfo.rcScrollBar, Pt, Vertical))
938 {
939 Pos = LastClickPos;
940 }
941 else
942 {
943 Pt = IntScrollClipPos(&ScrollBarInfo.rcScrollBar, Pt);
944 Pos = Vertical ? (Pt.y - ScrollBarInfo.rcScrollBar.top)
945 : (Pt.x - ScrollBarInfo.rcScrollBar.left);
946 }
947 if (Pos != LastMousePos || ! ScrollMovingThumb)
948 {
949 LastMousePos = Pos;
950 ScrollTrackingPos = TrackThumbPos + Pos - LastClickPos;
951 ScrollTrackingVal = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo,
952 Vertical, ScrollTrackingPos);
953 NewInfo.nTrackPos = ScrollTrackingVal;
954 NtUserSetScrollBarInfo(Wnd, IntScrollGetObjectId(SBType), &NewInfo);
955 IntScrollDrawMovingThumb(Dc, &ScrollBarInfo, Vertical);
956 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
957 MAKEWPARAM(SB_THUMBTRACK, ScrollTrackingVal),
958 (LPARAM) WndCtl);
959 }
960 }
961 break;
962
963 case SCROLL_BOTTOM_RECT:
964 if (HitTest == ScrollTrackHitTest)
965 {
966 if ((Msg == WM_LBUTTONDOWN) || (Msg == WM_SYSTIMER))
967 {
968 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
969 SB_PAGEDOWN, (LPARAM) WndCtl);
970 }
971 SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
972 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
973 (TIMERPROC) NULL);
974 }
975 else
976 {
977 KillSystemTimer(Wnd, SCROLL_TIMER);
978 }
979 break;
980
981 case SCROLL_BOTTOM_ARROW:
982 if (HitTest == ScrollTrackHitTest)
983 {
984 if ((Msg == WM_LBUTTONDOWN) || (Msg == WM_SYSTIMER))
985 {
986 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
987 SB_LINEDOWN, (LPARAM) WndCtl);
988 }
989 SetSystemTimer(Wnd, SCROLL_TIMER, (WM_LBUTTONDOWN == Msg) ?
990 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
991 (TIMERPROC) NULL);
992 }
993 else KillSystemTimer(Wnd, SCROLL_TIMER);
994 break;
995 }
996
997 if (Msg == WM_LBUTTONDOWN)
998 {
999 if (SCROLL_THUMB == HitTest)
1000 {
1001 UINT Val = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo, Vertical,
1002 TrackThumbPos + LastMousePos - LastClickPos);
1003 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
1004 MAKEWPARAM(SB_THUMBTRACK, Val), (LPARAM) WndCtl);
1005 }
1006 }
1007
1008 if (Msg == WM_LBUTTONUP)
1009 {
1010 HitTest = ScrollTrackHitTest;
1011 ScrollTrackHitTest = SCROLL_NOWHERE; /* Terminate tracking */
1012
1013 if (SCROLL_THUMB == HitTest)
1014 {
1015 UINT Val = IntScrollGetThumbVal(Wnd, SBType, &ScrollBarInfo, Vertical,
1016 TrackThumbPos + LastMousePos - LastClickPos);
1017 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
1018 MAKEWPARAM(SB_THUMBPOSITION, Val), (LPARAM) WndCtl);
1019 }
1020 /* SB_ENDSCROLL doesn't report thumb position */
1021 SendMessageW(WndOwner, Vertical ? WM_VSCROLL : WM_HSCROLL,
1022 SB_ENDSCROLL, (LPARAM) WndCtl);
1023
1024 /* Terminate tracking */
1025 ScrollTrackingWin = 0;
1026 }
1027
1028 ReleaseDC(Wnd, Dc);
1029 }
1030
1031
1032 /***********************************************************************
1033 * IntScrollCreateScrollBar
1034 *
1035 * Create a scroll bar
1036 */
1037 static void IntScrollCreateScrollBar(
1038 HWND Wnd /* [in] Handle of window with scrollbar(s) */,
1039 LPCREATESTRUCTW lpCreate /* [in] The style and place of the scroll bar */)
1040 {
1041 SCROLLINFO Info;
1042
1043 Info.cbSize = sizeof(SCROLLINFO);
1044 Info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
1045 Info.nMin = 0;
1046 Info.nMax = 0;
1047 Info.nPage = 0;
1048 Info.nPos = 0;
1049 Info.nTrackPos = 0;
1050 NtUserSetScrollInfo(Wnd, SB_CTL, &Info, FALSE);
1051
1052 TRACE("hwnd=%p lpCreate=%p\n", Wnd, lpCreate);
1053
1054 #if 0 /* FIXME */
1055 if (lpCreate->style & WS_DISABLED)
1056 {
1057 // info->flags = ESB_DISABLE_BOTH;
1058 //NtUserEnableScrollBar(Wnd,SB_CTL,(wParam ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH));
1059 NtUserMessageCall( Wnd, WM_ENABLE, FALSE, 0, 0, FNID_SCROLLBAR, FALSE);
1060 ERR("Created WS_DISABLED scrollbar\n");
1061 }
1062 #endif
1063 if (0 != (lpCreate->style & (SBS_SIZEGRIP | SBS_SIZEBOX)))
1064 {
1065 if (0 != (lpCreate->style & SBS_SIZEBOXTOPLEFTALIGN))
1066 {
1067 MoveWindow(Wnd, lpCreate->x, lpCreate->y, GetSystemMetrics(SM_CXVSCROLL) + 1,
1068 GetSystemMetrics(SM_CYHSCROLL) + 1, FALSE);
1069 }
1070 else if (0 != (lpCreate->style & SBS_SIZEBOXBOTTOMRIGHTALIGN))
1071 {
1072 MoveWindow(Wnd, lpCreate->x + lpCreate->cx - GetSystemMetrics(SM_CXVSCROLL) - 1,
1073 lpCreate->y + lpCreate->cy - GetSystemMetrics(SM_CYHSCROLL) - 1,
1074 GetSystemMetrics(SM_CXVSCROLL) + 1,
1075 GetSystemMetrics(SM_CYHSCROLL) + 1, FALSE);
1076 }
1077 }
1078 else if (0 != (lpCreate->style & SBS_VERT))
1079 {
1080 if (0 != (lpCreate->style & SBS_LEFTALIGN))
1081 {
1082 MoveWindow(Wnd, lpCreate->x, lpCreate->y,
1083 GetSystemMetrics(SM_CXVSCROLL) + 1, lpCreate->cy, FALSE);
1084 }
1085 else if (0 != (lpCreate->style & SBS_RIGHTALIGN))
1086 {
1087 MoveWindow(Wnd,
1088 lpCreate->x + lpCreate->cx - GetSystemMetrics(SM_CXVSCROLL) - 1,
1089 lpCreate->y,
1090 GetSystemMetrics(SM_CXVSCROLL) + 1, lpCreate->cy, FALSE);
1091 }
1092 }
1093 else /* SBS_HORZ */
1094 {
1095 if (0 != (lpCreate->style & SBS_TOPALIGN))
1096 {
1097 MoveWindow(Wnd, lpCreate->x, lpCreate->y,
1098 lpCreate->cx, GetSystemMetrics(SM_CYHSCROLL) + 1, FALSE);
1099 }
1100 else if (0 != (lpCreate->style & SBS_BOTTOMALIGN))
1101 {
1102 MoveWindow(Wnd,
1103 lpCreate->x,
1104 lpCreate->y + lpCreate->cy - GetSystemMetrics(SM_CYHSCROLL) - 1,
1105 lpCreate->cx, GetSystemMetrics(SM_CYHSCROLL) + 1, FALSE);
1106 }
1107 }
1108 }
1109
1110 /* USER32 INTERNAL FUNCTIONS **************************************************/
1111
1112 /***********************************************************************
1113 * ScrollTrackScrollBar
1114 *
1115 * Track a mouse button press on a scroll-bar.
1116 * pt is in screen-coordinates for non-client scroll bars.
1117 */
1118 VOID FASTCALL
1119 ScrollTrackScrollBar(HWND Wnd, INT SBType, POINT Pt)
1120 {
1121 MSG Msg;
1122 UINT XOffset = 0, YOffset = 0;
1123
1124 if (SBType != SB_CTL)
1125 { // Used with CMD mouse tracking.
1126 PWND pwnd = ValidateHwnd(Wnd);
1127 if (!pwnd) return;
1128 XOffset = pwnd->rcClient.left - pwnd->rcWindow.left;
1129 YOffset = pwnd->rcClient.top - pwnd->rcWindow.top;
1130 // RECT rect;
1131 // WIN_GetRectangles( Wnd, COORDS_CLIENT, &rect, NULL );
1132 ScreenToClient(Wnd, &Pt);
1133 // Pt.x -= rect.left;
1134 // Pt.y -= rect.top;
1135 Pt.x += XOffset;
1136 Pt.y += YOffset;
1137 }
1138
1139 IntScrollHandleScrollEvent(Wnd, SBType, WM_LBUTTONDOWN, Pt);
1140
1141 do
1142 {
1143 if (!GetMessageW(&Msg, 0, 0, 0)) break;
1144 if (CallMsgFilterW(&Msg, MSGF_SCROLLBAR)) continue;
1145 if ( Msg.message == WM_LBUTTONUP ||
1146 Msg.message == WM_MOUSEMOVE ||
1147 (Msg.message == WM_SYSTIMER && Msg.wParam == SCROLL_TIMER))
1148 {
1149 Pt.x = LOWORD(Msg.lParam) + XOffset;
1150 Pt.y = HIWORD(Msg.lParam) + YOffset;
1151 IntScrollHandleScrollEvent(Wnd, SBType, Msg.message, Pt);
1152 }
1153 else
1154 {
1155 TranslateMessage(&Msg);
1156 DispatchMessageW(&Msg);
1157 }
1158 if (!IsWindow(Wnd))
1159 {
1160 ReleaseCapture();
1161 break;
1162 }
1163 } while (Msg.message != WM_LBUTTONUP && GetCapture() == Wnd);
1164 }
1165
1166
1167 static DWORD FASTCALL
1168 IntSetScrollInfo(HWND Wnd, LPCSCROLLINFO Info, BOOL bRedraw)
1169 {
1170 DWORD Ret = NtUserSetScrollInfo(Wnd, SB_CTL, Info, bRedraw);
1171 if (Ret) IntNotifyWinEvent(EVENT_OBJECT_VALUECHANGE, Wnd, OBJID_CLIENT, CHILDID_SELF, WEF_SETBYWNDPTI);
1172 return Ret;
1173 }
1174
1175
1176 /***********************************************************************
1177 * ScrollBarWndProc
1178 */
1179 LRESULT WINAPI
1180 ScrollBarWndProc_common(WNDPROC DefWindowProc, HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL unicode )
1181 {
1182 #ifdef __REACTOS__ // Do this now, remove after Server side is fixed.
1183 PWND pWnd;
1184 PSBWND pSBWnd;
1185 SCROLLINFO ScrollInfo;
1186
1187 pWnd = ValidateHwnd(Wnd);
1188 if (pWnd)
1189 {
1190 if (!pWnd->fnid)
1191 {
1192 TRACE("ScrollBar CTL size %d\n", (sizeof(SBWND)-sizeof(WND)));
1193 if ( pWnd->cbwndExtra != (sizeof(SBWND)-sizeof(WND)) )
1194 {
1195 ERR("Wrong Extra bytes for Scrollbar!\n");
1196 return 0;
1197 }
1198
1199 if (Msg != WM_CREATE)
1200 {
1201 return DefWindowProc(Wnd, Msg, wParam, lParam);
1202 }
1203 NtUserSetWindowFNID(Wnd, FNID_SCROLLBAR);
1204 }
1205 else
1206 {
1207 if (pWnd->fnid != FNID_SCROLLBAR)
1208 {
1209 ERR("Wrong window class for Scrollbar!\n");
1210 return 0;
1211 }
1212 }
1213 }
1214 #endif
1215
1216 if (! IsWindow(Wnd))
1217 {
1218 return 0;
1219 }
1220
1221 // Must be a scroll bar control!
1222 pSBWnd = (PSBWND)pWnd;
1223
1224 switch (Msg)
1225 {
1226 case WM_CREATE:
1227 IntScrollCreateScrollBar(Wnd, (LPCREATESTRUCTW) lParam);
1228 break;
1229
1230 case WM_ENABLE:
1231 {
1232 return SendMessageW( Wnd, SBM_ENABLE_ARROWS, wParam ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH, 0);
1233 }
1234
1235 case WM_LBUTTONDBLCLK:
1236 case WM_LBUTTONDOWN:
1237 if (GetWindowLongW( Wnd, GWL_STYLE ) & SBS_SIZEGRIP)
1238 {
1239 SendMessageW( GetParent(Wnd), WM_SYSCOMMAND,
1240 SC_SIZE + ((GetWindowLongW( Wnd, GWL_EXSTYLE ) & WS_EX_LAYOUTRTL) ?
1241 WMSZ_BOTTOMLEFT : WMSZ_BOTTOMRIGHT), lParam );
1242 }
1243 else
1244 {
1245 POINT Pt;
1246 Pt.x = (short)LOWORD(lParam);
1247 Pt.y = (short)HIWORD(lParam);
1248 ScrollTrackScrollBar(Wnd, SB_CTL, Pt);
1249 }
1250 break;
1251
1252 case WM_LBUTTONUP:
1253 case WM_MOUSEMOVE:
1254 case WM_SYSTIMER:
1255 {
1256 POINT Pt;
1257 Pt.x = (short)LOWORD(lParam);
1258 Pt.y = (short)HIWORD(lParam);
1259 IntScrollHandleScrollEvent(Wnd, SB_CTL, Msg, Pt);
1260 }
1261 break;
1262
1263 case WM_KEYDOWN:
1264 IntScrollHandleKbdEvent(Wnd, wParam, lParam);
1265 break;
1266
1267 case WM_KEYUP:
1268 ShowCaret(Wnd);
1269 break;
1270
1271 case WM_SETFOCUS:
1272 {
1273 /* Create a caret when a ScrollBar get focus */
1274 RECT Rect;
1275 int ArrowSize, ThumbSize, ThumbPos, Vertical;
1276
1277 Vertical = IntScrollGetScrollBarRect(Wnd, SB_CTL, &Rect,
1278 &ArrowSize, &ThumbSize, &ThumbPos);
1279 if (! Vertical)
1280 {
1281 CreateCaret(Wnd, (HBITMAP) 1, ThumbSize - 2, Rect.bottom - Rect.top - 2);
1282 SetCaretPos(ThumbPos + 1, Rect.top + 1);
1283 }
1284 else
1285 {
1286 CreateCaret(Wnd, (HBITMAP) 1, Rect.right - Rect.left - 2, ThumbSize - 2);
1287 SetCaretPos(Rect.top + 1, ThumbPos + 1);
1288 }
1289 ShowCaret(Wnd);
1290 }
1291 break;
1292
1293 case WM_KILLFOCUS:
1294 {
1295 RECT Rect;
1296 int ArrowSize, ThumbSize, ThumbPos, Vertical;
1297
1298 Vertical = IntScrollGetScrollBarRect(Wnd, SB_CTL, &Rect,
1299 &ArrowSize, &ThumbSize, &ThumbPos);
1300 if (! Vertical)
1301 {
1302 Rect.left = ThumbPos + 1;
1303 Rect.right = Rect.left + ThumbSize;
1304 }
1305 else
1306 {
1307 Rect.top = ThumbPos + 1;
1308 Rect.bottom = Rect.top + ThumbSize;
1309 }
1310 HideCaret(Wnd);
1311 InvalidateRect(Wnd, &Rect, FALSE);
1312 DestroyCaret();
1313 }
1314 break;
1315
1316 case WM_ERASEBKGND:
1317 return 1;
1318
1319 case WM_GETDLGCODE:
1320 return DLGC_WANTARROWS; /* Windows returns this value */
1321
1322 case WM_PAINT:
1323 {
1324 PAINTSTRUCT Ps;
1325 HDC Dc;
1326
1327 Dc = (0 != wParam ? (HDC) wParam : BeginPaint(Wnd, &Ps));
1328
1329 if (GetWindowLongPtrW(Wnd, GWL_STYLE) & SBS_SIZEGRIP)
1330 {
1331 IntScrollDrawSizeGrip(Wnd, Dc);
1332 }
1333 else if (0 != (GetWindowLongPtrW(Wnd, GWL_STYLE) & SBS_SIZEBOX))
1334 {
1335 RECT Rect;
1336 GetClientRect(Wnd, &Rect);
1337 FillRect(Dc, &Rect, GetSysColorBrush(COLOR_SCROLLBAR));
1338 }
1339 else
1340 {
1341 IntDrawScrollBar(Wnd, Dc, SB_CTL/*, TRUE, TRUE*/);
1342 }
1343
1344 if (0 == wParam)
1345 {
1346 EndPaint(Wnd, &Ps);
1347 }
1348 }
1349 break;
1350
1351 case SBM_GETPOS:
1352 return pSBWnd->SBCalc.pos;
1353
1354 case SBM_GETRANGE:
1355 *(LPINT)wParam = pSBWnd->SBCalc.posMin;
1356 *(LPINT)lParam = pSBWnd->SBCalc.posMax;
1357 // This message does not return a value.
1358 return 0;
1359
1360 case SBM_ENABLE_ARROWS:
1361 return EnableScrollBar( Wnd, SB_CTL, wParam );
1362
1363 case SBM_SETPOS:
1364 {
1365 ScrollInfo.cbSize = sizeof(SCROLLINFO);
1366 ScrollInfo.fMask = SIF_POS|SIF_PREVIOUSPOS;
1367 ScrollInfo.nPos = wParam;
1368 return IntSetScrollInfo(Wnd, &ScrollInfo, lParam);
1369 }
1370
1371 case SBM_SETRANGEREDRAW:
1372 case SBM_SETRANGE:
1373 {
1374 ScrollInfo.cbSize = sizeof(SCROLLINFO);
1375 ScrollInfo.fMask = SIF_RANGE|SIF_PREVIOUSPOS;
1376 ScrollInfo.nMin = wParam;
1377 ScrollInfo.nMax = lParam;
1378 return IntSetScrollInfo(Wnd, &ScrollInfo, Msg == SBM_SETRANGEREDRAW ? TRUE : FALSE);
1379 }
1380
1381 case SBM_SETSCROLLINFO:
1382 return IntSetScrollInfo(Wnd, (LPCSCROLLINFO)lParam, wParam);
1383
1384 case SBM_GETSCROLLINFO:
1385 {
1386 PSBDATA pSBData = (PSBDATA)&pSBWnd->SBCalc;
1387 DWORD ret = NtUserSBGetParms(Wnd, SB_CTL, pSBData, (SCROLLINFO *) lParam);
1388 if (!ret)
1389 {
1390 ERR("SBM_GETSCROLLINFO No ScrollInfo\n");
1391 }
1392 return ret;
1393 }
1394 case SBM_GETSCROLLBARINFO:
1395 ((PSCROLLBARINFO)lParam)->cbSize = sizeof(SCROLLBARINFO);
1396 return NtUserGetScrollBarInfo(Wnd, OBJID_CLIENT, (PSCROLLBARINFO)lParam);
1397
1398 case 0x00e5:
1399 case 0x00e7:
1400 case 0x00e8:
1401 case 0x00ec:
1402 case 0x00ed:
1403 case 0x00ee:
1404 case 0x00ef:
1405 WARN("unknown Win32 msg %04x wp=%08lx lp=%08lx\n",
1406 Msg, wParam, lParam );
1407 break;
1408
1409 default:
1410 if (WM_USER <= Msg)
1411 {
1412 WARN("unknown msg %04x wp=%04lx lp=%08lx\n", Msg, wParam, lParam);
1413 }
1414 if (unicode)
1415 return DefWindowProcW( Wnd, Msg, wParam, lParam );
1416 else
1417 return DefWindowProcA( Wnd, Msg, wParam, lParam );
1418 }
1419
1420 return 0;
1421 }
1422
1423 LRESULT WINAPI
1424 ScrollBarWndProcW(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
1425 {
1426 return ScrollBarWndProc_common(DefWindowProcW, Wnd, Msg, wParam, lParam, TRUE);
1427 }
1428
1429 LRESULT WINAPI
1430 ScrollBarWndProcA(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
1431 {
1432 return ScrollBarWndProc_common(DefWindowProcA, Wnd, Msg, wParam, lParam, FALSE);
1433 }
1434
1435
1436 /* PUBLIC FUNCTIONS ***********************************************************/
1437
1438 /*
1439 * @implemented
1440 */
1441 BOOL
1442 WINAPI
1443 DECLSPEC_HOTPATCH
1444 EnableScrollBar( HWND hwnd, UINT nBar, UINT flags )
1445 {
1446 BOOL Hook, Ret = FALSE;
1447
1448 LoadUserApiHook();
1449
1450 Hook = BeginIfHookedUserApiHook();
1451
1452 /* Bypass SEH and go direct. */
1453 if (!Hook)
1454 {
1455 Ret = NtUserEnableScrollBar(hwnd, nBar, flags);
1456 if (!Ret) return Ret;
1457 SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
1458 return Ret;
1459 }
1460 _SEH2_TRY
1461 {
1462 Ret = guah.EnableScrollBar(hwnd, nBar, flags);
1463 }
1464 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1465 {
1466 }
1467 _SEH2_END;
1468
1469 EndUserApiHook();
1470
1471 return Ret;
1472 }
1473
1474 BOOL WINAPI
1475 RealGetScrollInfo(HWND Wnd, INT SBType, LPSCROLLINFO Info)
1476 {
1477 PWND pWnd;
1478 PSBDATA pSBData;
1479
1480 if (SB_CTL == SBType)
1481 {
1482 return SendMessageW(Wnd, SBM_GETSCROLLINFO, 0, (LPARAM) Info);
1483 }
1484
1485 pWnd = ValidateHwnd(Wnd);
1486 if (!pWnd) return FALSE;
1487
1488 if (SBType < SB_HORZ || SBType > SB_VERT)
1489 {
1490 SetLastError(ERROR_INVALID_PARAMETER);
1491 return FALSE;
1492 }
1493 if (!pWnd->pSBInfo)
1494 {
1495 SetLastError(ERROR_NO_SCROLLBARS);
1496 return FALSE;
1497 }
1498 pSBData = IntGetSBData(pWnd, SBType);
1499 return NtUserSBGetParms(Wnd, SBType, pSBData, Info);
1500 }
1501
1502 /*
1503 * @implemented
1504 */
1505 BOOL WINAPI GetScrollBarInfo( _In_ HWND hwnd, _In_ LONG idObject, _Inout_ LPSCROLLBARINFO info)
1506 {
1507 BOOL Ret;
1508 PWND pWnd = ValidateHwnd(hwnd);
1509 TRACE("hwnd=%p idObject=%d info=%p\n", hwnd, idObject, info);
1510 if (!pWnd) return FALSE;
1511 Ret = NtUserGetScrollBarInfo(hwnd, idObject, info); // This will be fixed once SB is server side.
1512 /* rcScrollBar needs to be in screen coordinates */
1513 OffsetRect( &(info->rcScrollBar), pWnd->rcWindow.left, pWnd->rcWindow.top );
1514 return Ret;
1515 }
1516
1517 /*
1518 * @implemented
1519 */
1520 BOOL
1521 WINAPI
1522 DECLSPEC_HOTPATCH
1523 GetScrollInfo(HWND Wnd, INT SBType, LPSCROLLINFO Info)
1524 {
1525 BOOL Hook, Ret = FALSE;
1526
1527 LoadUserApiHook();
1528
1529 Hook = BeginIfHookedUserApiHook();
1530
1531 /* Bypass SEH and go direct. */
1532 if (!Hook) return RealGetScrollInfo(Wnd, SBType, Info);
1533
1534 _SEH2_TRY
1535 {
1536 Ret = guah.GetScrollInfo(Wnd, SBType, Info);
1537 }
1538 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1539 {
1540 }
1541 _SEH2_END;
1542
1543 EndUserApiHook();
1544
1545 return Ret;
1546 }
1547
1548 /*
1549 * @implemented
1550 */
1551 INT
1552 WINAPI
1553 DECLSPEC_HOTPATCH
1554 GetScrollPos(HWND Wnd, INT Bar)
1555 {
1556 PWND pwnd;
1557 PSBDATA pSBData;
1558
1559 TRACE("Wnd=%p Bar=%d\n", Wnd, Bar);
1560
1561 /* Refer SB_CTL requests to the window */
1562 if (SB_CTL == Bar)
1563 {
1564 return SendMessageW(Wnd, SBM_GETPOS, (WPARAM) 0, (LPARAM) 0);
1565 }
1566 else if (Bar == SB_HORZ || Bar == SB_VERT )
1567 {
1568 pwnd = ValidateHwnd(Wnd);
1569 if (!pwnd) return 0;
1570
1571 if (pwnd->pSBInfo)
1572 {
1573 pSBData = IntGetSBData(pwnd, Bar);
1574 return pSBData->pos;
1575 }
1576
1577 SetLastError(ERROR_NO_SCROLLBARS);
1578 TRACE("GetScrollPos No Scroll Info\n");
1579 return 0;
1580 }
1581 SetLastError(ERROR_INVALID_PARAMETER);
1582 return 0;
1583 }
1584
1585 /*
1586 * @implemented
1587 */
1588 BOOL
1589 WINAPI
1590 DECLSPEC_HOTPATCH
1591 GetScrollRange(HWND Wnd, int Bar, LPINT MinPos, LPINT MaxPos)
1592 {
1593 PWND pwnd;
1594 PSBDATA pSBData;
1595
1596 TRACE("Wnd=%x Bar=%d Min=%p Max=%p\n", Wnd, Bar, MinPos, MaxPos);
1597
1598 /* Refer SB_CTL requests to the window */
1599 if (SB_CTL == Bar)
1600 {
1601 return SendMessageW(Wnd, SBM_GETRANGE, (WPARAM) MinPos, (LPARAM) MaxPos);
1602 }
1603 else if (Bar == SB_HORZ || Bar == SB_VERT )
1604 {
1605 pwnd = ValidateHwnd(Wnd);
1606 if (!pwnd) return FALSE;
1607
1608 if (pwnd->pSBInfo)
1609 {
1610 pSBData = IntGetSBData(pwnd, Bar);
1611 *MinPos = pSBData->posMin;
1612 *MaxPos = pSBData->posMax;
1613 }
1614 else
1615 {
1616 SetLastError(ERROR_NO_SCROLLBARS);
1617 *MinPos = 0;
1618 *MaxPos = 0;
1619 }
1620 return TRUE;
1621 }
1622 SetLastError(ERROR_INVALID_PARAMETER);
1623 return FALSE;
1624 }
1625
1626 INT WINAPI
1627 RealSetScrollInfo(HWND Wnd, int SBType, LPCSCROLLINFO Info, BOOL bRedraw)
1628 {
1629 if (SB_CTL == SBType)
1630 {
1631 return SendMessageW(Wnd, SBM_SETSCROLLINFO, (WPARAM) bRedraw, (LPARAM) Info);
1632 }
1633 else
1634 {
1635 return NtUserSetScrollInfo(Wnd, SBType, Info, bRedraw);
1636 }
1637 }
1638
1639 /*
1640 * @implemented
1641 */
1642 INT
1643 WINAPI
1644 DECLSPEC_HOTPATCH
1645 SetScrollInfo(HWND Wnd, int SBType, LPCSCROLLINFO Info, BOOL bRedraw)
1646 {
1647 BOOL Hook;
1648 INT Ret = 0;
1649
1650 LoadUserApiHook();
1651
1652 Hook = BeginIfHookedUserApiHook();
1653
1654 /* Bypass SEH and go direct. */
1655 if (!Hook) return RealSetScrollInfo(Wnd, SBType, Info, bRedraw);
1656
1657 _SEH2_TRY
1658 {
1659 Ret = guah.SetScrollInfo(Wnd, SBType, Info, bRedraw);
1660 }
1661 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1662 {
1663 }
1664 _SEH2_END;
1665
1666 EndUserApiHook();
1667
1668 return Ret;
1669
1670 }
1671
1672 /*
1673 * @implemented
1674 */
1675 INT
1676 WINAPI
1677 DECLSPEC_HOTPATCH
1678 SetScrollPos(HWND hWnd, INT nBar, INT nPos, BOOL bRedraw)
1679 {
1680 SCROLLINFO ScrollInfo;
1681
1682 ScrollInfo.cbSize = sizeof(SCROLLINFO);
1683 ScrollInfo.fMask = SIF_POS|SIF_PREVIOUSPOS;
1684 ScrollInfo.nPos = nPos;
1685
1686 return RealSetScrollInfo(hWnd, nBar, &ScrollInfo, bRedraw);
1687 }
1688
1689 /*
1690 * @implemented
1691 */
1692 BOOL
1693 WINAPI
1694 DECLSPEC_HOTPATCH
1695 SetScrollRange(HWND hWnd, INT nBar, INT nMinPos, INT nMaxPos, BOOL bRedraw)
1696 {
1697 PWND pWnd;
1698 SCROLLINFO ScrollInfo;
1699
1700 pWnd = ValidateHwnd(hWnd);
1701 if ( !pWnd ) return FALSE;
1702
1703 if ((nMaxPos - nMinPos) > MAXLONG)
1704 {
1705 SetLastError(ERROR_INVALID_SCROLLBAR_RANGE);
1706 return FALSE;
1707 }
1708
1709 ScrollInfo.cbSize = sizeof(SCROLLINFO);
1710 ScrollInfo.fMask = SIF_RANGE;
1711 ScrollInfo.nMin = nMinPos;
1712 ScrollInfo.nMax = nMaxPos;
1713 SetScrollInfo(hWnd, nBar, &ScrollInfo, bRedraw); // do not bypass themes.
1714 return TRUE;
1715 }