Ignore:
Timestamp:
Oct 17, 1999, 2:17:46 PM (26 years ago)
Author:
cbratschi
Message:

added WINE scrollbars to frame, fixed pmframe, WM_ENTERIDLE

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/user32/scroll.cpp

    r1306 r1333  
    1 /* $Id: scroll.cpp,v 1.8 1999-10-15 09:26:23 sandervl Exp $ */
     1/* $Id: scroll.cpp,v 1.9 1999-10-17 12:17:44 cbratschi Exp $ */
    22/*
    33 * Scrollbar control
    44 *
    5  * Copyright 1999 Christoph Bratschi (ported from WINE)
     5 * Copyright 1999 Christoph Bratschi
    66 *
    77 * Copyright 1993 Martin Ayotte
     
    1010 * WINE version: 990923
    1111 */
    12 
    13 /* CB:
    14   - exported API removed, this functions are already implemented by Open32,
    15     code perhaps useful for new user32
    16   - only control, default scroll bars for windows need more work
    17   - SystemTimer not implemented
    18 */
    1912
    2013#include <stdlib.h>
     
    2417#include "win32wbase.h"
    2518#include "oslibwin.h"
     19
     20static BOOL bitmapsLoaded = FALSE;
    2621
    2722static HBITMAP hUpArrow = 0;
     
    112107{
    113108    HINSTANCE hinst;
     109
     110    if (bitmapsLoaded) return;
    114111
    115112    //CB: Open32 hack to load our own bitmap
     
    128125    hRgArrowI = NativeLoadBitmap( hinst, MAKEINTRESOURCEA(OBM_RGARROWI) );
    129126    FreeLibrary(hinst);
     127
     128    bitmapsLoaded = TRUE;
    130129}
    131130
    132131/***********************************************************************
    133  *           SCROLL_GetPtrScrollInfo
    134  */
    135 static SCROLLBAR_INFO *SCROLL_GetPtrScrollInfo( HWND hwnd, INT nBar )
    136 {
    137     SCROLLBAR_INFO *infoPtr;
     132 *           SCROLL_GetInfoPtr
     133 */
     134static SCROLLBAR_INFO *SCROLL_GetInfoPtr( HWND hwnd, INT nBar )
     135{
     136    Win32BaseWindow *win32wnd;
     137    HWND hwndFrame;
    138138
    139139    switch(nBar)
    140140    {
    141 /* CB: implement this later!
    142141        case SB_HORZ:
    143           infoPtr = (SCROLLBAR_INFO *)wndPtr->pHScroll;
    144           break;
    145142        case SB_VERT:
    146           infoPtr = (SCROLLBAR_INFO *)wndPtr->pVScroll;
    147           break;
    148 */
     143          win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
     144          if (!win32wnd) return NULL;
     145          hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_PARENT);
     146          win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
     147          if (!win32wnd) return NULL;
     148          return win32wnd->getScrollInfo(nBar);
     149
    149150        case SB_CTL:
    150           infoPtr = (SCROLLBAR_INFO *)GetInfoPtr(hwnd);
    151           break;
    152         default:      return NULL;
    153     }
    154 
    155     if (!infoPtr)  /* Create the info structure if needed */
    156     {
    157         infoPtr = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
    158         infoPtr->MinVal = infoPtr->CurVal = infoPtr->Page = 0;
    159         infoPtr->MaxVal = 100;
    160         infoPtr->flags  = ESB_ENABLE_BOTH;
    161 
    162         //CB: store in window class if not control!
    163         SetInfoPtr(hwnd,(DWORD)infoPtr);
    164 
    165         if (!hUpArrow) SCROLL_LoadBitmaps();
    166     }
    167     return infoPtr;
    168 }
    169 
    170 
    171 /***********************************************************************
    172  *           SCROLL_GetScrollInfo
    173  */
    174 static SCROLLBAR_INFO *SCROLL_GetScrollInfo( HWND hwnd, INT nBar )
    175 {
    176  Win32BaseWindow *window;
    177 
    178     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    179     if(!window && nBar != SB_CTL) {
    180         dprintf(("SCROLL_GetScrollInfo window %x not found!", hwnd));
    181         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
    182         return NULL;
    183     }
    184 
    185     if (window) {
    186             return window->getScrollInfo(nBar);
    187     }
    188 
    189     return SCROLL_GetPtrScrollInfo( hwnd, nBar );
     151          return (SCROLLBAR_INFO*)GetInfoPtr(hwnd);
     152    }
     153
     154    return NULL;
    190155}
    191156
     
    208173    INT pixels;
    209174    BOOL vertical;
    210     DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
    211175    RECT rectClient;
    212176
    213177    switch(nBar)
    214178    {
    215 /* CB: implement later!
    216179      case SB_HORZ:
    217         lprect->left   = wndPtr->rectClient.left - wndPtr->rectWindow.left;
    218         lprect->top    = wndPtr->rectClient.bottom - wndPtr->rectWindow.top;
    219         lprect->right  = wndPtr->rectClient.right - wndPtr->rectWindow.left;
    220         lprect->bottom = lprect->top + GetSystemMetrics(SM_CYHSCROLL);
    221         if(dwStyle & WS_BORDER) {
    222           lprect->left--;
    223           lprect->right++;
    224         } else if(dwStyle & WS_VSCROLL)
    225           lprect->right++;
    226         vertical = FALSE;
     180      case SB_VERT:
     181        GetClientRect( hwnd, lprect );
     182        vertical = (nBar == SB_VERT);
    227183        break;
    228184
    229       case SB_VERT:
    230         lprect->left   = wndPtr->rectClient.right - wndPtr->rectWindow.left;
    231         lprect->top    = wndPtr->rectClient.top - wndPtr->rectWindow.top;
    232         lprect->right  = lprect->left + GetSystemMetrics(SM_CXVSCROLL);
    233         lprect->bottom = wndPtr->rectClient.bottom - wndPtr->rectWindow.top;
    234         if(wndPtr->dwStyle & WS_BORDER) {
    235           lprect->top--;
    236           lprect->bottom++;
    237         } else if(wndPtr->dwStyle & WS_HSCROLL)
    238           lprect->bottom++;
    239         vertical = TRUE;
    240         break;
    241 */
    242185      case SB_CTL:
    243         GetClientRect( hwnd, lprect );
    244         vertical = ((dwStyle & SBS_VERT) != 0);
    245         break;
     186        {
     187          DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
     188
     189          GetClientRect( hwnd, lprect );
     190          vertical = ((dwStyle & SBS_VERT) != 0);
     191          break;
     192        }
    246193
    247194    default:
     
    262209    else
    263210    {
    264         SCROLLBAR_INFO *info = SCROLL_GetPtrScrollInfo( hwnd, nBar );
     211        SCROLLBAR_INFO *info = SCROLL_GetInfoPtr( hwnd, nBar );
    265212
    266213        *arrowSize = GetSystemMetrics(SM_CXVSCROLL);
     
    454401 * Draw the moving thumb rectangle.
    455402 */
    456 static void SCROLL_DrawMovingThumb_9x( HDC hdc, RECT *rect, BOOL vertical,
     403static void SCROLL_DrawMovingThumb( HDC hdc, RECT *rect, BOOL vertical,
    457404                       INT arrowSize, INT thumbSize )
    458405{
     
    477424
    478425  SCROLL_MovingThumb = !SCROLL_MovingThumb;
    479 }
    480 //******************************************************************************
    481 //******************************************************************************
    482 static void SCROLL_DrawMovingThumb( HDC hdc, RECT *rect, BOOL vertical,
    483                     INT arrowSize, INT thumbSize )
    484 {
    485   SCROLL_DrawMovingThumb_9x( hdc, rect, vertical, arrowSize, thumbSize );
    486426}
    487427/***********************************************************************
     
    511451    else
    512452    {
    513       //CB: implement!
    514       //hBrush = DEFWND_ControlColor( hdc, CTLCOLOR_SCROLLBAR );
     453      hBrush = (HBRUSH)SendMessageA( hwnd, WM_CTLCOLORSCROLLBAR,
     454                     (WPARAM)hdc,(LPARAM)hwnd);
    515455    }
    516456
     
    591531    BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
    592532
     533//SCROLL_DrawInterior_9x(hwnd,hdc,nBar,rect,arrowSize,thumbSize,thumbPos,flags,vertical,top_selected,bottom_selected);
     534//return; //CB: improve!
     535
    593536    if (Save_SCROLL_MovingThumb &&
    594537        (SCROLL_TrackingWin == hwnd) &&
     
    606549                                       (WPARAM)hdc,(LPARAM)hwnd);
    607550    } else {
    608         //CB: implement!
    609         //hBrush = DEFWND_ControlColor( hdc, CTLCOLOR_SCROLLBAR );
     551        hBrush = (HBRUSH)SendMessageA( hwnd, WM_CTLCOLORSCROLLBAR,
     552                                       (WPARAM)hdc,(LPARAM)hwnd);
     553
    610554    }
    611555
     
    706650    RECT rect;
    707651    BOOL vertical;
    708     SCROLLBAR_INFO *infoPtr = SCROLL_GetPtrScrollInfo( hwnd, nBar );
     652    SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
    709653    BOOL Save_SCROLL_MovingThumb = SCROLL_MovingThumb;
    710     DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
    711 
    712     if (!infoPtr ||
    713         ((nBar == SB_VERT) && !(dwStyle & WS_VSCROLL)) ||
    714         ((nBar == SB_HORZ) && !(dwStyle & WS_HSCROLL))) return;
    715     //if (!WIN_IsWindowDrawable( hwnd, FALSE )) return; //CB: what's that???
    716654
    717655    vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
     
    754692                                     BOOL arrows, BOOL interior )
    755693{
    756     HDC hdc = GetDCEx( hwnd, 0,
    757                            DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW) );
     694    //HDC hdc = GetDCEx( hwnd, 0,
     695    //                       DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW) );
     696HDC hdc;
     697
     698return;
     699//CB: bug: paints in client window!
     700//    GetClientRect returns wrong window size after GetDC
     701//    why?!?
     702
    758703    if (!hdc) return;
    759704
     
    811756    HDC hdc;
    812757
    813     SCROLLBAR_INFO *infoPtr = SCROLL_GetScrollInfo( hwnd, nBar );
     758    SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
    814759    if (!infoPtr) return;
    815760    if ((SCROLL_trackHitTest == SCROLL_NOWHERE) && (msg != WM_LBUTTONDOWN))
    816761                  return;
    817762
    818     hdc = GetDCEx( hwnd, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
    819763    vertical = SCROLL_GetScrollBarRect( hwnd, nBar, &rect,
    820764                                        &arrowSize, &thumbSize, &thumbPos );
    821     hwndOwner = (nBar == SB_CTL) ? GetParent(hwnd) : hwnd;
     765    if (nBar == SB_CTL) hwndOwner = GetParent(hwnd); else
     766    {
     767      Win32BaseWindow *win32wnd;
     768      HWND hwndFrame;
     769
     770      win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
     771      if (!win32wnd) return;
     772      hwndFrame = OSLibWinQueryWindow(win32wnd->getOS2WindowHandle(),QWOS_PARENT);
     773      win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwndFrame);
     774      if (!win32wnd) return;
     775      hwndOwner = win32wnd->getWindowHandle();
     776    }
     777
    822778    hwndCtl   = (nBar == SB_CTL) ? hwnd : 0;
    823779
     
    854810    }
    855811
     812    hdc = GetDCEx( hwnd, 0, DCX_CACHE | ((nBar == SB_CTL) ? 0 : DCX_WINDOW));
     813
    856814    //TRACE("Event: hwnd=%04x bar=%d msg=%x pt=%ld,%ld hit=%d\n",
    857815    //             hwnd, nBar, msg, pt.x, pt.y, hittest );
     
    872830                                SB_LINEUP, hwndCtl );
    873831            }
    874             //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    875             //                  SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    876             //                  (TIMERPROC)0 );
    877         }
    878         //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
     832            SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     833                            SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     834                            (TIMERPROC)0 );
     835        }
     836        else KillSystemTimer( hwnd, SCROLL_TIMER );
    879837        break;
    880838
     
    889847                SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    890848                                SB_PAGEUP, hwndCtl );
    891                 //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    892                 //                  SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    893                 //                  (TIMERPROC)0 );
     849                SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     850                                SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     851                                (TIMERPROC)0 );
    894852            }
    895853        }
    896         //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
     854        else KillSystemTimer( hwnd, SCROLL_TIMER );
    897855        break;
    898856
     
    955913                SendMessageA( hwndOwner, vertical ? WM_VSCROLL : WM_HSCROLL,
    956914                                SB_PAGEDOWN, hwndCtl );
    957                 //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    958                 //                  SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    959                 //                  (TIMERPROC)0 );
     915                SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     916                                SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     917                                (TIMERPROC)0 );
    960918            }
    961919        }
    962         //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
     920        else KillSystemTimer( hwnd, SCROLL_TIMER );
    963921        break;
    964922
     
    973931                                SB_LINEDOWN, hwndCtl );
    974932            }
    975             //CB: SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
    976             //                  SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
    977             //                  (TIMERPROC)0 );
    978         }
    979         //CB: else KillSystemTimer( hwnd, SCROLL_TIMER );
     933            SetSystemTimer( hwnd, SCROLL_TIMER, (msg == WM_LBUTTONDOWN) ?
     934                            SCROLL_FIRST_DELAY : SCROLL_REPEAT_DELAY,
     935                            (TIMERPROC)0 );
     936        }
     937        else KillSystemTimer( hwnd, SCROLL_TIMER );
    980938        break;
    981939    }
     
    1008966    switch(message)
    1009967    {
     968    case WM_NCCREATE:
     969      {
     970        SCROLLBAR_INFO *infoPtr = (SCROLLBAR_INFO*)malloc(sizeof(SCROLLBAR_INFO));
     971
     972        infoPtr->MinVal = infoPtr->CurVal = infoPtr->Page = 0;
     973        infoPtr->MaxVal = 100;
     974        infoPtr->flags  = ESB_ENABLE_BOTH;
     975
     976        SetInfoPtr(hwnd,(DWORD)infoPtr);
     977
     978        if (!bitmapsLoaded) SCROLL_LoadBitmaps();
     979
     980        return TRUE;
     981      }
    1010982    case WM_CREATE:
    1011983        {
     
    1014986            {
    1015987                //FIXME("Unimplemented style SBS_SIZEBOX.\n" );
    1016                 return 0;
     988                return 0; //CB: implement! (for frames/toolbar already done)
    1017989            }
    1018990
     
    10401012            }
    10411013        }
    1042         if (!hUpArrow) SCROLL_LoadBitmaps();
     1014
    10431015        //TRACE("ScrollBar creation, hwnd=%04x\n", hwnd );
    10441016        return 0;
     
    10811053
    10821054    case SBM_SETRANGE:
    1083         SetScrollRange( hwnd, SB_CTL, wParam, lParam, FALSE );
    1084         return 0;  /* FIXME: return previous position */
     1055        {
     1056          SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_CTL);
     1057          INT oldPos = infoPtr->CurVal;
     1058
     1059          SetScrollRange(hwnd,SB_CTL,wParam,lParam,FALSE);
     1060          return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
     1061        }
    10851062
    10861063    case SBM_GETRANGE:
     
    10921069
    10931070    case SBM_SETRANGEREDRAW:
    1094         SetScrollRange( hwnd, SB_CTL, wParam, lParam, TRUE );
    1095         return 0;  /* FIXME: return previous position */
     1071        {
     1072          SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_CTL);
     1073          INT oldPos = infoPtr->CurVal;
     1074
     1075          SetScrollRange(hwnd,SB_CTL,wParam,lParam,TRUE);
     1076          return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
     1077        }
    10961078
    10971079    case SBM_SETSCROLLINFO:
     
    11141096
    11151097    default:
    1116 //SvL: BUGFIX: Send WM_NCCREATE to defwndproc, return value 0 cancels window creation!
    1117 //        if (message >= WM_USER)
    1118             //WARN("unknown msg %04x wp=%04x lp=%08lx\n",
    1119             //             message, wParam, lParam );
    1120         return DefWindowProcA( hwnd, message, wParam, lParam );
     1098      return DefWindowProcA( hwnd, message, wParam, lParam );
    11211099    }
    11221100    return 0;
     1101}
     1102
     1103/* frame handlers */
     1104
     1105VOID SCROLL_SubclassScrollBars(HWND hwndHorz,HWND hwndVert)
     1106{
     1107  if (hwndHorz)
     1108  {
     1109    SetWindowLongA(hwndHorz,GWL_WNDPROC,(ULONG)HorzScrollBarWndProc);
     1110    //windowClass = Win32WndClass::FindClass(cs->hInstance, (LPSTR)classAtom);
     1111//    InvalidateRect(hwndHorz,NULL,FALSE);
     1112  }
     1113
     1114  if (hwndVert)
     1115  {
     1116    SetWindowLongA(hwndVert,GWL_WNDPROC,(ULONG)VertScrollBarWndProc);
     1117//    InvalidateRect(hwndVert,NULL,FALSE);
     1118  }
     1119
     1120  if (!bitmapsLoaded) SCROLL_LoadBitmaps();
     1121}
     1122
     1123LRESULT WINAPI HorzScrollBarWndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam )
     1124{
     1125  switch (message)
     1126  {
     1127    case WM_LBUTTONDOWN:
     1128    case WM_LBUTTONUP:
     1129    case WM_MOUSEMOVE:
     1130    case WM_SYSTIMER:
     1131        {
     1132            POINT pt;
     1133            CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
     1134            SCROLL_HandleScrollEvent( hwnd, SB_HORZ, message, pt );
     1135        }
     1136        break;
     1137
     1138    case WM_ERASEBKGND:
     1139         return 1;
     1140
     1141    case WM_GETDLGCODE:
     1142         return DLGC_WANTARROWS; /* Windows returns this value */
     1143
     1144    case WM_PAINT:
     1145      {
     1146        PAINTSTRUCT ps;
     1147
     1148        HDC hdc = BeginPaint( hwnd, &ps );
     1149        SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
     1150        EndPaint( hwnd, &ps );
     1151      }
     1152      break;
     1153
     1154    case SBM_SETPOS:
     1155      return SetScrollPos( hwnd, SB_HORZ, wParam, (BOOL)lParam );
     1156
     1157    case SBM_GETPOS:
     1158        return GetScrollPos( hwnd, SB_HORZ );
     1159
     1160    case SBM_SETRANGE:
     1161        {
     1162          SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_HORZ);
     1163          INT oldPos = infoPtr->CurVal;
     1164
     1165          SetScrollRange(hwnd,SB_HORZ,wParam,lParam,FALSE);
     1166          return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
     1167        }
     1168
     1169    case SBM_GETRANGE:
     1170        GetScrollRange( hwnd, SB_HORZ, (LPINT)wParam, (LPINT)lParam );
     1171        return 0;
     1172
     1173    case SBM_ENABLE_ARROWS:
     1174        return EnableScrollBar( hwnd, SB_HORZ, wParam );
     1175
     1176    case SBM_SETRANGEREDRAW:
     1177        {
     1178          SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_HORZ);
     1179          INT oldPos = infoPtr->CurVal;
     1180
     1181          SetScrollRange(hwnd,SB_HORZ,wParam,lParam,TRUE);
     1182          return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
     1183        }
     1184
     1185    case SBM_SETSCROLLINFO:
     1186        return SetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam, wParam );
     1187
     1188    case SBM_GETSCROLLINFO:
     1189        return GetScrollInfo( hwnd, SB_HORZ, (SCROLLINFO *)lParam );
     1190
     1191    default:
     1192      return DefWindowProcA(hwnd,message,wParam,lParam);
     1193  }
     1194
     1195  return 0;
     1196}
     1197
     1198LRESULT WINAPI VertScrollBarWndProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam )
     1199{
     1200  switch (message)
     1201  {
     1202    case WM_LBUTTONDOWN:
     1203    case WM_LBUTTONUP:
     1204    case WM_MOUSEMOVE:
     1205    case WM_SYSTIMER:
     1206        {
     1207            POINT pt;
     1208            CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
     1209            SCROLL_HandleScrollEvent( hwnd, SB_VERT, message, pt );
     1210        }
     1211        break;
     1212
     1213    case WM_ERASEBKGND:
     1214         return 1;
     1215
     1216    case WM_GETDLGCODE:
     1217         return DLGC_WANTARROWS; /* Windows returns this value */
     1218
     1219    case WM_PAINT:
     1220      {
     1221        PAINTSTRUCT ps;
     1222
     1223        HDC hdc = BeginPaint( hwnd, &ps );
     1224        SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
     1225        EndPaint( hwnd, &ps );
     1226      }
     1227      break;
     1228
     1229    case SBM_SETPOS:
     1230      return SetScrollPos( hwnd, SB_VERT, wParam, (BOOL)lParam );
     1231
     1232    case SBM_GETPOS:
     1233        return GetScrollPos( hwnd, SB_VERT );
     1234
     1235    case SBM_SETRANGE:
     1236        {
     1237          SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_VERT);
     1238          INT oldPos = infoPtr->CurVal;
     1239
     1240          SetScrollRange(hwnd,SB_VERT,wParam,lParam,FALSE);
     1241          return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
     1242        }
     1243
     1244    case SBM_GETRANGE:
     1245        GetScrollRange( hwnd, SB_VERT, (LPINT)wParam, (LPINT)lParam );
     1246        return 0;
     1247
     1248    case SBM_ENABLE_ARROWS:
     1249        return EnableScrollBar( hwnd, SB_VERT, wParam );
     1250
     1251    case SBM_SETRANGEREDRAW:
     1252        {
     1253          SCROLLBAR_INFO *infoPtr = SCROLL_GetInfoPtr(hwnd,SB_VERT);
     1254          INT oldPos = infoPtr->CurVal;
     1255
     1256          SetScrollRange(hwnd,SB_VERT,wParam,lParam,TRUE);
     1257          return (oldPos != infoPtr->CurVal) ? infoPtr->CurVal:0;
     1258        }
     1259
     1260    case SBM_SETSCROLLINFO:
     1261        return SetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam, wParam );
     1262
     1263    case SBM_GETSCROLLINFO:
     1264        return GetScrollInfo( hwnd, SB_VERT, (SCROLLINFO *)lParam );
     1265
     1266    default:
     1267      return DefWindowProcA(hwnd,message,wParam,lParam);
     1268  }
     1269
     1270  return 0;
    11231271}
    11241272
     
    11481296  INT retVal;
    11491297
     1298/* CB: handled here, todo: hide/show
    11501299    window = Win32BaseWindow::GetWindowFromHandle(hwnd);
    11511300    if(!window && nBar != SB_CTL) {
     
    11571306        return window->setScrollInfo(nBar, (SCROLLINFO *)info, bRedraw);
    11581307    }
     1308*/
    11591309
    11601310    retVal = SCROLL_SetScrollInfo( hwnd, nBar, info, &action );
     
    11871337   *action = 0;
    11881338
    1189     if (!(infoPtr = SCROLL_GetScrollInfo(hwnd, nBar))) return 0;
     1339    if (!(infoPtr = SCROLL_GetInfoPtr(hwnd, nBar))) return 0;
    11901340    if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return 0;
    11911341    if ((info->cbSize != sizeof(*info)) &&
     
    13031453  SCROLLBAR_INFO *infoPtr;
    13041454
    1305     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return FALSE;
     1455    if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return FALSE;
    13061456    if (info->fMask & ~(SIF_ALL | SIF_DISABLENOSCROLL)) return FALSE;
    13071457    if ((info->cbSize != sizeof(*info)) &&
     
    13411491
    13421492    dprintf(("SetScrollPos %x %d %d %d", hwnd, nBar, nPos, bRedraw));
    1343     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return 0;
     1493    if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return 0;
    13441494    oldPos      = infoPtr->CurVal;
    13451495    info.cbSize = sizeof(info);
     
    13681518    dprintf(("GetScrollPos %x %d", hwnd, nBar));
    13691519
    1370     infoPtr = SCROLL_GetScrollInfo( hwnd, nBar );
     1520    infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
    13711521    if (!infoPtr) return 0;
    13721522
     
    14421592  SCROLLBAR_INFO *infoPtr;
    14431593
    1444     infoPtr = SCROLL_GetScrollInfo( hwnd, nBar );
     1594    infoPtr = SCROLL_GetInfoPtr( hwnd, nBar );
    14451595    if (!infoPtr)
    14461596    {
     
    16171767    if (nBar == SB_BOTH)
    16181768    {
    1619         if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, SB_VERT ))) return FALSE;
     1769        if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, SB_VERT ))) return FALSE;
    16201770        if (!(bFineWithMe = (infoPtr->flags == flags)) )
    16211771        {
     
    16281778        bFineWithMe = TRUE;
    16291779
    1630     if (!(infoPtr = SCROLL_GetScrollInfo( hwnd, nBar ))) return FALSE;
     1780    if (!(infoPtr = SCROLL_GetInfoPtr( hwnd, nBar ))) return FALSE;
    16311781    if (bFineWithMe && infoPtr->flags == flags) return FALSE;
    16321782    infoPtr->flags = flags;
Note: See TracChangeset for help on using the changeset viewer.