Changeset 1418 for trunk/src


Ignore:
Timestamp:
Oct 23, 1999, 6:45:24 PM (26 years ago)
Author:
cbratschi
Message:

GetSystemMetrics, timer and scrollbar fixes

Location:
trunk/src/user32
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/pmwindow.cpp

    r1408 r1418  
    1 /* $Id: pmwindow.cpp,v 1.41 1999-10-23 10:21:43 sandervl Exp $ */
     1/* $Id: pmwindow.cpp,v 1.42 1999-10-23 16:45:20 cbratschi Exp $ */
    22/*
    33 * Win32 Window Managment Code for OS/2
    … …  
    2929#include "oslibmsg.h"
    3030#include "dc.h"
     31#include "timer.h"
    3132#include <thread.h>
    3233#include <wprocess.h>
    … …  
    767768
    768769    case WM_TIMER:
    769         if (mp2) win32wnd->MsgTimer((ULONG)mp1);
     770        if (mp2)
     771        {
     772          BOOL sys;
     773          ULONG id;
     774
     775          if (TIMER_GetTimerInfo(hwnd,(ULONG)mp1,&sys,&id))
     776          {
     777            if (sys)
     778              win32wnd->MsgSysTimer(id);
     779            else
     780              win32wnd->MsgTimer(id);
     781          }
     782        }
    770783        goto RunDefWndProc;
    771784

  • trunk/src/user32/scroll.cpp

    r1378 r1418  
    1 /* $Id: scroll.cpp,v 1.12 1999-10-20 16:27:00 cbratschi Exp $ */
     1/* $Id: scroll.cpp,v 1.13 1999-10-23 16:45:21 cbratschi Exp $ */
    22/*
    33 * Scrollbar control
    … …  
    4242   (((flags)&ESB_DISABLE_RIGHT) ? hRgArrowI : ((pressed) ? hRgArrowD:hRgArrow))
    4343
    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   /* Overlap between arrows and thumb */
    52 #define SCROLL_ARROW_THUMB_OVERLAP 0
    53 
    54   /* Delay (in ms) before first repetition when holding the button down */
    55 #define SCROLL_FIRST_DELAY   200
    56 
    57   /* Delay (in ms) between scroll repetitions */
    58 #define SCROLL_REPEAT_DELAY  50
    59 
    60   /* Scroll timer id */
    61 #define SCROLL_TIMER   0
     44#define SCROLL_MIN_RECT  4 /* Minimum size of the rectangle between the arrows */
     45#define SCROLL_MIN_THUMB 6 /* Minimum size of the thumb in pixels */
     46
     47#define SCROLL_ARROW_THUMB_OVERLAP 0 /* Overlap between arrows and thumb */
     48
     49#define SCROLL_FIRST_DELAY   200 /* Delay (in ms) before first repetition when holding the button down */
     50#define SCROLL_REPEAT_DELAY  50  /* Delay (in ms) between scroll repetitions */
     51#define SCROLL_BLINK_DELAY   1000
     52
     53#define SCROLL_TIMER   0 /* Scroll timer id */
     54#define BLINK_TIMER    1
    6255
    6356  /* Scroll-bar hit testing */
    … …  
    8376static INT  SCROLL_TrackingPos = 0;
    8477static INT  SCROLL_TrackingVal = 0;
     78 /* Focus info */
     79static HWND SCROLL_FocusWin    = 0;
     80static BOOL SCROLL_HasFocus    = FALSE;
     81static BOOL SCROLL_Highlighted = FALSE;
     82
    8583 /* Hit test code of the last button-down event */
    8684static enum SCROLL_HITTEST SCROLL_trackHitTest;
    … …  
    155153}
    156154
     155/* Scrollbar Functions */
    157156
    158157/***********************************************************************
    … …  
    240239}
    241240
    242 
    243 /***********************************************************************
    244  *           SCROLL_GetThumbVal
    245  *
    246  * Compute the current scroll position based on the thumb position in pixels
    247  * from the top of the scroll-bar.
    248  */
    249 static UINT SCROLL_GetThumbVal( SCROLLBAR_INFO *infoPtr, RECT *rect,
    250                                   BOOL vertical, INT pos )
    251 {
    252     INT thumbSize;
    253     INT pixels = vertical ? rect->bottom-rect->top : rect->right-rect->left;
    254 
    255     if ((pixels -= 2*(GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP)) <= 0)
    256         return infoPtr->MinVal;
    257 
    258     if (infoPtr->Page)
    259     {
    260         thumbSize = pixels * infoPtr->Page/(infoPtr->MaxVal-infoPtr->MinVal+1);
    261         if (thumbSize < SCROLL_MIN_THUMB) thumbSize = SCROLL_MIN_THUMB;
    262     }
    263     else thumbSize = GetSystemMetrics(SM_CXVSCROLL);
    264 
    265     if ((pixels -= thumbSize) <= 0) return infoPtr->MinVal;
    266 
    267     pos = MAX( 0, pos - (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP) );
    268     if (pos > pixels) pos = pixels;
    269 
    270     if (!infoPtr->Page) pos *= infoPtr->MaxVal - infoPtr->MinVal;
    271     else pos *= infoPtr->MaxVal - infoPtr->MinVal - infoPtr->Page + 1;
    272     return infoPtr->MinVal + ((pos + pixels / 2) / pixels);
    273 }
    274 
    275241/***********************************************************************
    276242 *           SCROLL_PtInRectEx
    … …  
    292258    return PtInRect( &rect, pt );
    293259}
    294 
    295 /***********************************************************************
    296  *           SCROLL_ClipPos
    297  */
    298 static POINT SCROLL_ClipPos( LPRECT lpRect, POINT pt )
    299 {
    300     if( pt.x < lpRect->left )
    301         pt.x = lpRect->left;
    302     else
    303     if( pt.x > lpRect->right )
    304         pt.x = lpRect->right;
    305 
    306     if( pt.y < lpRect->top )
    307         pt.y = lpRect->top;
    308     else
    309     if( pt.y > lpRect->bottom )
    310         pt.y = lpRect->bottom;
    311 
    312     return pt;
    313 }
    314 
    315260
    316261/***********************************************************************
    … …  
    357302 * Draw the scroll bar arrows.
    358303 */
    359 static void SCROLL_DrawArrows_9x( HDC hdc, SCROLLBAR_INFO *infoPtr,
    360                                   RECT *rect, INT arrowSize, BOOL vertical,
    361                                   BOOL top_pressed, BOOL bottom_pressed )
     304static void SCROLL_DrawArrows( HDC hdc, SCROLLBAR_INFO *infoPtr,
     305                               RECT *rect, INT arrowSize, BOOL vertical,
     306                               BOOL top_pressed, BOOL bottom_pressed )
    362307{
    363308  RECT r;
    … …  
    385330            | (infoPtr->flags&ESB_DISABLE_RTDN ? DFCS_INACTIVE : 0) );
    386331}
    387 //******************************************************************************
    388 //******************************************************************************
    389 static void SCROLL_DrawArrows( HDC hdc, SCROLLBAR_INFO *infoPtr,
    390                    RECT *rect, INT arrowSize, BOOL vertical,
    391                    BOOL top_pressed, BOOL bottom_pressed )
    392 {
    393   SCROLL_DrawArrows_9x( hdc, infoPtr, rect, arrowSize,
    394                         vertical, top_pressed,bottom_pressed );
    395 }
    396 
    397332
    398333/***********************************************************************
    … …  
    425360  SCROLL_MovingThumb = !SCROLL_MovingThumb;
    426361}
     362
     363static void SCROLL_DrawInterior( HWND hwnd, HDC hdc, INT nBar,
     364                                 RECT *rect, INT arrowSize,
     365                                 INT thumbSize, INT thumbPos,
     366                                 UINT flags, BOOL vertical,
     367                                 BOOL top_selected, BOOL bottom_selected )
     368{
     369    RECT r;
     370    HPEN hSavePen;
     371    HBRUSH hSaveBrush,hBrush;
     372    BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
     373
     374//SCROLL_DrawInterior_9x(hwnd,hdc,nBar,rect,arrowSize,thumbSize,thumbPos,flags,vertical,top_selected,bottom_selected);
     375//return; //CB: improve!
     376
     377    if (Save_SCROLL_MovingThumb &&
     378        (SCROLL_TrackingWin == hwnd) &&
     379        (SCROLL_TrackingBar == nBar))
     380        SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
     381
     382      /* Select the correct brush and pen */
     383
     384    /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
     385     * The window-owned scrollbars need to call DEFWND_ControlColor
     386     * to correctly setup default scrollbar colors
     387     */
     388    if (nBar == SB_CTL) {
     389        hBrush = (HBRUSH)SendMessageA( GetParent(hwnd), WM_CTLCOLORSCROLLBAR,
     390                                       (WPARAM)hdc,(LPARAM)hwnd);
     391    } else {
     392        hBrush = (HBRUSH)SendMessageA( hwnd, WM_CTLCOLORSCROLLBAR,
     393                                       (WPARAM)hdc,(LPARAM)hwnd);
     394
     395    }
     396
     397    hSavePen = SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
     398    hSaveBrush = SelectObject( hdc, hBrush );
     399
     400      /* Calculate the scroll rectangle */
     401
     402    r = *rect;
     403    if (vertical)
     404    {
     405        r.top    += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
     406        r.bottom -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
     407    }
     408    else
     409    {
     410        r.left  += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
     411        r.right -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
     412    }
     413
     414      /* Draw the scroll rectangles and thumb */
     415
     416    if (!thumbPos)  /* No thumb to draw */
     417    {
     418        INT offset = 0;
     419
     420        PatBlt( hdc, r.left+offset, r.top+offset,
     421                     r.right - r.left - 2*offset, r.bottom - r.top - 2*offset,
     422                     PATCOPY );
     423
     424        /* cleanup and return */
     425        SelectObject( hdc, hSavePen );
     426        SelectObject( hdc, hSaveBrush );
     427        return;
     428    }
     429
     430    if (vertical)
     431    {
     432        INT offset = 0;
     433
     434        PatBlt( hdc, r.left + offset, r.top + offset,
     435                  r.right - r.left - offset*2,
     436                  thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP) - offset,
     437                  top_selected ? 0x0f0000 : PATCOPY );
     438        r.top += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
     439        PatBlt( hdc, r.left + offset, r.top + thumbSize,
     440                  r.right - r.left - offset*2,
     441                  r.bottom - r.top - thumbSize - offset,
     442                  bottom_selected ? 0x0f0000 : PATCOPY );
     443        r.bottom = r.top + thumbSize;
     444    }
     445    else  /* horizontal */
     446    {
     447        INT offset = 0;
     448
     449        PatBlt( hdc, r.left + offset, r.top + offset,
     450                  thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
     451                  r.bottom - r.top - offset*2,
     452                  top_selected ? 0x0f0000 : PATCOPY );
     453        r.left += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
     454        PatBlt( hdc, r.left + thumbSize, r.top + offset,
     455                  r.right - r.left - thumbSize - offset,
     456                  r.bottom - r.top - offset*2,
     457                  bottom_selected ? 0x0f0000 : PATCOPY );
     458        r.right = r.left + thumbSize;
     459    }
     460
     461      /* Draw the thumb */
     462
     463    SelectObject(hdc,(SCROLL_FocusWin == hwnd && SCROLL_Highlighted) ? GetSysColorBrush(COLOR_3DHILIGHT):GetSysColorBrush(COLOR_BTNFACE));
     464
     465    Rectangle(hdc,r.left+1,r.top+1,r.right-1,r.bottom-1);
     466
     467    DrawEdge( hdc, &r, EDGE_RAISED, BF_RECT );
     468
     469    if (Save_SCROLL_MovingThumb &&
     470        (SCROLL_TrackingWin == hwnd) &&
     471        (SCROLL_TrackingBar == nBar))
     472        SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
     473
     474    /* cleanup */
     475    SelectObject( hdc, hSavePen );
     476    SelectObject( hdc, hSaveBrush );
     477}
     478
     479/***********************************************************************
     480 *           SCROLL_ClipPos
     481 */
     482static POINT SCROLL_ClipPos( LPRECT lpRect, POINT pt )
     483{
     484    if( pt.x < lpRect->left )
     485        pt.x = lpRect->left;
     486    else
     487    if( pt.x > lpRect->right )
     488        pt.x = lpRect->right;
     489
     490    if( pt.y < lpRect->top )
     491        pt.y = lpRect->top;
     492    else
     493    if( pt.y > lpRect->bottom )
     494        pt.y = lpRect->bottom;
     495
     496    return pt;
     497}
     498
     499/***********************************************************************
     500 *           SCROLL_GetThumbVal
     501 *
     502 * Compute the current scroll position based on the thumb position in pixels
     503 * from the top of the scroll-bar.
     504 */
     505static UINT SCROLL_GetThumbVal( SCROLLBAR_INFO *infoPtr, RECT *rect,
     506                                  BOOL vertical, INT pos )
     507{
     508    INT thumbSize;
     509    INT pixels = vertical ? rect->bottom-rect->top : rect->right-rect->left;
     510
     511    if ((pixels -= 2*(GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP)) <= 0)
     512        return infoPtr->MinVal;
     513
     514    if (infoPtr->Page)
     515    {
     516        thumbSize = pixels * infoPtr->Page/(infoPtr->MaxVal-infoPtr->MinVal+1);
     517        if (thumbSize < SCROLL_MIN_THUMB) thumbSize = SCROLL_MIN_THUMB;
     518    }
     519    else thumbSize = GetSystemMetrics(SM_CXVSCROLL);
     520
     521    if ((pixels -= thumbSize) <= 0) return infoPtr->MinVal;
     522
     523    pos = MAX( 0, pos - (GetSystemMetrics(SM_CXVSCROLL) - SCROLL_ARROW_THUMB_OVERLAP) );
     524    if (pos > pixels) pos = pixels;
     525
     526    if (!infoPtr->Page) pos *= infoPtr->MaxVal - infoPtr->MinVal;
     527    else pos *= infoPtr->MaxVal - infoPtr->MinVal - infoPtr->Page + 1;
     528    return infoPtr->MinVal + ((pos + pixels / 2) / pixels);
     529}
     530
     531/***********************************************************************
     532 *           SCROLL_DrawScrollBar
     533 *
     534 * Redraw the whole scrollbar.
     535 */
     536void SCROLL_DrawScrollBar( HWND hwnd, HDC hdc, INT nBar,
     537                           BOOL arrows, BOOL interior )
     538{
     539    INT arrowSize, thumbSize, thumbPos;
     540    RECT rect;
     541    BOOL vertical;
     542    SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
     543    BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
     544
     545    if (nBar == SB_CTL)
     546    {
     547      DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     548
     549      if (dwStyle & (SBS_SIZEBOX | SBS_SIZEGRIP))
     550      {
     551        //CB: todo
     552
     553        return;
     554      }
     555    }
     556
     557    vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
     558                                        &arrowSize, &thumbSize, &thumbPos );
     559
     560    if (Save_SCROLL_MovingThumb &&
     561        (SCROLL_TrackingWin == hwnd) &&
     562        (SCROLL_TrackingBar == nBar))
     563        SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
     564
     565      /* Draw the arrows */
     566
     567    if (arrows && arrowSize)
     568    {
     569        if( vertical == SCROLL_trackVertical && GetCapture() == hwnd )
     570            SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
     571                               (SCROLL_trackHitTest == SCROLL_TOP_ARROW),
     572                               (SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW) );
     573        else
     574            SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
     575                                                               FALSE, FALSE );
     576    }
     577    if( interior )
     578        SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
     579                         thumbPos, infoPtr->flags, vertical, FALSE, FALSE );
     580
     581    if (Save_SCROLL_MovingThumb &&
     582        (SCROLL_TrackingWin == hwnd) &&
     583        (SCROLL_TrackingBar == nBar))
     584        SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
     585
     586}
     587
    427588/***********************************************************************
    428589 *           SCROLL_DrawInterior
    … …  
    518679    SelectObject( hdc, hSaveBrush );
    519680}
    520 //******************************************************************************
    521 //******************************************************************************
    522 static void SCROLL_DrawInterior( HWND hwnd, HDC hdc, INT nBar,
    523                                  RECT *rect, INT arrowSize,
    524                                  INT thumbSize, INT thumbPos,
    525                                  UINT flags, BOOL vertical,
    526                                  BOOL top_selected, BOOL bottom_selected )
    527 {
    528     RECT r;
    529     HPEN hSavePen;
    530     HBRUSH hSaveBrush,hBrush;
    531     BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
    532 
    533 //SCROLL_DrawInterior_9x(hwnd,hdc,nBar,rect,arrowSize,thumbSize,thumbPos,flags,vertical,top_selected,bottom_selected);
    534 //return; //CB: improve!
    535 
    536     if (Save_SCROLL_MovingThumb &&
    537         (SCROLL_TrackingWin == hwnd) &&
    538         (SCROLL_TrackingBar == nBar))
    539         SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
    540 
    541       /* Select the correct brush and pen */
    542 
    543     /* Only scrollbar controls send WM_CTLCOLORSCROLLBAR.
    544      * The window-owned scrollbars need to call DEFWND_ControlColor
    545      * to correctly setup default scrollbar colors
    546      */
    547     if (nBar == SB_CTL) {
    548         hBrush = (HBRUSH)SendMessageA( GetParent(hwnd), WM_CTLCOLORSCROLLBAR,
    549                                        (WPARAM)hdc,(LPARAM)hwnd);
    550     } else {
    551         hBrush = (HBRUSH)SendMessageA( hwnd, WM_CTLCOLORSCROLLBAR,
    552                                        (WPARAM)hdc,(LPARAM)hwnd);
    553 
    554     }
    555 
    556     hSavePen = SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
    557     hSaveBrush = SelectObject( hdc, hBrush );
    558 
    559       /* Calculate the scroll rectangle */
    560 
    561     r = *rect;
    562     if (vertical)
    563     {
    564         r.top    += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
    565         r.bottom -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    566     }
    567     else
    568     {
    569         r.left  += arrowSize - SCROLL_ARROW_THUMB_OVERLAP;
    570         r.right -= (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    571     }
    572 
    573       /* Draw the scroll bar frame */
    574 
    575     /* Only draw outline if Win 3.1.  Mar 24, 1999 - Ronald B. Cemer */
    576 
    577       /* Draw the scroll rectangles and thumb */
    578 
    579     if (!thumbPos)  /* No thumb to draw */
    580     {
    581         INT offset = 0;
    582 
    583         PatBlt( hdc, r.left+offset, r.top+offset,
    584                      r.right - r.left - 2*offset, r.bottom - r.top - 2*offset,
    585                      PATCOPY );
    586 
    587         /* cleanup and return */
    588         SelectObject( hdc, hSavePen );
    589         SelectObject( hdc, hSaveBrush );
    590         return;
    591     }
    592 
    593     if (vertical)
    594     {
    595         INT offset = 0;
    596 
    597         PatBlt( hdc, r.left + offset, r.top + offset,
    598                   r.right - r.left - offset*2,
    599                   thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP) - offset,
    600                   top_selected ? 0x0f0000 : PATCOPY );
    601         r.top += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    602         PatBlt( hdc, r.left + offset, r.top + thumbSize,
    603                   r.right - r.left - offset*2,
    604                   r.bottom - r.top - thumbSize - offset,
    605                   bottom_selected ? 0x0f0000 : PATCOPY );
    606         r.bottom = r.top + thumbSize;
    607     }
    608     else  /* horizontal */
    609     {
    610         INT offset = 0;
    611 
    612         PatBlt( hdc, r.left + offset, r.top + offset,
    613                   thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP),
    614                   r.bottom - r.top - offset*2,
    615                   top_selected ? 0x0f0000 : PATCOPY );
    616         r.left += thumbPos - (arrowSize - SCROLL_ARROW_THUMB_OVERLAP);
    617         PatBlt( hdc, r.left + thumbSize, r.top + offset,
    618                   r.right - r.left - thumbSize - offset,
    619                   r.bottom - r.top - offset*2,
    620                   bottom_selected ? 0x0f0000 : PATCOPY );
    621         r.right = r.left + thumbSize;
    622     }
    623 
    624       /* Draw the thumb */
    625 
    626     SelectObject( hdc, GetSysColorBrush(COLOR_BTNFACE) );
    627 
    628     Rectangle( hdc, r.left+1, r.top+1, r.right-1, r.bottom-1 );
    629 
    630     DrawEdge( hdc, &r, EDGE_RAISED, BF_RECT );
    631 
    632     if (Save_SCROLL_MovingThumb &&
    633         (SCROLL_TrackingWin == hwnd) &&
    634         (SCROLL_TrackingBar == nBar))
    635         SCROLL_DrawMovingThumb( hdc, rect, vertical, arrowSize, thumbSize );
    636 
    637     /* cleanup */
    638     SelectObject( hdc, hSavePen );
    639     SelectObject( hdc, hSaveBrush );
    640 }
    641 /***********************************************************************
    642  *           SCROLL_DrawScrollBar
    643  *
    644  * Redraw the whole scrollbar.
    645  */
    646 void SCROLL_DrawScrollBar( HWND hwnd, HDC hdc, INT nBar,
    647                            BOOL arrows, BOOL interior )
    648 {
    649     INT arrowSize, thumbSize, thumbPos;
    650     RECT rect;
    651     BOOL vertical;
    652     SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
    653     BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
    654 
    655     vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
    656                                         &arrowSize, &thumbSize, &thumbPos );
    657 
    658     if (Save_SCROLL_MovingThumb &&
    659         (SCROLL_TrackingWin == hwnd) &&
    660         (SCROLL_TrackingBar == nBar))
    661         SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
    662 
    663       /* Draw the arrows */
    664 
    665     if (arrows && arrowSize)
    666     {
    667         if( vertical == SCROLL_trackVertical && GetCapture() == hwnd )
    668             SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    669                                (SCROLL_trackHitTest == SCROLL_TOP_ARROW),
    670                                (SCROLL_trackHitTest == SCROLL_BOTTOM_ARROW) );
    671         else
    672             SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    673                                                                FALSE, FALSE );
    674     }
    675     if( interior )
    676         SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
    677                          thumbPos, infoPtr->flags, vertical, FALSE, FALSE );
    678 
    679     if (Save_SCROLL_MovingThumb &&
    680         (SCROLL_TrackingWin == hwnd) &&
    681         (SCROLL_TrackingBar == nBar))
    682         SCROLL_DrawMovingThumb( hdc, &rect, vertical, arrowSize, thumbSize );
    683 
    684 }
     681
    685682/***********************************************************************
    686683 *           SCROLL_RefreshScrollBar
    … …  
    724721    ReleaseDC( hwndScroll, hdc );
    725722}
    726 /***********************************************************************
    727  *           SCROLL_HandleKbdEvent
    728  *
    729  * Handle a keyboard event (only for SB_CTL scrollbars).
    730  */
    731 static void SCROLL_HandleKbdEvent( HWND hwnd, WPARAM wParam )
    732 {
    733     DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
    734     WPARAM msg;
    735 
    736     switch(wParam)
    737     {
    738     case VK_PRIOR: msg = SB_PAGEUP; break;
    739     case VK_NEXT:  msg = SB_PAGEDOWN; break;
    740     case VK_HOME:  msg = SB_TOP; break;
    741     case VK_END:   msg = SB_BOTTOM; break;
    742     case VK_UP:    msg = SB_LINEUP; break;
    743     case VK_DOWN:  msg = SB_LINEDOWN; break;
    744     default:
    745         return;
    746     }
    747     SendMessageA( GetParent(hwnd),
    748                     (dwStyle & SBS_VERT) ? WM_VSCROLL : WM_HSCROLL,
    749                     msg, hwnd );
    750 }
     723
     724/* Message Handler */
     725
     726LRESULT SCROLL_NCCreate(HWND hwnd,WPARAM wParam,LPARAM lParam)
     727{
     728  SCROLLBAR_INFO *infoPtr = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
     729
     730  infoPtr->MinVal = infoPtr->CurVal = infoPtr->Page = 0;
     731  infoPtr->MaxVal = 100;
     732  infoPtr->flags  = ESB_ENABLE_BOTH;
     733
     734  SetInfoPtr(hwnd,(DWORD)infoPtr);
     735
     736  if (!bitmapsLoaded) SCROLL_LoadBitmaps();
     737
     738  return TRUE;
     739}
     740
     741LRESULT SCROLL_Create(HWND hwnd,WPARAM wParam,LPARAM lParam)
     742{
     743  CREATESTRUCTA *lpCreat = (CREATESTRUCTA *)lParam;
     744
     745  if (lpCreat->style & SBS_VERT)
     746  {
     747    if (lpCreat->style & SBS_LEFTALIGN)
     748      MoveWindow( hwnd, lpCreat->x, lpCreat->y,
     749                                  GetSystemMetrics(SM_CXVSCROLL), lpCreat->cy, FALSE );
     750    else if (lpCreat->style & SBS_RIGHTALIGN)
     751      MoveWindow( hwnd,
     752                  lpCreat->x+lpCreat->cx-GetSystemMetrics(SM_CXVSCROLL)-1,
     753                  lpCreat->y,
     754                  GetSystemMetrics(SM_CXVSCROLL), lpCreat->cy, FALSE );
     755  } else  /* SBS_HORZ */
     756  {
     757    if (lpCreat->style & SBS_TOPALIGN)
     758      MoveWindow( hwnd, lpCreat->x, lpCreat->y,
     759                  lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL), FALSE );
     760    else if (lpCreat->style & SBS_BOTTOMALIGN)
     761      MoveWindow( hwnd,
     762                  lpCreat->x,
     763                  lpCreat->y+lpCreat->cy-GetSystemMetrics(SM_CYHSCROLL)-1,
     764                  lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL), FALSE );
     765  }
     766
     767  return 0;
     768}
     769
    751770/***********************************************************************
    752771 *           SCROLL_HandleScrollEvent
    … …  
    756775 * windows coordinates.
    757776 */
    758 void SCROLL_HandleScrollEvent( HWND hwnd, INT nBar, UINT msg, POINT pt)
    759 {
    760       /* Previous mouse position for timer events */
    761     static POINT prevPt;
    762       /* Thumb position when tracking started. */
    763     static UINT trackThumbPos;
    764       /* Position in the scroll-bar of the last button-down event. */
    765     static INT lastClickPos;
    766       /* Position in the scroll-bar of the last mouse event. */
    767     static INT lastMousePos;
     777LRESULT SCROLL_HandleScrollEvent(HWND hwnd,WPARAM wParam,LPARAM lParam,INT nBar,UINT msg)
     778{
     779    static POINT prevPt;       /* Previous mouse position for timer events */
     780    static UINT trackThumbPos; /* Thumb position when tracking started. */
     781    static INT lastClickPos;   /* Position in the scroll-bar of the last button-down event. */
     782    static INT lastMousePos;   /* Position in the scroll-bar of the last mouse event. */
    768783
    769784    enum SCROLL_HITTEST hittest;
    … …  
    773788    RECT rect;
    774789    HDC hdc;
     790    POINT pt;
     791    LRESULT res = (msg == WM_MOUSEMOVE) ? 1:0;
    775792
    776793    SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
    777     if (!infoPtr) return;
    778     if ((SCROLL_trackHitTest == SCROLL_NOWHERE) && (msg != WM_LBUTTONDOWN))
    779                   return;
     794    if (!infoPtr) return res;
     795
     796    if (nBar == SB_CTL)
     797    {
     798      DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     799
     800      if ((dwStyle & (SBS_SIZEBOX | SBS_SIZEGRIP)))
     801      {
     802        //CB: todo
     803
     804        return res;
     805      }
     806    }
     807
     808    if ((SCROLL_trackHitTest == SCROLL_NOWHERE) && (msg == WM_MOUSEMOVE || msg == WM_LBUTTONUP))
     809      return res;
    780810
    781811    vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
    … …  
    787817
    788818      win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
    789       if (!win32wnd) return;
     819      if (!win32wnd) return res;
    790820      hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_PARENT);
    791821      win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
    792       if (!win32wnd) return;
     822      if (!win32wnd) return res;
    793823      hwndOwner = win32wnd->getWindowHandle();
    794824    }
    … …  
    796826    hwndCtl   = (nBar == SB_CTL) ? hwnd : 0;
    797827
    798     switch(msg)
     828    switch (msg)
    799829    {
    800830      case WM_LBUTTONDOWN:  /* Initialise mouse tracking */
    801           SCROLL_trackVertical = vertical;
    802           SCROLL_trackHitTest  = hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
    803           lastClickPos  = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
    804           lastMousePos  = lastClickPos;
    805           trackThumbPos = thumbPos;
    806           prevPt = pt;
    807           SetCapture( hwnd );
    808           if (nBar == SB_CTL) SetFocus( hwnd );
    809           break;
     831        pt.x = (SHORT)LOWORD(lParam);
     832        pt.y = (SHORT)HIWORD(lParam);
     833        SCROLL_trackVertical = vertical;
     834        SCROLL_trackHitTest  = hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
     835        lastClickPos  = vertical ? (pt.y - rect.top) : (pt.x - rect.left);
     836        lastMousePos  = lastClickPos;
     837        trackThumbPos = thumbPos;
     838        prevPt = pt;
     839        SetCapture( hwnd );
     840        if (nBar == SB_CTL) SetFocus( hwnd );
     841        break;
    810842
    811843      case WM_MOUSEMOVE:
    812           hittest = SCROLL_HitTest( hwnd, nBar, pt, TRUE );
    813           prevPt = pt;
    814           break;
     844        pt.x = (SHORT)LOWORD(lParam);
     845        pt.y = (SHORT)HIWORD(lParam);
     846        hittest = SCROLL_HitTest( hwnd, nBar, pt, TRUE );
     847        prevPt = pt;
     848        break;
    815849
    816850      case WM_LBUTTONUP:
    817           hittest = SCROLL_NOWHERE;
    818           ReleaseCapture();
    819           break;
     851        pt.x = (SHORT)LOWORD(lParam);
     852        pt.y = (SHORT)HIWORD(lParam);
     853        hittest = SCROLL_NOWHERE;
     854        ReleaseCapture();
     855        break;
     856
     857      case WM_SETFOCUS:
     858        if (nBar == SB_CTL)
     859        {
     860          SCROLL_FocusWin   = hwnd;
     861          SCROLL_HasFocus   = TRUE;
     862          SCROLL_Highlighted = FALSE;
     863          SetSystemTimer(hwnd,BLINK_TIMER,SCROLL_BLINK_DELAY,(TIMERPROC)0);
     864        }
     865        return res;
     866
     867      case WM_KILLFOCUS:
     868        if (SCROLL_FocusWin == hwnd)
     869        {
     870          SCROLL_FocusWin    = 0;
     871          SCROLL_HasFocus    = FALSE;
     872          if (SCROLL_Highlighted)
     873          {
     874            SCROLL_Highlighted = FALSE;
     875            hdc = GetDCEx(hwnd,0,DCX_CACHE);
     876            SCROLL_DrawScrollBar(hwnd,hdc,nBar,FALSE,TRUE);
     877            ReleaseDC(hwnd,hdc);
     878          }
     879          KillSystemTimer(hwnd,BLINK_TIMER);
     880        }
     881        return res;
    820882
    821883      case WM_SYSTIMER:
     884        if (wParam == SCROLL_TIMER)
     885        {
    822886          pt = prevPt;
    823887          hittest = SCROLL_HitTest( hwnd, nBar, pt, FALSE );
    824888          break;
     889        } else if (wParam == BLINK_TIMER)
     890        {
     891          SCROLL_Highlighted = ~SCROLL_Highlighted;
     892          hdc = GetDCEx(hwnd,0,DCX_CACHE);
     893          SCROLL_DrawScrollBar(hwnd,hdc,nBar,FALSE,TRUE);
     894          ReleaseDC(hwnd,hdc);
     895          return res;
     896        } else return res;
    825897
    826898      default:
    827           return;  /* Should never happen */
    828     }
    829 
    830     hdc = GetDCEx( hwnd, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
     899        return res;  /* Should never happen */
     900    }
     901
     902    hdc = GetDCEx(hwnd,0,DCX_CACHE | ((nBar == SB_CTL) ? 0:DCX_WINDOW));
    831903
    832904    //TRACE("Event: hwnd=%04x bar=%d msg=%x pt=%ld,%ld hit=%d\n",
    … …  
    835907    switch(SCROLL_trackHitTest)
    836908    {
    837     case SCROLL_NOWHERE:  /* No tracking in progress */
     909      case SCROLL_NOWHERE:  /* No tracking in progress */
    838910        break;
    839911
    840     case SCROLL_TOP_ARROW:
     912      case SCROLL_TOP_ARROW:
    841913        SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    842914                           (hittest == SCROLL_trackHitTest), FALSE );
    … …  
    855927        break;
    856928
    857     case SCROLL_TOP_RECT:
     929      case SCROLL_TOP_RECT:
    858930        SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
    859931                             thumbPos, infoPtr->flags, vertical,
    … …  
    873945        break;
    874946
    875     case SCROLL_THUMB:
     947      case SCROLL_THUMB:
    876948        if (msg == WM_LBUTTONDOWN)
    877949        {
    … …  
    921993        break;
    922994
    923     case SCROLL_BOTTOM_RECT:
     995      case SCROLL_BOTTOM_RECT:
    924996        SCROLL_DrawInterior( hwnd, hdc, nBar, &rect, arrowSize, thumbSize,
    925997                             thumbPos, infoPtr->flags, vertical,
    … …  
    9391011        break;
    9401012
    941     case SCROLL_BOTTOM_ARROW:
     1013      case SCROLL_BOTTOM_ARROW:
    9421014        SCROLL_DrawArrows( hdc, infoPtr, &rect, arrowSize, vertical,
    9431015                           FALSE, (hittest == SCROLL_trackHitTest) );
    … …  
    9751047
    9761048    ReleaseDC( hwnd, hdc );
    977 }
     1049
     1050    return res;
     1051}
     1052
     1053/***********************************************************************
     1054 *           SCROLL_HandleKbdEvent
     1055 *
     1056 * Handle a keyboard event (only for SB_CTL scrollbars).
     1057 */
     1058LRESULT SCROLL_KeyDown(HWND hwnd,WPARAM wParam,LPARAM lParam)
     1059{
     1060  DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     1061  UINT msg;
     1062
     1063  if (dwStyle & (SBS_SIZEBOX | SBS_SIZEGRIP)) return 0;
     1064
     1065  switch(wParam)
     1066  {
     1067    case VK_PRIOR: msg = SB_PAGEUP; break;
     1068    case VK_NEXT:  msg = SB_PAGEDOWN; break;
     1069    case VK_HOME:  msg = SB_TOP; break;
     1070    case VK_END:   msg = SB_BOTTOM; break;
     1071    case VK_UP:    msg = SB_LINEUP; break;
     1072    case VK_DOWN:  msg = SB_LINEDOWN; break;
     1073    default:
     1074      return 0;
     1075  }
     1076  SendMessageA( GetParent(hwnd),
     1077                (dwStyle & SBS_VERT) ? WM_VSCROLL : WM_HSCROLL,
     1078                msg, hwnd );
     1079
     1080  return 0;
     1081}
     1082
     1083LRESULT SCROLL_Paint(HWND hwnd,WPARAM wParam,LPARAM lParam,INT nBar)
     1084{
     1085  PAINTSTRUCT ps;
     1086  HDC hdc = wParam ? (HDC)wParam:BeginPaint( hwnd, &ps );
     1087
     1088  SCROLL_DrawScrollBar( hwnd, hdc, nBar, TRUE, TRUE );
     1089  if (!wParam) EndPaint( hwnd, &ps );
     1090
     1091  return 0;
     1092}
     1093
     1094LRESULT SCROLL_SetRange(HWND hwnd,WPARAM wParam,LPARAM lParam,INT nBar,BOOL redraw)
     1095{
     1096  SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,nBar);
     1097  INT oldPos = infoPtr->CurVal;
     1098
     1099  SetScrollRange(hwnd,nBar,wParam,lParam,redraw);
     1100  return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
     1101}
     1102
     1103/* Window Procedures */
     1104
    9781105/***********************************************************************
    9791106 *           ScrollBarWndProc
    … …  
    9821109                                 LPARAM lParam )
    9831110{
    984     switch(message)
    985     {
     1111  switch(message)
     1112  {
    9861113    case WM_NCCREATE:
    987       {
    988         SCROLLBAR_INFO *infoPtr = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
    989 
    990         infoPtr->MinVal = infoPtr->CurVal = infoPtr->Page = 0;
    991         infoPtr->MaxVal = 100;
    992         infoPtr->flags  = ESB_ENABLE_BOTH;
    993 
    994         SetInfoPtr(hwnd,(DWORD)infoPtr);
    995 
    996         if (!bitmapsLoaded) SCROLL_LoadBitmaps();
    997 
    998         return TRUE;
    999       }
     1114      return SCROLL_NCCreate(hwnd,wParam,lParam);
     1115
    10001116    case WM_CREATE:
    1001         {
    1002             CREATESTRUCTA *lpCreat = (CREATESTRUCTA *)lParam;
    1003             if (lpCreat->style & SBS_SIZEBOX)
    1004             {
    1005                 //FIXME("Unimplemented style SBS_SIZEBOX.\n" );
    1006                 return 0; //CB: implement! (for frames/toolbar already done)
    1007             }
    1008 
    1009             if (lpCreat->style & SBS_VERT)
    1010             {
    1011                 if (lpCreat->style & SBS_LEFTALIGN)
    1012                     MoveWindow( hwnd, lpCreat->x, lpCreat->y,
    1013                                   GetSystemMetrics(SM_CXVSCROLL)+1, lpCreat->cy, FALSE );
    1014                 else if (lpCreat->style & SBS_RIGHTALIGN)
    1015                     MoveWindow( hwnd,
    1016                                   lpCreat->x+lpCreat->cx-GetSystemMetrics(SM_CXVSCROLL)-1,
    1017                                   lpCreat->y,
    1018                                   GetSystemMetrics(SM_CXVSCROLL)+1, lpCreat->cy, FALSE );
    1019             }
    1020             else  /* SBS_HORZ */
    1021             {
    1022                 if (lpCreat->style & SBS_TOPALIGN)
    1023                     MoveWindow( hwnd, lpCreat->x, lpCreat->y,
    1024                                   lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL)+1, FALSE );
    1025                 else if (lpCreat->style & SBS_BOTTOMALIGN)
    1026                     MoveWindow( hwnd,
    1027                                   lpCreat->x,
    1028                                   lpCreat->y+lpCreat->cy-GetSystemMetrics(SM_CYHSCROLL)-1,
    1029                                   lpCreat->cx, GetSystemMetrics(SM_CYHSCROLL)+1, FALSE );
    1030             }
    1031         }
    1032 
    1033         //TRACE("ScrollBar creation, hwnd=%04x\n", hwnd );
    1034         return 0;
     1117      return SCROLL_Create(hwnd,wParam,lParam);
    10351118
    10361119    case WM_LBUTTONDOWN:
    … …  
    10381121    case WM_MOUSEMOVE:
    10391122    case WM_SYSTIMER:
    1040         {
    1041             POINT pt;
    1042             CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
    1043             SCROLL_HandleScrollEvent( hwnd, SB_CTL, message, pt );
    1044         }
    1045         break;
     1123    case WM_SETFOCUS:
     1124    case WM_KILLFOCUS:
     1125      return SCROLL_HandleScrollEvent(hwnd,wParam,lParam,SB_CTL,message);
    10461126
    10471127    case WM_KEYDOWN:
    1048         SCROLL_HandleKbdEvent( hwnd, wParam );
    1049         break;
     1128      return SCROLL_KeyDown(hwnd,wParam,lParam);
    10501129
    10511130    case WM_ERASEBKGND:
    1052          return 1;
     1131      return 1;
    10531132
    10541133    case WM_GETDLGCODE:
    1055          return DLGC_WANTARROWS; /* Windows returns this value */
     1134      return DLGC_WANTARROWS; /* Windows returns this value */
    10561135
    10571136    case WM_PAINT:
    1058         {
    1059             PAINTSTRUCT ps;
    1060             HDC hdc = BeginPaint( hwnd, &ps );
    1061             SCROLL_DrawScrollBar( hwnd, hdc, SB_CTL, TRUE, TRUE );
    1062             EndPaint( hwnd, &ps );
    1063         }
    1064         break;
     1137      return SCROLL_Paint(hwnd,wParam,lParam,SB_CTL);
    10651138
    10661139    case SBM_SETPOS:
    1067         return SetScrollPos( hwnd, SB_CTL, wParam, (BOOL)lParam );
     1140      return SetScrollPos( hwnd, SB_CTL, wParam, (BOOL)lParam );
    10681141
    10691142    case SBM_GETPOS:
    1070         return GetScrollPos( hwnd, SB_CTL );
     1143      return GetScrollPos( hwnd, SB_CTL );
    10711144
    10721145    case SBM_SETRANGE:
    1073         {
    1074           SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_CTL);
    1075           INT oldPos = infoPtr->CurVal;
    1076 
    1077           SetScrollRange(hwnd,SB_CTL,wParam,lParam,FALSE);
    1078           return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
    1079         }
     1146      return SCROLL_SetRange(hwnd,wParam,lParam,SB_CTL,FALSE);
    10801147
    10811148    case SBM_GETRANGE:
    1082         GetScrollRange( hwnd, SB_CTL, (LPINT)wParam, (LPINT)lParam );
    1083         return 0;
     1149      GetScrollRange( hwnd, SB_CTL, (LPINT)wParam, (LPINT)lParam );
     1150      return 0;
    10841151
    10851152    case SBM_ENABLE_ARROWS:
    1086         return EnableScrollBar( hwnd, SB_CTL, wParam );
     1153      return EnableScrollBar( hwnd, SB_CTL, wParam );
    10871154
    10881155    case SBM_SETRANGEREDRAW:
    1089         {
    1090           SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_CTL);
    1091           INT oldPos = infoPtr->CurVal;
    1092 
    1093           SetScrollRange(hwnd,SB_CTL,wParam,lParam,TRUE);
    1094           return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
    1095         }
     1156      return SCROLL_SetRange(hwnd,wParam,lParam,SB_CTL,TRUE);
    10961157
    10971158    case SBM_SETSCROLLINFO:
    1098         return SetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam, wParam );
     1159      return SetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam, wParam );
    10991160
    11001161    case SBM_GETSCROLLINFO:
    1101         return GetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam );
     1162      return GetScrollInfo( hwnd, SB_CTL, (SCROLLINFO *)lParam );
    11021163
    11031164    case 0x00e5:
    … …  
    11151176    default:
    11161177      return DefWindowProcA( hwnd, message, wParam, lParam );
    1117     }
    1118     return 0;
     1178  }
     1179
     1180  return 0;
    11191181}
    11201182
    … …  
    11231185VOID SCROLL_SubclassScrollBars(HWND hwndHorz,HWND hwndVert)
    11241186{
    1125   if (hwndHorz)
    1126   {
    1127     SetWindowLongA(hwndHorz,GWL_WNDPROC,(ULONG)HorzScrollBarWndProc);
    1128     //windowClass = Win32WndClass::FindClass(cs->hInstance, (LPSTR)classAtom);
    1129 //    InvalidateRect(hwndHorz,NULL,FALSE);
    1130   }
    1131 
    1132   if (hwndVert)
    1133   {
    1134     SetWindowLongA(hwndVert,GWL_WNDPROC,(ULONG)VertScrollBarWndProc);
    1135 //    InvalidateRect(hwndVert,NULL,FALSE);
    1136   }
     1187  if (hwndHorz) SetWindowLongA(hwndHorz,GWL_WNDPROC,(ULONG)HorzScrollBarWndProc);
     1188  if (hwndVert) SetWindowLongA(hwndVert,GWL_WNDPROC,(ULONG)VertScrollBarWndProc);
    11371189
    11381190  if (!bitmapsLoaded) SCROLL_LoadBitmaps();
    … …  
    11471199    case WM_MOUSEMOVE:
    11481200    case WM_SYSTIMER:
    1149         {
    1150             POINT pt;
    1151             CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
    1152             SCROLL_HandleScrollEvent( hwnd, SB_HORZ, message, pt );
    1153             if(message == WM_MOUSEMOVE) {
    1154                 return 1; //SvL: Let PM change the mouse cursor to the default
    1155             }
    1156         }
    1157         break;
     1201    case WM_SETFOCUS:
     1202    case WM_KILLFOCUS:
     1203      return SCROLL_HandleScrollEvent(hwnd,wParam,lParam,SB_HORZ,message);
    11581204
    11591205    case WM_ERASEBKGND:
    1160          return 1;
     1206      return 1;
    11611207
    11621208    case WM_GETDLGCODE:
    1163          return DLGC_WANTARROWS; /* Windows returns this value */
     1209      return DLGC_WANTARROWS; /* Windows returns this value */
    11641210
    11651211    case WM_PAINT:
    1166       {
    1167         PAINTSTRUCT ps;
    1168 
    1169         HDC hdc = BeginPaint( hwnd, &ps );
    1170         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
    1171         EndPaint( hwnd, &ps );
    1172       }
    1173       break;
     1212      return SCROLL_Paint(hwnd,wParam,lParam,SB_HORZ);
    11741213
    11751214    case SBM_SETPOS:
    … …  
    11771216
    11781217    case SBM_GETPOS:
    1179         return GetScrollPos( hwnd, SB_HORZ );
     1218      return GetScrollPos( hwnd, SB_HORZ );
    11801219
    11811220    case SBM_SETRANGE:
    1182         {
    1183           SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_HORZ);
    1184           INT oldPos = infoPtr->CurVal;
    1185 
    1186           SetScrollRange(hwnd,SB_HORZ,wParam,lParam,FALSE);
    1187           return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
    1188         }
     1221      return SCROLL_SetRange(hwnd,wParam,lParam,SB_HORZ,FALSE);
    11891222
    11901223    case SBM_GETRANGE:
    1191         GetScrollRange( hwnd, SB_HORZ, (LPINT)wParam, (LPINT)lParam );
    1192         return 0;
     1224      GetScrollRange( hwnd, SB_HORZ, (LPINT)wParam, (LPINT)lParam );
     1225      return 0;
    11931226
    11941227    case SBM_ENABLE_ARROWS:
    1195         return EnableScrollBar( hwnd, SB_HORZ, wParam );
     1228      return EnableScrollBar( hwnd, SB_HORZ, wParam );
    11961229
    11971230    case SBM_SETRANGEREDRAW:
    1198         {
    1199           SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_HORZ);
    1200           INT oldPos = infoPtr->CurVal;
    1201 
    1202           SetScrollRange(hwnd,SB_HORZ,wParam,lParam,TRUE);
    1203           return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
    1204         }
     1231      return SCROLL_SetRange(hwnd,wParam,lParam,SB_HORZ,TRUE);
    12051232
    12061233    case SBM_SETSCROLLINFO:
    1207         return SetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam, wParam );
     1234      return SetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam, wParam );
    12081235
    12091236    case SBM_GETSCROLLINFO:
    1210         return GetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam );
     1237      return GetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam );
    12111238
    12121239    default:
    … …  
    12251252    case WM_MOUSEMOVE:
    12261253    case WM_SYSTIMER:
    1227         {
    1228             POINT pt;
    1229             CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
    1230             SCROLL_HandleScrollEvent( hwnd, SB_VERT, message, pt );
    1231             if(message == WM_MOUSEMOVE) {
    1232                 return 1; //SvL: Let PM change the mouse cursor to the default
    1233             }
    1234         }
    1235         break;
     1254    case WM_SETFOCUS:
     1255    case WM_KILLFOCUS:
     1256      return SCROLL_HandleScrollEvent(hwnd,wParam,lParam,SB_VERT,message);
    12361257
    12371258    case WM_ERASEBKGND:
    1238          return 1;
     1259      return 1;
    12391260
    12401261    case WM_GETDLGCODE:
    1241          return DLGC_WANTARROWS; /* Windows returns this value */
     1262      return DLGC_WANTARROWS; /* Windows returns this value */
    12421263
    12431264    case WM_PAINT:
    1244       {
    1245         PAINTSTRUCT ps;
    1246 
    1247         HDC hdc = BeginPaint( hwnd, &ps );
    1248         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
    1249         EndPaint( hwnd, &ps );
    1250       }
    1251       break;
     1265      return SCROLL_Paint(hwnd,wParam,lParam,SB_VERT);
    12521266
    12531267    case SBM_SETPOS:
    … …  
    12551269
    12561270    case SBM_GETPOS:
    1257         return GetScrollPos( hwnd, SB_VERT );
     1271      return GetScrollPos( hwnd, SB_VERT );
    12581272
    12591273    case SBM_SETRANGE:
    1260         {
    1261           SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_VERT);
    1262           INT oldPos = infoPtr->CurVal;
    1263 
    1264           SetScrollRange(hwnd,SB_VERT,wParam,lParam,FALSE);
    1265           return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
    1266         }
     1274      return SCROLL_SetRange(hwnd,wParam,lParam,SB_VERT,FALSE);
    12671275
    12681276    case SBM_GETRANGE:
    1269         GetScrollRange( hwnd, SB_VERT, (LPINT)wParam, (LPINT)lParam );
    1270         return 0;
     1277      GetScrollRange( hwnd, SB_VERT, (LPINT)wParam, (LPINT)lParam );
     1278      return 0;
    12711279
    12721280    case SBM_ENABLE_ARROWS:
    1273         return EnableScrollBar( hwnd, SB_VERT, wParam );
     1281      return EnableScrollBar( hwnd, SB_VERT, wParam );
    12741282
    12751283    case SBM_SETRANGEREDRAW:
    1276         {
    1277           SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_VERT);
    1278           INT oldPos = infoPtr->CurVal;
    1279 
    1280           SetScrollRange(hwnd,SB_VERT,wParam,lParam,TRUE);
    1281           return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
    1282         }
     1284      return SCROLL_SetRange(hwnd,wParam,lParam,SB_VERT,TRUE);
    12831285
    12841286    case SBM_SETSCROLLINFO:
    1285         return SetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam, wParam );
     1287      return SetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam, wParam );
    12861288
    12871289    case SBM_GETSCROLLINFO:
    1288         return GetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam );
     1290      return GetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam );
    12891291
    12901292    default:
    … …  
    12951297}
    12961298
     1299/* Scrollbar API */
     1300
     1301//CB: fix hide/show bugs
    12971302
    12981303/*************************************************************************

  • trunk/src/user32/timer.cpp

    r1405 r1418  
    1 /* $Id: timer.cpp,v 1.5 1999-10-22 18:11:47 sandervl Exp $ */
     1/* $Id: timer.cpp,v 1.6 1999-10-23 16:45:21 cbratschi Exp $ */
    22
    33/*
    … …  
    2727#endif
    2828
    29 #define WM_TIMER_W 0x0113
     29#define WM_TIMER_W    0x0113
     30#define WM_SYSTIMER_W 0x0118
    3031typedef VOID (CALLBACK *TIMERPROC)(HWND hwnd, UINT msg, UINT id, DWORD dwTime);
    3132
    … …  
    6263}
    6364
     65BOOL TIMER_GetTimerInfo(HWND PMhwnd,ULONG PMid,PBOOL sys,PULONG id)
     66{
     67  int i;
     68  TIMER *pTimer;
     69
     70  for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
     71      if (pTimer->inUse && (pTimer->PMhwnd == PMhwnd) && (pTimer->PMid == PMid))
     72          break;
     73
     74  if (i == NB_TIMERS)  /* no matching timer found */
     75      return (FALSE);  /* forward message */
     76
     77  *sys = pTimer->inUse == TIMER::SystemTimer;
     78  *id  = pTimer->id;
     79
     80  return TRUE;
     81}
     82
    6483BOOL TIMER_HandleTimer (PQMSG pMsg)
    6584{
    … …  
    7695        return (FALSE);  /* forward message */
    7796
    78     pMsg->mp1 = MPFROMLONG (pTimer->id);
    7997    pMsg->mp2 = MPFROMLONG (TRUE);   /* mark for Win32 */
    8098    if (!pTimer->proc)
    … …  
    82100
    83101    if (!WinInSendMsg (GetThreadHAB()))
    84         pTimer->proc (pTimer->hwnd, WM_TIMER_W, pTimer->id, pMsg->time);
     102        pTimer->proc (pTimer->hwnd, (pTimer->inUse == TIMER::SystemTimer) ? WM_SYSTIMER_W:WM_TIMER_W, pTimer->id, pMsg->time);
    85103
    86104    return (TRUE);
    … …  
    100118
    101119    for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
    102         if (pTimer->inUse && (pTimer->hwnd == hwnd) && (pTimer->id == id))
     120        if (pTimer->inUse && (pTimer->hwnd == hwnd) && (pTimer->id == id) && ((sys && pTimer->inUse == TIMER::SystemTimer) || !sys))
    103121            break;
    104122
    … …  
    151169    for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
    152170        if (pTimer->inUse &&
    153             (pTimer->hwnd == hwnd) && (pTimer->id == id)) break;
     171            (pTimer->hwnd == hwnd) && (pTimer->id == id) && ((sys && pTimer->inUse == TIMER::SystemTimer) || !sys)) break;
    154172
    155173    if ((i >= NB_TIMERS) ||

  • trunk/src/user32/timer.h

    r1066 r1418  
    1 /* $Id: timer.h,v 1.1 1999-09-26 16:09:04 dengert Exp $ */
     1/* $Id: timer.h,v 1.2 1999-10-23 16:45:22 cbratschi Exp $ */
    22/*
    33 * public timer functions
    … …  
    1313#define __TIMER_H__
    1414
     15extern BOOL TIMER_GetTimerInfo(HWND PMhwnd,ULONG PMid,PBOOL sys,PULONG id);
    1516extern BOOL TIMER_HandleTimer (PQMSG pMsg);
    1617

  • trunk/src/user32/user32.cpp

    r1387 r1418  
    1 /* $Id: user32.cpp,v 1.46 1999-10-20 22:35:54 sandervl Exp $ */
     1/* $Id: user32.cpp,v 1.47 1999-10-23 16:45:22 cbratschi Exp $ */
    22
    33/*
    … …  
    951951        rc = FALSE;
    952952        break;
     953    case SM_MOUSEWHEELPRESENT:
     954        rc = FALSE;
     955        break;
     956    case SM_XVIRTUALSCREEN:
     957        rc = 0;
     958        break;
     959    case SM_YVIRTUALSCREEN:
     960        rc = 0;
     961        break;
     962    case SM_CXVIRTUALSCREEN:
     963        rc = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CXSCREEN);
     964        break;
     965    case SM_CYVIRTUALSCREEN:
     966        rc = OSLibWinQuerySysValue(OSLIB_HWND_DESKTOP,SVOS_CYSCREEN);
     967        break;
     968    case SM_CMONITORS:
     969        rc = 1;
     970        break;
     971    case SM_SAMEDISPLAYFORMAT:
     972        rc = TRUE;
     973        break;
    953974    case SM_CMETRICS:
    954         //CB: replace with const
    955         rc = O32_GetSystemMetrics(44);  //Open32 changed this one
     975        rc = 81;
     976        //rc = O32_GetSystemMetrics(44);  //Open32 changed this one
    956977        break;
    957978    default:

  • trunk/src/user32/win32wbase.cpp

    r1408 r1418  
    1 /* $Id: win32wbase.cpp,v 1.60 1999-10-23 10:21:44 sandervl Exp $ */
     1/* $Id: win32wbase.cpp,v 1.61 1999-10-23 16:45:23 cbratschi Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    … …  
    814814  // TODO: call TIMERPROC if not NULL
    815815  return SendInternalMessageA(WM_TIMER, TimerID, 0);
     816}
     817//******************************************************************************
     818//******************************************************************************
     819ULONG Win32BaseWindow::MsgSysTimer(ULONG TimerID)
     820{
     821  // TODO: call TIMERPROC if not NULL
     822  return SendInternalMessageA(WM_SYSTIMER, TimerID, 0);
    816823}
    817824//******************************************************************************

  • trunk/src/user32/win32wbase.h

    r1405 r1418  
    1 /* $Id: win32wbase.h,v 1.32 1999-10-22 18:11:48 sandervl Exp $ */
     1/* $Id: win32wbase.h,v 1.33 1999-10-23 16:45:24 cbratschi Exp $ */
    22/*
    33 * Win32 Window Base Class for OS/2
    … …  
    7777         ULONG  MsgKillFocus(HWND hwnd);
    7878         ULONG  MsgTimer(ULONG TimerID);
     79         ULONG  MsgSysTimer(ULONG TimerID);
    7980         ULONG  MsgScroll(ULONG msg, ULONG scrollCode, ULONG scrollPos);
    8081         ULONG  MsgCommand(ULONG cmd, ULONG Id, HWND hwnd);
    … …  
    148149         BOOL   ShowWindow(ULONG nCmdShow);
    149150         BOOL   SetWindowPos(HWND hwndInsertAfter, int x, int y, int cx, int cy, UINT fuFlags);
    150         BOOL   SetWindowPlacement(WINDOWPLACEMENT *winpos);
     151        BOOL   SetWindowPlacement(WINDOWPLACEMENT *winpos);
    151152         BOOL   DestroyWindow();
    152153         HWND   SetActiveWindow();
    … …  
    218219       ULONG getBorderHeight() { return borderHeight; };
    219220
    220 static  void  NC_AdjustRectInner(LPRECT rect, DWORD style, DWORD exStyle);
    221 static  void  NC_AdjustRectOuter(LPRECT rect, DWORD style, BOOL menu, DWORD exStyle);
    222 static  BOOL  WindowNeedsWMBorder( DWORD style, DWORD exStyle );
     221static  void  NC_AdjustRectInner(LPRECT rect, DWORD style, DWORD exStyle);
     222static  void  NC_AdjustRectOuter(LPRECT rect, DWORD style, BOOL menu, DWORD exStyle);
     223static  BOOL  WindowNeedsWMBorder( DWORD style, DWORD exStyle );
    223224
    224225       PVOID getOldWndProc() { return pOldWndProc; }
    … …  
    303304#ifndef OS2_INCLUDED
    304305        void  GetMinMaxInfo(POINT *maxSize, POINT *maxPos, POINT *minTrack, POINT *maxTrack );
    305         LONG  HandleWindowPosChanging(WINDOWPOS *winpos);
     306        LONG  HandleWindowPosChanging(WINDOWPOS *winpos);
    306307        LONG  HandleSysCommand(WPARAM wParam, POINT *pt32);
    307308
Note: See TracChangeset for help on using the changeset viewer.