win32ss/user/ntuser/scrollbar.c

   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
  61 BOOL APIENTRY
  62 IntEnableScrollBar(BOOL Horz, PSCROLLBARINFO Info, UINT wArrows);
  63
  64
  65 /* Ported from WINE20020904 */
  66 /* Compute the scroll bar rectangle, in drawing coordinates (i.e. client coords for SB_CTL, window coords for SB_VERT and
  67  * SB_HORZ). 'arrowSize' returns the width or height of an arrow (depending on * the orientation of the scrollbar),
  68  * 'thumbSize' returns the size of the thumb, and 'thumbPos' returns the position of the thumb relative to the left or to
  69  * the top. Return TRUE if the scrollbar is vertical, FALSE if horizontal.
  70  */
  71 static inline void mirror_rect( const RECT *window_rect, RECT *rect )
  72 {
  73     int width = window_rect->right - window_rect->left;
  74     int tmp = rect->left;
  75     rect->left = width - rect->right;
  76     rect->right = width - tmp;
  77 }
  78
  79 PSBDATA FASTCALL
  80 IntGetSBData(PWND pwnd, INT Bar)
  81 {
  82    PSBWND pSBWnd;
  83    PSBINFO pSBInfo;
  84
  85    pSBInfo = pwnd->pSBInfo;
  86    switch (Bar)
  87    {
  88        case SB_HORZ:
  89          return &pSBInfo->Horz;
  90        case SB_VERT:
  91          return &pSBInfo->Vert;
  92        case SB_CTL:
  93          if ( pwnd->cbwndExtra < (sizeof(SBWND)-sizeof(WND)) )
  94          {
  95             ERR("IntGetSBData Wrong Extra bytes for CTL Scrollbar!\n");
  96             return 0;
  97          }
  98          pSBWnd = (PSBWND)pwnd;
  99          return (PSBDATA)&pSBWnd->SBCalc;
 100        default:
 101             ERR("IntGetSBData Bad Bar!\n");
 102    }
 103    return NULL;
 104 }
 105
 106 BOOL FASTCALL
 107 IntGetScrollBarRect (PWND Wnd, INT nBar, RECTL *lprect)
 108 {
 109    BOOL vertical;
 110    *lprect = Wnd->rcClient;
 111
 112    RECTL_vOffsetRect( lprect, -Wnd->rcWindow.left, -Wnd->rcWindow.top );
 113    if (Wnd->ExStyle & WS_EX_LAYOUTRTL)
 114       mirror_rect( &Wnd->rcWindow, lprect );
 115
 116    switch (nBar)
 117    {
 118       case SB_HORZ:
 119          lprect->top = lprect->bottom;
 120          lprect->bottom += UserGetSystemMetrics (SM_CYHSCROLL);
 121          if (Wnd->style & WS_BORDER)
 122          {
 123             lprect->left--;
 124             lprect->right++;
 125          }
 126          else if (Wnd->style & WS_VSCROLL)
 127          {
 128             lprect->right++;
 129          }
 130          vertical = FALSE;
 131          break;
 132
 133       case SB_VERT:
 134          if(Wnd->ExStyle & WS_EX_LEFTSCROLLBAR)
 135          {
 136             lprect->right = lprect->left;
 137             lprect->left -= UserGetSystemMetrics(SM_CXVSCROLL);
 138          }
 139          else
 140          {
 141             lprect->left = lprect->right;
 142             lprect->right += UserGetSystemMetrics(SM_CXVSCROLL);
 143          }
 144          if (Wnd->style & WS_BORDER)
 145          {
 146             lprect->top--;
 147             lprect->bottom++;
 148          }
 149          else if (Wnd->style & WS_HSCROLL)
 150          {
 151             lprect->bottom++;
 152          }
 153          vertical = TRUE;
 154          break;
 155
 156       case SB_CTL:
 157          IntGetClientRect (Wnd, lprect);
 158          vertical = !!(Wnd->style & SBS_VERT);
 159          break;
 160
 161       default:
 162          return FALSE;
 163    }
 164
 165    return vertical;
 166 }
 167
 168 BOOL FASTCALL
 169 IntCalculateThumb(PWND Wnd, LONG idObject, PSCROLLBARINFO psbi, PSBDATA pSBData)
 170 {
 171    INT Thumb, ThumbBox, ThumbPos, cxy, mx;
 172    RECTL ClientRect;
 173
 174    switch(idObject)
 175    {
 176       case SB_HORZ:
 177          Thumb = UserGetSystemMetrics(SM_CXHSCROLL);
 178          cxy = psbi->rcScrollBar.right - psbi->rcScrollBar.left;
 179          break;
 180       case SB_VERT:
 181          Thumb = UserGetSystemMetrics(SM_CYVSCROLL);
 182          cxy = psbi->rcScrollBar.bottom - psbi->rcScrollBar.top;
 183          break;
 184       case SB_CTL:
 185          IntGetClientRect(Wnd, &ClientRect);
 186          if(Wnd->style & SBS_VERT)
 187          {
 188             Thumb = UserGetSystemMetrics(SM_CYVSCROLL);
 189             cxy = ClientRect.bottom - ClientRect.top;
 190          }
 191          else
 192          {
 193             Thumb = UserGetSystemMetrics(SM_CXHSCROLL);
 194             cxy = ClientRect.right - ClientRect.left;
 195          }
 196          break;
 197       default:
 198          return FALSE;
 199    }
 200
 201    ThumbPos = Thumb;
 202    /* Calculate Thumb */
 203    if(cxy <= (2 * Thumb))
 204    {
 205       Thumb = cxy / 2;
 206       psbi->xyThumbTop = 0;
 207       psbi->xyThumbBottom = 0;
 208       ThumbPos = Thumb;
 209    }
 210    else if (psbi->rgstate[SBRG_TOPRIGHTBTN] == STATE_SYSTEM_UNAVAILABLE &&
 211             psbi->rgstate[SBRG_BOTTOMLEFTBTN] == STATE_SYSTEM_UNAVAILABLE &&
 212             pSBData->posMin >= (int)(pSBData->posMax - max(pSBData->page - 1, 0)))
 213    {
 214       /* Nothing to scroll */
 215       psbi->xyThumbTop = 0;
 216       psbi->xyThumbBottom = 0;
 217    }
 218    else
 219    {
 220       ThumbBox = pSBData->page ? MINTRACKTHUMB : UserGetSystemMetrics(SM_CXHTHUMB);
 221       cxy -= (2 * Thumb);
 222       if(cxy >= ThumbBox)
 223       {
 224          if(pSBData->page)
 225          {
 226             ThumbBox = max(EngMulDiv(cxy, pSBData->page, pSBData->posMax - pSBData->posMin + 1), ThumbBox);
 227          }
 228
 229          if(cxy > ThumbBox)
 230          {
 231             mx = pSBData->posMax - max(pSBData->page - 1, 0);
 232             if(pSBData->posMin < mx)
 233                ThumbPos = Thumb + EngMulDiv(cxy - ThumbBox, pSBData->pos - pSBData->posMin, mx - pSBData->posMin);
 234             else
 235                ThumbPos = Thumb + ThumbBox;
 236          }
 237
 238          psbi->xyThumbTop = ThumbPos;
 239          psbi->xyThumbBottom = ThumbPos + ThumbBox;
 240       }
 241       else
 242       {
 243          psbi->xyThumbTop = 0;
 244          psbi->xyThumbBottom = 0;
 245       }
 246    }
 247    psbi->dxyLineButton = Thumb;
 248
 249    return TRUE;
 250 }
 251 /*
 252 static VOID FASTCALL
 253 IntUpdateSBInfo(PWND Window, int wBar)
 254 {
 255    PSCROLLBARINFO sbi;
 256    PSBDATA pSBData;
 257
 258    ASSERT(Window);
 259    ASSERT(Window->pSBInfo);
 260    ASSERT(Window->pSBInfoex);
 261
 262    sbi = IntGetScrollbarInfoFromWindow(Window, wBar);
 263    pSBData = IntGetSBData(Window, wBar);
 264    IntGetScrollBarRect(Window, wBar, &(sbi->rcScrollBar));
 265    IntCalculateThumb(Window, wBar, sbi, pSBData);
 266 }
 267 */
 268 static BOOL FASTCALL
 269 co_IntGetScrollInfo(PWND Window, INT nBar, PSBDATA pSBData, LPSCROLLINFO lpsi)
 270 {
 271    UINT Mask;
 272    LPSCROLLINFO psi;
 273
 274    ASSERT_REFS_CO(Window);
 275
 276    if(!SBID_IS_VALID(nBar))
 277    {
 278       EngSetLastError(ERROR_INVALID_PARAMETER);
 279       ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", nBar);
 280       return FALSE;
 281    }
 282
 283    if (!Window->pSBInfo)
 284    {
 285       ERR("IntGetScrollInfo No window scrollbar info!\n");
 286       return FALSE;
 287    }
 288
 289    psi = IntGetScrollInfoFromWindow(Window, nBar);
 290
 291    if (lpsi->fMask == SIF_ALL)
 292    {
 293       Mask = SIF_PAGE | SIF_POS | SIF_RANGE | SIF_TRACKPOS;
 294    }
 295    else
 296    {
 297       Mask = lpsi->fMask;
 298    }
 299
 300    if (0 != (Mask & SIF_PAGE))
 301    {
 302       lpsi->nPage = psi->nPage;
 303    }
 304
 305    if (0 != (Mask & SIF_POS))
 306    {
 307       lpsi->nPos = psi->nPos;
 308    }
 309
 310    if (0 != (Mask & SIF_RANGE))
 311    {
 312       lpsi->nMin = psi->nMin;
 313       lpsi->nMax = psi->nMax;
 314    }
 315
 316    if (0 != (Mask & SIF_TRACKPOS))
 317    {
 318       lpsi->nTrackPos = psi->nTrackPos;
 319    }
 320
 321    return TRUE;
 322 }
 323
 324 BOOL FASTCALL
 325 NEWco_IntGetScrollInfo(
 326   PWND pWnd,
 327   INT nBar,
 328   PSBDATA pSBData,
 329   LPSCROLLINFO lpsi)
 330 {
 331   UINT Mask;
 332   PSBTRACK pSBTrack = pWnd->head.pti->pSBTrack;
 333
 334   if (!SBID_IS_VALID(nBar))
 335   {
 336      EngSetLastError(ERROR_INVALID_PARAMETER);
 337      ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", nBar);
 338      return FALSE;
 339   }
 340
 341   if (!pWnd->pSBInfo || !pSBTrack) return FALSE;
 342
 343   Mask = lpsi->fMask;
 344
 345   if (0 != (Mask & SIF_PAGE))
 346   {
 347      lpsi->nPage = pSBData->page;
 348   }
 349
 350   if (0 != (Mask & SIF_POS))
 351   {
 352      lpsi->nPos = pSBData->pos;
 353   }
 354
 355   if (0 != (Mask & SIF_RANGE))
 356   {
 357      lpsi->nMin = pSBData->posMin;
 358      lpsi->nMax = pSBData->posMax;
 359   }
 360
 361   if (0 != (Mask & SIF_TRACKPOS))
 362   {
 363      if ( pSBTrack &&
 364           pSBTrack->nBar == nBar &&
 365           pSBTrack->spwndTrack == pWnd )
 366         lpsi->nTrackPos = pSBTrack->posNew;
 367      else
 368         lpsi->nTrackPos = pSBData->pos;
 369   }
 370   return (Mask & SIF_ALL) !=0;
 371 }
 372
 373 /*************************************************************************
 374  *           SCROLL_GetScrollBarInfo
 375  *
 376  * Internal helper for the API function
 377  *
 378  * PARAMS
 379  *    hwnd     [I]  Handle of window with scrollbar(s)
 380  *    idObject [I]  One of OBJID_CLIENT, OBJID_HSCROLL, or OBJID_VSCROLL
 381  *    info     [IO] cbSize specifies the size of the structure
 382  *
 383  * RETURNS
 384  *    FALSE if failed
 385  */
 386 #if 0
 387 static BOOL SCROLL_GetScrollBarInfo(HWND hwnd, LONG idObject, LPSCROLLBARINFO info)
 388 {
 389     LPSCROLLBAR_INFO infoPtr;
 390     INT nBar;
 391     INT nDummy;
 392     DWORD style = GetWindowLongW(hwnd, GWL_STYLE);
 393     BOOL pressed;
 394     RECT rect;
 395
 396     switch (idObject)
 397     {
 398         case OBJID_CLIENT: nBar = SB_CTL; break;
 399         case OBJID_HSCROLL: nBar = SB_HORZ; break;
 400         case OBJID_VSCROLL: nBar = SB_VERT; break;
 401         default: return FALSE;
 402     }
 403
 404     /* handle invalid data structure */
 405     if (info->cbSize != sizeof(*info))
 406         return FALSE;
 407
 408     SCROLL_GetScrollBarRect(hwnd, nBar, &info->rcScrollBar, &nDummy,
 409                             &info->dxyLineButton, &info->xyThumbTop);
 410     /* rcScrollBar needs to be in screen coordinates */
 411     GetWindowRect(hwnd, &rect);
 412     OffsetRect(&info->rcScrollBar, rect.left, rect.top);
 413
 414     info->xyThumbBottom = info->xyThumbTop + info->dxyLineButton;
 415
 416     infoPtr = SCROLL_GetInternalInfo(hwnd, nBar, TRUE);
 417     if (!infoPtr)
 418         return FALSE;
 419
 420     /* Scroll bar state */
 421     info->rgstate[0] = 0;
 422     if ((nBar == SB_HORZ && !(style & WS_HSCROLL))
 423         || (nBar == SB_VERT && !(style & WS_VSCROLL)))
 424         info->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
 425     if (infoPtr->minVal >= infoPtr->maxVal - max(infoPtr->page - 1, 0))
 426     {
 427         if (!(info->rgstate[0] & STATE_SYSTEM_INVISIBLE))
 428             info->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
 429         else
 430             info->rgstate[0] |= STATE_SYSTEM_OFFSCREEN;
 431     }
 432     if (nBar == SB_CTL && !IsWindowEnabled(hwnd))
 433         info->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
 434
 435     pressed = ((nBar == SB_VERT) == SCROLL_trackVertical && GetCapture() == hwnd);
 436
 437     /* Top/left arrow button state. MSDN says top/right, but I don't believe it */
 438     info->rgstate[1] = 0;
 439     if (pressed && SCROLL_trackHitTest == SCROLL_TOP_ARROW)
 440         info->rgstate[1] |= STATE_SYSTEM_PRESSED;
 441     if (infoPtr->flags & ESB_DISABLE_LTUP)
 442         info->rgstate[1] |= STATE_SYSTEM_UNAVAILABLE;
 443
 444     /* Page up/left region state. MSDN says up/right, but I don't believe it */
 445     info->rgstate[2] = 0;
 446     if (infoPtr->curVal == infoPtr->minVal)
 447         info->rgstate[2] |= STATE_SYSTEM_INVISIBLE;
 448     if (pressed && SCROLL_trackHitTest == SCROLL_TOP_RECT)
 449         info->rgstate[2] |= STATE_SYSTEM_PRESSED;
 450
 451     /* Thumb state */
 452     info->rgstate[3] = 0;
 453     if (pressed && SCROLL_trackHitTest == SCROLL_THUMB)
 454         info->rgstate[3] |= STATE_SYSTEM_PRESSED;
 455
 456     /* Page down/right region state. MSDN says down/left, but I don't believe it */
 457     info->rgstate[4] = 0;
 458     if (infoPtr->curVal >= infoPtr->maxVal - 1)
 459         info->rgstate[4] |= STATE_SYSTEM_INVISIBLE;
 460     if (pressed && SCROLL_trackHitTest == SCROLL_BOTTOM_RECT)
 461         info->rgstate[4] |= STATE_SYSTEM_PRESSED;
 462
 463     /* Bottom/right arrow button state. MSDN says bottom/left, but I don't believe it */
 464     info->rgstate[5] = 0;
 465     if (pressed && SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW)
 466         info->rgstate[5] |= STATE_SYSTEM_PRESSED;
 467     if (infoPtr->flags & ESB_DISABLE_RTDN)
 468         info->rgstate[5] |= STATE_SYSTEM_UNAVAILABLE;
 469
 470     return TRUE;
 471 }
 472 #endif
 473 static DWORD FASTCALL
 474 co_IntSetScrollInfo(PWND Window, INT nBar, LPCSCROLLINFO lpsi, BOOL bRedraw)
 475 {
 476    /*
 477     * Update the scrollbar state and set action flags according to
 478     * what has to be done graphics wise.
 479     */
 480
 481    LPSCROLLINFO Info;
 482    PSCROLLBARINFO psbi;
 483    UINT new_flags;
 484    INT action = 0;
 485    PSBDATA pSBData;
 486    DWORD OldPos = 0;
 487    BOOL bChangeParams = FALSE; /* Don't show/hide scrollbar if params don't change */
 488    UINT MaxPage;
 489    int MaxPos;
 490
 491    ASSERT_REFS_CO(Window);
 492
 493    if(!SBID_IS_VALID(nBar))
 494    {
 495       EngSetLastError(ERROR_INVALID_PARAMETER);
 496       ERR("Trying to set scrollinfo for unknown scrollbar type %d", nBar);
 497       return FALSE;
 498    }
 499
 500    if(!co_IntCreateScrollBars(Window))
 501    {
 502       return FALSE;
 503    }
 504
 505    if (lpsi->cbSize != sizeof(SCROLLINFO) &&
 506          lpsi->cbSize != (sizeof(SCROLLINFO) - sizeof(lpsi->nTrackPos)))
 507    {
 508       EngSetLastError(ERROR_INVALID_PARAMETER);
 509       return 0;
 510    }
 511    if (lpsi->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL | SIF_PREVIOUSPOS))
 512    {
 513       EngSetLastError(ERROR_INVALID_PARAMETER);
 514       return 0;
 515    }
 516
 517    psbi = IntGetScrollbarInfoFromWindow(Window, nBar);
 518    Info = IntGetScrollInfoFromWindow(Window, nBar);
 519    pSBData = IntGetSBData(Window, nBar);
 520
 521    /* Set the page size */
 522    if (lpsi->fMask & SIF_PAGE)
 523    {
 524       if (Info->nPage != lpsi->nPage)
 525       {
 526          Info->nPage = lpsi->nPage;
 527          pSBData->page = lpsi->nPage;
 528          bChangeParams = TRUE;
 529       }
 530    }
 531
 532    /* Set the scroll pos */
 533    if (lpsi->fMask & SIF_POS)
 534    {
 535       if (Info->nPos != lpsi->nPos)
 536       {
 537          OldPos = Info->nPos;
 538          Info->nPos = lpsi->nPos;
 539          pSBData->pos = lpsi->nPos;
 540          bChangeParams = TRUE;
 541       }
 542    }
 543
 544    /* Set the scroll range */
 545    if (lpsi->fMask & SIF_RANGE)
 546    {
 547       if (lpsi->nMin > lpsi->nMax)
 548       {
 549          Info->nMin = lpsi->nMin;
 550          Info->nMax = lpsi->nMin;
 551          pSBData->posMin = lpsi->nMin;
 552          pSBData->posMax = lpsi->nMin;
 553          bChangeParams = TRUE;
 554       }
 555       else if (Info->nMin != lpsi->nMin || Info->nMax != lpsi->nMax)
 556       {
 557          Info->nMin = lpsi->nMin;
 558          Info->nMax = lpsi->nMax;
 559          pSBData->posMin = lpsi->nMin;
 560          pSBData->posMax = lpsi->nMax;
 561          bChangeParams = TRUE;
 562       }
 563    }
 564
 565    /* Make sure the page size is valid */
 566    MaxPage = abs(Info->nMax - Info->nMin) + 1;
 567    if (Info->nPage > MaxPage)
 568    {
 569       pSBData->page = Info->nPage = MaxPage;
 570    }
 571
 572    /* Make sure the pos is inside the range */
 573    MaxPos = Info->nMax + 1 - (int)max(Info->nPage, 1);
 574    ASSERT(MaxPos >= Info->nMin);
 575    if (Info->nPos < Info->nMin)
 576    {
 577       pSBData->pos = Info->nPos = Info->nMin;
 578    }
 579    else if (Info->nPos > MaxPos)
 580    {
 581       pSBData->pos = Info->nPos = MaxPos;
 582    }
 583
 584    /*
 585     * Don't change the scrollbar state if SetScrollInfo is just called
 586     * with SIF_DISABLENOSCROLL
 587     */
 588    if (!(lpsi->fMask & SIF_ALL))
 589    {
 590       //goto done;
 591       return lpsi->fMask & SIF_PREVIOUSPOS ? OldPos : pSBData->pos;
 592    }
 593
 594    /* Check if the scrollbar should be hidden or disabled */
 595    if (lpsi->fMask & (SIF_RANGE | SIF_PAGE | SIF_DISABLENOSCROLL))
 596    {
 597       new_flags = Window->pSBInfo->WSBflags;
 598       if (Info->nMin >= (int)(Info->nMax - max(Info->nPage - 1, 0)))
 599       {
 600          /* Hide or disable scroll-bar */
 601          if (lpsi->fMask & SIF_DISABLENOSCROLL)
 602          {
 603             new_flags = ESB_DISABLE_BOTH;
 604             bChangeParams = TRUE;
 605          }
 606          else if ((nBar != SB_CTL) && bChangeParams)
 607          {
 608             action = SA_SSI_HIDE;
 609          }
 610       }
 611       else /* Show and enable scroll-bar only if no page only changed. */
 612       if (lpsi->fMask != SIF_PAGE)
 613       {
 614          new_flags = ESB_ENABLE_BOTH;
 615          if ((nBar != SB_CTL) && bChangeParams)
 616          {
 617             action |= SA_SSI_SHOW;
 618          }
 619       }
 620
 621       if (Window->pSBInfo->WSBflags != new_flags) /* Check arrow flags */
 622       {
 623          Window->pSBInfo->WSBflags = new_flags;
 624          action |= SA_SSI_REPAINT_ARROWS;
 625       }
 626    }
 627
 628 //done:
 629    if ( action & SA_SSI_HIDE )
 630    {
 631       co_UserShowScrollBar(Window, nBar, FALSE, FALSE);
 632    }
 633    else
 634    {
 635       if ( action & SA_SSI_SHOW )
 636          if ( co_UserShowScrollBar(Window, nBar, TRUE, TRUE) )
 637             return lpsi->fMask & SIF_PREVIOUSPOS ? OldPos : pSBData->pos; /* SetWindowPos() already did the painting */
 638       if (bRedraw)
 639       { // FIXME: Arrows and interior.
 640          RECTL UpdateRect = psbi->rcScrollBar;
 641          UpdateRect.left -= Window->rcClient.left - Window->rcWindow.left;
 642          UpdateRect.right -= Window->rcClient.left - Window->rcWindow.left;
 643          UpdateRect.top -= Window->rcClient.top - Window->rcWindow.top;
 644          UpdateRect.bottom -= Window->rcClient.top - Window->rcWindow.top;
 645          co_UserRedrawWindow(Window, &UpdateRect, 0, RDW_INVALIDATE | RDW_FRAME);
 646       } // FIXME: Arrows
 647 /*      else if( action & SA_SSI_REPAINT_ARROWS )
 648       {
 649          RECTL UpdateRect = psbi->rcScrollBar;
 650          UpdateRect.left -= Window->rcClient.left - Window->rcWindow.left;
 651          UpdateRect.right -= Window->rcClient.left - Window->rcWindow.left;
 652          UpdateRect.top -= Window->rcClient.top - Window->rcWindow.top;
 653          UpdateRect.bottom -= Window->rcClient.top - Window->rcWindow.top;
 654          co_UserRedrawWindow(Window, &UpdateRect, 0, RDW_INVALIDATE | RDW_FRAME);
 655       }
 656 */   }
 657
 658    if (bChangeParams && (nBar == SB_HORZ || nBar == SB_VERT) && (lpsi->fMask & SIF_DISABLENOSCROLL))
 659    {
 660        IntEnableScrollBar(nBar == SB_HORZ, psbi, Window->pSBInfo->WSBflags);
 661    }
 662
 663    /* Return current position */
 664    return lpsi->fMask & SIF_PREVIOUSPOS ? OldPos : pSBData->pos;
 665 }
 666
 667 BOOL FASTCALL
 668 co_IntGetScrollBarInfo(PWND Window, LONG idObject, PSCROLLBARINFO psbi)
 669 {
 670    INT Bar;
 671    PSCROLLBARINFO sbi;
 672    PSBDATA pSBData;
 673    ASSERT_REFS_CO(Window);
 674
 675    Bar = SBOBJ_TO_SBID(idObject);
 676
 677    if(!SBID_IS_VALID(Bar))
 678    {
 679       EngSetLastError(ERROR_INVALID_PARAMETER);
 680       ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", Bar);
 681       return FALSE;
 682    }
 683
 684    if(!co_IntCreateScrollBars(Window))
 685    {
 686       ERR("Failed to create scrollbars for window.\n");
 687       return FALSE;
 688    }
 689
 690    sbi = IntGetScrollbarInfoFromWindow(Window, Bar);
 691    pSBData = IntGetSBData(Window, Bar);
 692
 693    IntGetScrollBarRect(Window, Bar, &(sbi->rcScrollBar));
 694    IntCalculateThumb(Window, Bar, sbi, pSBData);
 695
 696     /* Scroll bar state */
 697     psbi->rgstate[0] = 0;
 698     if ((Bar == SB_HORZ && !(Window->style & WS_HSCROLL))
 699         || (Bar == SB_VERT && !(Window->style & WS_VSCROLL)))
 700         psbi->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
 701     if (pSBData->posMin >= pSBData->posMax - max(pSBData->page - 1, 0))
 702     {
 703         if (!(psbi->rgstate[0] & STATE_SYSTEM_INVISIBLE))
 704             psbi->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
 705         else
 706             psbi->rgstate[0] |= STATE_SYSTEM_OFFSCREEN;
 707     }
 708     if (Bar == SB_CTL && !(Window->style & WS_DISABLED))
 709         psbi->rgstate[0] |= STATE_SYSTEM_UNAVAILABLE;
 710
 711    RtlCopyMemory(psbi, sbi, sizeof(SCROLLBARINFO));
 712
 713    return TRUE;
 714 }
 715
 716 BOOL FASTCALL
 717 co_IntSetScrollBarInfo(PWND Window, LONG idObject, PSETSCROLLBARINFO psbi)
 718 {
 719    INT Bar;
 720    PSCROLLBARINFO sbi;
 721    LPSCROLLINFO psi;
 722    ASSERT_REFS_CO(Window);
 723
 724    Bar = SBOBJ_TO_SBID(idObject);
 725
 726    if(!SBID_IS_VALID(Bar))
 727    {
 728       EngSetLastError(ERROR_INVALID_PARAMETER);
 729       ERR("Trying to get scrollinfo for unknown scrollbar type %d\n", Bar);
 730       return FALSE;
 731    }
 732
 733    if(!co_IntCreateScrollBars(Window))
 734    {
 735       ERR("Failed to create scrollbars for window.\n");
 736       return FALSE;
 737    }
 738
 739    sbi = IntGetScrollbarInfoFromWindow(Window, Bar);
 740    psi = IntGetScrollInfoFromWindow(Window, Bar);
 741
 742    psi->nTrackPos = psbi->nTrackPos;
 743    sbi->reserved  = psbi->reserved;
 744    RtlCopyMemory(&sbi->rgstate, &psbi->rgstate, sizeof(psbi->rgstate));
 745
 746    return TRUE;
 747 }
 748
 749 BOOL FASTCALL
 750 co_IntCreateScrollBars(PWND Window)
 751 {
 752    PSCROLLBARINFO psbi;
 753    PSBDATA pSBData;
 754    ULONG Size, s;
 755    INT i;
 756
 757    ASSERT_REFS_CO(Window);
 758
 759    if (Window->pSBInfo && Window->pSBInfoex)
 760    {
 761       /* No need to create it anymore */
 762       return TRUE;
 763    }
 764
 765    /* Allocate memory for all scrollbars (HORZ, VERT, CONTROL) */
 766    Size = 3 * (sizeof(SBINFOEX));
 767    if(!(Window->pSBInfoex = ExAllocatePoolWithTag(PagedPool, Size, TAG_SBARINFO)))
 768    {
 769       ERR("Unable to allocate memory for scrollbar information for window %p\n", Window->head.h);
 770       return FALSE;
 771    }
 772
 773    RtlZeroMemory(Window->pSBInfoex, Size);
 774
 775    if(!(Window->pSBInfo = DesktopHeapAlloc( Window->head.rpdesk, sizeof(SBINFO))))
 776    {
 777       ERR("Unable to allocate memory for scrollbar information for window %p\n", Window->head.h);
 778       return FALSE;
 779    }
 780
 781    RtlZeroMemory(Window->pSBInfo, sizeof(SBINFO));
 782    Window->pSBInfo->Vert.posMax = 100;
 783    Window->pSBInfo->Horz.posMax = 100;
 784
 785    co_WinPosGetNonClientSize(Window,
 786                              &Window->rcWindow,
 787                              &Window->rcClient);
 788
 789    for(s = SB_HORZ; s <= SB_VERT; s++)
 790    {
 791       psbi = IntGetScrollbarInfoFromWindow(Window, s);
 792       psbi->cbSize = sizeof(SCROLLBARINFO);
 793       for (i = 0; i < CCHILDREN_SCROLLBAR + 1; i++)
 794          psbi->rgstate[i] = 0;
 795
 796       pSBData = IntGetSBData(Window, s);
 797
 798       IntGetScrollBarRect(Window, s, &(psbi->rcScrollBar));
 799       IntCalculateThumb(Window, s, psbi, pSBData);
 800    }
 801
 802    return TRUE;
 803 }
 804
 805 BOOL FASTCALL
 806 IntDestroyScrollBars(PWND Window)
 807 {
 808    if (Window->pSBInfo && Window->pSBInfoex)
 809    {
 810       DesktopHeapFree(Window->head.rpdesk, Window->pSBInfo);
 811       Window->pSBInfo = NULL;
 812       ExFreePoolWithTag(Window->pSBInfoex, TAG_SBARINFO);
 813       Window->pSBInfoex = NULL;
 814       return TRUE;
 815    }
 816    return FALSE;
 817 }
 818
 819 BOOL APIENTRY
 820 IntEnableScrollBar(BOOL Horz, PSCROLLBARINFO Info, UINT wArrows)
 821 {
 822    BOOL Chg = FALSE;
 823    switch(wArrows)
 824    {
 825       case ESB_DISABLE_BOTH:
 826          CHANGERGSTATE(SBRG_TOPRIGHTBTN, STATE_SYSTEM_UNAVAILABLE);
 827          CHANGERGSTATE(SBRG_BOTTOMLEFTBTN, STATE_SYSTEM_UNAVAILABLE);
 828          break;
 829       case ESB_DISABLE_RTDN:
 830          if(Horz)
 831          {
 832             CHANGERGSTATE(SBRG_BOTTOMLEFTBTN, STATE_SYSTEM_UNAVAILABLE);
 833          }
 834          else
 835          {
 836             CHANGERGSTATE(SBRG_TOPRIGHTBTN, STATE_SYSTEM_UNAVAILABLE);
 837          }
 838          break;
 839       case ESB_DISABLE_LTUP:
 840          if(Horz)
 841          {
 842             CHANGERGSTATE(SBRG_TOPRIGHTBTN, STATE_SYSTEM_UNAVAILABLE);
 843          }
 844          else
 845          {
 846             CHANGERGSTATE(SBRG_BOTTOMLEFTBTN, STATE_SYSTEM_UNAVAILABLE);
 847          }
 848          break;
 849       case ESB_ENABLE_BOTH:
 850          CHANGERGSTATE(SBRG_TOPRIGHTBTN, 0);
 851          CHANGERGSTATE(SBRG_BOTTOMLEFTBTN, 0);
 852          break;
 853    }
 854    return Chg;
 855 }
 856
 857 /* Ported from WINE20020904 (SCROLL_ShowScrollBar) */
 858 DWORD FASTCALL
 859 co_UserShowScrollBar(PWND Wnd, int nBar, BOOL fShowH, BOOL fShowV)
 860 {
 861    ULONG old_style, set_bits = 0, clear_bits = 0;
 862
 863    ASSERT_REFS_CO(Wnd);
 864
 865    switch(nBar)
 866    {
 867       case SB_CTL:
 868          {
 869             //IntUpdateSBInfo(Wnd, SB_CTL); // Is this needed? Was tested w/o!
 870
 871             co_WinPosShowWindow(Wnd, fShowH ? SW_SHOW : SW_HIDE);
 872             return TRUE;
 873          }
 874       case SB_BOTH:
 875       case SB_HORZ:
 876          if (fShowH) set_bits |= WS_HSCROLL;
 877          else clear_bits |= WS_HSCROLL;
 878          if( nBar == SB_HORZ ) break;
 879       /* Fall through */
 880       case SB_VERT:
 881          if (fShowV) set_bits |= WS_VSCROLL;
 882          else clear_bits |= WS_VSCROLL;
 883          break;
 884       default:
 885          EngSetLastError(ERROR_INVALID_PARAMETER);
 886          return FALSE; /* Nothing to do! */
 887    }
 888
 889    old_style = IntSetStyle( Wnd, set_bits, clear_bits );
 890    if ((old_style & clear_bits) != 0 || (old_style & set_bits) != set_bits)
 891    {
 892       /////  Is this needed? Was tested w/o!
 893       //if (Wnd->style & WS_HSCROLL) IntUpdateSBInfo(Wnd, SB_HORZ);
 894       //if (Wnd->style & WS_VSCROLL) IntUpdateSBInfo(Wnd, SB_VERT);
 895       /////
 896          /* Frame has been changed, let the window redraw itself */
 897       co_WinPosSetWindowPos( Wnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
 898                            | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
 899       return TRUE;
 900    }
 901    return FALSE; /* no frame changes */
 902 }
 903
 904 static void
 905 IntDrawScrollInterior(PWND pWnd, HDC hDC, INT nBar, BOOL Vertical, PSCROLLBARINFO ScrollBarInfo)
 906 {
 907    INT ThumbSize = ScrollBarInfo->xyThumbBottom - ScrollBarInfo->xyThumbTop;
 908    INT ThumbTop = ScrollBarInfo->xyThumbTop;
 909    RECT Rect;
 910    HBRUSH hSaveBrush, hBrush;
 911    BOOL TopSelected = FALSE, BottomSelected = FALSE;
 912
 913    if (ScrollBarInfo->rgstate[SCROLL_TOP_RECT] & STATE_SYSTEM_PRESSED)
 914       TopSelected = TRUE;
 915    if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_RECT] & STATE_SYSTEM_PRESSED)
 916       BottomSelected = TRUE;
 917
 918    /*
 919     * Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
 920     * The window-owned scrollbars need to call DefWndControlColor
 921     * to correctly setup default scrollbar colors
 922     */
 923    if (nBar == SB_CTL)
 924    {
 925       hBrush = GetControlBrush( pWnd, hDC, WM_CTLCOLORSCROLLBAR);
 926       if (!hBrush)
 927          hBrush = IntGetSysColorBrush(COLOR_SCROLLBAR);
 928    }
 929    else
 930    {
 931       hBrush = DefWndControlColor(hDC, CTLCOLOR_SCROLLBAR);
 932    }
 933
 934    hSaveBrush = NtGdiSelectBrush(hDC, hBrush);
 935
 936    /* Calculate the scroll rectangle */
 937    if (Vertical)
 938    {
 939       Rect.top = ScrollBarInfo->rcScrollBar.top + ScrollBarInfo->dxyLineButton;
 940       Rect.bottom = ScrollBarInfo->rcScrollBar.bottom - ScrollBarInfo->dxyLineButton;
 941       Rect.left = ScrollBarInfo->rcScrollBar.left;
 942       Rect.right = ScrollBarInfo->rcScrollBar.right;
 943    }
 944    else
 945    {
 946       Rect.top = ScrollBarInfo->rcScrollBar.top;
 947       Rect.bottom = ScrollBarInfo->rcScrollBar.bottom;
 948       Rect.left = ScrollBarInfo->rcScrollBar.left + ScrollBarInfo->dxyLineButton;
 949       Rect.right = ScrollBarInfo->rcScrollBar.right - ScrollBarInfo->dxyLineButton;
 950    }
 951
 952    /* Draw the scroll rectangles and thumb */
 953    if (!ScrollBarInfo->xyThumbBottom)
 954    {
 955       NtGdiPatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
 956          Rect.bottom - Rect.top, PATCOPY);
 957
 958       /* Cleanup and return */
 959       NtGdiSelectBrush(hDC, hSaveBrush);
 960       return;
 961    }
 962
 963    ThumbTop -= ScrollBarInfo->dxyLineButton;
 964
 965    if (ScrollBarInfo->dxyLineButton)
 966    {
 967       if (Vertical)
 968       {
 969          if (ThumbSize)
 970          {
 971             NtGdiPatBlt(hDC, Rect.left, Rect.top, Rect.right - Rect.left,
 972                    ThumbTop, TopSelected ? BLACKNESS : PATCOPY);
 973             Rect.top += ThumbTop;
 974             NtGdiPatBlt(hDC, Rect.left, Rect.top + ThumbSize, Rect.right - Rect.left,
 975                Rect.bottom - Rect.top - ThumbSize, BottomSelected ? BLACKNESS : PATCOPY);
 976             Rect.bottom = Rect.top + ThumbSize;
 977          }
 978          else
 979          {
 980             if (ThumbTop)
 981             {
 982                NtGdiPatBlt(hDC, Rect.left, ScrollBarInfo->dxyLineButton,
 983                   Rect.right - Rect.left, Rect.bottom - Rect.top, PATCOPY);
 984             }
 985          }
 986       }
 987       else
 988       {
 989          if (ThumbSize)
 990          {
 991             NtGdiPatBlt(hDC, Rect.left, Rect.top, ThumbTop,
 992                Rect.bottom - Rect.top, TopSelected ? BLACKNESS : PATCOPY);
 993             Rect.left += ThumbTop;
 994             NtGdiPatBlt(hDC, Rect.left + ThumbSize, Rect.top,
 995                Rect.right - Rect.left - ThumbSize, Rect.bottom - Rect.top,
 996                BottomSelected ? BLACKNESS : PATCOPY);
 997             Rect.right = Rect.left + ThumbSize;
 998          }
 999          else
1000          {
1001             if (ThumbTop)
1002             {
1003                NtGdiPatBlt(hDC, ScrollBarInfo->dxyLineButton, Rect.top,
1004                   Rect.right - Rect.left, Rect.bottom - Rect.top, PATCOPY);
1005             }
1006          }
1007       }
1008    }
1009
1010    /* Draw the thumb */
1011    if (ThumbSize)
1012       DrawEdge(hDC, &Rect, EDGE_RAISED, BF_RECT | BF_MIDDLE);
1013
1014    /* Cleanup */
1015    NtGdiSelectBrush(hDC, hSaveBrush);
1016 }
1017
1018
1019 static VOID FASTCALL
1020 IntDrawScrollArrows(HDC hDC, PSCROLLBARINFO ScrollBarInfo, BOOL Vertical)
1021 {
1022    RECT RectLT, RectRB;
1023    INT ScrollDirFlagLT, ScrollDirFlagRB;
1024
1025    RectLT = RectRB = ScrollBarInfo->rcScrollBar;
1026    if (Vertical)
1027    {
1028       ScrollDirFlagLT = DFCS_SCROLLUP;
1029       ScrollDirFlagRB = DFCS_SCROLLDOWN;
1030       RectLT.bottom = RectLT.top + ScrollBarInfo->dxyLineButton;
1031       RectRB.top = RectRB.bottom - ScrollBarInfo->dxyLineButton;
1032    }
1033    else
1034    {
1035       ScrollDirFlagLT = DFCS_SCROLLLEFT;
1036       ScrollDirFlagRB = DFCS_SCROLLRIGHT;
1037       RectLT.right = RectLT.left + ScrollBarInfo->dxyLineButton;
1038       RectRB.left = RectRB.right - ScrollBarInfo->dxyLineButton;
1039    }
1040
1041    if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_PRESSED)
1042    {
1043       ScrollDirFlagLT |= DFCS_PUSHED | DFCS_FLAT;
1044    }
1045    if (ScrollBarInfo->rgstate[SCROLL_TOP_ARROW] & STATE_SYSTEM_UNAVAILABLE)
1046    {
1047       ScrollDirFlagLT |= DFCS_INACTIVE;
1048    }
1049    if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_ARROW] & STATE_SYSTEM_PRESSED)
1050    {
1051       ScrollDirFlagRB |= DFCS_PUSHED | DFCS_FLAT;
1052    }
1053    if (ScrollBarInfo->rgstate[SCROLL_BOTTOM_ARROW] & STATE_SYSTEM_UNAVAILABLE)
1054    {
1055       ScrollDirFlagRB |= DFCS_INACTIVE;
1056    }
1057
1058    DrawFrameControl(hDC, &RectLT, DFC_SCROLL, ScrollDirFlagLT);
1059    DrawFrameControl(hDC, &RectRB, DFC_SCROLL, ScrollDirFlagRB);
1060 }
1061
1062 static LONG FASTCALL
1063 IntScrollGetObjectId(INT SBType)
1064 {
1065    if (SBType == SB_VERT)
1066        return OBJID_VSCROLL;
1067    if (SBType == SB_HORZ)
1068        return OBJID_HSCROLL;
1069    return OBJID_CLIENT;
1070 }
1071
1072 void
1073 IntDrawScrollBar(PWND Wnd, HDC DC, INT Bar)
1074 {
1075    //PSBWND pSBWnd;
1076    //INT ThumbSize;
1077    PTHREADINFO pti;
1078    SCROLLBARINFO Info;
1079    BOOL Vertical;
1080
1081    pti = PsGetCurrentThreadWin32Thread();
1082
1083   /*
1084    * Get scroll bar info.
1085    */
1086    switch (Bar)
1087    {
1088       case SB_HORZ:
1089         Vertical = FALSE;
1090         break;
1091
1092       case SB_VERT:
1093         Vertical = TRUE;
1094         break;
1095
1096       case SB_CTL:
1097         Vertical = (Wnd->style & SBS_VERT) != 0;
1098         break;
1099
1100       default:
1101         return;
1102    }
1103
1104    if (!co_IntGetScrollBarInfo(Wnd, IntScrollGetObjectId(Bar), &Info))
1105    {
1106       return;
1107    }
1108
1109    if (RECTL_bIsEmptyRect(&Info.rcScrollBar))
1110    {
1111       return;
1112    }
1113
1114   //ThumbSize = pSBWnd->pSBCalc->pxThumbBottom - pSBWnd->pSBCalc->pxThumbTop;
1115
1116   /*
1117    * Draw the arrows.
1118    */
1119    if (Info.dxyLineButton)
1120    {
1121       IntDrawScrollArrows(DC, &Info, Vertical);
1122    }
1123
1124   /*
1125    * Draw the interior.
1126    */
1127    IntDrawScrollInterior(Wnd, DC, Bar, Vertical, &Info);
1128
1129   /*
1130    * If scroll bar has focus, reposition the caret.
1131    */
1132    if ( Wnd == pti->MessageQueue->spwndFocus && Bar == SB_CTL )
1133    {
1134       if (Vertical)
1135       {
1136           co_IntSetCaretPos(Info.rcScrollBar.top + 1, Info.dxyLineButton + 1);
1137       }
1138       else
1139       {
1140           co_IntSetCaretPos(Info.dxyLineButton + 1, Info.rcScrollBar.top + 1);
1141       }
1142    }
1143 }
1144
1145
1146 LRESULT APIENTRY
1147 ScrollBarWndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
1148 {
1149    LRESULT lResult = 0;
1150    PWND pWnd;
1151    pWnd = UserGetWindowObject(hWnd);
1152    if (!pWnd) return 0;
1153
1154    switch(Msg)
1155    {
1156        case WM_ENABLE:
1157        {
1158            if (pWnd->pSBInfo)
1159            {
1160               pWnd->pSBInfo->WSBflags = wParam ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH;
1161            }
1162        }
1163        break;
1164    }
1165    return lResult;
1166 }
1167
1168 ////
1169
1170 BOOL
1171 APIENTRY
1172 NtUserGetScrollBarInfo(HWND hWnd, LONG idObject, PSCROLLBARINFO psbi)
1173 {
1174    NTSTATUS Status;
1175    SCROLLBARINFO sbi;
1176    PWND Window;
1177    BOOL Ret;
1178    DECLARE_RETURN(BOOL);
1179    USER_REFERENCE_ENTRY Ref;
1180
1181    TRACE("Enter NtUserGetScrollBarInfo\n");
1182    UserEnterExclusive();
1183
1184    Status = MmCopyFromCaller(&sbi, psbi, sizeof(SCROLLBARINFO));
1185    if(!NT_SUCCESS(Status) || (sbi.cbSize != sizeof(SCROLLBARINFO)))
1186    {
1187       SetLastNtError(Status);
1188       RETURN(FALSE);
1189    }
1190
1191    if(!(Window = UserGetWindowObject(hWnd)))
1192    {
1193       RETURN(FALSE);
1194    }
1195
1196    UserRefObjectCo(Window, &Ref);
1197    Ret = co_IntGetScrollBarInfo(Window, idObject, &sbi);
1198    UserDerefObjectCo(Window);
1199
1200    Status = MmCopyToCaller(psbi, &sbi, sizeof(SCROLLBARINFO));
1201    if(!NT_SUCCESS(Status))
1202    {
1203       SetLastNtError(Status);
1204       Ret = FALSE;
1205    }
1206
1207    RETURN( Ret);
1208
1209 CLEANUP:
1210    TRACE("Leave NtUserGetScrollBarInfo, ret=%i\n",_ret_);
1211    UserLeave();
1212    END_CLEANUP;
1213
1214 }
1215
1216 BOOL
1217 APIENTRY
1218 NtUserSBGetParms(
1219   HWND hWnd,
1220   int fnBar,
1221   PSBDATA pSBData,
1222   LPSCROLLINFO lpsi)
1223 {
1224    PWND Window;
1225    SCROLLINFO psi;
1226    BOOL Ret;
1227    SBDATA SBDataSafe;
1228    DECLARE_RETURN(BOOL);
1229    USER_REFERENCE_ENTRY Ref;
1230
1231    TRACE("Enter NtUserGetScrollInfo\n");
1232    UserEnterShared();
1233
1234    _SEH2_TRY
1235    {
1236       RtlCopyMemory(&psi, lpsi, sizeof(SCROLLINFO));
1237       if (pSBData)
1238       {
1239          RtlCopyMemory(&SBDataSafe, pSBData, sizeof(SBDATA));
1240       }
1241    }
1242    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1243    {
1244       ERR("NtUserGetScrollInfo Failed size.\n");
1245       SetLastNtError(_SEH2_GetExceptionCode());
1246       _SEH2_YIELD(RETURN(FALSE));
1247    }
1248    _SEH2_END
1249
1250    if(!(Window = UserGetWindowObject(hWnd)))
1251    {
1252       ERR("NtUserGetScrollInfo Bad window.\n");
1253       RETURN(FALSE);
1254    }
1255
1256    UserRefObjectCo(Window, &Ref);
1257    Ret = co_IntGetScrollInfo(Window, fnBar, &SBDataSafe, &psi);
1258    UserDerefObjectCo(Window);
1259
1260    _SEH2_TRY
1261    {
1262       RtlCopyMemory(lpsi, &psi, sizeof(SCROLLINFO));
1263    }
1264    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1265    {
1266       ERR("NtUserGetScrollInfo Failed copy to user.\n");
1267       SetLastNtError(_SEH2_GetExceptionCode());
1268       _SEH2_YIELD(RETURN(FALSE));
1269    }
1270    _SEH2_END
1271
1272    RETURN( Ret);
1273
1274 CLEANUP:
1275    TRACE("Leave NtUserGetScrollInfo, ret=%i\n",_ret_);
1276    UserLeave();
1277    END_CLEANUP;
1278 }
1279
1280 BOOL
1281 APIENTRY
1282 NtUserEnableScrollBar(
1283    HWND hWnd,
1284    UINT wSBflags,
1285    UINT wArrows)
1286 {
1287    UINT OrigArrows;
1288    PWND Window = NULL;
1289    PSCROLLBARINFO InfoV = NULL, InfoH = NULL;
1290    BOOL Chg = FALSE;
1291    DECLARE_RETURN(BOOL);
1292    USER_REFERENCE_ENTRY Ref;
1293
1294    TRACE("Enter NtUserEnableScrollBar\n");
1295    UserEnterExclusive();
1296
1297    if (!(Window = UserGetWindowObject(hWnd)) ||
1298         UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
1299    {
1300       RETURN(FALSE);
1301    }
1302    UserRefObjectCo(Window, &Ref);
1303
1304    if (!co_IntCreateScrollBars(Window))
1305    {
1306       RETURN( FALSE);
1307    }
1308
1309    OrigArrows = Window->pSBInfo->WSBflags;
1310    Window->pSBInfo->WSBflags = wArrows;
1311
1312    if (wSBflags == SB_CTL)
1313    {
1314       if ((wArrows == ESB_DISABLE_BOTH || wArrows == ESB_ENABLE_BOTH))
1315          IntEnableWindow(hWnd, (wArrows == ESB_ENABLE_BOTH));
1316
1317       RETURN(TRUE);
1318    }
1319
1320    if(wSBflags != SB_BOTH && !SBID_IS_VALID(wSBflags))
1321    {
1322       EngSetLastError(ERROR_INVALID_PARAMETER);
1323       ERR("Trying to set scrollinfo for unknown scrollbar type %u", wSBflags);
1324       RETURN(FALSE);
1325    }
1326
1327    switch(wSBflags)
1328    {
1329       case SB_BOTH:
1330          InfoV = IntGetScrollbarInfoFromWindow(Window, SB_VERT);
1331          /* Fall through */
1332       case SB_HORZ:
1333          InfoH = IntGetScrollbarInfoFromWindow(Window, SB_HORZ);
1334          break;
1335       case SB_VERT:
1336          InfoV = IntGetScrollbarInfoFromWindow(Window, SB_VERT);
1337          break;
1338       default:
1339          RETURN(FALSE);
1340    }
1341
1342    if(InfoV)
1343       Chg = IntEnableScrollBar(FALSE, InfoV, wArrows);
1344
1345    if(InfoH)
1346       Chg = (IntEnableScrollBar(TRUE, InfoH, wArrows) || Chg);
1347
1348    ERR("FIXME: EnableScrollBar wSBflags %u wArrows %u Chg %d\n", wSBflags, wArrows, Chg);
1349 // Done in user32:
1350 //   SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
1351
1352    RETURN( Chg);
1353    if (OrigArrows == wArrows) RETURN( FALSE);
1354    RETURN( TRUE);
1355
1356 CLEANUP:
1357    if (Window)
1358       UserDerefObjectCo(Window);
1359
1360    TRACE("Leave NtUserEnableScrollBar, ret=%i\n",_ret_);
1361    UserLeave();
1362    END_CLEANUP;
1363 }
1364
1365 DWORD
1366 APIENTRY
1367 NtUserSetScrollInfo(
1368    HWND hWnd,
1369    int fnBar,
1370    LPCSCROLLINFO lpsi,
1371    BOOL bRedraw)
1372 {
1373    PWND Window = NULL;
1374    NTSTATUS Status;
1375    SCROLLINFO ScrollInfo;
1376    DECLARE_RETURN(DWORD);
1377    USER_REFERENCE_ENTRY Ref;
1378
1379    TRACE("Enter NtUserSetScrollInfo\n");
1380    UserEnterExclusive();
1381
1382    if(!(Window = UserGetWindowObject(hWnd)) ||
1383         UserIsDesktopWindow(Window) || UserIsMessageWindow(Window))
1384    {
1385       RETURN( 0);
1386    }
1387    UserRefObjectCo(Window, &Ref);
1388
1389    Status = MmCopyFromCaller(&ScrollInfo, lpsi, sizeof(SCROLLINFO) - sizeof(ScrollInfo.nTrackPos));
1390    if(!NT_SUCCESS(Status))
1391    {
1392       SetLastNtError(Status);
1393       RETURN( 0);
1394    }
1395
1396    RETURN(co_IntSetScrollInfo(Window, fnBar, &ScrollInfo, bRedraw));
1397
1398 CLEANUP:
1399    if (Window)
1400       UserDerefObjectCo(Window);
1401
1402    TRACE("Leave NtUserSetScrollInfo, ret=%lu\n", _ret_);
1403    UserLeave();
1404    END_CLEANUP;
1405
1406 }
1407
1408 DWORD APIENTRY
1409 NtUserShowScrollBar(HWND hWnd, int nBar, DWORD bShow)
1410 {
1411    PWND Window;
1412    DECLARE_RETURN(DWORD);
1413    DWORD ret;
1414    USER_REFERENCE_ENTRY Ref;
1415
1416    TRACE("Enter NtUserShowScrollBar\n");
1417    UserEnterExclusive();
1418
1419    if (!(Window = UserGetWindowObject(hWnd)))
1420    {
1421       RETURN(0);
1422    }
1423
1424    UserRefObjectCo(Window, &Ref);
1425    ret = co_UserShowScrollBar(Window, nBar, (nBar == SB_VERT) ? 0 : bShow,
1426                                             (nBar == SB_HORZ) ? 0 : bShow);
1427    UserDerefObjectCo(Window);
1428
1429    RETURN(ret);
1430
1431 CLEANUP:
1432    TRACE("Leave NtUserShowScrollBar,  ret%lu\n", _ret_);
1433    UserLeave();
1434    END_CLEANUP;
1435
1436 }
1437
1438
1439 //// Ugly NtUser API ////
1440
1441 BOOL
1442 APIENTRY
1443 NtUserSetScrollBarInfo(
1444    HWND hWnd,
1445    LONG idObject,
1446    SETSCROLLBARINFO *info)
1447 {
1448    PWND Window = NULL;
1449    SETSCROLLBARINFO Safeinfo;
1450    PSCROLLBARINFO sbi;
1451    LPSCROLLINFO psi;
1452    NTSTATUS Status;
1453    LONG Obj;
1454    DECLARE_RETURN(BOOL);
1455    USER_REFERENCE_ENTRY Ref;
1456
1457    TRACE("Enter NtUserSetScrollBarInfo\n");
1458    UserEnterExclusive();
1459
1460    if(!(Window = UserGetWindowObject(hWnd)))
1461    {
1462       RETURN( FALSE);
1463    }
1464    UserRefObjectCo(Window, &Ref);
1465
1466    Obj = SBOBJ_TO_SBID(idObject);
1467    if(!SBID_IS_VALID(Obj))
1468    {
1469       EngSetLastError(ERROR_INVALID_PARAMETER);
1470       ERR("Trying to set scrollinfo for unknown scrollbar type %d\n", Obj);
1471       RETURN( FALSE);
1472    }
1473
1474    if(!co_IntCreateScrollBars(Window))
1475    {
1476       RETURN(FALSE);
1477    }
1478
1479    Status = MmCopyFromCaller(&Safeinfo, info, sizeof(SETSCROLLBARINFO));
1480    if(!NT_SUCCESS(Status))
1481    {
1482       SetLastNtError(Status);
1483       RETURN(FALSE);
1484    }
1485
1486    sbi = IntGetScrollbarInfoFromWindow(Window, Obj);
1487    psi = IntGetScrollInfoFromWindow(Window, Obj);
1488
1489    psi->nTrackPos = Safeinfo.nTrackPos;
1490    sbi->reserved = Safeinfo.reserved;
1491    RtlCopyMemory(&sbi->rgstate, &Safeinfo.rgstate, sizeof(Safeinfo.rgstate));
1492
1493    RETURN(TRUE);
1494
1495 CLEANUP:
1496    if (Window)
1497       UserDerefObjectCo(Window);
1498
1499    TRACE("Leave NtUserSetScrollBarInfo, ret=%i\n",_ret_);
1500    UserLeave();
1501    END_CLEANUP;
1502 }
1503
1504 /* EOF */