ReactOS  0.4.15-dev-3299-gbe8e5fc
scrollbar.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS kernel
4  * PURPOSE: Scrollbars
5  * FILE: win32ss/user/ntuser/scrollbar.c
6  * PROGRAMER: Thomas Weidenmueller (w3seek@users.sourceforge.net)
7  * Jason Filby (jasonfilby@yahoo.com)
8  */
9 
10 #include <win32k.h>
11 DBG_DEFAULT_CHANNEL(UserScrollbar);
12 
13 /* Definitions for scrollbar hit testing [See SCROLLBARINFO in MSDN] */
14 #define SCROLL_NOWHERE 0x00 /* Outside the scroll bar */
15 #define SCROLL_TOP_ARROW 0x01 /* Top or left arrow */
16 #define SCROLL_TOP_RECT 0x02 /* Rectangle between the top arrow and the thumb */
17 #define SCROLL_THUMB 0x03 /* Thumb rectangle */
18 #define SCROLL_BOTTOM_RECT 0x04 /* Rectangle between the thumb and the bottom arrow */
19 #define SCROLL_BOTTOM_ARROW 0x05 /* Bottom or right arrow */
20 
21 #define SCROLL_FIRST_DELAY 200 /* Delay (in ms) before first repetition when
22  holding the button down */
23 #define SCROLL_REPEAT_DELAY 50 /* Delay (in ms) between scroll repetitions */
24 
25 #define SCROLL_TIMER 0 /* Scroll timer id */
26 
27  /* Minimum size of the rectangle between the arrows */
28 #define SCROLL_MIN_RECT 4
29 
30  /* Minimum size of the thumb in pixels */
31 #define SCROLL_MIN_THUMB 6
32 
33  /* Overlap between arrows and thumb */
34 #define SCROLL_ARROW_THUMB_OVERLAP 0
35 
36 //
37 //
38 //
39 #define MINTRACKTHUMB 8 /* Minimum size of the rectangle between the arrows */
40 
41  /* What to do after SetScrollInfo() */
42  #define SA_SSI_HIDE 0x0001
43  #define SA_SSI_SHOW 0x0002
44  #define SA_SSI_REFRESH 0x0004
45  #define SA_SSI_REPAINT_ARROWS 0x0008
46 
47 #define SBRG_SCROLLBAR 0 /* The scrollbar itself */
48 #define SBRG_TOPRIGHTBTN 1 /* The top or right button */
49 #define SBRG_PAGEUPRIGHT 2 /* The page up or page right region */
50 #define SBRG_SCROLLBOX 3 /* The scroll box */
51 #define SBRG_PAGEDOWNLEFT 4 /* The page down or page left region */
52 #define SBRG_BOTTOMLEFTBTN 5 /* The bottom or left button */
53 
54 #define CHANGERGSTATE(item, status) \
55  if(Info->rgstate[(item)] != (status)) \
56  Chg = TRUE; \
57  Info->rgstate[(item)] = (status);
58 
59 /* FUNCTIONS *****************************************************************/
60 
63 
64 static void
66 
67 
68 /* Ported from WINE20020904 */
69 /* Compute the scroll bar rectangle, in drawing coordinates (i.e. client coords for SB_CTL, window coords for SB_VERT and
70  * SB_HORZ). 'arrowSize' returns the width or height of an arrow (depending on * the orientation of the scrollbar),
71  * 'thumbSize' returns the size of the thumb, and 'thumbPos' returns the position of the thumb relative to the left or to
72  * the top. Return TRUE if the scrollbar is vertical, FALSE if horizontal.
73  */
74 static inline void mirror_rect( const RECT *window_rect, RECT *rect )
75 {
76  int width = window_rect->right - window_rect->left;
77  int tmp = rect->left;
78  rect->left = width - rect->right;
79  rect->right = width - tmp;
80 }
81 
84 {
85  PSBWND pSBWnd;
86  PSBINFO pSBInfo;
87 
88  pSBInfo = pwnd->pSBInfo;
89  switch (Bar)
90  {
91  case SB_HORZ:
92  return &pSBInfo->Horz;
93  case SB_VERT:
94  return &pSBInfo->Vert;
95  case SB_CTL:
96  if ( pwnd->cbwndExtra < (sizeof(SBWND)-sizeof(WND)) )
97  {
98  ERR("IntGetSBData Wrong Extra bytes for CTL Scrollbar!\n");
99  return 0;
100  }
101  pSBWnd = (PSBWND)pwnd;
102  return (PSBDATA)&pSBWnd->SBCalc;
103  default:
104  ERR("IntGetSBData Bad Bar!\n");
105  }
106  return NULL;
107 }
108 
110 IntGetScrollBarRect (PWND Wnd, INT nBar, RECTL *lprect)
111 {
112  BOOL vertical;
113  *lprect = Wnd->rcClient;
114 
115  RECTL_vOffsetRect( lprect, -Wnd->rcWindow.left, -Wnd->rcWindow.top );
116  if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
117  mirror_rect( &Wnd->rcWindow, lprect );
118 
119  switch (nBar)
120  {
121  case SB_HORZ:
122  lprect->top = lprect->bottom;
124  if (Wnd->style & WS_BORDER)
125  {
126  lprect->left--;
127  lprect->right++;
128  }
129  else if (Wnd->style & WS_VSCROLL)
130  {
131  lprect->right++;
132  }
133  vertical = FALSE;
134  break;
135 
136  case SB_VERT:
137  if(Wnd->ExStyle & WS_EX_LEFTSCROLLBAR)
138  {
139  lprect->right = lprect->left;
141  }
142  else
143  {
144  lprect->left = lprect->right;
146  }
147  if (Wnd->style & WS_BORDER)
148  {
149  lprect->top--;
150  lprect->bottom++;
151  }
152  else if (Wnd->style & WS_HSCROLL)
153  {
154  lprect->bottom++;
155  }
156  vertical = TRUE;
157  break;
158 
159  case SB_CTL:
160  IntGetClientRect (Wnd, lprect);
161  vertical = !!(Wnd->style & SBS_VERT);
162  break;
163 
164  default:
165  return FALSE;
166  }
167 
168  return vertical;
169 }
170 
172 IntCalculateThumb(PWND Wnd, LONG idObject, PSCROLLBARINFO psbi, PSBDATA pSBData)
173 {
174  INT Thumb, ThumbBox, ThumbPos, cxy, mx;
175  RECTL ClientRect;
176 
177  switch(idObject)
178  {
179  case SB_HORZ:
181  cxy = psbi->rcScrollBar.right - psbi->rcScrollBar.left;
182  break;
183  case SB_VERT:
185  cxy = psbi->rcScrollBar.bottom - psbi->rcScrollBar.top;
186  break;
187  case SB_CTL:
188  IntGetClientRect(Wnd, &ClientRect);
189  if(Wnd->style & SBS_VERT)
190  {
192  cxy = ClientRect.bottom - ClientRect.top;
193  }
194  else
195  {
197  cxy = ClientRect.right - ClientRect.left;
198  }
199  break;
200  default:
201  return FALSE;
202  }
203 
204  ThumbPos = Thumb;
205  /* Calculate Thumb */
206  if(cxy <= (2 * Thumb))
207  {
208  Thumb = cxy / 2;
209  psbi->xyThumbTop = 0;
210  psbi->xyThumbBottom = 0;
211  ThumbPos = Thumb;
212  }
215  pSBData->posMin >= (int)(pSBData->posMax - max(pSBData->page - 1, 0)))
216  {
217  /* Nothing to scroll */
218  psbi->xyThumbTop = 0;
219  psbi->xyThumbBottom = 0;
220  }
221  else
222  {
223  ThumbBox = pSBData->page ? MINTRACKTHUMB : UserGetSystemMetrics(SM_CXHTHUMB);
224  cxy -= (2 * Thumb);
225  if(cxy >= ThumbBox)
226  {
227  if(pSBData->page)
228  {
229  ThumbBox = max(EngMulDiv(cxy, pSBData->page, pSBData->posMax - pSBData->posMin + 1), ThumbBox);
230  }
231 
232  if(cxy > ThumbBox)
233  {
234  mx = pSBData->posMax - max(pSBData->page - 1, 0);
235  if(pSBData->posMin < mx)
236  ThumbPos = Thumb + EngMulDiv(cxy - ThumbBox, pSBData->pos - pSBData->posMin, mx - pSBData->posMin);
237  else
238  ThumbPos = Thumb + ThumbBox;
239  }
240 
241  psbi->xyThumbTop = ThumbPos;
242  psbi->xyThumbBottom = ThumbPos + ThumbBox;
243  }
244  else
245  {
246  psbi->xyThumbTop = 0;
247  psbi->xyThumbBottom = 0;
248  }
249  }
250  psbi->dxyLineButton = Thumb;
251 
252  return TRUE;
253 }
254 /*
255 static VOID FASTCALL
256 IntUpdateSBInfo(PWND Window, int wBar)
257 {
258  PSCROLLBARINFO sbi;
259  PSBDATA pSBData;
260 
261  ASSERT(Window);
262  ASSERT(Window->pSBInfo);
263  ASSERT(Window->pSBInfoex);
264 
265  sbi = IntGetScrollbarInfoFromWindow(Window, wBar);
266  pSBData = IntGetSBData(Window, wBar);
267  IntGetScrollBarRect(Window, wBar, &(sbi->rcScrollBar));
268  IntCalculateThumb(Window, wBar, sbi, pSBData);
269 }
270 */
271 static BOOL FASTCALL
273 {
274  UINT Mask;
275  LPSCROLLINFO psi;
276 
278 
279  lpsi->fMask &= ~SIF_THEMED; // Remove Theme bit
280  if(!SBID_IS_VALID(nBar))
281  {
283  ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", nBar);
284  return FALSE;
285  }
286 
287  if (!Window->pSBInfo)
288  {
289  ERR("IntGetScrollInfo No window scrollbar info!\n");
290  return FALSE;
291  }
292 
293  psi = IntGetScrollInfoFromWindow(Window, nBar);
294 
295  if (lpsi->fMask == SIF_ALL)
296  {
298  }
299  else
300  {
301  Mask = lpsi->fMask;
302  }
303 
304  if (0 != (Mask & SIF_PAGE))
305  {
306  lpsi->nPage = psi->nPage;
307  }
308 
309  if (0 != (Mask & SIF_POS))
310  {
311  lpsi->nPos = psi->nPos;
312  }
313 
314  if (0 != (Mask & SIF_RANGE))
315  {
316  lpsi->nMin = psi->nMin;
317  lpsi->nMax = psi->nMax;
318  }
319 
320  if (0 != (Mask & SIF_TRACKPOS))
321  {
322  lpsi->nTrackPos = psi->nTrackPos;
323  }
324 
325  return TRUE;
326 }
327 
330  PWND pWnd,
331  INT nBar,
332  PSBDATA pSBData,
333  LPSCROLLINFO lpsi)
334 {
335  UINT Mask;
336  PSBTRACK pSBTrack = pWnd->head.pti->pSBTrack;
337 
338  lpsi->fMask &= ~SIF_THEMED; // Remove Theme bit
339  if (!SBID_IS_VALID(nBar))
340  {
342  ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", nBar);
343  return FALSE;
344  }
345 
346  if (!pWnd->pSBInfo || !pSBTrack) return FALSE;
347 
348  Mask = lpsi->fMask;
349 
350  if (0 != (Mask & SIF_PAGE))
351  {
352  lpsi->nPage = pSBData->page;
353  }
354 
355  if (0 != (Mask & SIF_POS))
356  {
357  lpsi->nPos = pSBData->pos;
358  }
359 
360  if (0 != (Mask & SIF_RANGE))
361  {
362  lpsi->nMin = pSBData->posMin;
363  lpsi->nMax = pSBData->posMax;
364  }
365 
366  if (0 != (Mask & SIF_TRACKPOS))
367  {
368  if ( pSBTrack &&
369  pSBTrack->nBar == nBar &&
370  pSBTrack->spwndTrack == pWnd )
371  lpsi->nTrackPos = pSBTrack->posNew;
372  else
373  lpsi->nTrackPos = pSBData->pos;
374  }
375  return (Mask & SIF_ALL) !=0;
376 }
377 
378 /*************************************************************************
379  * SCROLL_GetScrollBarInfo
380  *
381  * Internal helper for the API function
382  *
383  * PARAMS
384  * hwnd [I] Handle of window with scrollbar(s)
385  * idObject [I] One of OBJID_CLIENT, OBJID_HSCROLL, or OBJID_VSCROLL
386  * info [IO] cbSize specifies the size of the structure
387  *
388  * RETURNS
389  * FALSE if failed
390  */
391 #if 0
392 static BOOL SCROLL_GetScrollBarInfo(HWND hwnd, LONG idObject, LPSCROLLBARINFO info)
393 {
394  LPSCROLLBAR_INFO infoPtr;
395  INT nBar;
396  INT nDummy;
398  BOOL pressed;
399  RECT rect;
400 
401  switch (idObject)
402  {
403  case OBJID_CLIENT: nBar = SB_CTL; break;
404  case OBJID_HSCROLL: nBar = SB_HORZ; break;
405  case OBJID_VSCROLL: nBar = SB_VERT; break;
406  default: return FALSE;
407  }
408 
409  /* handle invalid data structure */
410  if (info->cbSize != sizeof(*info))
411  return FALSE;
412 
413  SCROLL_GetScrollBarRect(hwnd, nBar, &info->rcScrollBar, &nDummy,
414  &info->dxyLineButton, &info->xyThumbTop);
415  /* rcScrollBar needs to be in screen coordinates */
417  OffsetRect(&info->rcScrollBar, rect.left, rect.top);
418 
419  info->xyThumbBottom = info->xyThumbTop + info->dxyLineButton;
420 
421  infoPtr = SCROLL_GetInternalInfo(hwnd, nBar, TRUE);
422  if (!infoPtr)
423  return FALSE;
424 
425  /* Scroll bar state */
426  info->rgstate[0] = 0;
427  if ((nBar == SB_HORZ && !(style & WS_HSCROLL))
428  || (nBar == SB_VERT && !(style & WS_VSCROLL)))
429  info->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
430  if (infoPtr->minVal >= infoPtr->maxVal - max(infoPtr->page - 1, 0))
431  {
432  if (!(info->rgstate[0] & STATE_SYSTEM_INVISIBLE))
433  info->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
434  else
435  info->rgstate[0] |= STATE_SYSTEM_OFFSCREEN;
436  }
437  if (nBar == SB_CTL && !IsWindowEnabled(hwnd))
438  info->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
439 
440  pressed = ((nBar == SB_VERT) == SCROLL_trackVertical && GetCapture() == hwnd);
441 
442  /* Top/left arrow button state. MSDN says top/right, but I don't believe it */
443  info->rgstate[1] = 0;
444  if (pressed && SCROLL_trackHitTest == SCROLL_TOP_ARROW)
445  info->rgstate[1] |= STATE_SYSTEM_PRESSED;
446  if (infoPtr->flags & ESB_DISABLE_LTUP)
447  info->rgstate[1] |= STATE_SYSTEM_UNAVAILABLE;
448 
449  /* Page up/left region state. MSDN says up/right, but I don't believe it */
450  info->rgstate[2] = 0;
451  if (infoPtr->curVal == infoPtr->minVal)
452  info->rgstate[2] |= STATE_SYSTEM_INVISIBLE;
453  if (pressed && SCROLL_trackHitTest == SCROLL_TOP_RECT)
454  info->rgstate[2] |= STATE_SYSTEM_PRESSED;
455 
456  /* Thumb state */
457  info->rgstate[3] = 0;
458  if (pressed && SCROLL_trackHitTest == SCROLL_THUMB)
459  info->rgstate[3] |= STATE_SYSTEM_PRESSED;
460 
461  /* Page down/right region state. MSDN says down/left, but I don't believe it */
462  info->rgstate[4] = 0;
463  if (infoPtr->curVal >= infoPtr->maxVal - 1)
464  info->rgstate[4] |= STATE_SYSTEM_INVISIBLE;
465  if (pressed && SCROLL_trackHitTest == SCROLL_BOTTOM_RECT)
466  info->rgstate[4] |= STATE_SYSTEM_PRESSED;
467 
468  /* Bottom/right arrow button state. MSDN says bottom/left, but I don't believe it */
469  info->rgstate[5] = 0;
470  if (pressed && SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW)
471  info->rgstate[5] |= STATE_SYSTEM_PRESSED;
472  if (infoPtr->flags & ESB_DISABLE_RTDN)
473  info->rgstate[5] |= STATE_SYSTEM_UNAVAILABLE;
474 
475  return TRUE;
476 }
477 #endif
478 static DWORD FASTCALL
480 {
481  /*
482  * Update the scrollbar state and set action flags according to
483  * what has to be done graphics wise.
484  */
485 
487  PSCROLLBARINFO psbi;
488  UINT new_flags;
489  INT action = 0;
490  PSBDATA pSBData;
491  DWORD OldPos = 0, CurrentPos = 0;
492  BOOL bChangeParams = FALSE; /* Don't show/hide scrollbar if params don't change */
493  UINT MaxPage;
494  int MaxPos;
495  /* [0] = SB_HORZ, [1] = SB_VERT, [2] = SB_CTL */
496  static PWND PrevHwnd[3] = { 0 };
497  static DWORD PrevPos[3] = { 0 };
498  static DWORD PrevMax[3] = { 0 };
499  static INT PrevAction[3] = { 0 };
500 
502 
503  if(!SBID_IS_VALID(nBar)) /* Assures nBar is 0, 1, or 2 */
504  {
506  ERR("Trying to set scrollinfo for unknown scrollbar type %d", nBar);
507  return FALSE;
508  }
509 
511  {
512  return FALSE;
513  }
514 
515  if (lpsi->cbSize != sizeof(SCROLLINFO) &&
516  lpsi->cbSize != (sizeof(SCROLLINFO) - sizeof(lpsi->nTrackPos)))
517  {
519  return 0;
520  }
522  {
524  return 0;
525  }
526 
529  pSBData = IntGetSBData(Window, nBar);
530 
531  /* Set the page size */
532  if (lpsi->fMask & SIF_PAGE)
533  {
534  if (Info->nPage != lpsi->nPage)
535  {
536  Info->nPage = lpsi->nPage;
537  pSBData->page = lpsi->nPage;
538  bChangeParams = TRUE;
539  }
540  }
541 
542  /* Set the scroll pos */
543  if (lpsi->fMask & SIF_POS)
544  {
545  if (Info->nPos != lpsi->nPos)
546  {
547  OldPos = Info->nPos;
548  Info->nPos = lpsi->nPos;
549  pSBData->pos = lpsi->nPos;
550  }
551  }
552 
553  /* Set the scroll range */
554  if (lpsi->fMask & SIF_RANGE)
555  {
556  if (lpsi->nMin > lpsi->nMax)
557  {
558  Info->nMin = lpsi->nMin;
559  Info->nMax = lpsi->nMin;
560  pSBData->posMin = lpsi->nMin;
561  pSBData->posMax = lpsi->nMin;
562  bChangeParams = TRUE;
563  }
564  else if (Info->nMin != lpsi->nMin || Info->nMax != lpsi->nMax)
565  {
566  Info->nMin = lpsi->nMin;
567  Info->nMax = lpsi->nMax;
568  pSBData->posMin = lpsi->nMin;
569  pSBData->posMax = lpsi->nMax;
570  bChangeParams = TRUE;
571  }
572  }
573 
574  /* Make sure the page size is valid */
575  MaxPage = abs(Info->nMax - Info->nMin) + 1;
576  if (Info->nPage > MaxPage)
577  {
578  pSBData->page = Info->nPage = MaxPage;
579  }
580 
581  /* Make sure the pos is inside the range */
582  MaxPos = Info->nMax + 1 - (int)max(Info->nPage, 1);
583  ASSERT(MaxPos >= Info->nMin);
584  if (Info->nPos < Info->nMin)
585  {
586  pSBData->pos = Info->nPos = Info->nMin;
587  }
588  else if (Info->nPos > MaxPos)
589  {
590  pSBData->pos = Info->nPos = MaxPos;
591  }
592 
593  /*
594  * Don't change the scrollbar state if SetScrollInfo is just called
595  * with SIF_DISABLENOSCROLL
596  */
597  if (!(lpsi->fMask & SIF_ALL))
598  {
599  //goto done;
600  return lpsi->fMask & SIF_PREVIOUSPOS ? OldPos : pSBData->pos;
601  }
602 
603  /* Check if the scrollbar should be hidden or disabled */
604  if (lpsi->fMask & (SIF_RANGE | SIF_PAGE | SIF_DISABLENOSCROLL))
605  {
606  new_flags = Window->pSBInfo->WSBflags;
607  if (Info->nMin + (int)max(Info->nPage, 1) > Info->nMax)
608  {
609  /* Hide or disable scroll-bar */
610  if (lpsi->fMask & SIF_DISABLENOSCROLL)
611  {
612  new_flags = ESB_DISABLE_BOTH;
613  bChangeParams = TRUE;
614  }
615  else if ((nBar != SB_CTL) && bChangeParams)
616  {
618  }
619  }
620  else /* Show and enable scroll-bar only if no page only changed. */
621  if ((lpsi->fMask & ~SIF_THEMED) != SIF_PAGE)
622  {
623  if ((nBar != SB_CTL) && bChangeParams)
624  {
625  new_flags = ESB_ENABLE_BOTH;
626  action |= SA_SSI_SHOW;
627  }
628  else if (nBar == SB_CTL)
629  {
630  new_flags = ESB_ENABLE_BOTH;
631  }
632  }
633 
634  if (Window->pSBInfo->WSBflags != new_flags) /* Check arrow flags */
635  {
636  Window->pSBInfo->WSBflags = new_flags;
638  }
639  }
640 
641 //done:
642  if ((Window != PrevHwnd[nBar]) || (action != PrevAction[nBar]))
643  {
644  if ((action == SA_SSI_SHOW) && (PrevAction[nBar] == SA_SSI_HIDE))
645  {
647  }
648  }
649  if ((action != PrevAction[nBar]) && action != 0)
650  PrevAction[nBar] = action;
651 
652  if ( action & SA_SSI_HIDE )
653  {
655  }
656  else
657  {
658  if ( action & SA_SSI_SHOW )
659  if ( co_UserShowScrollBar(Window, nBar, TRUE, TRUE) )
660  return lpsi->fMask & SIF_PREVIOUSPOS ? OldPos : pSBData->pos; /* SetWindowPos() already did the painting */
661  if (bRedraw)
662  {
663  if (!(lpsi->fMask & SIF_THEMED)) /* Not Using Themes */
664  {
665  TRACE("Not using themes.\n");
667  {
668  // Redraw the entire bar.
669  RECTL UpdateRect = psbi->rcScrollBar;
670  UpdateRect.left -= Window->rcClient.left - Window->rcWindow.left;
671  UpdateRect.right -= Window->rcClient.left - Window->rcWindow.left;
672  UpdateRect.top -= Window->rcClient.top - Window->rcWindow.top;
673  UpdateRect.bottom -= Window->rcClient.top - Window->rcWindow.top;
675  }
676  else
677  {
678  // Redraw only the interior part of the bar.
679  IntRefeshScrollInterior(Window, nBar, psbi);
680  }
681  }
682  else /* Using Themes */
683  {
684  RECTL UpdateRect = psbi->rcScrollBar;
685  TRACE("Using themes.\n");
686  UpdateRect.left -= Window->rcClient.left - Window->rcWindow.left;
687  UpdateRect.right -= Window->rcClient.left - Window->rcWindow.left;
688  UpdateRect.top -= Window->rcClient.top - Window->rcWindow.top;
689  UpdateRect.bottom -= Window->rcClient.top - Window->rcWindow.top;
690  /* Just paint the interior and not the arrows. */
691  if (!(action & SA_SSI_REPAINT_ARROWS))
692  {
693  if (nBar == SB_HORZ)
694  {
695  UpdateRect.left += psbi->dxyLineButton;
696  UpdateRect.right -= psbi->dxyLineButton;
697  }
698  if (nBar == SB_VERT)
699  {
700  UpdateRect.top += psbi->dxyLineButton;
701  UpdateRect.bottom -= psbi->dxyLineButton;
702  }
703  }
704  CurrentPos = lpsi->fMask & SIF_PREVIOUSPOS ? OldPos : pSBData->pos;
705  /* Check for changes to Window or CurrentPos or lpsi->nMax */
706  if ((Window != PrevHwnd[nBar]) || (CurrentPos != PrevPos[nBar]) ||
707  (lpsi->nMax != PrevMax[nBar]))
708  {
710  PrevHwnd[nBar] = Window;
711  PrevPos[nBar] = CurrentPos;
712  PrevMax[nBar] = lpsi->nMax;
713  }
714  }
715  } // FIXME: Arrows
716 /* else if( action & SA_SSI_REPAINT_ARROWS )
717  {
718  RECTL UpdateRect = psbi->rcScrollBar;
719  UpdateRect.left -= Window->rcClient.left - Window->rcWindow.left;
720  UpdateRect.right -= Window->rcClient.left - Window->rcWindow.left;
721  UpdateRect.top -= Window->rcClient.top - Window->rcWindow.top;
722  UpdateRect.bottom -= Window->rcClient.top - Window->rcWindow.top;
723  co_UserRedrawWindow(Window, &UpdateRect, 0, RDW_INVALIDATE | RDW_FRAME);
724  }
725 */ }
726 
727  if (bChangeParams && (nBar == SB_HORZ || nBar == SB_VERT) && (lpsi->fMask & SIF_DISABLENOSCROLL))
728  {
729  IntEnableScrollBar(nBar == SB_HORZ, psbi, Window->pSBInfo->WSBflags);
730  }
731 
732  /* Return current position */
733  return lpsi->fMask & SIF_PREVIOUSPOS ? OldPos : pSBData->pos;
734 }
735 
738 {
739  INT Bar;
740  PSCROLLBARINFO sbi;
741  PSBDATA pSBData;
743 
744  Bar = SBOBJ_TO_SBID(idObject);
745 
746  if(!SBID_IS_VALID(Bar))
747  {
749  ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", Bar);
750  return FALSE;
751  }
752 
754  {
755  ERR("Failed to create scrollbars for window.\n");
756  return FALSE;
757  }
758 
760  pSBData = IntGetSBData(Window, Bar);
761 
763  IntCalculateThumb(Window, Bar, sbi, pSBData);
764 
765  /* Scroll bar state */
766  psbi->rgstate[0] = 0;
767  if ((Bar == SB_HORZ && !(Window->style & WS_HSCROLL))
768  || (Bar == SB_VERT && !(Window->style & WS_VSCROLL)))
769  psbi->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
770  if (pSBData->posMin >= pSBData->posMax - max(pSBData->page - 1, 0))
771  {
772  if (!(psbi->rgstate[0] & STATE_SYSTEM_INVISIBLE))
773  psbi->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
774  else
775  psbi->rgstate[0] |= STATE_SYSTEM_OFFSCREEN;
776  }
777  if (Bar == SB_CTL && !(Window->style & WS_DISABLED))
778  psbi->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
779 
780  RtlCopyMemory(psbi, sbi, sizeof(SCROLLBARINFO));
781 
782  return TRUE;
783 }
784 
787 {
788  INT Bar;
789  PSCROLLBARINFO sbi;
790  LPSCROLLINFO psi;
792 
793  Bar = SBOBJ_TO_SBID(idObject);
794 
795  if(!SBID_IS_VALID(Bar))
796  {
798  ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", Bar);
799  return FALSE;
800  }
801 
803  {
804  ERR("Failed to create scrollbars for window.\n");
805  return FALSE;
806  }
807 
810 
811  psi->nTrackPos = psbi->nTrackPos;
812  sbi->reserved = psbi->reserved;
813  RtlCopyMemory(&sbi->rgstate, &psbi->rgstate, sizeof(psbi->rgstate));
814 
815  return TRUE;
816 }
817 
820 {
821  PSCROLLBARINFO psbi;
822  PSBDATA pSBData;
823  ULONG Size, s;
824  INT i;
825 
827 
828  if (Window->pSBInfo && Window->pSBInfoex)
829  {
830  /* No need to create it anymore */
831  return TRUE;
832  }
833 
834  /* Allocate memory for all scrollbars (HORZ, VERT, CONTROL) */
835  Size = 3 * (sizeof(SBINFOEX));
837  {
838  ERR("Unable to allocate memory for scrollbar information for window %p\n", Window->head.h);
839  return FALSE;
840  }
841 
842  RtlZeroMemory(Window->pSBInfoex, Size);
843 
844  if(!(Window->pSBInfo = DesktopHeapAlloc( Window->head.rpdesk, sizeof(SBINFO))))
845  {
846  ERR("Unable to allocate memory for scrollbar information for window %p\n", Window->head.h);
847  return FALSE;
848  }
849 
850  RtlZeroMemory(Window->pSBInfo, sizeof(SBINFO));
851  Window->pSBInfo->Vert.posMax = 100;
852  Window->pSBInfo->Horz.posMax = 100;
853 
855  &Window->rcWindow,
856  &Window->rcClient);
857 
858  for(s = SB_HORZ; s <= SB_VERT; s++)
859  {
861  psbi->cbSize = sizeof(SCROLLBARINFO);
862  for (i = 0; i < CCHILDREN_SCROLLBAR + 1; i++)
863  psbi->rgstate[i] = 0;
864 
865  pSBData = IntGetSBData(Window, s);
866 
868  IntCalculateThumb(Window, s, psbi, pSBData);
869  }
870 
871  return TRUE;
872 }
873 
876 {
877  if (Window->pSBInfo && Window->pSBInfoex)
878  {
879  DesktopHeapFree(Window->head.rpdesk, Window->pSBInfo);
880  Window->pSBInfo = NULL;
882  Window->pSBInfoex = NULL;
883  return TRUE;
884  }
885  return FALSE;
886 }
887 
890 {
891  BOOL Chg = FALSE;
892  switch(wArrows)
893  {
894  case ESB_DISABLE_BOTH:
897  break;
898  case ESB_DISABLE_RTDN:
899  if(Horz)
900  {
902  }
903  else
904  {
906  }
907  break;
908  case ESB_DISABLE_LTUP:
909  if(Horz)
910  {
912  }
913  else
914  {
916  }
917  break;
918  case ESB_ENABLE_BOTH:
921  break;
922  }
923  return Chg;
924 }
925 
926 /* Ported from WINE20020904 (SCROLL_ShowScrollBar) */
928 co_UserShowScrollBar(PWND Wnd, int nBar, BOOL fShowH, BOOL fShowV)
929 {
930  ULONG old_style, set_bits = 0, clear_bits = 0;
931 
932  ASSERT_REFS_CO(Wnd);
933 
934  switch(nBar)
935  {
936  case SB_CTL:
937  {
938  //IntUpdateSBInfo(Wnd, SB_CTL); // Is this needed? Was tested w/o!
939 
940  co_WinPosShowWindow(Wnd, fShowH ? SW_SHOW : SW_HIDE);
941  return TRUE;
942  }
943  case SB_BOTH:
944  case SB_HORZ:
945  if (fShowH) set_bits |= WS_HSCROLL;
946  else clear_bits |= WS_HSCROLL;
947  if( nBar == SB_HORZ ) break;
948  /* Fall through */
949  case SB_VERT:
950  if (fShowV) set_bits |= WS_VSCROLL;
951  else clear_bits |= WS_VSCROLL;
952  break;
953  default:
955  return FALSE; /* Nothing to do! */
956  }
957 
958  old_style = IntSetStyle( Wnd, set_bits, clear_bits );
959  if ((old_style & clear_bits) != 0 || (old_style & set_bits) != set_bits)
960  {
962  //if (Wnd->style & WS_HSCROLL) IntUpdateSBInfo(Wnd, SB_HORZ);
963  //if (Wnd->style & WS_VSCROLL) IntUpdateSBInfo(Wnd, SB_VERT);
965  /* Frame has been changed, let the window redraw itself */
966  co_WinPosSetWindowPos( Wnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
968  return TRUE;
969  }
970  return FALSE; /* no frame changes */
971 }
972 
973 static void
974 IntDrawScrollInterior(PWND pWnd, HDC hDC, INT nBar, BOOL Vertical, PSCROLLBARINFO ScrollBarInfo)
975 {
976  INT ThumbSize = ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop;
977  INT ThumbTop = ScrollBarInfo->xyThumbTop;
978  RECT Rect;
979  HBRUSH hSaveBrush, hBrush;
980  BOOL TopSelected = FALSE, BottomSelected = FALSE;
981 
982  if (ScrollBarInfo->rgstate[SCROLL_TOP_RECT] & STATE_SYSTEM_PRESSED)
983  TopSelected = TRUE;
984  if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_RECT] & STATE_SYSTEM_PRESSED)
985  BottomSelected = TRUE;
986 
987  /*
988  * Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
989  * The window-owned scrollbars need to call DefWndControlColor
990  * to correctly setup default scrollbar colors
991  */
992  if (nBar == SB_CTL)
993  {
994  hBrush = GetControlBrush( pWnd, hDC, WM_CTLCOLORSCROLLBAR);
995  if (!hBrush)
997  }
998  else
999  {
1001  }
1002 
1003  hSaveBrush = NtGdiSelectBrush(hDC, hBrush);
1004 
1005  /* Calculate the scroll rectangle */
1006  if (Vertical)
1007  {
1008  Rect.top = ScrollBarInfo->rcScrollBar.top + ScrollBarInfo->dxyLineButton;
1009  Rect.bottom = ScrollBarInfo->rcScrollBar.bottom - ScrollBarInfo->dxyLineButton;
1010  Rect.left = ScrollBarInfo->rcScrollBar.left;
1011  Rect.right = ScrollBarInfo->rcScrollBar.right;
1012  }
1013  else
1014  {
1015  Rect.top = ScrollBarInfo->rcScrollBar.top;
1016  Rect.bottom = ScrollBarInfo->rcScrollBar.bottom;
1017  Rect.left = ScrollBarInfo->rcScrollBar.left + ScrollBarInfo->dxyLineButton;
1018  Rect.right = ScrollBarInfo->rcScrollBar.right - ScrollBarInfo->dxyLineButton;
1019  }
1020 
1021  /* Draw the scroll rectangles and thumb */
1022  if (!ScrollBarInfo->xyThumbBottom)
1023  {
1024  NtGdiPatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
1025  Rect.bottom - Rect.top, PATCOPY);
1026 
1027  /* Cleanup and return */
1028  NtGdiSelectBrush(hDC, hSaveBrush);
1029  return;
1030  }
1031 
1032  ThumbTop -= ScrollBarInfo->dxyLineButton;
1033 
1034  if (ScrollBarInfo->dxyLineButton)
1035  {
1036  if (Vertical)
1037  {
1038  if (ThumbSize)
1039  {
1040  NtGdiPatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
1041  ThumbTop, TopSelected ? BLACKNESS : PATCOPY);
1042  Rect.top += ThumbTop;
1043  NtGdiPatBlt(hDC, Rect.left, Rect.top + ThumbSize, Rect.right - Rect.left,
1044  Rect.bottom - Rect.top - ThumbSize, BottomSelected ? BLACKNESS : PATCOPY);
1045  Rect.bottom = Rect.top + ThumbSize;
1046  }
1047  else
1048  {
1049  if (ThumbTop)
1050  {
1051  NtGdiPatBlt(hDC, Rect.left, ScrollBarInfo->dxyLineButton,
1052  Rect.right - Rect.left, Rect.bottom - Rect.top, PATCOPY);
1053  }
1054  }
1055  }
1056  else
1057  {
1058  if (ThumbSize)
1059  {
1060  NtGdiPatBlt(hDC, Rect.left, Rect.top, ThumbTop,
1061  Rect.bottom - Rect.top, TopSelected ? BLACKNESS : PATCOPY);
1062  Rect.left += ThumbTop;
1063  NtGdiPatBlt(hDC, Rect.left + ThumbSize, Rect.top,
1064  Rect.right - Rect.left - ThumbSize, Rect.bottom - Rect.top,
1065  BottomSelected ? BLACKNESS : PATCOPY);
1066  Rect.right = Rect.left + ThumbSize;
1067  }
1068  else
1069  {
1070  if (ThumbTop)
1071  {
1072  NtGdiPatBlt(hDC, ScrollBarInfo->dxyLineButton, Rect.top,
1073  Rect.right - Rect.left, Rect.bottom - Rect.top, PATCOPY);
1074  }
1075  }
1076  }
1077  }
1078 
1079  /* Draw the thumb */
1080  if (ThumbSize)
1082 
1083  /* Cleanup */
1084  NtGdiSelectBrush(hDC, hSaveBrush);
1085 }
1086 
1087 
1088 static VOID FASTCALL
1089 IntDrawScrollArrows(HDC hDC, PSCROLLBARINFO ScrollBarInfo, BOOL Vertical)
1090 {
1091  RECT RectLT, RectRB;
1092  INT ScrollDirFlagLT, ScrollDirFlagRB;
1093 
1094  RectLT = RectRB = ScrollBarInfo->rcScrollBar;
1095  if (Vertical)
1096  {
1097  ScrollDirFlagLT = DFCS_SCROLLUP;
1098  ScrollDirFlagRB = DFCS_SCROLLDOWN;
1099  RectLT.bottom = RectLT.top + ScrollBarInfo->dxyLineButton;
1100  RectRB.top = RectRB.bottom - ScrollBarInfo->dxyLineButton;
1101  }
1102  else
1103  {
1104  ScrollDirFlagLT = DFCS_SCROLLLEFT;
1105  ScrollDirFlagRB = DFCS_SCROLLRIGHT;
1106  RectLT.right = RectLT.left + ScrollBarInfo->dxyLineButton;
1107  RectRB.left = RectRB.right - ScrollBarInfo->dxyLineButton;
1108  }
1109 
1110  if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_PRESSED)
1111  {
1112  ScrollDirFlagLT |= DFCS_PUSHED | DFCS_FLAT;
1113  }
1114  if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_UNAVAILABLE)
1115  {
1116  ScrollDirFlagLT |= DFCS_INACTIVE;
1117  }
1118  if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_ARROW] & STATE_SYSTEM_PRESSED)
1119  {
1120  ScrollDirFlagRB |= DFCS_PUSHED | DFCS_FLAT;
1121  }
1123  {
1124  ScrollDirFlagRB |= DFCS_INACTIVE;
1125  }
1126 
1127  DrawFrameControl(hDC, &RectLT, DFC_SCROLL, ScrollDirFlagLT);
1128  DrawFrameControl(hDC, &RectRB, DFC_SCROLL, ScrollDirFlagRB);
1129 }
1130 
1131 static LONG FASTCALL
1133 {
1134  if (SBType == SB_VERT)
1135  return OBJID_VSCROLL;
1136  if (SBType == SB_HORZ)
1137  return OBJID_HSCROLL;
1138  return OBJID_CLIENT;
1139 }
1140 
1141 static void
1143 {
1144  HDC hdc;
1145  BOOL Vertical = ((nBar == SB_CTL) ? ((pWnd->style & SBS_VERT) != 0) : (nBar == SB_VERT));
1146 
1147  hdc = UserGetDCEx(pWnd, NULL, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
1148  if (hdc)
1149  { /* Get updated info. */
1150  co_IntGetScrollBarInfo(pWnd, IntScrollGetObjectId(nBar), psbi);
1151  IntDrawScrollInterior(pWnd, hdc, nBar, Vertical, psbi);
1152  UserReleaseDC(pWnd, hdc, FALSE);
1153  }
1154 }
1155 
1156 void
1158 {
1159  //PSBWND pSBWnd;
1160  //INT ThumbSize;
1161  PTHREADINFO pti;
1163  BOOL Vertical;
1164 
1166 
1167  /*
1168  * Get scroll bar info.
1169  */
1170  switch (Bar)
1171  {
1172  case SB_HORZ:
1173  Vertical = FALSE;
1174  break;
1175 
1176  case SB_VERT:
1177  Vertical = TRUE;
1178  break;
1179 
1180  case SB_CTL:
1181  Vertical = (Wnd->style & SBS_VERT) != 0;
1182  break;
1183 
1184  default:
1185  return;
1186  }
1187 
1189  {
1190  return;
1191  }
1192 
1193  if (RECTL_bIsEmptyRect(&Info.rcScrollBar))
1194  {
1195  return;
1196  }
1197 
1198  //ThumbSize = pSBWnd->pSBCalc->pxThumbBottom - pSBWnd->pSBCalc->pxThumbTop;
1199 
1200  /*
1201  * Draw the arrows.
1202  */
1203  if (Info.dxyLineButton)
1204  {
1205  IntDrawScrollArrows(DC, &Info, Vertical);
1206  }
1207 
1208  /*
1209  * Draw the interior.
1210  */
1211  IntDrawScrollInterior(Wnd, DC, Bar, Vertical, &Info);
1212 
1213  /*
1214  * If scroll bar has focus, reposition the caret.
1215  */
1216  if ( Wnd == pti->MessageQueue->spwndFocus && Bar == SB_CTL )
1217  {
1218  if (Vertical)
1219  {
1220  co_IntSetCaretPos(Info.rcScrollBar.top + 1, Info.dxyLineButton + 1);
1221  }
1222  else
1223  {
1224  co_IntSetCaretPos(Info.dxyLineButton + 1, Info.rcScrollBar.top + 1);
1225  }
1226  }
1227 }
1228 
1229 
1232 {
1233  LRESULT lResult = 0;
1234  PWND pWnd;
1235  pWnd = UserGetWindowObject(hWnd);
1236  if (!pWnd) return 0;
1237 
1238  switch(Msg)
1239  {
1240  case WM_ENABLE:
1241  {
1242  if (pWnd->pSBInfo)
1243  {
1245  }
1246  }
1247  break;
1248  }
1249  return lResult;
1250 }
1251 
1253 
1254 BOOL
1255 APIENTRY
1257 {
1258  NTSTATUS Status;
1259  SCROLLBARINFO sbi;
1260  PWND Window;
1261  BOOL Ret;
1264 
1265  TRACE("Enter NtUserGetScrollBarInfo\n");
1267 
1268  Status = MmCopyFromCaller(&sbi, psbi, sizeof(SCROLLBARINFO));
1269  if(!NT_SUCCESS(Status) || (sbi.cbSize != sizeof(SCROLLBARINFO)))
1270  {
1272  RETURN(FALSE);
1273  }
1274 
1275  if(!(Window = UserGetWindowObject(hWnd)))
1276  {
1277  RETURN(FALSE);
1278  }
1279 
1280  UserRefObjectCo(Window, &Ref);
1281  Ret = co_IntGetScrollBarInfo(Window, idObject, &sbi);
1283 
1284  Status = MmCopyToCaller(psbi, &sbi, sizeof(SCROLLBARINFO));
1285  if(!NT_SUCCESS(Status))
1286  {
1288  Ret = FALSE;
1289  }
1290 
1291  RETURN( Ret);
1292 
1293 CLEANUP:
1294  TRACE("Leave NtUserGetScrollBarInfo, ret=%i\n",_ret_);
1295  UserLeave();
1296  END_CLEANUP;
1297 
1298 }
1299 
1300 BOOL
1301 APIENTRY
1303  HWND hWnd,
1304  int fnBar,
1305  PSBDATA pSBData,
1306  LPSCROLLINFO lpsi)
1307 {
1308  PWND Window;
1309  SCROLLINFO psi;
1310  BOOL Ret;
1311  SBDATA SBDataSafe;
1314 
1315  TRACE("Enter NtUserGetScrollInfo\n");
1316  UserEnterShared();
1317 
1318  _SEH2_TRY
1319  {
1320  RtlCopyMemory(&psi, lpsi, sizeof(SCROLLINFO));
1321  if (pSBData)
1322  {
1323  RtlCopyMemory(&SBDataSafe, pSBData, sizeof(SBDATA));
1324  }
1325  }
1327  {
1328  ERR("NtUserGetScrollInfo Failed size.\n");
1331  }
1332  _SEH2_END
1333 
1334  if(!(Window = UserGetWindowObject(hWnd)))
1335  {
1336  ERR("NtUserGetScrollInfo Bad window.\n");
1337  RETURN(FALSE);
1338  }
1339 
1340  UserRefObjectCo(Window, &Ref);
1341  Ret = co_IntGetScrollInfo(Window, fnBar, &SBDataSafe, &psi);
1343 
1344  _SEH2_TRY
1345  {
1346  RtlCopyMemory(lpsi, &psi, sizeof(SCROLLINFO));
1347  }
1349  {
1350  ERR("NtUserGetScrollInfo Failed copy to user.\n");
1353  }
1354  _SEH2_END
1355 
1356  RETURN( Ret);
1357 
1358 CLEANUP:
1359  TRACE("Leave NtUserGetScrollInfo, ret=%i\n",_ret_);
1360  UserLeave();
1361  END_CLEANUP;
1362 }
1363 
1364 BOOL
1365 APIENTRY
1367  HWND hWnd,
1368  UINT wSBflags,
1369  UINT wArrows)
1370 {
1371  UINT OrigArrows;
1372  PWND Window = NULL;
1373  PSCROLLBARINFO InfoV = NULL, InfoH = NULL;
1374  BOOL Chg = FALSE;
1377 
1378  TRACE("Enter NtUserEnableScrollBar\n");
1380 
1381  if (!(Window = UserGetWindowObject(hWnd)) ||
1383  {
1384  RETURN(FALSE);
1385  }
1386  UserRefObjectCo(Window, &Ref);
1387 
1389  {
1390  RETURN( FALSE);
1391  }
1392 
1393  OrigArrows = Window->pSBInfo->WSBflags;
1394  Window->pSBInfo->WSBflags = wArrows;
1395 
1396  if (wSBflags == SB_CTL)
1397  {
1398  if ((wArrows == ESB_DISABLE_BOTH || wArrows == ESB_ENABLE_BOTH))
1399  IntEnableWindow(hWnd, (wArrows == ESB_ENABLE_BOTH));
1400 
1401  RETURN(TRUE);
1402  }
1403 
1404  if(wSBflags != SB_BOTH && !SBID_IS_VALID(wSBflags))
1405  {
1407  ERR("Trying to set scrollinfo for unknown scrollbar type %u", wSBflags);
1408  RETURN(FALSE);
1409  }
1410 
1411  switch(wSBflags)
1412  {
1413  case SB_BOTH:
1415  /* Fall through */
1416  case SB_HORZ:
1418  break;
1419  case SB_VERT:
1421  break;
1422  default:
1423  RETURN(FALSE);
1424  }
1425 
1426  if(InfoV)
1427  Chg = IntEnableScrollBar(FALSE, InfoV, wArrows);
1428 
1429  if(InfoH)
1430  Chg = (IntEnableScrollBar(TRUE, InfoH, wArrows) || Chg);
1431 
1432  ERR("FIXME: EnableScrollBar wSBflags %u wArrows %u Chg %d\n", wSBflags, wArrows, Chg);
1433 // Done in user32:
1434 // SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
1435 
1436  RETURN( Chg);
1437  if (OrigArrows == wArrows) RETURN( FALSE);
1438  RETURN( TRUE);
1439 
1440 CLEANUP:
1441  if (Window)
1443 
1444  TRACE("Leave NtUserEnableScrollBar, ret=%i\n",_ret_);
1445  UserLeave();
1446  END_CLEANUP;
1447 }
1448 
1449 DWORD
1450 APIENTRY
1452  HWND hWnd,
1453  int fnBar,
1454  LPCSCROLLINFO lpsi,
1455  BOOL bRedraw)
1456 {
1457  PWND Window = NULL;
1458  NTSTATUS Status;
1459  SCROLLINFO ScrollInfo;
1462 
1463  TRACE("Enter NtUserSetScrollInfo\n");
1465 
1466  if(!(Window = UserGetWindowObject(hWnd)) ||
1468  {
1469  RETURN( 0);
1470  }
1471  UserRefObjectCo(Window, &Ref);
1472 
1473  Status = MmCopyFromCaller(&ScrollInfo, lpsi, sizeof(SCROLLINFO) - sizeof(ScrollInfo.nTrackPos));
1474  if(!NT_SUCCESS(Status))
1475  {
1477  RETURN( 0);
1478  }
1479 
1480  RETURN(co_IntSetScrollInfo(Window, fnBar, &ScrollInfo, bRedraw));
1481 
1482 CLEANUP:
1483  if (Window)
1485 
1486  TRACE("Leave NtUserSetScrollInfo, ret=%lu\n", _ret_);
1487  UserLeave();
1488  END_CLEANUP;
1489 
1490 }
1491 
1494 {
1495  PWND Window;
1497  DWORD ret;
1499 
1500  TRACE("Enter NtUserShowScrollBar\n");
1502 
1503  if (!(Window = UserGetWindowObject(hWnd)))
1504  {
1505  RETURN(0);
1506  }
1507 
1508  UserRefObjectCo(Window, &Ref);
1509  ret = co_UserShowScrollBar(Window, nBar, (nBar == SB_VERT) ? 0 : bShow,
1510  (nBar == SB_HORZ) ? 0 : bShow);
1512 
1513  RETURN(ret);
1514 
1515 CLEANUP:
1516  TRACE("Leave NtUserShowScrollBar, ret%lu\n", _ret_);
1517  UserLeave();
1518  END_CLEANUP;
1519 
1520 }
1521 
1522 
1524 
1525 BOOL
1526 APIENTRY
1528  HWND hWnd,
1529  LONG idObject,
1531 {
1532  PWND Window = NULL;
1533  SETSCROLLBARINFO Safeinfo;
1534  PSCROLLBARINFO sbi;
1535  LPSCROLLINFO psi;
1536  NTSTATUS Status;
1537  LONG Obj;
1540 
1541  TRACE("Enter NtUserSetScrollBarInfo\n");
1543 
1544  if(!(Window = UserGetWindowObject(hWnd)))
1545  {
1546  RETURN( FALSE);
1547  }
1548  UserRefObjectCo(Window, &Ref);
1549 
1550  Obj = SBOBJ_TO_SBID(idObject);
1551  if(!SBID_IS_VALID(Obj))
1552  {
1554  ERR("Trying to set scrollinfo for unknown scrollbar type %d\n", Obj);
1555  RETURN( FALSE);
1556  }
1557 
1559  {
1560  RETURN(FALSE);
1561  }
1562 
1563  Status = MmCopyFromCaller(&Safeinfo, info, sizeof(SETSCROLLBARINFO));
1564  if(!NT_SUCCESS(Status))
1565  {
1567  RETURN(FALSE);
1568  }
1569 
1572 
1573  psi->nTrackPos = Safeinfo.nTrackPos;
1574  sbi->reserved = Safeinfo.reserved;
1575  RtlCopyMemory(&sbi->rgstate, &Safeinfo.rgstate, sizeof(Safeinfo.rgstate));
1576 
1577  RETURN(TRUE);
1578 
1579 CLEANUP:
1580  if (Window)
1582 
1583  TRACE("Leave NtUserSetScrollBarInfo, ret=%i\n",_ret_);
1584  UserLeave();
1585  END_CLEANUP;
1586 }
1587 
1588 /* EOF */
BOOL FASTCALL IntGetScrollBarRect(PWND Wnd, INT nBar, RECTL *lprect)
Definition: scrollbar.c:110
PSBDATA FASTCALL IntGetSBData(PWND pwnd, INT Bar)
Definition: scrollbar.c:83
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
BOOL FASTCALL co_IntGetScrollBarInfo(PWND Window, LONG idObject, PSCROLLBARINFO psbi)
Definition: scrollbar.c:737
#define WS_DISABLED
Definition: pedump.c:621
#define abs(i)
Definition: fconv.c:206
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define DFCS_FLAT
Definition: winuser.h:510
VOID FASTCALL UserEnterShared(VOID)
Definition: ntuser.c:239
#define BF_MIDDLE
Definition: winuser.h:468
GLint GLint GLsizei width
Definition: gl.h:1546
static DWORD FASTCALL co_IntSetScrollInfo(PWND Window, INT nBar, LPCSCROLLINFO lpsi, BOOL bRedraw)
Definition: scrollbar.c:479
#define max(a, b)
Definition: svc.c:63
static void IntDrawScrollInterior(PWND pWnd, HDC hDC, INT nBar, BOOL Vertical, PSCROLLBARINFO ScrollBarInfo)
Definition: scrollbar.c:974
DWORD ExStyle
Definition: ntuser.h:674
#define STATE_SYSTEM_UNAVAILABLE
Definition: winuser.h:2838
#define SM_CYHSCROLL
Definition: winuser.h:952
#define CLEANUP
Definition: ntuser.h:5
#define STATE_SYSTEM_OFFSCREEN
Definition: winuser.h:2854
#define SIF_RANGE
Definition: winuser.h:1221
__kernel_entry W32KAPI BOOL APIENTRY NtGdiPatBlt(_In_ HDC hdcDest, _In_ INT x, _In_ INT y, _In_ INT cx, _In_ INT cy, _In_ DWORD dwRop)
Definition: bitblt.c:984
BOOL WINAPI OffsetRect(_Inout_ LPRECT, _In_ int, _In_ int)
#define SA_SSI_HIDE
Definition: scrollbar.c:42
HGDIOBJ FASTCALL IntGetSysColorBrush(INT Object)
Definition: stockobj.c:317
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:220
#define SB_CTL
Definition: winuser.h:554
#define ESB_DISABLE_BOTH
Definition: winuser.h:556
#define ESB_DISABLE_RTDN
Definition: winuser.h:561
#define SB_VERT
Definition: winuser.h:553
#define TRUE
Definition: types.h:120
static BOOL FASTCALL co_IntGetScrollInfo(PWND Window, INT nBar, PSBDATA pSBData, LPSCROLLINFO lpsi)
Definition: scrollbar.c:272
#define SW_HIDE
Definition: winuser.h:762
INT page
Definition: ntuser.h:481
#define ASSERT_REFS_CO(_obj_)
Definition: userfuncs.h:13
#define SIF_THEMED
Definition: winuser.h:1224
SBDATA Vert
Definition: ntuser.h:489
static void IntRefeshScrollInterior(PWND pWnd, INT nBar, PSCROLLBARINFO psbi)
Definition: scrollbar.c:1142
#define SB_HORZ
Definition: winuser.h:552
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1720
LONG NTSTATUS
Definition: precomp.h:26
#define SCROLL_BOTTOM_RECT
Definition: scrollbar.c:18
static HDC
Definition: imagelist.c:92
#define SM_CYVSCROLL
Definition: winuser.h:971
#define DFCS_INACTIVE
Definition: winuser.h:502
HWND hWnd
Definition: settings.c:17
#define CCHILDREN_SCROLLBAR
Definition: winuser.h:3721
#define SBOBJ_TO_SBID(Obj)
Definition: scroll.h:39
LONG top
Definition: windef.h:307
#define WS_EX_LAYOUTRTL
Definition: winuser.h:390
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:25
#define CTLCOLOR_SCROLLBAR
Definition: winuser.h:946
long bottom
Definition: polytest.cpp:53
INT pos
Definition: ntuser.h:482
PSBINFO pSBInfo
Definition: ntuser.h:696
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:361
#define SCROLL_BOTTOM_ARROW
Definition: scrollbar.c:19
#define MmCopyFromCaller
Definition: polytest.cpp:29
HDC FASTCALL UserGetDCEx(PWND Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
BOOL WINAPI DrawFrameControl(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
UINT_PTR WPARAM
Definition: windef.h:207
RECT rcClient
Definition: ntuser.h:687
#define CHANGERGSTATE(item, status)
Definition: scrollbar.c:54
#define RDW_FRAME
Definition: winuser.h:1198
LONG left
Definition: windef.h:306
DBG_DEFAULT_CHANNEL(UserScrollbar)
#define SWP_NOZORDER
Definition: winuser.h:1233
VOID FASTCALL IntGetClientRect(PWND WindowObject, RECTL *Rect)
Definition: winpos.c:91
#define SCROLL_TOP_ARROW
Definition: scrollbar.c:15
DWORD APIENTRY NtUserShowScrollBar(HWND hWnd, int nBar, DWORD bShow)
Definition: scrollbar.c:1493
INT WSBflags
Definition: ntuser.h:487
LONG right
Definition: windef.h:308
#define WS_EX_LEFTSCROLLBAR
Definition: winuser.h:392
#define FASTCALL
Definition: nt_native.h:50
int32_t INT
Definition: typedefs.h:58
#define SIF_PAGE
Definition: winuser.h:1219
& rect
Definition: startmenu.cpp:1413
WPARAM wParam
Definition: combotst.c:138
#define RETURN(x)
#define WM_ENABLE
Definition: winuser.h:1598
#define DCX_WINDOW
Definition: winuser.h:2096
SBCALC SBCalc
Definition: ntuser.h:746
_SEH2_TRY
Definition: create.c:4226
__kernel_entry W32KAPI HBRUSH APIENTRY NtGdiSelectBrush(_In_ HDC hdc, _In_ HBRUSH hbrush)
BOOL FASTCALL NEWco_IntGetScrollInfo(PWND pWnd, INT nBar, PSBDATA pSBData, LPSCROLLINFO lpsi)
Definition: scrollbar.c:329
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:683
DWORD APIENTRY NtUserSetScrollInfo(HWND hWnd, int fnBar, LPCSCROLLINFO lpsi, BOOL bRedraw)
Definition: scrollbar.c:1451
#define TAG_SBARINFO
Definition: tags.h:9
#define IntGetScrollbarInfoFromWindow(Window, i)
Definition: scroll.h:33
#define BF_RECT
Definition: winuser.h:462
ULONG cbwndExtra
Definition: ntuser.h:708
#define DFCS_PUSHED
Definition: winuser.h:503
long right
Definition: polytest.cpp:53
Definition: window.c:28
BOOL APIENTRY NtUserGetScrollBarInfo(HWND hWnd, LONG idObject, PSCROLLBARINFO psbi)
Definition: scrollbar.c:1256
static __inline PVOID DesktopHeapAlloc(IN PDESKTOP Desktop, IN SIZE_T Bytes)
Definition: desktop.h:230
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
INT posNew
Definition: scroll.h:21
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:38
#define COLOR_SCROLLBAR
Definition: winuser.h:902
void Bar(void)
Definition: terminate.cpp:70
BOOL WINAPI DrawEdge(_In_ HDC, _Inout_ LPRECT, _In_ UINT, _In_ UINT)
static LONG FASTCALL IntScrollGetObjectId(INT SBType)
Definition: scrollbar.c:1132
long top
Definition: polytest.cpp:53
void IntDrawScrollBar(PWND Wnd, HDC DC, INT Bar)
Definition: scrollbar.c:1157
#define SCROLL_THUMB
Definition: scrollbar.c:17
HWND WINAPI GetCapture(void)
Definition: message.c:2880
#define WM_CTLCOLORSCROLLBAR
Definition: winuser.h:1754
DWORD rgstate[CCHILDREN_SCROLLBAR+1]
Definition: ntuser.h:3687
#define STATE_SYSTEM_PRESSED
Definition: winuser.h:2841
BOOL FASTCALL co_IntCreateScrollBars(PWND Window)
Definition: scrollbar.c:819
THRDESKHEAD head
Definition: ntuser.h:665
LONG WINAPI GetWindowLongW(_In_ HWND, _In_ int)
Definition: object.h:3
#define SM_CXHTHUMB
Definition: winuser.h:961
#define MINTRACKTHUMB
Definition: scrollbar.c:39
LONG_PTR LPARAM
Definition: windef.h:208
BOOL WINAPI IsWindowEnabled(_In_ HWND)
BOOL APIENTRY NtUserSBGetParms(HWND hWnd, int fnBar, PSBDATA pSBData, LPSCROLLINFO lpsi)
Definition: scrollbar.c:1302
#define SW_SHOW
Definition: winuser.h:769
long left
Definition: polytest.cpp:53
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:103
#define DFCS_SCROLLDOWN
Definition: winuser.h:490
#define SBS_VERT
Definition: winuser.h:334
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:180
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2488
DWORD rgstate[CCHILDREN_SCROLLBAR+1]
Definition: winuser.h:3730
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:245
Status
Definition: gdiplustypes.h:24
#define OBJID_CLIENT
Definition: winable.h:19
#define ESB_DISABLE_LTUP
Definition: winuser.h:559
#define TRACE(s)
Definition: solgame.cpp:4
Definition: polytest.cpp:40
BOOL FASTCALL IntCalculateThumb(PWND Wnd, LONG idObject, PSCROLLBARINFO psbi, PSBDATA pSBData)
Definition: scrollbar.c:172
#define OBJID_HSCROLL
Definition: winable.h:21
#define ASSERT(a)
Definition: mode.c:44
#define SM_CXHSCROLL
Definition: winuser.h:972
BOOL APIENTRY NtUserSetScrollBarInfo(HWND hWnd, LONG idObject, SETSCROLLBARINFO *info)
Definition: scrollbar.c:1527
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define SWP_NOACTIVATE
Definition: winuser.h:1228
static void mirror_rect(const RECT *window_rect, RECT *rect)
Definition: scrollbar.c:74
PWND spwndTrack
Definition: scroll.h:11
BOOL FASTCALL IntDestroyScrollBars(PWND Window)
Definition: scrollbar.c:875
unsigned long DWORD
Definition: ntddk_ex.h:95
#define DECLARE_RETURN(type)
Definition: ntuser.h:3
#define DFCS_SCROLLRIGHT
Definition: winuser.h:492
#define DFCS_SCROLLUP
Definition: winuser.h:489
HBRUSH DefWndControlColor(HDC hDC, UINT ctlType)
Definition: defwnd.c:33
#define OBJID_VSCROLL
Definition: winable.h:20
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:223
int Window
Definition: x11stubs.h:26
#define WS_HSCROLL
Definition: pedump.c:628
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
BOOL FASTCALL co_IntSetCaretPos(int X, int Y)
Definition: caret.c:205
int ret
HDC hdc
Definition: main.c:9
#define SA_SSI_SHOW
Definition: scrollbar.c:43
#define SWP_FRAMECHANGED
Definition: winuser.h:1226
INT posMin
Definition: ntuser.h:479
GLdouble s
Definition: gl.h:2039
RECT rcWindow
Definition: ntuser.h:686
#define SB_BOTH
Definition: winuser.h:555
static VOID FASTCALL IntDrawScrollArrows(HDC hDC, PSCROLLBARINFO ScrollBarInfo, BOOL Vertical)
Definition: scrollbar.c:1089
struct _SBWND * PSBWND
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:36
processorSet Mask
BOOL FASTCALL IntEnableWindow(HWND hWnd, BOOL bEnable)
Definition: window.c:201
Definition: ntuser.h:741
#define PATCOPY
Definition: wingdi.h:335
#define SIF_POS
Definition: winuser.h:1220
#define EDGE_RAISED
Definition: winuser.h:450
#define SWP_NOSIZE
Definition: winuser.h:1231
#define ERR(fmt,...)
Definition: debug.h:110
#define GWL_STYLE
Definition: winuser.h:846
Definition: ntuser.h:663
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:90
FORCEINLINE VOID RECTL_vOffsetRect(_Inout_ RECTL *prcl, _In_ INT cx, _In_ INT cy)
Definition: rect.h:31
SBDATA Horz
Definition: ntuser.h:488
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:253
static HDC hDC
Definition: 3dtext.c:33
#define SIF_PREVIOUSPOS
Definition: undocuser.h:88
#define DCX_CACHE
Definition: winuser.h:2097
_SEH2_END
Definition: create.c:4400
#define WS_BORDER
Definition: pedump.c:625
const WCHAR * action
Definition: action.c:7783
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define BLACKNESS
Definition: wingdi.h:323
BOOL APIENTRY IntEnableScrollBar(BOOL Horz, PSCROLLBARINFO Info, UINT wArrows)
Definition: scrollbar.c:889
BOOL FASTCALL co_UserRedrawWindow(PWND Window, const RECTL *UpdateRect, PREGION UpdateRgn, ULONG Flags)
Definition: painting.c:888
DWORD FASTCALL co_UserShowScrollBar(PWND Wnd, int nBar, BOOL fShowH, BOOL fShowV)
Definition: scrollbar.c:928
#define SIF_TRACKPOS
Definition: winuser.h:1223
#define SA_SSI_REPAINT_ARROWS
Definition: scrollbar.c:45
struct tagSCROLLBARINFO SCROLLBARINFO
unsigned int UINT
Definition: ndis.h:50
#define NULL
Definition: types.h:112
#define WS_VSCROLL
Definition: pedump.c:627
INT FASTCALL UserReleaseDC(PWND Window, HDC hDc, BOOL EndPaint)
Definition: windc.c:917
#define SM_CXVSCROLL
Definition: winuser.h:951
ENGAPI INT APIENTRY EngMulDiv(_In_ INT a, _In_ INT b, _In_ INT c)
Definition: math.c:26
#define DFC_SCROLL
Definition: winuser.h:475
#define SBRG_TOPRIGHTBTN
Definition: scrollbar.c:48
#define SBRG_BOTTOMLEFTBTN
Definition: scrollbar.c:52
#define SIF_DISABLENOSCROLL
Definition: winuser.h:1222
#define IntGetScrollInfoFromWindow(Window, i)
Definition: scroll.h:36
struct @1587 Msg[]
ULONG FASTCALL IntSetStyle(PWND pwnd, ULONG set_bits, ULONG clear_bits)
Definition: window.c:124
#define SBID_IS_VALID(id)
Definition: scroll.h:40
FORCEINLINE BOOL RECTL_bIsEmptyRect(_In_ const RECTL *prcl)
Definition: rect.h:44
unsigned int ULONG
Definition: retypes.h:1
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
LONG bottom
Definition: windef.h:309
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define SWP_NOMOVE
Definition: winuser.h:1230
BOOL WINAPI GetWindowRect(_In_ HWND, _Out_ LPRECT)
INT nBar
Definition: scroll.h:22
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
BOOL APIENTRY NtUserEnableScrollBar(HWND hWnd, UINT wSBflags, UINT wArrows)
Definition: scrollbar.c:1366
static int UpdateRect(TreeListData *pData, unsigned uItem, unsigned uSub)
Definition: treelist.c:1529
static __inline BOOL DesktopHeapFree(IN PDESKTOP Desktop, IN PVOID lpMem)
Definition: desktop.h:241
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define DFCS_SCROLLLEFT
Definition: winuser.h:491
LONG_PTR LRESULT
Definition: windef.h:209
LRESULT APIENTRY ScrollBarWndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: scrollbar.c:1231
Arabic default style
Definition: afstyles.h:93
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
HBRUSH FASTCALL GetControlBrush(PWND pwnd, HDC hdc, UINT ctlType)
Definition: misc.c:171
#define SCROLL_TOP_RECT
Definition: scrollbar.c:16
LPARAM lParam
Definition: combotst.c:139
#define ESB_ENABLE_BOTH
Definition: winuser.h:563
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
BOOL FASTCALL co_IntSetScrollBarInfo(PWND Window, LONG idObject, PSETSCROLLBARINFO psbi)
Definition: scrollbar.c:786
#define STATE_SYSTEM_INVISIBLE
Definition: winuser.h:2853
struct _SBINFOEX SBINFOEX
#define APIENTRY
Definition: api.h:79
struct Rect Rect
#define END_CLEANUP
Definition: ntuser.h:6
INT posMax
Definition: ntuser.h:480
#define RDW_INVALIDATE
Definition: winuser.h:1200
LRESULT FASTCALL co_WinPosGetNonClientSize(PWND Window, RECT *WindowRect, RECT *ClientRect)
Definition: winpos.c:2289
#define SIF_ALL
Definition: winuser.h:1218
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
DWORD style
Definition: ntuser.h:676