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