controls/scroll.c

   1 /*
   2  * Scrollbar control
   3  *
   4  * Copyright 1993 Martin Ayotte
   5  * Copyright 1994, 1996 Alexandre Julliard
   6  */
   7
   8 #include <stdlib.h>
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include "windows.h"
  13 #include "sysmetrics.h"
  14 #include "scroll.h"
  15 #include "graphics.h"
  16 #include "heap.h"
  17 #include "win.h"
  18 #include "stddebug.h"
  19 #include "debug.h"
  20
  21
  22 static HBITMAP32 hUpArrow = 0;
  23 static HBITMAP32 hDnArrow = 0;
  24 static HBITMAP32 hLfArrow = 0;
  25 static HBITMAP32 hRgArrow = 0;
  26 static HBITMAP32 hUpArrowD = 0;
  27 static HBITMAP32 hDnArrowD = 0;
  28 static HBITMAP32 hLfArrowD = 0;
  29 static HBITMAP32 hRgArrowD = 0;
  30 static HBITMAP32 hUpArrowI = 0;
  31 static HBITMAP32 hDnArrowI = 0;
  32 static HBITMAP32 hLfArrowI = 0;
  33 static HBITMAP32 hRgArrowI = 0;
  34
  35 #define TOP_ARROW(flags,pressed) \
  36    (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
  37 #define BOTTOM_ARROW(flags,pressed) \
  38    (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
  39 #define LEFT_ARROW(flags,pressed) \
  40    (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
  41 #define RIGHT_ARROW(flags,pressed) \
  42    (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
  43
  44
  45   /* Minimum size of the rectangle between the arrows */
  46 #define SCROLL_MIN_RECT  4
  47
  48   /* Minimum size of the thumb in pixels */
  49 #define SCROLL_MIN_THUMB 6
  50
  51   /* Delay (in ms) before first repetition when holding the button down */
  52 #define SCROLL_FIRST_DELAY   200
  53
  54   /* Delay (in ms) between scroll repetitions */
  55 #define SCROLL_REPEAT_DELAY  50
  56
  57   /* Scroll timer id */
  58 #define SCROLL_TIMER   0
  59
  60   /* Scroll-bar hit testing */
  61 enum SCROLL_HITTEST
  62 {
  63     SCROLL_NOWHERE,      /* Outside the scroll bar */
  64     SCROLL_TOP_ARROW,    /* Top or left arrow */
  65     SCROLL_TOP_RECT,     /* Rectangle between the top arrow and the thumb */
  66     SCROLL_THUMB,        /* Thumb rectangle */
  67     SCROLL_BOTTOM_RECT,  /* Rectangle between the thumb and the bottom arrow */
  68     SCROLL_BOTTOM_ARROW  /* Bottom or right arrow */
  69 };
  70
  71  /* Thumb-tracking info */
  72 static HWND32 SCROLL_TrackingWin = 0;
  73 static INT32  SCROLL_TrackingBar = 0;
  74 static INT32  SCROLL_TrackingPos = 0;
  75 static INT32  SCROLL_TrackingVal = 0;
  76
  77 /* Is the moving thumb being displayed? */
  78 static BOOL32 SCROLL_MovingThumb = FALSE;
  79
  80 /***********************************************************************
  81  *           SCROLL_LoadBitmaps
  82  */
  83 static void SCROLL_LoadBitmaps(void)
  84 {
  85     hUpArrow  = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_UPARROW) );
  86     hDnArrow  = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_DNARROW) );
  87     hLfArrow  = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_LFARROW) );
  88     hRgArrow  = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RGARROW) );
  89     hUpArrowD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_UPARROWD) );
  90     hDnArrowD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_DNARROWD) );
  91     hLfArrowD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_LFARROWD) );
  92     hRgArrowD = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RGARROWD) );
  93     hUpArrowI = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_UPARROWI) );
  94     hDnArrowI = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_DNARROWI) );
  95     hLfArrowI = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_LFARROWI) );
  96     hRgArrowI = LoadBitmap16( 0, MAKEINTRESOURCE(OBM_RGARROWI) );
  97 }
  98
  99
 100 /***********************************************************************
 101  *           SCROLL_GetPtrScrollInfo
 102  */
 103 static SCROLLBAR_INFO *SCROLL_GetPtrScrollInfo( WND* wndPtr, INT32 nBar )
 104 {
 105     SCROLLBAR_INFO *infoPtr;
 106
 107     if (!wndPtr) return NULL;
 108     switch(nBar)
 109     {
 110         case SB_HORZ: infoPtr = (SCROLLBAR_INFO *)wndPtr->pHScroll; break;
 111         case SB_VERT: infoPtr = (SCROLLBAR_INFO *)wndPtr->pVScroll; break;
 112         case SB_CTL:  infoPtr = (SCROLLBAR_INFO *)wndPtr->wExtra; break;
 113         default:      return NULL;
 114     }
 115
 116     if (!infoPtr)  /* Create the info structure if needed */
 117     {
 118         if ((infoPtr = HeapAlloc( SystemHeap, 0, sizeof(SCROLLBAR_INFO) )))
 119         {
 120             infoPtr->MinVal = infoPtr->CurVal = infoPtr->Page = 0;
 121             infoPtr->MaxVal = 100;
 122             infoPtr->flags  = ESB_ENABLE_BOTH;
 123             if (nBar == SB_HORZ) wndPtr->pHScroll = infoPtr;
 124             else wndPtr->pVScroll = infoPtr;
 125         }
 126         if (!hUpArrow) SCROLL_LoadBitmaps();
 127     }
 128     return infoPtr;
 129 }
 130
 131
 132 /***********************************************************************
 133  *           SCROLL_GetScrollInfo
 134  */
 135 static SCROLLBAR_INFO *SCROLL_GetScrollInfo( HWND32 hwnd, INT32 nBar )
 136 {
 137    WND *wndPtr = WIN_FindWndPtr( hwnd );
 138    return SCROLL_GetPtrScrollInfo( wndPtr, nBar );
 139 }
 140
 141
 142 /***********************************************************************
 143  *           SCROLL_GetScrollBarRect
 144  *
 145  * Compute the scroll bar rectangle, in drawing coordinates (i.e. client
 146  * coords for SB_CTL, window coords for SB_VERT and SB_HORZ).
 147  * 'arrowSize' returns the width or height of an arrow (depending on
 148  * the orientation of the scrollbar), 'thumbSize' returns the size of
 149  * the thumb, and 'thumbPos' returns the position of the thumb
 150  * relative to the left or to the top.
 151  * Return TRUE if the scrollbar is vertical, FALSE if horizontal.
 152  */
 153 static BOOL32 SCROLL_GetScrollBarRect( HWND32 hwnd, INT32 nBar, RECT32 *lprect,
 154                                        INT32 *arrowSize, INT32 *thumbSize,
 155                                        INT32 *thumbPos )
 156 {
 157     INT32 pixels;
 158     BOOL32 vertical;
 159     WND *wndPtr = WIN_FindWndPtr( hwnd );
 160
 161     switch(nBar)
 162     {
 163       case SB_HORZ:
 164         lprect->left   = wndPtr->rectClient.left - wndPtr->rectWindow.left - 1;
 165         lprect->top    = wndPtr->rectClient.bottom - wndPtr->rectWindow.top;
 166         lprect->right  = wndPtr->rectClient.right - wndPtr->rectWindow.left +1;
 167         lprect->bottom = lprect->top + SYSMETRICS_CYHSCROLL + 1;
 168         vertical = FALSE;
 169         break;
 170
 171       case SB_VERT:
 172         lprect->left   = wndPtr->rectClient.right - wndPtr->rectWindow.left;
 173         lprect->top    = wndPtr->rectClient.top - wndPtr->rectWindow.top - 1;
 174         lprect->right  = lprect->left + SYSMETRICS_CXVSCROLL + 1;
 175         lprect->bottom = wndPtr->rectClient.bottom - wndPtr->rectWindow.top +1;
 176         vertical = TRUE;
 177         break;
 178
 179       case SB_CTL:
 180         GetClientRect32( hwnd, lprect );
 181         vertical = ((wndPtr->dwStyle & SBS_VERT) != 0);
 182         break;
 183
 184     default:
 185         return FALSE;
 186     }
 187
 188     if (vertical) pixels = lprect->bottom - lprect->top;
 189     else pixels = lprect->right - lprect->left;
 190
 191     if (pixels <= 2*SYSMETRICS_CXVSCROLL + SCROLL_MIN_RECT)
 192     {
 193         if (pixels > SCROLL_MIN_RECT)
 194             *arrowSize = (pixels - SCROLL_MIN_RECT) / 2;
 195         else
 196             *arrowSize = 0;
 197         *thumbPos = *thumbSize = 0;
 198     }
 199     else
 200     {
 201         SCROLLBAR_INFO *info = SCROLL_GetPtrScrollInfo( wndPtr, nBar );
 202
 203         *arrowSize = SYSMETRICS_CXVSCROLL;
 204         pixels -= 2 * SYSMETRICS_CXVSCROLL;
 205
 206         if (info->Page)
 207         {
 208             *thumbSize = pixels * info->Page / (info->MaxVal-info->MinVal+1);
 209             if (*thumbSize < SCROLL_MIN_THUMB) *thumbSize = SCROLL_MIN_THUMB;
 210         }
 211         else *thumbSize = SYSMETRICS_CXVSCROLL;
 212
 213         if (((pixels -= *thumbSize + 1) < 0) ||
 214             ((info->flags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH))
 215         {
 216             /* Rectangle too small or scrollbar disabled -> no thumb */
 217             *thumbPos = *thumbSize = 0;
 218         }
 219         else
 220         {
 221             INT32 max = info->MaxVal - MAX( info->Page-1, 0 );
 222             if (info->MinVal >= max)
 223                 *thumbPos = *arrowSize;
 224             else
 225                 *thumbPos = *arrowSize + pixels * (info->CurVal-info->MinVal) /
 226                                                   (max - info->MinVal);
 227         }
 228     }
 229     return vertical;
 230 }
 231
 232
 233 /***********************************************************************
 234  *           SCROLL_GetThumbVal
 235  *
 236  * Compute the current scroll position based on the thumb position in pixels
 237  * from the top of the scroll-bar.
 238  */
 239 static UINT32 SCROLL_GetThumbVal( SCROLLBAR_INFO *infoPtr, RECT32 *rect,
 240                                   BOOL32 vertical, INT32 pos )
 241 {
 242     INT32 thumbSize;
 243     INT32 pixels = vertical ? rect->bottom-rect->top : rect->right-rect->left;
 244
 245     if ((pixels -= 2*SYSMETRICS_CXVSCROLL) <= 0) return infoPtr->MinVal;
 246
 247     if (infoPtr->Page)
 248     {
 249         thumbSize = pixels * infoPtr->Page/(infoPtr->MaxVal-infoPtr->MinVal+1);
 250         if (thumbSize < SCROLL_MIN_THUMB) thumbSize = SCROLL_MIN_THUMB;
 251     }
 252     else thumbSize = SYSMETRICS_CXVSCROLL;
 253
 254     if ((pixels -= thumbSize + 1) <= 0) return infoPtr->MinVal;
 255
 256     pos = MAX( 0, pos - SYSMETRICS_CXVSCROLL );
 257     if (pos > pixels) pos = pixels;
 258
 259     if (!infoPtr->Page) pos *= infoPtr->MaxVal - infoPtr->MinVal;
 260     else pos *= infoPtr->MaxVal - infoPtr->MinVal - infoPtr->Page + 1;
 261     return infoPtr->MinVal + ((pos + pixels / 2) / pixels);
 262 }
 263
 264
 265 /***********************************************************************
 266  *           SCROLL_HitTest
 267  *
 268  * Scroll-bar hit testing (don't confuse this with WM_NCHITTEST!).
 269  */
 270 static enum SCROLL_HITTEST SCROLL_HitTest( HWND32 hwnd, INT32 nBar,
 271                                            POINT32 pt )
 272 {
 273     INT32 arrowSize, thumbSize, thumbPos;
 274     RECT32 rect;
 275
 276     BOOL32 vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
 277                                            &arrowSize, &thumbSize, &thumbPos );
 278     if (!PtInRect32( &rect, pt )) return SCROLL_NOWHERE;
 279
 280     if (vertical)
 281     {
 282         if (pt.y <= rect.top + arrowSize + 1) return SCROLL_TOP_ARROW;
 283         if (pt.y >= rect.bottom - arrowSize) return SCROLL_BOTTOM_ARROW;
 284         if (!thumbPos) return SCROLL_TOP_RECT;
 285         pt.y -= rect.top;
 286         if (pt.y < thumbPos) return SCROLL_TOP_RECT;
 287         if (pt.y > thumbPos + thumbSize) return SCROLL_BOTTOM_RECT;
 288         return SCROLL_THUMB;
 289     }
 290     else  /* horizontal */
 291     {
 292         if (pt.x <= rect.left + arrowSize) return SCROLL_TOP_ARROW;
 293         if (pt.x >= rect.right - arrowSize) return SCROLL_BOTTOM_ARROW;
 294         if (!thumbPos) return SCROLL_TOP_RECT;
 295         pt.x -= rect.left;
 296         if (pt.x < thumbPos) return SCROLL_TOP_RECT;
 297         if (pt.x > thumbPos + thumbSize) return SCROLL_BOTTOM_RECT;
 298         return SCROLL_THUMB;
 299     }
 300 }
 301
 302
 303 /***********************************************************************
 304  *           SCROLL_DrawArrows
 305  *
 306  * Draw the scroll bar arrows.
 307  */
 308 static void SCROLL_DrawArrows( HDC32 hdc, SCROLLBAR_INFO *infoPtr,
 309                                RECT32 *rect, INT32 arrowSize, BOOL32 vertical,
 310                                BOOL32 top_pressed, BOOL32 bottom_pressed )
 311 {
 312     HDC32 hdcMem = CreateCompatibleDC32( hdc );
 313     HBITMAP32 hbmpPrev = SelectObject32( hdcMem, vertical ?
 314                                     TOP_ARROW(infoPtr->flags, top_pressed)
 315                                     : LEFT_ARROW(infoPtr->flags, top_pressed));
 316     SetStretchBltMode32( hdc, STRETCH_DELETESCANS );
 317     StretchBlt32( hdc, rect->left, rect->top,
 318                   vertical ? rect->right-rect->left : arrowSize+1,
 319                   vertical ? arrowSize+1 : rect->bottom-rect->top,
 320                   hdcMem, 0, 0,
 321                   SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
 322                   SRCCOPY );
 323
 324     SelectObject32( hdcMem, vertical ?
 325                     BOTTOM_ARROW( infoPtr->flags, bottom_pressed )
 326                     : RIGHT_ARROW( infoPtr->flags, bottom_pressed ) );
 327     if (vertical)
 328         StretchBlt32( hdc, rect->left, rect->bottom - arrowSize - 1,
 329                       rect->right - rect->left, arrowSize + 1,
 330                       hdcMem, 0, 0,
 331                       SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
 332                       SRCCOPY );
 333     else
 334         StretchBlt32( hdc, rect->right - arrowSize - 1, rect->top,
 335                       arrowSize + 1, rect->bottom - rect->top,
 336                       hdcMem, 0, 0,
 337                       SYSMETRICS_CXVSCROLL + 1, SYSMETRICS_CYHSCROLL + 1,
 338                       SRCCOPY );
 339     SelectObject32( hdcMem, hbmpPrev );
 340     DeleteDC32( hdcMem );
 341 }
 342
 343
 344 /***********************************************************************
 345  *           SCROLL_DrawMovingThumb
 346  *
 347  * Draw the moving thumb rectangle.
 348  */
 349 static void SCROLL_DrawMovingThumb( HDC32 hdc, RECT32 *rect, BOOL32 vertical,
 350                                     INT32 arrowSize, INT32 thumbSize )
 351 {
 352     RECT32 r = *rect;
 353     if (vertical)
 354     {
 355         r.top += SCROLL_TrackingPos;
 356         if (r.top < rect->top + arrowSize) r.top = rect->top + arrowSize;
 357         if (r.top + thumbSize >= rect->bottom - arrowSize)
 358             r.top = rect->bottom - arrowSize - thumbSize - 1;
 359         r.bottom = r.top + thumbSize + 1;
 360     }
 361     else
 362     {
 363         r.left += SCROLL_TrackingPos;
 364         if (r.left < rect->left + arrowSize) r.left = rect->left + arrowSize;
 365         if (r.left + thumbSize >= rect->right - arrowSize)
 366             r.left = rect->right - arrowSize - thumbSize - 1;
 367         r.right = r.left + thumbSize + 1;
 368     }
 369     InflateRect32( &r, -1, -1 );
 370     DrawFocusRect32( hdc, &r );
 371     SCROLL_MovingThumb = !SCROLL_MovingThumb;
 372 }
 373
 374
 375 /***********************************************************************
 376  *           SCROLL_DrawInterior
 377  *
 378  * Draw the scroll bar interior (everything except the arrows).
 379  */
 380 static void SCROLL_DrawInterior( HWND32 hwnd, HDC32 hdc, INT32 nBar,
 381                                  RECT32 *rect, INT32 arrowSize,
 382                                  INT32 thumbSize, INT32 thumbPos,
 383                                  UINT32 flags, BOOL32 vertical,
 384                                  BOOL32 top_selected, BOOL32 bottom_selected )
 385 {
 386     RECT32 r;
 387
 388       /* Select the correct brush and pen */
 389
 390     SelectObject32( hdc, GetSysColorPen32(COLOR_WINDOWFRAME) );
 391     if ((flags & ESB_DISABLE_BOTH) == ESB_DISABLE_BOTH)
 392     {
 393           /* This ought to be the color of the parent window */
 394         SelectObject32( hdc, GetSysColorBrush32(COLOR_WINDOW) );
 395     }
 396     else
 397     {
 398         if (nBar == SB_CTL)  /* Only scrollbar controls send WM_CTLCOLOR */
 399         {
 400             HBRUSH32 hbrush = SendMessage32A(GetParent32(hwnd),
 401                                              WM_CTLCOLORSCROLLBAR, hdc, hwnd );
 402             SelectObject32( hdc, hbrush );
 403         }
 404         else SelectObject32( hdc, GetSysColorBrush32(COLOR_SCROLLBAR) );
 405     }
 406
 407       /* Calculate the scroll rectangle */
 408
 409     r = *rect;
 410     if (vertical)
 411     {
 412         r.top    += arrowSize - 1;
 413         r.bottom -= arrowSize;
 414         r.right--;
 415     }
 416     else
 417     {
 418         r.left  += arrowSize - 1;
 419         r.right -= arrowSize;
 420         r.bottom--;
 421     }
 422
 423       /* Draw the scroll bar frame */
 424
 425     GRAPH_DrawRectangle( hdc, r.left, r.top, r.right - r.left, r.bottom - r.top, 0);
 426
 427       /* Draw the scroll rectangles and thumb */
 428
 429     if (!thumbPos)  /* No thumb to draw */
 430     {
 431         PatBlt32( hdc, r.left+1, r.top+1, r.right - r.left - 2,
 432                   r.bottom - r.top - 2, PATCOPY );
 433         return;
 434     }
 435
 436     if (vertical)
 437     {
 438         PatBlt32( hdc, r.left + 1, r.top + 1,
 439                   r.right - r.left - 2,
 440                   thumbPos - arrowSize,
 441                   top_selected ? 0x0f0000 : PATCOPY );
 442         r.top += thumbPos - arrowSize;
 443         PatBlt32( hdc, r.left + 1, r.top + thumbSize + 1,
 444                   r.right - r.left - 2,
 445                   r.bottom - r.top - thumbSize - 2,
 446                   bottom_selected ? 0x0f0000 : PATCOPY );
 447         r.bottom = r.top + thumbSize + 2;
 448     }
 449     else  /* horizontal */
 450     {
 451         PatBlt32( hdc, r.left + 1, r.top + 1,
 452                   thumbPos - arrowSize,
 453                   r.bottom - r.top - 2,
 454                   top_selected ? 0x0f0000 : PATCOPY );
 455         r.left += thumbPos - arrowSize;
 456         PatBlt32( hdc, r.left + thumbSize + 1, r.top + 1,
 457                   r.right - r.left - thumbSize - 2,
 458                   r.bottom - r.top - 2,
 459                   bottom_selected ? 0x0f0000 : PATCOPY );
 460         r.right = r.left + thumbSize + 2;
 461     }
 462
 463       /* Draw the thumb */
 464
 465     SelectObject32( hdc, GetSysColorBrush32(COLOR_BTNFACE) );
 466     Rectangle32( hdc, r.left, r.top, r.right, r.bottom );
 467     InflateRect32( &r, -1, -1 );
 468     GRAPH_DrawReliefRect( hdc, &r, 1, 2, FALSE );
 469     if (SCROLL_MovingThumb &&
 470         (SCROLL_TrackingWin == hwnd) &&
 471         (SCROLL_TrackingBar == nBar))
 472     {
 473         SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
 474         SCROLL_MovingThumb = TRUE;
 475     }
 476 }
 477
 478
 479 /***********************************************************************
 480  *           SCROLL_DrawScrollBar
 481  *
 482  * Redraw the whole scrollbar.
 483  */
 484 void SCROLL_DrawScrollBar( HWND32 hwnd, HDC32 hdc, INT32 nBar, BOOL32 arrows )
 485 {
 486     INT32 arrowSize, thumbSize, thumbPos;
 487     RECT32 rect;
 488     BOOL32 vertical;
 489     WND *wndPtr = WIN_FindWndPtr( hwnd );
 490     SCROLLBAR_INFO *infoPtr = SCROLL_GetPtrScrollInfo( wndPtr, nBar );
 491
 492     if (!wndPtr || !infoPtr ||
 493         ((nBar == SB_VERT) && !(wndPtr->dwStyle & WS_VSCROLL)) ||
 494         ((nBar == SB_HORZ) && !(wndPtr->dwStyle & WS_HSCROLL))) return;
 495
 496     vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
 497                                         &arrowSize, &thumbSize, &thumbPos );
 498       /* Draw the arrows */
 499
 500     if (arrows && arrowSize) SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize,
 501                                                 vertical, FALSE, FALSE );
 502
 503     SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
 504                          thumbPos, infoPtr->flags, vertical, FALSE, FALSE );
 505 }
 506
 507
 508 /***********************************************************************
 509  *           SCROLL_RefreshScrollBar
 510  *
 511  * Repaint the scroll bar interior after a SetScrollRange() or
 512  * SetScrollPos() call.
 513  */
 514 static void SCROLL_RefreshScrollBar( HWND32 hwnd, INT32 nBar, BOOL32 arrows )
 515 {
 516     HDC32 hdc = GetDCEx32( hwnd, 0,
 517                            DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW) );
 518     if (!hdc) return;
 519     SCROLL_DrawScrollBar( hwnd, hdc, nBar, arrows );
 520     ReleaseDC32( hwnd, hdc );
 521 }
 522
 523
 524 /***********************************************************************
 525  *           SCROLL_HandleKbdEvent
 526  *
 527  * Handle a keyboard event (only for SB_CTL scrollbars).
 528  */
 529 static void SCROLL_HandleKbdEvent( HWND32 hwnd, WPARAM32 wParam )
 530 {
 531     WND *wndPtr = WIN_FindWndPtr( hwnd );
 532     WPARAM32 msg;
 533
 534     switch(wParam)
 535     {
 536     case VK_PRIOR: msg = SB_PAGEUP; break;
 537     case VK_NEXT:  msg = SB_PAGEDOWN; break;
 538     case VK_HOME:  msg = SB_TOP; break;
 539     case VK_END:   msg = SB_BOTTOM; break;
 540     case VK_UP:    msg = SB_LINEUP; break;
 541     case VK_DOWN:  msg = SB_LINEDOWN; break;
 542     default:
 543         return;
 544     }
 545     SendMessage32A( GetParent32(hwnd),
 546                     (wndPtr->dwStyle & SBS_VERT) ? WM_VSCROLL : WM_HSCROLL,
 547                     msg, hwnd );
 548 }
 549
 550
 551 /***********************************************************************
 552  *           SCROLL_HandleScrollEvent
 553  *
 554  * Handle a mouse or timer event for the scrollbar.
 555  * 'pt' is the location of the mouse event in client (for SB_CTL) or
 556  * windows coordinates.
 557  */
 558 void SCROLL_HandleScrollEvent( HWND32 hwnd, INT32 nBar, UINT32 msg, POINT32 pt)
 559 {
 560       /* Previous mouse position for timer events */
 561     static POINT32 prevPt;
 562       /* Hit test code of the last button-down event */
 563     static enum SCROLL_HITTEST trackHitTest;
 564       /* Thumb position when tracking started. */
 565     static UINT32 trackThumbPos;
 566       /* Position in the scroll-bar of the last button-down event. */
 567     static INT32 lastClickPos;
 568       /* Position in the scroll-bar of the last mouse event. */
 569     static INT32 lastMousePos;
 570
 571     enum SCROLL_HITTEST hittest;
 572     HWND32 hwndOwner, hwndCtl;
 573     BOOL32 vertical;
 574     INT32 arrowSize, thumbSize, thumbPos;
 575     RECT32 rect;
 576     HDC32 hdc;
 577
 578     SCROLLBAR_INFO *infoPtr = SCROLL_GetScrollInfo( hwnd, nBar );
 579     if (!infoPtr) return;
 580     if ((trackHitTest == SCROLL_NOWHERE) && (msg != WM_LBUTTONDOWN)) return;
 581
 582     hdc = GetDCEx32( hwnd, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
 583     vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
 584                                         &arrowSize, &thumbSize, &thumbPos );
 585     hwndOwner = (nBar == SB_CTL) ? GetParent32(hwnd) : hwnd;
 586     hwndCtl   = (nBar == SB_CTL) ? hwnd : 0;
 587
 588     switch(msg)
 589     {
 590       case WM_LBUTTONDOWN:  /* Initialise mouse tracking */
 591           trackHitTest  = hittest = SCROLL_HitTest( hwnd, nBar, pt );
 592           lastClickPos  = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
 593           lastMousePos  = lastClickPos;
 594           trackThumbPos = thumbPos;
 595           prevPt = pt;
 596           SetCapture32( hwnd );
 597           if (nBar == SB_CTL) SetFocus32( hwnd );
 598           break;
 599
 600       case WM_MOUSEMOVE:
 601           hittest = SCROLL_HitTest( hwnd, nBar, pt );
 602           prevPt = pt;
 603           break;
 604
 605       case WM_LBUTTONUP:
 606           hittest = SCROLL_NOWHERE;
 607           ReleaseCapture();
 608           break;
 609
 610       case WM_SYSTIMER:
 611           pt = prevPt;
 612           hittest = SCROLL_HitTest( hwnd, nBar, pt );
 613           break;
 614
 615       default:
 616           return;  /* Should never happen */
 617     }
 618
 619     dprintf_scroll( stddeb, "ScrollBar Event: hwnd=%04x bar=%d msg=%x pt=%d,%d hit=%d\n",
 620                     hwnd, nBar, msg, pt.x, pt.y, hittest );
 621
 622     switch(trackHitTest)
 623     {
 624     case SCROLL_NOWHERE:  /* No tracking in progress */
 625         break;
 626
 627     case SCROLL_TOP_ARROW:
 628         SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
 629                            (hittest == trackHitTest), FALSE );
 630         if (hittest == trackHitTest)
 631         {
 632             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
 633             {
 634                 SendMessage32A( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
 635                                 SB_LINEUP, hwndCtl );
 636                 SetSystemTimer32( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
 637                                   SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
 638                                   (TIMERPROC32)0 );
 639             }
 640         }
 641         else KillSystemTimer32( hwnd, SCROLL_TIMER );
 642         break;
 643
 644     case SCROLL_TOP_RECT:
 645         SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
 646                              thumbPos, infoPtr->flags, vertical,
 647                              (hittest == trackHitTest), FALSE );
 648         if (hittest == trackHitTest)
 649         {
 650             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
 651             {
 652                 SendMessage32A( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
 653                                 SB_PAGEUP, hwndCtl );
 654                 SetSystemTimer32( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
 655                                   SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
 656                                   (TIMERPROC32)0 );
 657             }
 658         }
 659         else KillSystemTimer32( hwnd, SCROLL_TIMER );
 660         break;
 661
 662     case SCROLL_THUMB:
 663         if (msg == WM_LBUTTONDOWN)
 664         {
 665             SCROLL_TrackingWin = hwnd;
 666             SCROLL_TrackingBar = nBar;
 667             SCROLL_TrackingPos = trackThumbPos + lastMousePos - lastClickPos;
 668             SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
 669         }
 670         else if (msg == WM_LBUTTONUP)
 671         {
 672             SCROLL_TrackingWin = 0;
 673             SCROLL_MovingThumb = FALSE;
 674             SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
 675                                  thumbPos, infoPtr->flags, vertical,
 676                                  FALSE, FALSE );
 677         }
 678         else  /* WM_MOUSEMOVE */
 679         {
 680             UINT32 pos;
 681
 682             if (!PtInRect32( &rect, pt )) pos = lastClickPos;
 683             else pos = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
 684             if (pos != lastMousePos)
 685             {
 686                 SCROLL_DrawMovingThumb( hdc, &rect, vertical,
 687                                         arrowSize, thumbSize );
 688                 lastMousePos = pos;
 689                 SCROLL_TrackingPos = trackThumbPos + pos - lastClickPos;
 690                 SCROLL_TrackingVal = SCROLL_GetThumbVal( infoPtr, &rect,
 691                                                          vertical,
 692                                                          SCROLL_TrackingPos );
 693                 SendMessage32A( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
 694                                 MAKEWPARAM( SB_THUMBTRACK, SCROLL_TrackingVal),
 695                                 hwndCtl );
 696                 SCROLL_DrawMovingThumb( hdc, &rect, vertical,
 697                                         arrowSize, thumbSize );
 698             }
 699         }
 700         break;
 701
 702     case SCROLL_BOTTOM_RECT:
 703         SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
 704                              thumbPos, infoPtr->flags, vertical,
 705                              FALSE, (hittest == trackHitTest) );
 706         if (hittest == trackHitTest)
 707         {
 708             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
 709             {
 710                 SendMessage32A( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
 711                                 SB_PAGEDOWN, hwndCtl );
 712                 SetSystemTimer32( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
 713                                   SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
 714                                   (TIMERPROC32)0 );
 715             }
 716         }
 717         else KillSystemTimer32( hwnd, SCROLL_TIMER );
 718         break;
 719
 720     case SCROLL_BOTTOM_ARROW:
 721         SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
 722                            FALSE, (hittest == trackHitTest) );
 723         if (hittest == trackHitTest)
 724         {
 725             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
 726             {
 727                 SendMessage32A( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
 728                                 SB_LINEDOWN, hwndCtl );
 729                 SetSystemTimer32( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
 730                                   SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
 731                                   (TIMERPROC32)0 );
 732             }
 733         }
 734         else KillSystemTimer32( hwnd, SCROLL_TIMER );
 735         break;
 736     }
 737
 738     if (msg == WM_LBUTTONUP)
 739     {
 740         if (trackHitTest == SCROLL_THUMB)
 741         {
 742             UINT32 val = SCROLL_GetThumbVal( infoPtr, &rect, vertical,
 743                                  trackThumbPos + lastMousePos - lastClickPos );
 744             SendMessage32A( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
 745                             MAKEWPARAM( SB_THUMBPOSITION, val ), hwndCtl );
 746         }
 747         else
 748             SendMessage32A( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
 749                             SB_ENDSCROLL, hwndCtl );
 750         trackHitTest = SCROLL_NOWHERE;  /* Terminate tracking */
 751     }
 752
 753     ReleaseDC32( hwnd, hdc );
 754 }
 755
 756
 757 /***********************************************************************
 758  *           ScrollBarWndProc
 759  */
 760 LRESULT WINAPI ScrollBarWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam,
 761                                  LPARAM lParam )
 762 {
 763     switch(message)
 764     {
 765     case WM_CREATE:
 766         {
 767             CREATESTRUCT32A *lpCreat = (CREATESTRUCT32A *)lParam;
 768             if (lpCreat->style & SBS_SIZEBOX)
 769             {
 770                 fprintf( stdnimp, "Unimplemented style SBS_SIZEBOX.\n" );
 771                 return 0;  /* FIXME */
 772             }
 773
 774             if (lpCreat->style & SBS_VERT)
 775             {
 776                 if (lpCreat->style & SBS_LEFTALIGN)
 777                     MoveWindow32( hwnd, lpCreat->x, lpCreat->y,
 778                                   SYSMETRICS_CXVSCROLL+1, lpCreat->cy, FALSE );
 779                 else if (lpCreat->style & SBS_RIGHTALIGN)
 780                     MoveWindow32( hwnd,
 781                                   lpCreat->x+lpCreat->cx-SYSMETRICS_CXVSCROLL-1,
 782                                   lpCreat->y,
 783                                   SYSMETRICS_CXVSCROLL+1, lpCreat->cy, FALSE );
 784             }
 785             else  /* SBS_HORZ */
 786             {
 787                 if (lpCreat->style & SBS_TOPALIGN)
 788                     MoveWindow32( hwnd, lpCreat->x, lpCreat->y,
 789                                   lpCreat->cx, SYSMETRICS_CYHSCROLL+1, FALSE );
 790                 else if (lpCreat->style & SBS_BOTTOMALIGN)
 791                     MoveWindow32( hwnd,
 792                                   lpCreat->x,
 793                                   lpCreat->y+lpCreat->cy-SYSMETRICS_CYHSCROLL-1,
 794                                   lpCreat->cx, SYSMETRICS_CYHSCROLL+1, FALSE );
 795             }
 796         }
 797         if (!hUpArrow) SCROLL_LoadBitmaps();
 798         dprintf_scroll( stddeb, "ScrollBar creation, hwnd=%04x\n", hwnd );
 799         return 0;
 800
 801     case WM_LBUTTONDOWN:
 802     case WM_LBUTTONUP:
 803     case WM_MOUSEMOVE:
 804     case WM_SYSTIMER:
 805         {
 806             POINT32 pt;
 807             CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
 808             SCROLL_HandleScrollEvent( hwnd, SB_CTL, message, pt );
 809         }
 810         break;
 811
 812     case WM_KEYDOWN:
 813         SCROLL_HandleKbdEvent( hwnd, wParam );
 814         break;
 815
 816     case WM_ERASEBKGND:
 817          return 1;
 818
 819     case WM_GETDLGCODE:
 820          return DLGC_WANTARROWS; /* Windows returns this value */
 821
 822     case WM_PAINT:
 823         {
 824             PAINTSTRUCT32 ps;
 825             HDC32 hdc = BeginPaint32( hwnd, &ps );
 826             SCROLL_DrawScrollBar( hwnd, hdc, SB_CTL, TRUE );
 827             EndPaint32( hwnd, &ps );
 828         }
 829         break;
 830
 831     case SBM_SETPOS16:
 832     case SBM_SETPOS32:
 833         return SetScrollPos32( hwnd, SB_CTL, wParam, (BOOL32)lParam );
 834
 835     case SBM_GETPOS16:
 836     case SBM_GETPOS32:
 837         return GetScrollPos32( hwnd, SB_CTL );
 838
 839     case SBM_SETRANGE16:
 840         SetScrollRange32( hwnd, SB_CTL, LOWORD(lParam), HIWORD(lParam),
 841                           wParam  /* FIXME: Is this correct? */ );
 842         return 0;
 843
 844     case SBM_SETRANGE32:
 845         SetScrollRange32( hwnd, SB_CTL, wParam, lParam, FALSE );
 846         return 0;  /* FIXME: return previous position */
 847
 848     case SBM_GETRANGE16:
 849         /* FIXME */
 850         fprintf( stderr, "ScrollBar: don't know how to handle SBM_GETRANGE16 (wp=%04x,lp=%08lx)\n",
 851                  wParam, lParam );
 852         return 0;
 853
 854     case SBM_GETRANGE32:
 855         GetScrollRange32( hwnd, SB_CTL, (LPINT32)wParam, (LPINT32)lParam );
 856         return 0;
 857
 858     case SBM_ENABLE_ARROWS16:
 859     case SBM_ENABLE_ARROWS32:
 860         return EnableScrollBar32( hwnd, SB_CTL, wParam );
 861
 862     case SBM_SETRANGEREDRAW32:
 863         SetScrollRange32( hwnd, SB_CTL, wParam, lParam, TRUE );
 864         return 0;  /* FIXME: return previous position */
 865
 866     case SBM_SETSCROLLINFO32:
 867         return SetScrollInfo32( hwnd, SB_CTL, (SCROLLINFO *)lParam, wParam );
 868
 869     case SBM_GETSCROLLINFO32:
 870         return GetScrollInfo32( hwnd, SB_CTL, (SCROLLINFO *)lParam );
 871
 872     case 0x00e5:
 873     case 0x00e7:
 874     case 0x00e8:
 875     case 0x00eb:
 876     case 0x00ec:
 877     case 0x00ed:
 878     case 0x00ee:
 879     case 0x00ef:
 880         fprintf(stderr, "ScrollBar: unknown Win32 msg %04x wp=%08x lp=%08lx\n",
 881                 message, wParam, lParam );
 882         break;
 883
 884     default:
 885         if (message >= WM_USER)
 886             fprintf( stderr, "ScrollBar: unknown msg %04x wp=%04x lp=%08lx\n",
 887                      message, wParam, lParam );
 888         return DefWindowProc32A( hwnd, message, wParam, lParam );
 889     }
 890     return 0;
 891 }
 892
 893
 894 /*************************************************************************
 895  *           SetScrollInfo16   (USER.475)
 896  */
 897 INT16 WINAPI SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info,
 898                               BOOL16 bRedraw )
 899 {
 900     return (INT16)SetScrollInfo32( hwnd, nBar, info, bRedraw );
 901 }
 902
 903
 904 /*************************************************************************
 905  *           SetScrollInfo32   (USER32.501)
 906  */
 907 INT32 WINAPI SetScrollInfo32( HWND32 hwnd, INT32 nBar, const SCROLLINFO *info,
 908                               BOOL32 bRedraw )
 909 {
 910     SCROLLBAR_INFO *infoPtr;
 911     UINT32 new_flags;
 912     BOOL32 repaint_arrows = FALSE;
 913
 914     if (!(infoPtr = SCROLL_GetScrollInfo(hwnd, nBar))) return 0;
 915     if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return 0;
 916     if ((info->cbSize != sizeof(*info)) &&
 917         (info->cbSize != sizeof(*info)-sizeof(info->nTrackPos))) return 0;
 918
 919     dprintf_scroll( stddeb, "SetScrollInfo: hwnd=%04x bar=%d", hwnd, nBar );
 920
 921     /* Set the page size */
 922
 923     if (info->fMask & SIF_PAGE)
 924     {
 925         dprintf_scroll( stddeb, " page=%d", info->nPage );
 926         infoPtr->Page = info->nPage;
 927     }
 928
 929     /* Set the scroll pos */
 930
 931     if (info->fMask & SIF_POS)
 932     {
 933         dprintf_scroll( stddeb, " pos=%d", info->nPos );
 934         infoPtr->CurVal = info->nPos;
 935     }
 936
 937     /* Set the scroll range */
 938
 939     if (info->fMask & SIF_RANGE)
 940     {
 941         dprintf_scroll( stddeb, " min=%d max=%d", info->nMin, info->nMax );
 942
 943         /* Invalid range -> range is set to (0,0) */
 944         if ((info->nMin > info->nMax) ||
 945             ((UINT32)(info->nMax - info->nMin) >= 0x80000000))
 946         {
 947             infoPtr->MinVal = 0;
 948             infoPtr->MaxVal = 0;
 949         }
 950         else
 951         {
 952             infoPtr->MinVal = info->nMin;
 953             infoPtr->MaxVal = info->nMax;
 954         }
 955     }
 956
 957     /* Make sure the page size is valid */
 958
 959     if (infoPtr->Page < 0) infoPtr->Page = 0;
 960     else if (infoPtr->Page > infoPtr->MaxVal - infoPtr->MinVal + 1 )
 961         infoPtr->Page = infoPtr->MaxVal - infoPtr->MinVal + 1;
 962
 963     /* Make sure the pos is inside the range */
 964
 965     if (infoPtr->CurVal < infoPtr->MinVal)
 966         infoPtr->CurVal = infoPtr->MinVal;
 967     else if (infoPtr->CurVal > infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 ))
 968         infoPtr->CurVal = infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 );
 969
 970     dprintf_scroll( stddeb, "\n   new values: page=%d pos=%d min=%d max=%d\n",
 971                     infoPtr->Page, infoPtr->CurVal,
 972                     infoPtr->MinVal, infoPtr->MaxVal );
 973
 974     /* Check if the scrollbar should be hidden or disabled */
 975
 976     new_flags = infoPtr->flags;
 977     if (infoPtr->MinVal >= infoPtr->MaxVal - MAX( infoPtr->Page-1, 0 ))
 978     {
 979         /* Hide or disable scroll-bar */
 980         if (info->fMask & SIF_DISABLENOSCROLL) new_flags = ESB_DISABLE_BOTH;
 981         else if (nBar != SB_CTL)
 982         {
 983             ShowScrollBar32( hwnd, nBar, FALSE );
 984             bRedraw = FALSE;  /* No need to repaint anything */
 985         }
 986     }
 987     else  /* Show and enable scroll-bar */
 988     {
 989         new_flags = 0;
 990         if (nBar != SB_CTL) ShowScrollBar32( hwnd, nBar, TRUE );
 991     }
 992
 993     if (infoPtr->flags != new_flags)
 994     {
 995         infoPtr->flags = new_flags;
 996         repaint_arrows = TRUE;
 997     }
 998
 999     if (bRedraw || repaint_arrows)
1000         SCROLL_RefreshScrollBar( hwnd, nBar, repaint_arrows );
1001
1002     /* Return current position */
1003
1004     return infoPtr->CurVal;
1005 }
1006
1007
1008 /*************************************************************************
1009  *           GetScrollInfo16   (USER.476)
1010  */
1011 BOOL16 WINAPI GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
1012 {
1013     return GetScrollInfo32( hwnd, nBar, info );
1014 }
1015
1016
1017 /*************************************************************************
1018  *           GetScrollInfo32   (USER32.283)
1019  */
1020 BOOL32 WINAPI GetScrollInfo32( HWND32 hwnd, INT32 nBar, LPSCROLLINFO info )
1021 {
1022     SCROLLBAR_INFO *infoPtr;
1023
1024     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return FALSE;
1025     if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return FALSE;
1026     if ((info->cbSize != sizeof(*info)) &&
1027         (info->cbSize != sizeof(*info)-sizeof(info->nTrackPos))) return FALSE;
1028
1029     if (info->fMask & SIF_PAGE) info->nPage = infoPtr->Page;
1030     if (info->fMask & SIF_POS) info->nPos = infoPtr->CurVal;
1031     if ((info->fMask & SIF_TRACKPOS) && (info->cbSize == sizeof(*info)))
1032         info->nTrackPos = (SCROLL_TrackingWin==hwnd) ? SCROLL_TrackingVal : 0;
1033     if (info->fMask & SIF_RANGE)
1034     {
1035         info->nMin = infoPtr->MinVal;
1036         info->nMax = infoPtr->MaxVal;
1037     }
1038     return (info->fMask & SIF_ALL) != 0;
1039 }
1040
1041
1042 /*************************************************************************
1043  *           SetScrollPos16   (USER.62)
1044  */
1045 INT16 WINAPI SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos,
1046                              BOOL16 bRedraw )
1047 {
1048     return (INT16)SetScrollPos32( hwnd, nBar, nPos, bRedraw );
1049 }
1050
1051
1052 /*************************************************************************
1053  *           SetScrollPos32   (USER32.502)
1054  */
1055 INT32 WINAPI SetScrollPos32( HWND32 hwnd, INT32 nBar, INT32 nPos,
1056                              BOOL32 bRedraw )
1057 {
1058     SCROLLINFO info;
1059     SCROLLBAR_INFO *infoPtr;
1060     INT32 oldPos;
1061
1062     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return 0;
1063     oldPos      = infoPtr->CurVal;
1064     info.cbSize = sizeof(info);
1065     info.nPos   = nPos;
1066     info.fMask  = SIF_POS;
1067     SetScrollInfo32( hwnd, nBar, &info, bRedraw );
1068     return oldPos;
1069 }
1070
1071
1072 /*************************************************************************
1073  *           GetScrollPos16   (USER.63)
1074  */
1075 INT16 WINAPI GetScrollPos16( HWND16 hwnd, INT16 nBar )
1076 {
1077     return (INT16)GetScrollPos32( hwnd, nBar );
1078 }
1079
1080
1081 /*************************************************************************
1082  *           GetScrollPos32   (USER32.284)
1083  */
1084 INT32 WINAPI GetScrollPos32( HWND32 hwnd, INT32 nBar )
1085 {
1086     SCROLLBAR_INFO *infoPtr;
1087
1088     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return 0;
1089     return infoPtr->CurVal;
1090 }
1091
1092
1093 /*************************************************************************
1094  *           SetScrollRange16   (USER.64)
1095  */
1096 void WINAPI SetScrollRange16( HWND16 hwnd, INT16 nBar,
1097                               INT16 MinVal, INT16 MaxVal, BOOL16 bRedraw )
1098 {
1099     /* Invalid range -> range is set to (0,0) */
1100     if ((INT32)MaxVal - (INT32)MinVal > 0x7fff) MinVal = MaxVal = 0;
1101     SetScrollRange32( hwnd, nBar, MinVal, MaxVal, bRedraw );
1102 }
1103
1104
1105 /*************************************************************************
1106  *           SetScrollRange32   (USER32.503)
1107  */
1108 BOOL32 WINAPI SetScrollRange32( HWND32 hwnd, INT32 nBar,
1109                                 INT32 MinVal, INT32 MaxVal, BOOL32 bRedraw )
1110 {
1111     SCROLLINFO info;
1112
1113     info.cbSize = sizeof(info);
1114     info.nMin   = MinVal;
1115     info.nMax   = MaxVal;
1116     info.fMask  = SIF_RANGE;
1117     SetScrollInfo32( hwnd, nBar, &info, bRedraw );
1118     return TRUE;
1119 }
1120
1121
1122 /*************************************************************************
1123  *           SCROLL_SetNCSbState
1124  *
1125  * This is for CalcChildScroll in windows/mdi.c
1126  */
1127 DWORD SCROLL_SetNCSbState(WND* wndPtr, int vMin, int vMax, int vPos,
1128                                        int hMin, int hMax, int hPos)
1129 {
1130   SCROLLBAR_INFO  *infoPtr = SCROLL_GetPtrScrollInfo(wndPtr, SB_VERT);
1131
1132   wndPtr->dwStyle |= (WS_VSCROLL | WS_HSCROLL);
1133
1134   if( vMin >= vMax )
1135     { vMin = vMax;
1136       wndPtr->dwStyle &= ~WS_VSCROLL; }
1137   if( vPos > vMax ) vPos = vMax; else if( vPos < vMin ) vPos = vMin;
1138   infoPtr->MinVal = vMin;
1139   infoPtr->MaxVal = vMax;
1140   infoPtr->CurVal = vPos;
1141
1142   infoPtr = SCROLL_GetPtrScrollInfo(wndPtr, SB_HORZ);
1143
1144   if( hMin >= hMax )
1145     { hMin = hMax;
1146       wndPtr->dwStyle &= ~WS_HSCROLL; }
1147   if( hPos > hMax ) hPos = hMax; else if( hPos < hMin ) hPos = hMin;
1148   infoPtr->MinVal = hMin;
1149   infoPtr->MaxVal = hMax;
1150   infoPtr->CurVal = hPos;
1151
1152   return wndPtr->dwStyle & (WS_VSCROLL | WS_HSCROLL);
1153 }
1154
1155
1156 /*************************************************************************
1157  *           GetScrollRange16   (USER.65)
1158  */
1159 BOOL16 WINAPI GetScrollRange16( HWND16 hwnd, INT16 nBar,
1160                                 LPINT16 lpMin, LPINT16 lpMax)
1161 {
1162     INT32 min, max;
1163     BOOL16 ret = GetScrollRange32( hwnd, nBar, &min, &max );
1164     if (lpMin) *lpMin = min;
1165     if (lpMax) *lpMax = max;
1166     return ret;
1167 }
1168
1169
1170 /*************************************************************************
1171  *           GetScrollRange32   (USER32.285)
1172  */
1173 BOOL32 WINAPI GetScrollRange32( HWND32 hwnd, INT32 nBar,
1174                                 LPINT32 lpMin, LPINT32 lpMax)
1175 {
1176     SCROLLBAR_INFO *infoPtr;
1177
1178     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar )))
1179     {
1180         if (lpMin) lpMin = 0;
1181         if (lpMax) lpMax = 0;
1182         return FALSE;
1183     }
1184     if (lpMin) *lpMin = infoPtr->MinVal;
1185     if (lpMax) *lpMax = infoPtr->MaxVal;
1186     return TRUE;
1187 }
1188
1189
1190 /*************************************************************************
1191  *           ShowScrollBar16   (USER.267)
1192  */
1193 void WINAPI ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
1194 {
1195     ShowScrollBar32( hwnd, nBar, fShow );
1196 }
1197
1198
1199 /*************************************************************************
1200  *           ShowScrollBar32   (USER32.531)
1201  */
1202 BOOL32 WINAPI ShowScrollBar32( HWND32 hwnd, INT32 nBar, BOOL32 fShow )
1203 {
1204     WND *wndPtr = WIN_FindWndPtr( hwnd );
1205
1206     if (!wndPtr) return FALSE;
1207     dprintf_scroll( stddeb, "ShowScrollBar: hwnd=%04x bar=%d on=%d\n",
1208                     hwnd, nBar, fShow );
1209
1210     switch(nBar)
1211     {
1212     case SB_CTL:
1213         ShowWindow32( hwnd, fShow ? SW_SHOW : SW_HIDE );
1214         return TRUE;
1215
1216     case SB_HORZ:
1217         if (fShow)
1218         {
1219             if (wndPtr->dwStyle & WS_HSCROLL) return TRUE;
1220             wndPtr->dwStyle |= WS_HSCROLL;
1221         }
1222         else  /* hide it */
1223         {
1224             if (!(wndPtr->dwStyle & WS_HSCROLL)) return TRUE;
1225             wndPtr->dwStyle &= ~WS_HSCROLL;
1226         }
1227         break;
1228
1229     case SB_VERT:
1230         if (fShow)
1231         {
1232             if (wndPtr->dwStyle & WS_VSCROLL) return TRUE;
1233             wndPtr->dwStyle |= WS_VSCROLL;
1234         }
1235         else  /* hide it */
1236         {
1237             if (!(wndPtr->dwStyle & WS_VSCROLL)) return TRUE;
1238             wndPtr->dwStyle &= ~WS_VSCROLL;
1239         }
1240         break;
1241
1242     case SB_BOTH:
1243         if (fShow)
1244         {
1245             if ((wndPtr->dwStyle & WS_HSCROLL)
1246                 && (wndPtr->dwStyle & WS_VSCROLL)) return TRUE;
1247             wndPtr->dwStyle |= WS_HSCROLL | WS_VSCROLL;
1248         }
1249         else  /* hide it */
1250         {
1251             if (!(wndPtr->dwStyle & WS_HSCROLL)
1252                 && !(wndPtr->dwStyle & WS_VSCROLL)) return TRUE;
1253             wndPtr->dwStyle &= ~(WS_HSCROLL | WS_VSCROLL);
1254         }
1255         break;
1256
1257     default:
1258         return TRUE;  /* Nothing to do! */
1259     }
1260     SetWindowPos32( hwnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
1261                     | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
1262     return TRUE;
1263 }
1264
1265
1266 /*************************************************************************
1267  *           EnableScrollBar16   (USER.482)
1268  */
1269 BOOL16 WINAPI EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
1270 {
1271     return EnableScrollBar32( hwnd, nBar, flags );
1272 }
1273
1274
1275 /*************************************************************************
1276  *           EnableScrollBar32   (USER32.170)
1277  */
1278 BOOL32 WINAPI EnableScrollBar32( HWND32 hwnd, INT32 nBar, UINT32 flags )
1279 {
1280     SCROLLBAR_INFO *infoPtr;
1281
1282     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return FALSE;
1283     dprintf_scroll( stddeb, "EnableScrollBar: %04x %d %d\n",
1284                     hwnd, nBar, flags );
1285     flags &= ESB_DISABLE_BOTH;
1286     if (infoPtr->flags == flags) return FALSE;
1287     infoPtr->flags = flags;
1288
1289     /* Redraw the whole scroll bar */
1290     SCROLL_RefreshScrollBar( hwnd, nBar, TRUE );
1291     return TRUE;
1292 }