Changeset 1511 for trunk/src


Ignore:
Timestamp:
Oct 29, 1999, 6:06:56 PM (26 years ago)
Author:
cbratschi
Message:

scrollbar updates

Location:
trunk/src/user32
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/oslibwin.cpp

    r1491 r1511  
    1 /* $Id: oslibwin.cpp,v 1.37 1999-10-28 15:20:25 sandervl Exp $ */
     1/* $Id: oslibwin.cpp,v 1.38 1999-10-29 16:06:55 cbratschi Exp $ */
    22/*
    33 * Window API wrappers for OS/2
    … …  
    926926//******************************************************************************
    927927//******************************************************************************
     928HWND OSLibWinQueryObjectWindow(VOID)
     929{
     930  return WinQueryObjectWindow(HWND_DESKTOP);
     931}
     932//******************************************************************************
     933//******************************************************************************
    928934BOOL OSLibWinShowScrollBar(HWND hwndParent, HWND hwndScroll, int scrollBar,
    929935                           BOOL fShow, BOOL fForceChange)
    930936{
     937   HWND hwndObj = WinQueryObjectWindow(HWND_DESKTOP),hwndCurPar = WinQueryWindow(hwndScroll,QW_PARENT);
     938
    931939   if(hwndScroll == NULL) {
    932940        dprintf(("OSLibWinShowScrollBar: scrollbar %d (parent %x) not found!", scrollBar, hwndParent));
    … …  
    934942   }
    935943
    936    if(fShow != WinIsWindowVisible(hwndScroll) || fForceChange)
     944   if ((fShow && hwndCurPar == hwndObj) || (!fShow && hwndCurPar != hwndObj) || fForceChange)
    937945   {
    938          WinSetParent(hwndScroll, fShow ? hwndParent : HWND_OBJECT, FALSE);
     946     //CB: bug: winhlp32: hide vert scrollbar on maximize doesn't update the frame
     947         WinSetParent(hwndScroll,fShow ? hwndParent:HWND_OBJECT,FALSE);
    939948         WinSendMsg(hwndParent, WM_UPDATEFRAME,
    940949                    MPFROMLONG( ( scrollBar == OSLIB_VSCROLL ) ? FCF_VERTSCROLL
    941950                                                               : FCF_HORZSCROLL),
    942951                    MPVOID );
    943 
    944          WinShowWindow(hwndScroll, fShow);
    945952   }
    946953   return TRUE;
    … …  
    10491056                    OSWinStyle);
    10501057
     1058  //CB: bug: it doesn't work with child windows!
     1059
    10511060  if(OSFrameStyle & FCF_TITLEBAR)
    10521061  {

  • trunk/src/user32/oslibwin.h

    r1446 r1511  
    1 /* $Id: oslibwin.h,v 1.21 1999-10-25 20:17:20 sandervl Exp $ */
     1/* $Id: oslibwin.h,v 1.22 1999-10-29 16:06:55 cbratschi Exp $ */
    22/*
    33 * Window API wrappers for OS/2
    … …  
    266266#define OSLIB_VSCROLL   1
    267267BOOL  OSLibWinEnableScrollBar(HWND hwndParent, int scrollBar, BOOL fEnable);
     268HWND  OSLibWinQueryObjectWindow(VOID);
    268269BOOL  OSLibWinShowScrollBar(HWND hwndParent, HWND hwndScroll, int scrollBar, BOOL fShow, BOOL fForceChange = FALSE);
    269270HWND  OSLibWinQueryScrollBarHandle(HWND hwndParent, int scrollBar);

  • trunk/src/user32/pmframe.cpp

    r1490 r1511  
    1 /* $Id: pmframe.cpp,v 1.12 1999-10-28 12:00:34 sandervl Exp $ */
     1/* $Id: pmframe.cpp,v 1.13 1999-10-29 16:06:55 cbratschi Exp $ */
    22/*
    33 * Win32 Frame Managment Code for OS/2
    … …  
    6767  DWORD dwStyle = win32wnd->getStyle();
    6868
     69  //CB: todo: switch to RGB mode and use win colors
    6970  clrWhite = CLR_WHITE;
    7071  clrBlack = CLR_BLACK;
    … …  
    144145  INT x;
    145146
     147  //CB: todo: switch to RGB mode and use win colors
    146148  WinFillRect(hps,&rect,SYSCLR_DIALOGBACKGROUND);
    147149  p1.x = rect.xRight-2;
    … …  
    198200        WinReleasePS(hps);
    199201    }
     202}
     203//******************************************************************************
     204//******************************************************************************
     205void FrameTrackFrame(Win32BaseWindow *win32wnd,BOOL lefttop)
     206{
     207  INT flags = lefttop ? (TF_LEFT | TF_TOP):(TF_RIGHT | TF_BOTTOM);
     208
     209  WinSendMsg(win32wnd->getOS2FrameWindowHandle(),WM_TRACKFRAME,(MPARAM)flags,(MPARAM)0);
    200210}
    201211//******************************************************************************

  • trunk/src/user32/pmframe.h

    r1248 r1511  
    1 /* $Id: pmframe.h,v 1.2 1999-10-11 16:04:51 cbratschi Exp $ */
     1/* $Id: pmframe.h,v 1.3 1999-10-29 16:06:55 cbratschi Exp $ */
    22/*
    33 * Win32 Frame Managment Code for OS/2
    … …  
    1212VOID  FrameSetBorderSize(Win32BaseWindow *win32wnd,BOOL resize);
    1313UINT  FrameGetDefSizeBorderSize(VOID);
     14VOID  FrameTrackFrame(Win32BaseWindow *win32wnd,BOOL lefttop);
    1415
    1516#endif

  • trunk/src/user32/scroll.cpp

    r1433 r1511  
    1 /* $Id: scroll.cpp,v 1.15 1999-10-24 22:56:07 sandervl Exp $ */
     1/* $Id: scroll.cpp,v 1.16 1999-10-29 16:06:56 cbratschi Exp $ */
    22/*
    33 * Scrollbar control
    … …  
    1818#include "oslibwin.h"
    1919#include "initterm.h"
    20 
    21 static BOOL bitmapsLoaded = FALSE;
    22 
    23 static HBITMAP hUpArrow = 0;
    24 static HBITMAP hDnArrow = 0;
    25 static HBITMAP hLfArrow = 0;
    26 static HBITMAP hRgArrow = 0;
    27 static HBITMAP hUpArrowD = 0;
    28 static HBITMAP hDnArrowD = 0;
    29 static HBITMAP hLfArrowD = 0;
    30 static HBITMAP hRgArrowD = 0;
    31 static HBITMAP hUpArrowI = 0;
    32 static HBITMAP hDnArrowI = 0;
    33 static HBITMAP hLfArrowI = 0;
    34 static HBITMAP hRgArrowI = 0;
    35 
    36 #define TOP_ARROW(flags,pressed) \
    37    (((flags)&ESB_DISABLE_UP) ? hUpArrowI : ((pressed) ? hUpArrowD:hUpArrow))
    38 #define BOTTOM_ARROW(flags,pressed) \
    39    (((flags)&ESB_DISABLE_DOWN) ? hDnArrowI : ((pressed) ? hDnArrowD:hDnArrow))
    40 #define LEFT_ARROW(flags,pressed) \
    41    (((flags)&ESB_DISABLE_LEFT) ? hLfArrowI : ((pressed) ? hLfArrowD:hLfArrow))
    42 #define RIGHT_ARROW(flags,pressed) \
    43    (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
     20#include "pmframe.h"
    4421
    4522#define SCROLL_MIN_RECT  4 /* Minimum size of the rectangle between the arrows */
    … …  
    6643};
    6744
    68  /* What to do after SCROLL_SetScrollInfo() */
     45 /* What to do in SetScrollInfo() */
    6946#define SA_SSI_HIDE             0x0001
    7047#define SA_SSI_SHOW             0x0002
    71 #define SA_SSI_REFRESH          0x0004
     48#define SA_SSI_REPAINT_INTERIOR 0x0004
    7249#define SA_SSI_REPAINT_ARROWS   0x0008
     50#define SA_SSI_MOVE_THUMB       0x0010
     51#define SA_SSI_REFRESH          0x0020
    7352
    7453 /* Thumb-tracking info */
    … …  
    8160static BOOL SCROLL_HasFocus    = FALSE;
    8261static BOOL SCROLL_Highlighted = FALSE;
     62static BOOL SCROLL_Scrolling   = FALSE;
    8363
    8464 /* Hit test code of the last button-down event */
    8565static enum SCROLL_HITTEST SCROLL_trackHitTest;
     66static enum SCROLL_HITTEST SCROLL_lastHitTest;
    8667static BOOL SCROLL_trackVertical;
    8768
    … …  
    8970static BOOL SCROLL_MovingThumb = FALSE;
    9071
    91  /* Local functions */
    92 static BOOL SCROLL_ShowScrollBar( HWND hwnd, INT nBar,
    93                                     BOOL fShowH, BOOL fShowV );
    94 static INT SCROLL_SetScrollInfo( HWND hwnd, INT nBar,
    95                                    const SCROLLINFO *info, INT *action );
    96 static void SCROLL_DrawInterior_9x( HWND hwnd, HDC hdc, INT nBar,
    97                     RECT *rect, INT arrowSize,
    98                     INT thumbSize, INT thumbPos,
    99                     UINT flags, BOOL vertical,
    100                     BOOL top_selected, BOOL bottom_selected );
    101 
    102 /***********************************************************************
    103  *           SCROLL_LoadBitmaps
    104  */
    105 static void SCROLL_LoadBitmaps(void)
    106 {
    107     if (bitmapsLoaded) return;
    108 
    109     hUpArrow  = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_UPARROW) );
    110     hDnArrow  = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_DNARROW) );
    111     hLfArrow  = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_LFARROW) );
    112     hRgArrow  = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_RGARROW) );
    113     hUpArrowD = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_UPARROWD) );
    114     hDnArrowD = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_DNARROWD) );
    115     hLfArrowD = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_LFARROWD) );
    116     hRgArrowD = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_RGARROWD) );
    117     hUpArrowI = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_UPARROWI) );
    118     hDnArrowI = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_DNARROWI) );
    119     hLfArrowI = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_LFARROWI) );
    120     hRgArrowI = LoadBitmapA( hInstanceUser32, MAKEINTRESOURCEA(OBM_RGARROWI) );
    121 
    122     bitmapsLoaded = TRUE;
    123 }
    124 
    125 /***********************************************************************
    126  *           SCROLL_GetInfoPtr
    127  */
     72// Get the scrollbar handle: works only with frame/control handles
     73
     74static HWND SCROLL_GetScrollHandle(HWND hwnd,INT nBar)
     75{
     76  switch(nBar)
     77  {
     78    case SB_HORZ:
     79    case SB_VERT:
     80      {
     81        Win32BaseWindow *win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
     82        if (!win32wnd) return 0;
     83        if (nBar == SB_HORZ) return  Win32BaseWindow::OS2ToWin32Handle(win32wnd->getHorzScrollHandle());
     84        else return  Win32BaseWindow::OS2ToWin32Handle(win32wnd->getVertScrollHandle());
     85      }
     86    case SB_CTL:
     87      return hwnd;
     88
     89    default:
     90      return 0;
     91  }
     92}
     93
     94static HWND SCROLL_GetFrameHandle(HWND hwnd)
     95{
     96  Win32BaseWindow *win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
     97
     98  if (!win32wnd) return 0;
     99  return Win32BaseWindow::GetWindowFromOS2FrameHandle(OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_OWNER))->getWindowHandle();
     100}
     101
     102// Get the infoPtr: works only with scrollbar handles
     103
    128104static SCROLLBAR_INFO *SCROLL_GetInfoPtr( HWND hwnd, INT nBar )
    129105{
    … …  
    137113          win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
    138114          if (!win32wnd) return NULL;
    139           hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_PARENT);
     115          hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_OWNER);
    140116          win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
    141117          if (!win32wnd) return NULL;
    … …  
    244220    if (vertical)
    245221    {
    246         rect.left -= lpRect->right - lpRect->left;
    247         rect.right += lpRect->right - lpRect->left;
    248     }
    249     else
    250     {
    251         rect.top -= lpRect->bottom - lpRect->top;
    252         rect.bottom += lpRect->bottom - lpRect->top;
    253     }
     222      INT w = lpRect->right-lpRect->left;
     223
     224      rect.left  -= w;
     225      rect.right += w;
     226    } else
     227    {
     228      INT h = lpRect->bottom-lpRect->top;
     229
     230      rect.top    -= h;
     231      rect.bottom += h;
     232    }
     233
    254234    return PtInRect( &rect, pt );
    255235}
    … …  
    293273}
    294274
    295 /***********************************************************************
    296  *           SCROLL_DrawArrows
    297  *
    298  * Draw the scroll bar arrows.
    299  */
    300 static void SCROLL_DrawArrows( HDC hdc, SCROLLBAR_INFO *infoPtr,
    301                                RECT *rect, INT arrowSize, BOOL vertical,
    302                                BOOL top_pressed, BOOL bottom_pressed )
     275static void SCROLL_DrawTopArrow(HDC hdc,SCROLLBAR_INFO *infoPtr,RECT *rect,INT arrowSize,BOOL vertical,BOOL top_pressed)
    303276{
    304277  RECT r;
    … …  
    314287            | (top_pressed ? (DFCS_PUSHED | DFCS_FLAT) : 0 )
    315288            | (infoPtr->flags&ESB_DISABLE_LTUP ? DFCS_INACTIVE : 0 ) );
     289}
     290
     291static void SCROLL_DrawBottomArrow(HDC hdc,SCROLLBAR_INFO *infoPtr,RECT *rect,INT arrowSize,BOOL vertical,BOOL bottom_pressed)
     292{
     293  RECT r;
    316294
    317295  r = *rect;
    … …  
    328306
    329307/***********************************************************************
    330  *           SCROLL_DrawMovingThumb
    331  *
    332  * Draw the moving thumb rectangle.
    333  */
    334 static void SCROLL_DrawMovingThumb( HDC hdc, RECT *rect, BOOL vertical,
    335                        INT arrowSize, INT thumbSize )
    336 {
    337   INT pos = SCROLL_TrackingPos;
    338   INT max_size;
    339 
    340   if( vertical )
    341     max_size = rect->bottom - rect->top;
    342   else
    343     max_size = rect->right - rect->left;
    344 
    345   max_size -= (arrowSize-SCROLL_ARROW_THUMB_OVERLAP) + thumbSize;
    346 
    347   if( pos < (arrowSize-SCROLL_ARROW_THUMB_OVERLAP) )
    348     pos = (arrowSize-SCROLL_ARROW_THUMB_OVERLAP);
    349   else if( pos > max_size )
    350     pos = max_size;
    351 
    352   SCROLL_DrawInterior_9x( SCROLL_TrackingWin, hdc, SCROLL_TrackingBar,
    353               rect, arrowSize, thumbSize, pos,
    354               0, vertical, FALSE, FALSE );
    355 
    356   SCROLL_MovingThumb = !SCROLL_MovingThumb;
     308 *           SCROLL_DrawArrows
     309 *
     310 * Draw the scroll bar arrows.
     311 */
     312static void SCROLL_DrawArrows( HDC hdc, SCROLLBAR_INFO *infoPtr,
     313                               RECT *rect, INT arrowSize, BOOL vertical,
     314                               BOOL top_pressed, BOOL bottom_pressed )
     315{
     316  SCROLL_DrawTopArrow(hdc,infoPtr,rect,arrowSize,vertical,top_pressed);
     317  SCROLL_DrawBottomArrow(hdc,infoPtr,rect,arrowSize,vertical,bottom_pressed);
    357318}
    358319
    … …  
    366327    HPEN hSavePen;
    367328    HBRUSH hSaveBrush,hBrush;
    368     BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
    369 
    370 //SCROLL_DrawInterior_9x(hwnd,hdc,nBar,rect,arrowSize,thumbSize,thumbPos,flags,vertical,top_selected,bottom_selected);
    371 //return; //CB: improve!
    372 
    373     if (Save_SCROLL_MovingThumb &&
    374         (SCROLL_TrackingWin == hwnd) &&
    375         (SCROLL_TrackingBar == nBar))
    376         SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
    377329
    378330      /* Select the correct brush and pen */
    … …  
    408360    }
    409361
    410       /* Draw the scroll rectangles and thumb */
    411 
    412     if (!thumbPos)  /* No thumb to draw */
    413     {
    414         INT offset = 0;
    415 
    416         PatBlt( hdc, r.left+offset, r.top+offset,
    417                      r.right - r.left - 2*offset, r.bottom - r.top - 2*offset,
    418                      PATCOPY );
    419 
    420         /* cleanup and return */
    421         SelectObject( hdc, hSavePen );
    422         SelectObject( hdc, hSaveBrush );
    423         return;
    424     }
    425 
    426     if (vertical)
    427     {
    428         INT offset = 0;
    429 
    430         PatBlt( hdc, r.left + offset, r.top + offset,
    431                   r.right - r.left - offset*2,
    432                   thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP) - offset,
    433                   top_selected ? 0x0f0000 : PATCOPY );
    434         r.top += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    435         PatBlt( hdc, r.left + offset, r.top + thumbSize,
    436                   r.right - r.left - offset*2,
    437                   r.bottom - r.top - thumbSize - offset,
    438                   bottom_selected ? 0x0f0000 : PATCOPY );
    439         r.bottom = r.top + thumbSize;
    440     }
    441     else  /* horizontal */
    442     {
    443         INT offset = 0;
    444 
    445         PatBlt( hdc, r.left + offset, r.top + offset,
    446                   thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
    447                   r.bottom - r.top - offset*2,
    448                   top_selected ? 0x0f0000 : PATCOPY );
    449         r.left += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    450         PatBlt( hdc, r.left + thumbSize, r.top + offset,
    451                   r.right - r.left - thumbSize - offset,
    452                   r.bottom - r.top - offset*2,
    453                   bottom_selected ? 0x0f0000 : PATCOPY );
    454         r.right = r.left + thumbSize;
    455     }
    456 
    457       /* Draw the thumb */
    458 
    459     SelectObject(hdc,(SCROLL_FocusWin == hwnd && SCROLL_Highlighted) ? GetSysColorBrush(COLOR_3DHILIGHT):GetSysColorBrush(COLOR_BTNFACE));
    460 
    461     Rectangle(hdc,r.left+1,r.top+1,r.right-1,r.bottom-1);
    462 
    463     DrawEdge( hdc, &r, EDGE_RAISED, BF_RECT );
    464 
    465     if (Save_SCROLL_MovingThumb &&
    466         (SCROLL_TrackingWin == hwnd) &&
    467         (SCROLL_TrackingBar == nBar))
    468         SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
    469 
    470     /* cleanup */
    471     SelectObject( hdc, hSavePen );
    472     SelectObject( hdc, hSaveBrush );
    473 }
    474 
    475 /***********************************************************************
    476  *           SCROLL_ClipPos
    477  */
    478 static POINT SCROLL_ClipPos( LPRECT lpRect, POINT pt )
    479 {
    480     if( pt.x < lpRect->left )
    481         pt.x = lpRect->left;
    482     else
    483     if( pt.x > lpRect->right )
    484         pt.x = lpRect->right;
    485 
    486     if( pt.y < lpRect->top )
    487         pt.y = lpRect->top;
    488     else
    489     if( pt.y > lpRect->bottom )
    490         pt.y = lpRect->bottom;
    491 
    492     return pt;
    493 }
    494 
    495 /***********************************************************************
    496  *           SCROLL_GetThumbVal
    497  *
    498  * Compute the current scroll position based on the thumb position in pixels
    499  * from the top of the scroll-bar.
    500  */
    501 static UINT SCROLL_GetThumbVal( SCROLLBAR_INFO *infoPtr, RECT *rect,
    502                                   BOOL vertical, INT pos )
    503 {
    504     INT thumbSize;
    505     INT pixels = vertical ? rect->bottom-rect->top : rect->right-rect->left;
    506 
    507     if ((pixels -= 2*(GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP)) <= 0)
    508         return infoPtr->MinVal;
    509 
    510     if (infoPtr->Page)
    511     {
    512         thumbSize = pixels * infoPtr->Page/(infoPtr->MaxVal-infoPtr->MinVal+1);
    513         if (thumbSize < SCROLL_MIN_THUMB) thumbSize = SCROLL_MIN_THUMB;
    514     }
    515     else thumbSize = GetSystemMetrics(SM_CXVSCROLL);
    516 
    517     if ((pixels -= thumbSize) <= 0) return infoPtr->MinVal;
    518 
    519     pos = MAX( 0, pos - (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP) );
    520     if (pos > pixels) pos = pixels;
    521 
    522     if (!infoPtr->Page) pos *= infoPtr->MaxVal - infoPtr->MinVal;
    523     else pos *= infoPtr->MaxVal - infoPtr->MinVal - infoPtr->Page + 1;
    524     return infoPtr->MinVal + ((pos + pixels / 2) / pixels);
    525 }
    526 
    527 /***********************************************************************
    528  *           SCROLL_DrawScrollBar
    529  *
    530  * Redraw the whole scrollbar.
    531  */
    532 void SCROLL_DrawScrollBar( HWND hwnd, HDC hdc, INT nBar,
    533                            BOOL arrows, BOOL interior )
    534 {
    535     INT arrowSize, thumbSize, thumbPos;
    536     RECT rect;
    537     BOOL vertical;
    538     SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
    539     BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
    540 
    541     if (nBar == SB_CTL)
    542     {
    543       DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
    544 
    545       if (dwStyle & (SBS_SIZEBOX | SBS_SIZEGRIP))
    546       {
    547         //CB: todo
    548 
    549         return;
    550       }
    551     }
    552 
    553     vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
    554                                         &arrowSize, &thumbSize, &thumbPos );
    555 
    556     if (Save_SCROLL_MovingThumb &&
    557         (SCROLL_TrackingWin == hwnd) &&
    558         (SCROLL_TrackingBar == nBar))
    559         SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
    560 
    561       /* Draw the arrows */
    562 
    563     if (arrows && arrowSize)
    564     {
    565         if( vertical == SCROLL_trackVertical && GetCapture() == hwnd )
    566             SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    567                                (SCROLL_trackHitTest == SCROLL_TOP_ARROW),
    568                                (SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW) );
    569         else
    570             SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    571                                                                FALSE, FALSE );
    572     }
    573     if( interior )
    574         SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
    575                          thumbPos, infoPtr->flags, vertical, FALSE, FALSE );
    576 
    577     if (Save_SCROLL_MovingThumb &&
    578         (SCROLL_TrackingWin == hwnd) &&
    579         (SCROLL_TrackingBar == nBar))
    580         SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
    581 
    582 }
    583 
    584 /***********************************************************************
    585  *           SCROLL_DrawInterior
    586  *
    587  * Draw the scroll bar interior (everything except the arrows).
    588  */
    589 static void SCROLL_DrawInterior_9x( HWND hwnd, HDC hdc, INT nBar,
    590                     RECT *rect, INT arrowSize,
    591                     INT thumbSize, INT thumbPos,
    592                     UINT flags, BOOL vertical,
    593                     BOOL top_selected, BOOL bottom_selected )
    594 {
    595     RECT r;
    596     HPEN hSavePen;
    597     HBRUSH hSaveBrush,hBrush;
    598 
    599     /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
    600      * The window-owned scrollbars need to call DEFWND_ControlColor
    601      * to correctly setup default scrollbar colors
    602      */
    603     if (nBar == SB_CTL)
    604     {
    605       hBrush = (HBRUSH)SendMessageA( GetParent(hwnd), WM_CTLCOLORSCROLLBAR,
    606                      (WPARAM)hdc,(LPARAM)hwnd);
    607     }
    608     else
    609     {
    610       hBrush = (HBRUSH)SendMessageA( hwnd, WM_CTLCOLORSCROLLBAR,
    611                      (WPARAM)hdc,(LPARAM)hwnd);
    612     }
    613 
    614     hSavePen = SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
    615     hSaveBrush = SelectObject( hdc, hBrush );
    616 
    617     /* Calculate the scroll rectangle */
    618     r = *rect;
    619     if (vertical)
    620     {
    621         r.top    += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
    622         r.bottom -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    623     }
    624     else
    625     {
    626         r.left  += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
    627         r.right -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    628     }
    629 
    630362    /* Draw the scroll rectangles and thumb */
    631363    if (!thumbPos)  /* No thumb to draw */
    … …  
    669401
    670402    /* Draw the thumb */
    671     DrawEdge( hdc, &r, EDGE_RAISED, BF_RECT | BF_MIDDLE  );
     403
     404    DrawEdge(hdc,&r,EDGE_RAISED,BF_RECT | BF_ADJUST);
     405    FillRect(hdc,&r,(SCROLL_FocusWin == hwnd && SCROLL_Highlighted && !SCROLL_Scrolling) ? GetSysColorBrush(COLOR_3DSHADOW):GetSysColorBrush(COLOR_BTNFACE));
    672406
    673407    /* cleanup */
    … …  
    677411
    678412/***********************************************************************
     413 *           SCROLL_DrawMovingThumb
     414 *
     415 * Draw the moving thumb rectangle.
     416 */
     417static void SCROLL_DrawMovingThumb( HDC hdc, RECT *rect, BOOL vertical,
     418                       INT arrowSize, INT thumbSize )
     419{
     420  INT pos = SCROLL_TrackingPos;
     421  INT max_size;
     422
     423  if( vertical )
     424    max_size = rect->bottom - rect->top;
     425  else
     426    max_size = rect->right - rect->left;
     427
     428  max_size -= (arrowSize-SCROLL_ARROW_THUMB_OVERLAP) + thumbSize;
     429
     430  if( pos < (arrowSize-SCROLL_ARROW_THUMB_OVERLAP) )
     431    pos = (arrowSize-SCROLL_ARROW_THUMB_OVERLAP);
     432  else if( pos > max_size )
     433    pos = max_size;
     434
     435  SCROLL_DrawInterior( SCROLL_TrackingWin, hdc, SCROLL_TrackingBar,
     436              rect, arrowSize, thumbSize, pos,
     437              0, vertical, FALSE, FALSE );
     438}
     439
     440/***********************************************************************
     441 *           SCROLL_ClipPos
     442 */
     443static POINT SCROLL_ClipPos( LPRECT lpRect, POINT pt )
     444{
     445    if( pt.x < lpRect->left )
     446        pt.x = lpRect->left;
     447    else
     448    if( pt.x >= lpRect->right )
     449        pt.x = lpRect->right-1;
     450
     451    if( pt.y < lpRect->top )
     452        pt.y = lpRect->top;
     453    else
     454    if( pt.y >= lpRect->bottom )
     455        pt.y = lpRect->bottom-1;
     456
     457    return pt;
     458}
     459
     460/***********************************************************************
     461 *           SCROLL_GetThumbVal
     462 *
     463 * Compute the current scroll position based on the thumb position in pixels
     464 * from the top of the scroll-bar.
     465 */
     466static UINT SCROLL_GetThumbVal( SCROLLBAR_INFO *infoPtr, RECT *rect,
     467                                  BOOL vertical, INT pos )
     468{
     469    INT thumbSize;
     470    INT pixels = vertical ? rect->bottom-rect->top : rect->right-rect->left;
     471
     472    if ((pixels -= 2*(GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP)) <= 0)
     473        return infoPtr->MinVal;
     474
     475    if (infoPtr->Page)
     476    {
     477        thumbSize = pixels * infoPtr->Page/(infoPtr->MaxVal-infoPtr->MinVal+1);
     478        if (thumbSize < SCROLL_MIN_THUMB) thumbSize = SCROLL_MIN_THUMB;
     479    }
     480    else thumbSize = GetSystemMetrics(SM_CXVSCROLL);
     481
     482    if ((pixels -= thumbSize) <= 0) return infoPtr->MinVal;
     483
     484    pos = MAX( 0, pos - (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP) );
     485    if (pos > pixels) pos = pixels;
     486
     487    if (!infoPtr->Page) pos *= infoPtr->MaxVal - infoPtr->MinVal;
     488    else pos *= infoPtr->MaxVal - infoPtr->MinVal - infoPtr->Page + 1;
     489    return infoPtr->MinVal + ((pos + pixels / 2) / pixels);
     490}
     491
     492void SCROLL_GetSizeBox(HWND hwnd,DWORD dwStyle,PRECT rect)
     493{
     494  RECT clientRect;
     495  INT cx = GetSystemMetrics(SM_CXVSCROLL);
     496  INT cy = GetSystemMetrics(SM_CYHSCROLL);
     497
     498  GetClientRect(hwnd,&clientRect);
     499
     500  if (dwStyle & SBS_SIZEBOXTOPLEFTALIGN)
     501  {
     502    rect->left   = 0;
     503    rect->right  = cx;
     504    rect->bottom = cy;
     505    rect->top    = 0;
     506  } else
     507  {
     508    rect->left   = clientRect.right-cx;
     509    rect->right  = clientRect.right;
     510    rect->bottom = clientRect.bottom;
     511    rect->top    = clientRect.bottom-cy;
     512  }
     513}
     514
     515void SCROLL_DrawSizeBox(HDC hdc,RECT rect)
     516{
     517  POINT p1,p2;
     518  HPEN penDark = GetSysColorPen(COLOR_3DSHADOW);
     519  HPEN penWhite = GetSysColorPen(COLOR_3DHILIGHT);
     520  HPEN oldPen = SelectObject(hdc,penDark);
     521  INT x;
     522
     523  p1.x = rect.right-2;
     524  p1.y = rect.bottom;
     525  p2.x = rect.right-1;
     526  p2.y = rect.bottom-1;
     527  for (x = 0;x < 3;x++)
     528  {
     529    SelectObject(hdc,penDark);
     530    MoveToEx(hdc,p1.x,p1.y,NULL);
     531    LineTo(hdc,p2.x,p2.y);
     532    p1.x--;
     533    p2.y--;
     534    MoveToEx(hdc,p1.x,p1.y,NULL);
     535    LineTo(hdc,p2.x,p2.y);
     536    SelectObject(hdc,penWhite);
     537    p1.x--;
     538    p2.y--;
     539    MoveToEx(hdc,p1.x,p1.y,NULL);
     540    LineTo(hdc,p2.x,p2.y);
     541    p1.x -= 2;
     542    p2.y -= 2;
     543  }
     544
     545  SelectObject(hdc,oldPen);
     546}
     547
     548/***********************************************************************
     549 *           SCROLL_DrawScrollBar
     550 *
     551 * Redraw the whole scrollbar.
     552 */
     553void SCROLL_DrawScrollBar( HWND hwnd, HDC hdc, INT nBar,
     554                           BOOL arrows, BOOL interior )
     555{
     556    INT arrowSize, thumbSize, thumbPos;
     557    RECT rect;
     558    BOOL vertical;
     559    SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
     560
     561    if (!infoPtr) return;
     562    if (nBar == SB_CTL)
     563    {
     564      DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     565
     566      if (dwStyle & (SBS_SIZEBOX | SBS_SIZEGRIP))
     567      {
     568        RECT rect;
     569        HBRUSH hBrush;
     570
     571        hdc = GetDC(hwnd);
     572        hBrush = GetSysColorBrush(COLOR_3DFACE);
     573        GetClientRect(hwnd,&rect);
     574        FillRect(hdc,&rect,hBrush);
     575
     576        if (dwStyle & SBS_SIZEGRIP)
     577        {
     578          SCROLL_GetSizeBox(hwnd,dwStyle,&rect);
     579          SCROLL_DrawSizeBox(hdc,rect);
     580        }
     581
     582        ReleaseDC(hwnd,hdc);
     583
     584        return;
     585      }
     586    }
     587
     588    vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
     589                                        &arrowSize, &thumbSize, &thumbPos );
     590
     591      /* Draw the arrows */
     592
     593    if (arrows && arrowSize)
     594    {
     595        if( vertical == SCROLL_trackVertical && GetCapture() == hwnd )
     596            SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
     597                               (SCROLL_trackHitTest == SCROLL_TOP_ARROW),
     598                               (SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW) );
     599        else
     600            SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
     601                                                               FALSE, FALSE );
     602    }
     603
     604    if (SCROLL_MovingThumb &&
     605        (SCROLL_TrackingWin == hwnd) &&
     606        (SCROLL_TrackingBar == nBar))
     607        SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
     608    else if( interior )
     609      SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
     610                           thumbPos, infoPtr->flags, vertical, SCROLL_trackHitTest == SCROLL_TOP_RECT && SCROLL_lastHitTest == SCROLL_TOP_RECT,SCROLL_trackHitTest == SCROLL_BOTTOM_RECT && SCROLL_lastHitTest == SCROLL_BOTTOM_RECT);
     611}
     612
     613/***********************************************************************
    679614 *           SCROLL_RefreshScrollBar
    680615 *
    … …  
    686621{
    687622  Win32BaseWindow *window;
    688   HWND hwndScroll;
    689623  HDC hdc;
    690624
    691     //SvL: Get scrollbar handle from parent window
    692     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    693     if(!window && nBar != SB_CTL) {
    694         dprintf(("SCROLL_RefreshScrollBar window %x not found!", hwnd));
    695         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
    696         return;
    697     }
    698     if(nBar == SB_VERT)
    699     {
    700         hwndScroll = Win32BaseWindow::OS2ToWin32Handle(window->getVertScrollHandle());
    701     }
    702     else
    703     if(nBar == SB_HORZ)
    704     {
    705         hwndScroll = Win32BaseWindow::OS2ToWin32Handle(window->getHorzScrollHandle());
    706     }
    707     else hwndScroll = hwnd;
    708 
    709     if(hwndScroll == 0)
    710         return;
    711 
    712     hdc = GetDCEx( hwndScroll, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
     625    hdc = GetDCEx( hwnd, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
    713626
    714627    if (!hdc) return;
    715628
    716     SCROLL_DrawScrollBar( hwndScroll, hdc, nBar, arrows, interior );
    717     ReleaseDC( hwndScroll, hdc );
     629    SCROLL_DrawScrollBar( hwnd, hdc, nBar, arrows, interior );
     630    ReleaseDC( hwnd, hdc );
    718631}
    719632
    … …  
    730643  SetInfoPtr(hwnd,(DWORD)infoPtr);
    731644
    732   if (!bitmapsLoaded) SCROLL_LoadBitmaps();
    733 
    734645  return TRUE;
    735646}
    … …  
    739650  CREATESTRUCTA *lpCreat = (CREATESTRUCTA *)lParam;
    740651
    741   if (lpCreat->style & SBS_VERT)
     652  if (!(lpCreat->style & (SBS_SIZEBOX | SBS_SIZEGRIP)) && lpCreat->style & (SBS_LEFTALIGN | SBS_RIGHTALIGN))
    742653  {
    743     if (lpCreat->style & SBS_LEFTALIGN)
    744       MoveWindow( hwnd, lpCreat->x, lpCreat->y,
    745                                   GetSystemMetrics(SM_CXVSCROLL), lpCreat->cy, FALSE );
    746     else if (lpCreat->style & SBS_RIGHTALIGN)
    747       MoveWindow( hwnd,
    748                   lpCreat->x+lpCreat->cx-GetSystemMetrics(SM_CXVSCROLL)-1,
    749                   lpCreat->y,
    750                   GetSystemMetrics(SM_CXVSCROLL), lpCreat->cy, FALSE );
    751   } else  /* SBS_HORZ */
    752   {
    753     if (lpCreat->style & SBS_TOPALIGN)
    754       MoveWindow( hwnd, lpCreat->x, lpCreat->y,
    755                   lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL), FALSE );
    756     else if (lpCreat->style & SBS_BOTTOMALIGN)
    757       MoveWindow( hwnd,
    758                   lpCreat->x,
    759                   lpCreat->y+lpCreat->cy-GetSystemMetrics(SM_CYHSCROLL)-1,
    760                   lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL), FALSE );
     654    if (lpCreat->style & SBS_VERT)
     655    {
     656      INT w,h;
     657
     658      w = GetSystemMetrics(SM_CXVSCROLL);
     659      h = lpCreat->cy;
     660
     661      if (lpCreat->style & SBS_LEFTALIGN)
     662        MoveWindow(hwnd,lpCreat->x,lpCreat->y,w,h,FALSE);
     663      else if (lpCreat->style & SBS_RIGHTALIGN)
     664        MoveWindow(hwnd,lpCreat->x+lpCreat->cx-w,lpCreat->y,w,h,FALSE);
     665    } else /* SBS_HORZ */
     666    {
     667      INT w,h;
     668
     669      w = lpCreat->cx;
     670      h = GetSystemMetrics(SM_CYHSCROLL);
     671
     672      if (lpCreat->style & SBS_TOPALIGN)
     673        MoveWindow(hwnd,lpCreat->x,lpCreat->y,w,h,FALSE);
     674      else if (lpCreat->style & SBS_BOTTOMALIGN)
     675        MoveWindow(hwnd,lpCreat->x,lpCreat->y+lpCreat->cy-h,w,h,FALSE);
     676    }
    761677  }
    762678
    … …  
    777693    static INT lastClickPos;   /* Position in the scroll-bar of the last button-down event. */
    778694    static INT lastMousePos;   /* Position in the scroll-bar of the last mouse event. */
     695    static BOOL timerRunning;
    779696
    780697    enum SCROLL_HITTEST hittest;
    … …  
    796713      if ((dwStyle & (SBS_SIZEBOX | SBS_SIZEGRIP)))
    797714      {
    798         //CB: todo
     715        if (!(dwStyle & SBS_SIZEGRIP)) return res;
     716
     717        if (msg == WM_MOUSEMOVE)
     718        {
     719          RECT rect;
     720
     721          SCROLL_GetSizeBox(hwnd,dwStyle,&rect);
     722          pt.x = (SHORT)LOWORD(lParam);
     723          pt.y = (SHORT)HIWORD(lParam);
     724
     725          if (PtInRect(&rect,pt))
     726          {
     727            SetCursor(LoadCursorA(0,IDC_SIZENWSEA));
     728            return 0;
     729          }
     730        } else if (msg == WM_LBUTTONDOWN)
     731        {
     732          if (dwStyle & SBS_SIZEGRIP)
     733          {
     734            RECT rect;
     735
     736            pt.x = (SHORT)LOWORD(lParam);
     737            pt.y = (SHORT)HIWORD(lParam);
     738            SCROLL_GetSizeBox(hwnd,dwStyle,&rect);
     739            if (PtInRect(&rect,pt))
     740            {
     741              HWND hwndFrame;
     742
     743              Win32BaseWindow *win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
     744              if (!win32wnd) return res;
     745              hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_OWNER);
     746              win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
     747              if (!win32wnd) return res;
     748              FrameTrackFrame(win32wnd,dwStyle & SBS_SIZEBOXTOPLEFTALIGN);
     749            }
     750          }
     751        }
    799752
    800753        return res;
    … …  
    802755    }
    803756
    804     if ((SCROLL_trackHitTest == SCROLL_NOWHERE) && (msg == WM_MOUSEMOVE || msg == WM_LBUTTONUP))
     757    if ((SCROLL_trackHitTest == SCROLL_NOWHERE) && (msg == WM_MOUSEMOVE || msg == WM_LBUTTONUP || msg == WM_CAPTURECHANGED))
    805758      return res;
    806759
    … …  
    814767      win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
    815768      if (!win32wnd) return res;
    816       hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_PARENT);
     769      hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_OWNER);
    817770      win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
    818771      if (!win32wnd) return res;
    … …  
    829782        SCROLL_trackVertical = vertical;
    830783        SCROLL_trackHitTest  = hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
    831         lastClickPos  = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
     784        SCROLL_Scrolling = TRUE;
     785        timerRunning = FALSE;
     786        if (SCROLL_FocusWin == hwnd && SCROLL_Highlighted)
     787        {
     788          hdc = GetDCEx(hwnd,0,DCX_CACHE);
     789          SCROLL_DrawScrollBar(hwnd,hdc,nBar,FALSE,TRUE);
     790          ReleaseDC(hwnd,hdc);
     791        }
     792        lastClickPos  = vertical ? pt.y:pt.x;
    832793        lastMousePos  = lastClickPos;
    833794        trackThumbPos = thumbPos;
    … …  
    849810        hittest = SCROLL_NOWHERE;
    850811        ReleaseCapture();
     812        SCROLL_Scrolling = FALSE;
     813        break;
     814
     815      case WM_CAPTURECHANGED:
     816        hittest = SCROLL_NOWHERE;
     817        SCROLL_Scrolling = FALSE;
    851818        break;
    852819
    … …  
    886853        {
    887854          SCROLL_Highlighted = ~SCROLL_Highlighted;
    888           hdc = GetDCEx(hwnd,0,DCX_CACHE);
    889           SCROLL_DrawScrollBar(hwnd,hdc,nBar,FALSE,TRUE);
    890           ReleaseDC(hwnd,hdc);
     855          if (!SCROLL_Scrolling)
     856          {
     857            hdc = GetDCEx(hwnd,0,DCX_CACHE);
     858            SCROLL_DrawScrollBar(hwnd,hdc,nBar,FALSE,TRUE);
     859            ReleaseDC(hwnd,hdc);
     860          }
    891861          return res;
    892862        } else return res;
    … …  
    907877
    908878      case SCROLL_TOP_ARROW:
    909         SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    910                            (hittest == SCROLL_trackHitTest), FALSE );
    911         if (hittest == SCROLL_trackHitTest)
    912         {
    913             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
    914             {
    915                 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    916                                 SB_LINEUP, hwndCtl );
    917             }
    918             SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    919                             SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    920                             (TIMERPROC)0 );
    921         }
    922         else KillSystemTimer( hwnd, SCROLL_TIMER );
     879        if (msg == WM_LBUTTONUP)
     880          KillSystemTimer(hwnd,SCROLL_TIMER);
     881        else if (msg == WM_LBUTTONDOWN || !timerRunning)
     882        {
     883          SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     884                          SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     885                          (TIMERPROC)0 );
     886          if (msg != WM_LBUTTONDOWN) timerRunning = TRUE;
     887        }
     888
     889        if (msg == WM_LBUTTONDOWN || SCROLL_lastHitTest != hittest)
     890        {
     891          SCROLL_DrawTopArrow(hdc,infoPtr,&rect,arrowSize,vertical,(hittest == SCROLL_trackHitTest));
     892          SCROLL_lastHitTest = hittest;
     893        }
     894        if (hittest == SCROLL_trackHitTest && (msg == WM_LBUTTONDOWN || msg == WM_SYSTIMER))
     895          SendMessageA(hwndOwner,vertical ? WM_VSCROLL:WM_HSCROLL,SB_LINEUP,hwndCtl);
     896
    923897        break;
    924898
    925899      case SCROLL_TOP_RECT:
    926         SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
     900        if (msg == WM_LBUTTONUP)
     901          KillSystemTimer(hwnd,SCROLL_TIMER);
     902        else if (msg == WM_LBUTTONDOWN || !timerRunning)
     903        {
     904          SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     905                          SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     906                          (TIMERPROC)0 );
     907          if (msg != WM_LBUTTONDOWN) timerRunning = TRUE;
     908        }
     909
     910        if (msg == WM_LBUTTONDOWN || SCROLL_lastHitTest != hittest)
     911        {
     912          SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
    927913                             thumbPos, infoPtr->flags, vertical,
    928914                             (hittest == SCROLL_trackHitTest), FALSE );
    929         if (hittest == SCROLL_trackHitTest)
    930         {
    931             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
    932             {
    933                 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    934                                 SB_PAGEUP, hwndCtl );
    935                 SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    936                                 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    937                                 (TIMERPROC)0 );
    938             }
    939         }
    940         else KillSystemTimer( hwnd, SCROLL_TIMER );
     915          SCROLL_lastHitTest = hittest;
     916        }
     917
     918        if (hittest == SCROLL_trackHitTest && (msg == WM_LBUTTONDOWN || msg == WM_SYSTIMER))
     919          SendMessageA(hwndOwner,vertical ? WM_VSCROLL:WM_HSCROLL,SB_PAGEUP,hwndCtl);
     920
    941921        break;
    942922
    … …  
    947927            SCROLL_TrackingBar = nBar;
    948928            SCROLL_TrackingPos = trackThumbPos + lastMousePos - lastClickPos;
    949             if (!SCROLL_MovingThumb)
    950                 SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
    951         }
    952         else if (msg == WM_LBUTTONUP)
    953         {
    954             if (SCROLL_MovingThumb)
    955                 SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
    956             SCROLL_TrackingWin = 0;
     929            SCROLL_MovingThumb = TRUE;
     930            SCROLL_DrawMovingThumb(hdc, &rect, vertical, arrowSize, thumbSize);
     931        } else if (msg == WM_LBUTTONUP || msg == WM_CAPTURECHANGED)
     932        {
     933          UINT val;
     934          INT oldPos = infoPtr->CurVal;
     935
     936          SCROLL_MovingThumb = FALSE;
     937          SCROLL_TrackingWin = 0;
     938          val = SCROLL_GetThumbVal( infoPtr, &rect, vertical,
     939                                    trackThumbPos + lastMousePos - lastClickPos );
     940          SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
     941                        MAKEWPARAM( SB_THUMBPOSITION, val ), hwndCtl );
     942
     943          if (oldPos == infoPtr->CurVal)
    957944            SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
    958945                                 thumbPos, infoPtr->flags, vertical,
    959946                                 FALSE, FALSE );
    960         }
    961         else  /* WM_MOUSEMOVE */
     947        } else if (msg == WM_MOUSEMOVE)
    962948        {
    963949            UINT pos;
    … …  
    967953            {
    968954                pt = SCROLL_ClipPos( &rect, pt );
    969                 pos = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
     955                pos = vertical ? pt.y:pt.x;
    970956            }
    971             if ( (pos != lastMousePos) || (!SCROLL_MovingThumb) )
     957            if (pos != lastMousePos)
    972958            {
    973                 if (SCROLL_MovingThumb)
    974                     SCROLL_DrawMovingThumb( hdc, &rect, vertical,
    975                                         arrowSize, thumbSize );
    976959                lastMousePos = pos;
    977960                SCROLL_TrackingPos = trackThumbPos + pos - lastClickPos;
    … …  
    979962                                                         vertical,
    980963                                                         SCROLL_TrackingPos );
     964                SCROLL_DrawMovingThumb( hdc, &rect, vertical,
     965                                        arrowSize, thumbSize );
    981966                SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    982967                                MAKEWPARAM( SB_THUMBTRACK, SCROLL_TrackingVal),
    983968                                hwndCtl );
    984                 if (!SCROLL_MovingThumb)
    985                     SCROLL_DrawMovingThumb( hdc, &rect, vertical,
    986                                         arrowSize, thumbSize );
    987969            }
    988970        }
    … …  
    990972
    991973      case SCROLL_BOTTOM_RECT:
    992         SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
    993                              thumbPos, infoPtr->flags, vertical,
    994                              FALSE, (hittest == SCROLL_trackHitTest) );
    995         if (hittest == SCROLL_trackHitTest)
    996         {
    997             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
    998             {
    999                 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    1000                                 SB_PAGEDOWN, hwndCtl );
    1001                 SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    1002                                 SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    1003                                 (TIMERPROC)0 );
    1004             }
    1005         }
    1006         else KillSystemTimer( hwnd, SCROLL_TIMER );
     974        if (msg == WM_LBUTTONUP)
     975          KillSystemTimer(hwnd,SCROLL_TIMER);
     976        else if (msg == WM_LBUTTONDOWN || !timerRunning)
     977        {
     978          SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     979                          SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     980                          (TIMERPROC)0 );
     981          if (msg != WM_LBUTTONDOWN) timerRunning = TRUE;
     982        }
     983
     984        if (msg == WM_LBUTTONDOWN || SCROLL_lastHitTest != hittest)
     985        {
     986          SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
     987                               thumbPos, infoPtr->flags, vertical,
     988                               FALSE, (hittest == SCROLL_trackHitTest) );
     989          SCROLL_lastHitTest = hittest;
     990        }
     991
     992        if (hittest == SCROLL_trackHitTest && (msg == WM_LBUTTONDOWN || msg == WM_SYSTIMER))
     993          SendMessageA(hwndOwner,vertical ? WM_VSCROLL:WM_HSCROLL,SB_PAGEDOWN,hwndCtl);
     994
    1007995        break;
    1008996
    1009997      case SCROLL_BOTTOM_ARROW:
    1010         SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    1011                            FALSE, (hittest == SCROLL_trackHitTest) );
    1012         if (hittest == SCROLL_trackHitTest)
    1013         {
    1014             if ((msg == WM_LBUTTONDOWN) || (msg == WM_SYSTIMER))
    1015             {
    1016                 SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    1017                                 SB_LINEDOWN, hwndCtl );
    1018             }
    1019             SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    1020                             SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    1021                             (TIMERPROC)0 );
    1022         }
    1023         else KillSystemTimer( hwnd, SCROLL_TIMER );
     998        if (msg == WM_LBUTTONUP)
     999          KillSystemTimer(hwnd,SCROLL_TIMER);
     1000        else if (msg == WM_LBUTTONDOWN || !timerRunning)
     1001        {
     1002          SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     1003                          SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     1004                          (TIMERPROC)0 );
     1005          if (msg != WM_LBUTTONDOWN) timerRunning = TRUE;
     1006        }
     1007
     1008        if (msg == WM_LBUTTONDOWN || SCROLL_lastHitTest != hittest)
     1009        {
     1010          SCROLL_DrawBottomArrow(hdc,infoPtr,&rect,arrowSize,vertical,(hittest == SCROLL_trackHitTest));
     1011          SCROLL_lastHitTest = hittest;
     1012        }
     1013        if (hittest == SCROLL_trackHitTest && (msg == WM_LBUTTONDOWN || msg == WM_SYSTIMER))
     1014          SendMessageA(hwndOwner,vertical ? WM_VSCROLL:WM_HSCROLL,SB_LINEDOWN,hwndCtl);
     1015
    10241016        break;
    10251017    }
    10261018
    1027     if (msg == WM_LBUTTONUP)
     1019    if (msg == WM_LBUTTONUP || msg == WM_CAPTURECHANGED)
    10281020    {
    10291021        hittest = SCROLL_trackHitTest;
    10301022        SCROLL_trackHitTest = SCROLL_NOWHERE;  /* Terminate tracking */
    10311023
    1032         if (hittest == SCROLL_THUMB)
    1033         {
    1034             UINT val = SCROLL_GetThumbVal( infoPtr, &rect, vertical,
    1035                                  trackThumbPos + lastMousePos - lastClickPos );
    1036             SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    1037                             MAKEWPARAM( SB_THUMBPOSITION, val ), hwndCtl );
    1038         }
    1039         else
    1040             SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    1041                             SB_ENDSCROLL, hwndCtl );
     1024        if (hittest != SCROLL_THUMB)
     1025          SendMessageA(hwndOwner,vertical ? WM_VSCROLL:WM_HSCROLL,SB_ENDSCROLL,hwndCtl);
    10421026    }
    10431027
    … …  
    10931077  INT oldPos = infoPtr->CurVal;
    10941078
    1095   SetScrollRange(hwnd,nBar,wParam,lParam,redraw);
     1079  SetScrollRange((nBar == SB_CTL) ? hwnd:SCROLL_GetFrameHandle(hwnd),nBar,wParam,lParam,redraw);
    10961080  return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
    10971081}
    … …  
    11151099    case WM_LBUTTONDOWN:
    11161100    case WM_LBUTTONUP:
     1101    case WM_CAPTURECHANGED:
    11171102    case WM_MOUSEMOVE:
    11181103    case WM_SYSTIMER:
    … …  
    11531138
    11541139    case SBM_SETSCROLLINFO:
    1155       return SetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam, wParam );
     1140      return SetScrollInfo(hwnd,SB_CTL,(SCROLLINFO*)lParam,wParam);
    11561141
    11571142    case SBM_GETSCROLLINFO:
    … …  
    11831168  if (hwndHorz) SetWindowLongA(hwndHorz,GWL_WNDPROC,(ULONG)HorzScrollBarWndProc);
    11841169  if (hwndVert) SetWindowLongA(hwndVert,GWL_WNDPROC,(ULONG)VertScrollBarWndProc);
    1185 
    1186   if (!bitmapsLoaded) SCROLL_LoadBitmaps();
    11871170}
    11881171
    … …  
    11931176    case WM_LBUTTONDOWN:
    11941177    case WM_LBUTTONUP:
     1178    case WM_CAPTURECHANGED:
    11951179    case WM_MOUSEMOVE:
    11961180    case WM_SYSTIMER:
    … …  
    12091193
    12101194    case SBM_SETPOS:
    1211       return SetScrollPos( hwnd, SB_HORZ, wParam, (BOOL)lParam );
     1195      return SetScrollPos(SCROLL_GetFrameHandle(hwnd),SB_HORZ,wParam,(BOOL)lParam);
    12121196
    12131197    case SBM_GETPOS:
    1214       return GetScrollPos( hwnd, SB_HORZ );
     1198      return GetScrollPos(SCROLL_GetFrameHandle(hwnd),SB_HORZ);
    12151199
    12161200    case SBM_SETRANGE:
    … …  
    12181202
    12191203    case SBM_GETRANGE:
    1220       GetScrollRange( hwnd, SB_HORZ, (LPINT)wParam, (LPINT)lParam );
     1204      GetScrollRange(SCROLL_GetFrameHandle(hwnd),SB_HORZ,(LPINT)wParam,(LPINT)lParam);
    12211205      return 0;
    12221206
    12231207    case SBM_ENABLE_ARROWS:
    1224       return EnableScrollBar( hwnd, SB_HORZ, wParam );
     1208      return EnableScrollBar(SCROLL_GetFrameHandle(hwnd),SB_HORZ,wParam);
    12251209
    12261210    case SBM_SETRANGEREDRAW:
    … …  
    12281212
    12291213    case SBM_SETSCROLLINFO:
    1230       return SetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam, wParam );
     1214      return SetScrollInfo(SCROLL_GetFrameHandle(hwnd),SB_HORZ,(SCROLLINFO*)lParam,wParam);
    12311215
    12321216    case SBM_GETSCROLLINFO:
    1233       return GetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam );
     1217      return GetScrollInfo(SCROLL_GetFrameHandle(hwnd),SB_HORZ,(SCROLLINFO*)lParam);
    12341218
    12351219    default:
    … …  
    12461230    case WM_LBUTTONDOWN:
    12471231    case WM_LBUTTONUP:
     1232    case WM_CAPTURECHANGED:
    12481233    case WM_MOUSEMOVE:
    12491234    case WM_SYSTIMER:
    … …  
    12621247
    12631248    case SBM_SETPOS:
    1264       return SetScrollPos( hwnd, SB_VERT, wParam, (BOOL)lParam );
     1249      return SetScrollPos(SCROLL_GetFrameHandle(hwnd),SB_VERT,wParam,(BOOL)lParam);
    12651250
    12661251    case SBM_GETPOS:
    1267       return GetScrollPos( hwnd, SB_VERT );
     1252      return GetScrollPos(SCROLL_GetFrameHandle(hwnd),SB_VERT);
    12681253
    12691254    case SBM_SETRANGE:
    … …  
    12711256
    12721257    case SBM_GETRANGE:
    1273       GetScrollRange( hwnd, SB_VERT, (LPINT)wParam, (LPINT)lParam );
     1258      GetScrollRange(SCROLL_GetFrameHandle(hwnd),SB_VERT,(LPINT)wParam,(LPINT)lParam);
    12741259      return 0;
    12751260
    12761261    case SBM_ENABLE_ARROWS:
    1277       return EnableScrollBar( hwnd, SB_VERT, wParam );
     1262      return EnableScrollBar(SCROLL_GetFrameHandle(hwnd),SB_VERT,wParam);
    12781263
    12791264    case SBM_SETRANGEREDRAW:
    … …  
    12811266
    12821267    case SBM_SETSCROLLINFO:
    1283       return SetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam, wParam );
     1268      return SetScrollInfo(SCROLL_GetFrameHandle(hwnd),SB_VERT,(SCROLLINFO*)lParam,wParam);
    12841269
    12851270    case SBM_GETSCROLLINFO:
    1286       return GetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam );
     1271      return GetScrollInfo(SCROLL_GetFrameHandle(hwnd),SB_VERT,(SCROLLINFO*)lParam);
    12871272
    12881273    default:
    … …  
    12951280/* Scrollbar API */
    12961281
    1297 //CB: fix hide/show bugs
    1298 
    12991282/*************************************************************************
    1300  *           SetScrollInfo32   (USER32.501)
     1283 *           SetScrollInfo   (USER32.501)
    13011284 * SetScrollInfo32 can be used to set the position, upper bound,
    13021285 * lower bound, and page size of a scrollbar control.
    … …  
    13111294 *  the text), and info->nPage=25.
    13121295 */
    1313 INT WINAPI SetScrollInfo(
    1314                 HWND hwnd /* [I] Handle of window whose scrollbar will be affected */,
    1315                 INT nBar /* [I] One of SB_HORZ, SB_VERT, or SB_CTL */,
    1316                 const SCROLLINFO *info /* [I] Specifies what to change and new values */,
    1317                 BOOL bRedraw /* [I] Should scrollbar be redrawn afterwards ? */)
    1318 {
    1319   Win32BaseWindow *window;
    1320   INT action;
    1321   INT retVal;
    1322 
    1323     retVal = SCROLL_SetScrollInfo( hwnd, nBar, info, &action );
    1324     if( action & SA_SSI_HIDE )
    1325         SCROLL_ShowScrollBar( hwnd, nBar, FALSE, FALSE );
    1326     else
    1327     {
    1328         if( action & SA_SSI_SHOW )
    1329             if( SCROLL_ShowScrollBar( hwnd, nBar, TRUE, TRUE ) )
    1330                 return retVal; /* SetWindowPos() already did the painting */
    1331 
    1332         if( bRedraw && (action & SA_SSI_REFRESH))
    1333             SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
    1334         else if( action & SA_SSI_REPAINT_ARROWS )
    1335             SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, FALSE );
    1336     }
    1337     return retVal;
    1338 }
    1339 //******************************************************************************
    1340 //******************************************************************************
    1341 INT SCROLL_SetScrollInfo( HWND hwnd, INT nBar,
    1342                             const SCROLLINFO *info, INT *action  )
     1296INT WINAPI SetScrollInfo(HWND hwnd,INT nBar,const SCROLLINFO *info,BOOL bRedraw)
    13431297{
    13441298    /* Update the scrollbar state and set action flags according to
    … …  
    13471301    SCROLLBAR_INFO *infoPtr;
    13481302    UINT new_flags;
    1349 
    1350    *action = 0;
    1351 
    1352     if (!(infoPtr = SCROLL_GetInfoPtr(hwnd, nBar))) return 0;
     1303    INT action = 0;
     1304    HWND hwndScroll = SCROLL_GetScrollHandle(hwnd,nBar);
     1305
     1306    if (!hwndScroll) return 0;
     1307    if (!(infoPtr = SCROLL_GetInfoPtr(hwndScroll,nBar))) return 0;
    13531308    if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return 0;
    13541309    if ((info->cbSize != sizeof(*info)) &&
    … …  
    13611316        {
    13621317            infoPtr->Page = info->nPage;
    1363            *action |= SA_SSI_REFRESH;
     1318            action |= SA_SSI_REPAINT_INTERIOR;
    13641319        }
    13651320    }
    … …  
    13721327        {
    13731328            infoPtr->CurVal = info->nPos;
    1374            *action |= SA_SSI_REFRESH;
     1329            action |= SA_SSI_MOVE_THUMB;
    13751330        }
    13761331    }
    … …  
    13911346                infoPtr->MaxVal != info->nMax )
    13921347            {
    1393                *action |= SA_SSI_REFRESH;
     1348                action |= SA_SSI_REPAINT_INTERIOR;
    13941349                infoPtr->MinVal = info->nMin;
    13951350                infoPtr->MaxVal = info->nMax;
    … …  
    14251380            {
    14261381                new_flags = ESB_DISABLE_BOTH;
    1427                *action |= SA_SSI_REFRESH;
     1382                action |= SA_SSI_REFRESH;
    14281383            }
    14291384            else if (nBar != SB_CTL)
    14301385            {
    1431                 *action = SA_SSI_HIDE;
     1386                action = SA_SSI_HIDE;
    14321387                goto done;
    14331388            }
    … …  
    14371392            new_flags = 0;
    14381393            if (nBar != SB_CTL)
    1439                 *action |= SA_SSI_SHOW;
     1394                action |= SA_SSI_SHOW;
    14401395        }
    14411396
    … …  
    14431398        {
    14441399            infoPtr->flags = new_flags;
    1445            *action |= SA_SSI_REPAINT_ARROWS;
     1400            action |= SA_SSI_REPAINT_ARROWS;
    14461401        }
    14471402    }
    14481403
    14491404done:
     1405    /* Update scrollbar */
     1406
     1407    if( action & SA_SSI_HIDE )
     1408      ShowScrollBar(hwnd,nBar,FALSE);
     1409    else
     1410    {
     1411        if(action & SA_SSI_SHOW)
     1412          ShowScrollBar(hwnd,nBar,TRUE);
     1413
     1414        if(bRedraw && (action & SA_SSI_REFRESH))
     1415            SCROLL_RefreshScrollBar(hwndScroll,nBar,TRUE,TRUE);
     1416        else
     1417        {
     1418          if (action & SA_SSI_REPAINT_INTERIOR || action & SA_SSI_MOVE_THUMB)
     1419            SCROLL_RefreshScrollBar(hwndScroll,nBar,FALSE,TRUE);
     1420          if (action & SA_SSI_REPAINT_ARROWS )
     1421            SCROLL_RefreshScrollBar(hwndScroll,nBar,TRUE,FALSE);
     1422        }
     1423    }
     1424
    14501425    /* Return current position */
    14511426
    … …  
    14531428}
    14541429/*************************************************************************
    1455  *           GetScrollInfo32   (USER32.284)
     1430 *           GetScrollInfo   (USER32.284)
    14561431 * GetScrollInfo32 can be used to retrieve the position, upper bound,
    14571432 * lower bound, and page size of a scrollbar control.
    … …  
    14661441  SCROLLBAR_INFO *infoPtr;
    14671442
    1468     if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return FALSE;
     1443    if (!(infoPtr = SCROLL_GetInfoPtr(SCROLL_GetScrollHandle(hwnd,nBar),nBar))) return FALSE;
    14691444    if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return FALSE;
    14701445    if ((info->cbSize != sizeof(*info)) &&
    … …  
    14831458}
    14841459/*************************************************************************
    1485  *           SetScrollPos32   (USER32.502)
     1460 *           SetScrollPos   (USER32.502)
    14861461 *
    14871462 * RETURNS
    … …  
    15041479
    15051480    dprintf(("SetScrollPos %x %d %d %d", hwnd, nBar, nPos, bRedraw));
    1506     if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return 0;
     1481    if (!(infoPtr = SCROLL_GetInfoPtr(SCROLL_GetScrollHandle(hwnd,nBar),nBar))) return 0;
    15071482    oldPos      = infoPtr->CurVal;
    15081483    info.cbSize = sizeof(info);
    … …  
    15131488}
    15141489/*************************************************************************
    1515  *           GetScrollPos32   (USER32.285)
     1490 *           GetScrollPos   (USER32.285)
    15161491 *
    15171492 * RETURNS
    … …  
    15311506    dprintf(("GetScrollPos %x %d", hwnd, nBar));
    15321507
    1533     infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
     1508    infoPtr = SCROLL_GetInfoPtr(SCROLL_GetScrollHandle(hwnd,nBar),nBar);
    15341509    if (!infoPtr) return 0;
    15351510
    … …  
    15371512}
    15381513/*************************************************************************
    1539  *           SetScrollRange32   (USER32.503)
     1514 *           SetScrollRange   (USER32.503)
    15401515 *
    15411516 * RETURNS STD
    … …  
    15581533    return TRUE;
    15591534}
     1535
    15601536/*************************************************************************
    1561  *           SCROLL_SetNCSbState
    1562  *
    1563  * Updates both scrollbars at the same time. Used by MDI CalcChildScroll().
    1564  */
    1565 INT SCROLL_SetNCSbState(HWND hwnd, int vMin, int vMax, int vPos,
    1566                                        int hMin, int hMax, int hPos)
    1567 {
    1568     INT vA, hA;
    1569     SCROLLINFO vInfo, hInfo;
    1570 
    1571     vInfo.cbSize = hInfo.cbSize = sizeof(SCROLLINFO);
    1572     vInfo.nMin   = vMin;         hInfo.nMin   = hMin;
    1573     vInfo.nMax   = vMax;         hInfo.nMax   = hMax;
    1574     vInfo.nPos   = vPos;         hInfo.nPos   = hPos;
    1575     vInfo.fMask  = hInfo.fMask = SIF_RANGE | SIF_POS;
    1576 
    1577     SCROLL_SetScrollInfo( hwnd, SB_VERT, &vInfo, &vA );
    1578     SCROLL_SetScrollInfo( hwnd, SB_HORZ, &hInfo, &hA );
    1579 
    1580     if( !SCROLL_ShowScrollBar( hwnd, SB_BOTH,
    1581                               (hA & SA_SSI_SHOW),(vA & SA_SSI_SHOW) ) )
    1582     {
    1583         /* SetWindowPos() wasn't called, just redraw the scrollbars if needed */
    1584         if( vA & SA_SSI_REFRESH )
    1585             SCROLL_RefreshScrollBar( hwnd, SB_VERT, FALSE, TRUE );
    1586 
    1587         if( hA & SA_SSI_REFRESH )
    1588             SCROLL_RefreshScrollBar( hwnd, SB_HORZ, FALSE, TRUE );
    1589     }
    1590     return 0;
    1591 }
    1592 
    1593 
    1594 /*************************************************************************
    1595  *           GetScrollRange32   (USER32.286)
     1537 *           GetScrollRange   (USER32.286)
    15961538 *
    15971539 * RETURNS STD
    … …  
    16051547  SCROLLBAR_INFO *infoPtr;
    16061548
    1607     infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
     1549    infoPtr = SCROLL_GetInfoPtr(SCROLL_GetScrollHandle(hwnd,nBar),nBar);
    16081550    if (!infoPtr)
    16091551    {
    … …  
    16161558    return TRUE;
    16171559}
     1560
    16181561/*************************************************************************
    1619  *           SCROLL_ShowScrollBar()
    1620  *
    1621  * Back-end for ShowScrollBar(). Returns FALSE if no action was taken.
    1622  * NOTE: fShowV/fShowH must be zero when nBar is SB_HORZ/SB_VERT.
    1623  */
    1624 BOOL SCROLL_ShowScrollBar(HWND hwnd, INT nBar,
    1625                           BOOL fShowH, BOOL fShowV )
    1626 {
    1627     BOOL retvalue = FALSE;
    1628     DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
    1629 
    1630     //TRACE("hwnd=%04x bar=%d horz=%d, vert=%d\n",
    1631     //                hwnd, nBar, fShowH, fShowV );
    1632 
    1633     switch(nBar)
    1634     {
    1635     case SB_CTL:
    1636         ShowWindow( hwnd, fShowH ? SW_SHOW : SW_HIDE );
    1637         retvalue = TRUE;
    1638         goto END;
    1639 
    1640     case SB_BOTH:
    1641     case SB_HORZ:
    1642         if (fShowH)
    1643         {
    1644             fShowH = !(dwStyle & WS_HSCROLL);
    1645             dwStyle |= WS_HSCROLL;
    1646         }
    1647         else  /* hide it */
    1648         {
    1649             fShowH = (dwStyle & WS_HSCROLL);
    1650             dwStyle &= ~WS_HSCROLL;
    1651         }
    1652         SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
    1653         if( nBar == SB_HORZ ) {
    1654             fShowV = FALSE;
    1655             break;
    1656         }
    1657         /* fall through */
    1658 
    1659     case SB_VERT:
    1660         if (fShowV)
    1661         {
    1662             fShowV = !(dwStyle & WS_VSCROLL);
    1663             dwStyle |= WS_VSCROLL;
    1664         }
    1665         else  /* hide it */
    1666         {
    1667             fShowV = (dwStyle & WS_VSCROLL);
    1668             dwStyle &= ~WS_VSCROLL;
    1669         }
    1670         SetWindowLongA(hwnd,GWL_STYLE,dwStyle);
    1671         if ( nBar == SB_VERT )
    1672            fShowH = FALSE;
    1673         break;
    1674 
    1675     default:
    1676         retvalue = FALSE;  /* Nothing to do! */
    1677         goto END;
    1678     }
    1679 
    1680     if( fShowH || fShowV ) /* frame has been changed, let the window redraw itself */
    1681     {
    1682         SetWindowPos( hwnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
    1683                     | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
    1684         retvalue = TRUE;
    1685         goto END;
    1686     }
    1687 
    1688     retvalue = FALSE; /* no frame changes */
    1689 END:
    1690     return retvalue;
    1691 }
    1692 
    1693 
    1694 /*************************************************************************
    1695  *           ShowScrollBar32   (USER32.532)
     1562 *           ShowScrollBar   (USER32.532)
    16961563 *
    16971564 * RETURNS STD
    … …  
    17021569                    BOOL fShow  /* [I] TRUE = show, FALSE = hide  */)
    17031570{
    1704   Win32BaseWindow *window;
    1705 
    17061571    dprintf(("ShowScrollBar %04x %d %d\n", hwnd, nBar, fShow));
    17071572
    1708     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    1709     if(!window && nBar != SB_CTL) {
     1573    if (nBar == SB_CTL)
     1574    {
     1575      ShowWindow(hwnd,fShow ? SW_SHOW:SW_HIDE);
     1576
     1577      return TRUE;
     1578    } else
     1579    {
     1580      Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
     1581
     1582      if (!window)
     1583      {
    17101584        dprintf(("ShowScrollBar window not found!"));
    17111585        SetLastError(ERROR_INVALID_WINDOW_HANDLE);
    17121586        return 0;
    1713     }
    1714     if(nBar != SB_CTL || (window->getStyle() & (WM_HSCROLL|WM_VSCROLL) != 0))
    1715     {
    1716      BOOL rc;
    1717 
    1718         if(nBar == SB_HORZ || nBar == SB_BOTH)
     1587      }
     1588
     1589      if (window->getStyle() & (WS_HSCROLL | WS_VSCROLL))
     1590      {
     1591        BOOL rc;
     1592
     1593        if (nBar == SB_HORZ || nBar == SB_BOTH)
    17191594            rc = OSLibWinShowScrollBar(window->getOS2FrameWindowHandle(),
    17201595                                       window->getHorzScrollHandle(),
    17211596                                       OSLIB_HSCROLL, fShow);
    17221597
    1723         if(nBar == SB_VERT || ( rc == TRUE && nBar == SB_BOTH))
     1598        if (nBar == SB_VERT || (rc == TRUE && nBar == SB_BOTH))
    17241599            rc = OSLibWinShowScrollBar(window->getOS2FrameWindowHandle(),
    17251600                                       window->getVertScrollHandle(),
    17261601                                       OSLIB_VSCROLL, fShow);
    1727 
    17281602        return rc;
    1729     }
    1730 
    1731     SCROLL_ShowScrollBar( hwnd, nBar, (nBar == SB_VERT) ? 0 : fShow,
    1732                                       (nBar == SB_HORZ) ? 0 : fShow );
     1603      }
     1604    }
     1605
    17331606    return TRUE;
    17341607}
    17351608/*************************************************************************
    1736  *           EnableScrollBar32   (USER32.171)
     1609 *           EnableScrollBar   (USER32.171)
    17371610 */
    17381611BOOL WINAPI EnableScrollBar( HWND hwnd, INT nBar, UINT flags)
    17391612{
    17401613  Win32BaseWindow *window;
    1741   BOOL bFineWithMe;
    17421614  SCROLLBAR_INFO *infoPtr;
    17431615
    1744     dprintf(("EnableScrollBar %04x %d %d\n", hwnd, nBar, flags));
    1745 
    1746     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    1747     if(!window && nBar != SB_CTL) {
    1748         dprintf(("EnableScrollBar window not found!"));
    1749         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
    1750         return 0;
    1751     }
    1752     if(nBar != SB_CTL || (window->getStyle() & (WM_HSCROLL|WM_VSCROLL) != 0))
    1753     {
    1754      BOOL fEnable, rc;
    1755 
    1756         //hwnd = parent window with default scrollbar(s)
    1757         switch(flags) {
    1758         case ESB_ENABLE_BOTH:
    1759             fEnable = TRUE;
    1760             break;
    1761         case ESB_DISABLE_BOTH:
    1762         case ESB_DISABLE_RTDN:
    1763         case ESB_DISABLE_LTUP:
    1764             fEnable = FALSE;
    1765             break;
    1766         default:
    1767             SetLastError(ERROR_INVALID_PARAMETER);
    1768             return 0;
    1769         }
    1770         if(nBar == SB_HORZ || nBar == SB_BOTH)
    1771             rc = OSLibWinEnableScrollBar(window->getOS2FrameWindowHandle(), OSLIB_HSCROLL, fEnable);
    1772 
    1773         if(nBar == SB_VERT || ( rc == TRUE && nBar == SB_BOTH))
    1774             rc = OSLibWinEnableScrollBar(window->getOS2FrameWindowHandle(), OSLIB_VSCROLL, fEnable);
    1775 
    1776         return rc;
    1777     }
    1778     flags &= ESB_DISABLE_BOTH;
    1779 
    1780     if (nBar == SB_BOTH)
    1781     {
    1782         if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, SB_VERT ))) return FALSE;
    1783         if (!(bFineWithMe = (infoPtr->flags == flags)) )
    1784         {
     1616  dprintf(("EnableScrollBar %04x %d %d\n", hwnd, nBar, flags));
     1617
     1618  if (nBar == SB_CTL)
     1619  {
     1620    if (!(infoPtr = SCROLL_GetInfoPtr(hwnd,nBar))) return FALSE;
     1621
     1622    if (infoPtr->flags != flags)
     1623    {
     1624      infoPtr->flags = flags;
     1625      SCROLL_RefreshScrollBar(hwnd,nBar,TRUE,TRUE);
     1626    }
     1627
     1628    return TRUE;
     1629  } else
     1630  {
     1631    Win32BaseWindow *window = Win32BaseWindow::GetWindowFromHandle(hwnd);
     1632    if(!window)
     1633    {
     1634      dprintf(("EnableScrollBar window not found!"));
     1635      SetLastError(ERROR_INVALID_WINDOW_HANDLE);
     1636      return FALSE;
     1637    }
     1638
     1639    if(window->getStyle() & (WS_HSCROLL | WS_VSCROLL))
     1640    {
     1641      BOOL rc = FALSE;
     1642
     1643      if (nBar == SB_VERT || nBar == SB_BOTH)
     1644      {
     1645        HWND hwndScroll =  Win32BaseWindow::OS2ToWin32Handle(window->getVertScrollHandle());
     1646
     1647        infoPtr = SCROLL_GetInfoPtr(hwndScroll,SB_VERT);
     1648        if (infoPtr)
     1649        {
     1650          if (infoPtr->flags != flags)
     1651          {
    17851652            infoPtr->flags = flags;
    1786             SCROLL_RefreshScrollBar( hwnd, SB_VERT, TRUE, TRUE );
    1787         }
    1788         nBar = SB_HORZ;
    1789     }
    1790     else
    1791         bFineWithMe = TRUE;
    1792 
    1793     if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return FALSE;
    1794     if (bFineWithMe && infoPtr->flags == flags) return FALSE;
    1795     infoPtr->flags = flags;
    1796 
    1797     SCROLL_RefreshScrollBar( hwnd, nBar, TRUE, TRUE );
    1798     return TRUE;
     1653            SCROLL_RefreshScrollBar(hwndScroll,nBar,TRUE,TRUE);
     1654          }
     1655
     1656          rc = TRUE;
     1657        }
     1658      }
     1659      if (nBar == SB_HORZ || (rc && nBar == SB_BOTH))
     1660      {
     1661        HWND hwndScroll =  Win32BaseWindow::OS2ToWin32Handle(window->getVertScrollHandle());
     1662
     1663        infoPtr = SCROLL_GetInfoPtr(hwndScroll,SB_VERT);
     1664        if (infoPtr)
     1665        {
     1666          if (infoPtr->flags != flags)
     1667          {
     1668            infoPtr->flags = flags;
     1669            SCROLL_RefreshScrollBar(hwndScroll,nBar,TRUE,TRUE);
     1670          }
     1671
     1672          rc = TRUE;
     1673        }
     1674      }
     1675
     1676      return rc;
     1677    }
     1678  }
     1679
     1680  return TRUE;
    17991681}
    18001682//******************************************************************************

  • trunk/src/user32/win32wbase.cpp

    r1507 r1511  
    1 /* $Id: win32wbase.cpp,v 1.66 1999-10-28 23:51:05 sandervl Exp $ */
     1/* $Id: win32wbase.cpp,v 1.67 1999-10-29 16:06:56 cbratschi Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    … …  
    596596
    597597  if (dwStyle & WS_HSCROLL)
    598   {
    599         hwndHorzScroll = OSLibWinQueryScrollBarHandle(OS2HwndFrame, OSLIB_HSCROLL);
    600 //        OSLibWinShowScrollBar(OS2HwndFrame, hwndHorzScroll, OSLIB_HSCROLL, FALSE, TRUE);
    601   }
    602 
    603   if (dwStyle & WS_VSCROLL) {
    604         hwndVertScroll = OSLibWinQueryScrollBarHandle(OS2HwndFrame, OSLIB_VSCROLL);
    605 //        OSLibWinShowScrollBar(OS2HwndFrame, hwndVertScroll, OSLIB_VSCROLL, FALSE, TRUE);
    606   }
    607 
    608   //CB: switch off -> OS/2 scrollbars
     598    hwndHorzScroll = OSLibWinQueryScrollBarHandle(OS2HwndFrame, OSLIB_HSCROLL);
     599
     600  if (dwStyle & WS_VSCROLL)
     601    hwndVertScroll = OSLibWinQueryScrollBarHandle(OS2HwndFrame, OSLIB_VSCROLL);
     602
    609603  subclassScrollBars(dwStyle & WS_HSCROLL,dwStyle & WS_VSCROLL);
    610604
    … …  
    732726    SendInternalMessageA(WM_DESTROY, 0, 0);
    733727
    734     if (hwndHorzScroll && OSLibWinQueryWindow(hwndHorzScroll,QWOS_PARENT) == OSLIB_HWND_OBJECT) OSLibWinDestroyWindow(hwndHorzScroll);
    735     if (hwndVertScroll && OSLibWinQueryWindow(hwndVertScroll,QWOS_PARENT) == OSLIB_HWND_OBJECT) OSLibWinDestroyWindow(hwndVertScroll);
     728    if (hwndHorzScroll && OSLibWinQueryWindow(hwndHorzScroll,QWOS_PARENT) == OSLibWinQueryObjectWindow()) OSLibWinDestroyWindow(hwndHorzScroll);
     729    if (hwndVertScroll && OSLibWinQueryWindow(hwndVertScroll,QWOS_PARENT) == OSLibWinQueryObjectWindow()) OSLibWinDestroyWindow(hwndVertScroll);
    736730
    737731    if(getFirstChild() == NULL) {
    … …  
    12481242}
    12491243//******************************************************************************
    1250 //TODO: Not complete (flags)
    12511244//******************************************************************************
    12521245SCROLLBAR_INFO *Win32BaseWindow::getScrollInfo(int nBar)
    12531246{
    1254     switch(nBar) {
     1247  switch(nBar)
     1248  {
    12551249    case SB_HORZ:
    1256         if(horzScrollInfo) {
    1257             //CB:horzScrollInfo->CurVal = OSLibWinGetScrollPos(OS2HwndFrame, hwndHorzScroll);
    1258             return horzScrollInfo;
    1259         }
    1260         break;
     1250      return horzScrollInfo;
     1251
    12611252    case SB_VERT:
    1262         if(vertScrollInfo) {
    1263             //CB:vertScrollInfo->CurVal = OSLibWinGetScrollPos(OS2HwndFrame, hwndVertScroll);
    1264             return vertScrollInfo;
    1265         }
    1266         break;
    1267     }
    1268     return NULL;
     1253      return vertScrollInfo;
     1254  }
     1255
     1256  return NULL;
    12691257}
    12701258/***********************************************************************/
Note: See TracChangeset for help on using the changeset viewer.