Ignore:
Timestamp:
Aug 25, 1999, 5:08:51 PM (26 years ago)
Author:
dengert
Message:

new window size/move code

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/new/win32wnd.cpp

    r650 r693  
    1 /* $Id: win32wnd.cpp,v 1.29 1999-08-23 15:34:47 dengert Exp $ */
     1/* $Id: win32wnd.cpp,v 1.30 1999-08-25 15:08:50 dengert Exp $ */
    22/*
    33 * Win32 Window Code for OS/2
    … …  
    5757//******************************************************************************
    5858Win32Window::Win32Window(CREATESTRUCTA *lpCreateStructA, ATOM classAtom, BOOL isUnicode)
    59                         : GenericObject(&windows, OBJTYPE_WINDOW), ChildWindow()
     59                        : GenericObject(&windows, OBJTYPE_WINDOW), ChildWindow()
    6060{
    6161  Init();
    … …  
    6767void Win32Window::Init()
    6868{
    69   isUnicode        = FALSE;
    70   fCreated         = FALSE;
    71   fFirstShow       = TRUE;
     69  isUnicode        = FALSE;
     70  fCreated         = FALSE;
     71  fFirstShow       = TRUE;
    7272
    7373  memset(windowNameA, 0, MAX_WINDOW_NAMELENGTH);
    … …  
    7878  nrUserWindowLong = 0;
    7979
    80   magic            = WIN32PM_MAGIC;
    81   OS2Hwnd          = 0;
    82   OS2HwndFrame     = 0;
    83   OS2HwndMenu      = 0;
    84   Win32Hwnd        = 0;
     80  magic            = WIN32PM_MAGIC;
     81  OS2Hwnd          = 0;
     82  OS2HwndFrame     = 0;
     83  OS2HwndMenu      = 0;
     84  Win32Hwnd        = 0;
    8585
    8686  if(HMHandleAllocate(&Win32Hwnd, (ULONG)this) != 0)
    8787  {
    88         dprintf(("Win32Window::Init HMHandleAllocate failed!!"));
    89         DebugInt3();
    90   }
    91   Win32Hwnd       &= 0xFFFF;
    92   Win32Hwnd       |= 0x68000000;
    93 
    94   posx = posy      = 0;
     88        dprintf(("Win32Window::Init HMHandleAllocate failed!!"));
     89        DebugInt3();
     90  }
     91  Win32Hwnd       &= 0xFFFF;
     92  Win32Hwnd       |= 0x68000000;
     93
     94  posx = posy      = 0;
    9595  width = height   = 0;
    9696
    97   dwExStyle        = 0;
    98   dwStyle          = 0;
    99   win32wndproc     = 0;
    100   hInstance        = 0;
    101   windowId         = 0xFFFFFFFF;        //default = -1
    102   userData         = 0;
     97  dwExStyle        = 0;
     98  dwStyle          = 0;
     99  win32wndproc     = 0;
     100  hInstance        = 0;
     101  windowId         = 0xFFFFFFFF;        //default = -1
     102  userData         = 0;
    103103
    104104  hwndLinkAfter    = HWND_BOTTOM;
    105   flags            = 0;
    106   isIcon           = FALSE;
     105  flags            = 0;
     106  isIcon           = FALSE;
    107107  lastHitTestVal   = 0;
    108   owner            = NULL;
    109   windowClass      = 0;
     108  owner            = NULL;
     109  windowClass      = 0;
    110110
    111111  acceltableResource = NULL;
    112   menuResource       = NULL;
    113   iconResource       = NULL;
     112  menuResource       = NULL;
     113  iconResource       = NULL;
    114114}
    115115//******************************************************************************
    … …  
    122122
    123123  if(Win32Hwnd)
    124         HMHandleFree(Win32Hwnd & 0xFFFF);
     124        HMHandleFree(Win32Hwnd & 0xFFFF);
    125125  if(userWindowLong)
    126         free(userWindowLong);
     126        free(userWindowLong);
    127127}
    128128//******************************************************************************
    … …  
    145145    if (cs->hwndParent)
    146146    {
    147             Win32Window *window = GetWindowFromHandle(cs->hwndParent);
    148             if(!window) {
    149                     dprintf(("Bad parent %04x\n", cs->hwndParent ));
    150                     SetLastError(ERROR_INVALID_PARAMETER);
    151                     return FALSE;
    152             }
    153             /* Make sure parent is valid */
    154             if (!window->IsWindow() )
    155             {
    156                     dprintf(("Bad parent %04x\n", cs->hwndParent ));
    157                     SetLastError(ERROR_INVALID_PARAMETER);
    158                     return FALSE;
    159             }
     147            Win32Window *window = GetWindowFromHandle(cs->hwndParent);
     148            if(!window) {
     149                    dprintf(("Bad parent %04x\n", cs->hwndParent ));
     150                    SetLastError(ERROR_INVALID_PARAMETER);
     151                    return FALSE;
     152            }
     153            /* Make sure parent is valid */
     154            if (!window->IsWindow() )
     155            {
     156                    dprintf(("Bad parent %04x\n", cs->hwndParent ));
     157                    SetLastError(ERROR_INVALID_PARAMETER);
     158                    return FALSE;
     159            }
    160160    }
    161161    else
    162162    if ((cs->style & WS_CHILD) && !(cs->style & WS_POPUP)) {
    163             dprintf(("No parent for child window\n" ));
    164             SetLastError(ERROR_INVALID_PARAMETER);
    165             return FALSE;  /* WS_CHILD needs a parent, but WS_POPUP doesn't */
     163            dprintf(("No parent for child window\n" ));
     164            SetLastError(ERROR_INVALID_PARAMETER);
     165            return FALSE;  /* WS_CHILD needs a parent, but WS_POPUP doesn't */
    166166    }
    167167
    … …  
    170170  if (!windowClass)
    171171  {
    172         GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
    173         dprintf(("Bad class '%s'\n", buffer ));
    174         return 0;
     172        GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
     173        dprintf(("Bad class '%s'\n", buffer ));
     174        return 0;
    175175  }
    176176
    … …  
    180180   */
    181181  if (!HIWORD(cs->lpszClass) ) {
    182         if (isUnicode) {
    183                 GlobalGetAtomNameW( classAtom, (LPWSTR)buffer, sizeof(buffer) );
    184         }
    185         else {
    186                 GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
    187         }
    188         cs->lpszClass = buffer;
     182        if (isUnicode) {
     183                GlobalGetAtomNameW( classAtom, (LPWSTR)buffer, sizeof(buffer) );
     184        }
     185        else {
     186                GlobalGetAtomNameA( classAtom, buffer, sizeof(buffer) );
     187        }
     188        cs->lpszClass = buffer;
    189189  }
    190190
    … …  
    192192  if (cs->x == CW_USEDEFAULT || cs->x == CW_USEDEFAULT16)
    193193  {
    194 //        PDB *pdb = PROCESS_Current();
     194//        PDB *pdb = PROCESS_Current();
    195195
    196196       /* Never believe Microsoft's documentation... CreateWindowEx doc says
    197         * that if an overlapped window is created with WS_VISIBLE style bit
    198         * set and the x parameter is set to CW_USEDEFAULT, the system ignores
    199         * the y parameter. However, disassembling NT implementation (WIN32K.SYS)
    200         * reveals that
    201         *
    202         * 1) not only if checks for CW_USEDEFAULT but also for CW_USEDEFAULT16
    203         * 2) it does not ignore the y parameter as the docs claim; instead, it
    204         *    uses it as second parameter to ShowWindow() unless y is either
    205         *    CW_USEDEFAULT or CW_USEDEFAULT16.
    206         *
    207         * The fact that we didn't do 2) caused bogus windows pop up when wine
    208         * was running apps that were using this obscure feature. Example -
    209         * calc.exe that comes with Win98 (only Win98, it's different from
    210         * the one that comes with Win95 and NT)
    211         */
    212         if (cs->y != CW_USEDEFAULT && cs->y != CW_USEDEFAULT16) sw = cs->y;
    213 
    214         /* We have saved cs->y, now we can trash it */
     197        * that if an overlapped window is created with WS_VISIBLE style bit
     198        * set and the x parameter is set to CW_USEDEFAULT, the system ignores
     199        * the y parameter. However, disassembling NT implementation (WIN32K.SYS)
     200        * reveals that
     201        *
     202        * 1) not only if checks for CW_USEDEFAULT but also for CW_USEDEFAULT16
     203        * 2) it does not ignore the y parameter as the docs claim; instead, it
     204        *    uses it as second parameter to ShowWindow() unless y is either
     205        *    CW_USEDEFAULT or CW_USEDEFAULT16.
     206        *
     207        * The fact that we didn't do 2) caused bogus windows pop up when wine
     208        * was running apps that were using this obscure feature. Example -
     209        * calc.exe that comes with Win98 (only Win98, it's different from
     210        * the one that comes with Win95 and NT)
     211        */
     212        if (cs->y != CW_USEDEFAULT && cs->y != CW_USEDEFAULT16) sw = cs->y;
     213
     214        /* We have saved cs->y, now we can trash it */
    215215#if 0
    216         if (   !(cs->style & (WS_CHILD | WS_POPUP))
    217             &&  (pdb->env_db->startup_info->dwFlags & STARTF_USEPOSITION) )
    218         {
    219             cs->x = pdb->env_db->startup_info->dwX;
    220             cs->y = pdb->env_db->startup_info->dwY;
    221         }
     216        if (   !(cs->style & (WS_CHILD | WS_POPUP))
     217            &&  (pdb->env_db->startup_info->dwFlags & STARTF_USEPOSITION) )
     218        {
     219            cs->x = pdb->env_db->startup_info->dwX;
     220            cs->y = pdb->env_db->startup_info->dwY;
     221        }
    222222#endif
    223             cs->x = 0;
    224             cs->y = 0;
    225 //        }
     223            cs->x = 0;
     224            cs->y = 0;
     225//        }
    226226  }
    227227  if (cs->cx == CW_USEDEFAULT || cs->cx == CW_USEDEFAULT16)
    228228  {
    229229#if 0
    230         PDB *pdb = PROCESS_Current();
    231         if (   !(cs->style & (WS_CHILD | WS_POPUP))
    232             &&  (pdb->env_db->startup_info->dwFlags & STARTF_USESIZE) )
    233         {
    234             cs->cx = pdb->env_db->startup_info->dwXSize;
    235             cs->cy = pdb->env_db->startup_info->dwYSize;
    236         }
    237         else
    238         {
     230        PDB *pdb = PROCESS_Current();
     231        if (   !(cs->style & (WS_CHILD | WS_POPUP))
     232            &&  (pdb->env_db->startup_info->dwFlags & STARTF_USESIZE) )
     233        {
     234            cs->cx = pdb->env_db->startup_info->dwXSize;
     235            cs->cy = pdb->env_db->startup_info->dwYSize;
     236        }
     237        else
     238        {
    239239#endif
    240             cs->cx = 600; /* FIXME */
    241             cs->cy = 400;
    242 //        }
     240            cs->cx = 600; /* FIXME */
     241            cs->cy = 400;
     242//        }
    243243  }
    244244
    … …  
    249249  nrUserWindowLong = windowClass->getExtraWndWords();
    250250  if(nrUserWindowLong) {
    251         userWindowLong = (ULONG *)malloc(nrUserWindowLong);
    252         memset(userWindowLong, 0, nrUserWindowLong);
     251        userWindowLong = (ULONG *)malloc(nrUserWindowLong);
     252        memset(userWindowLong, 0, nrUserWindowLong);
    253253  }
    254254
    255255  if ((cs->style & WS_CHILD) && cs->hwndParent)
    256256  {
    257         SetParent(cs->hwndParent);
     257        SetParent(cs->hwndParent);
    258258  }
    259259  else
    260260  {
    261         if (!cs->hwndParent) {
    262             owner = NULL;
    263         }
    264         else
    265         {
    266             owner = GetWindowFromHandle(cs->hwndParent);
    267             if(owner == NULL)
    268             {
    269                 dprintf(("HMHandleTranslateToOS2 couldn't find owner window %x!!!", cs->hwndParent));
    270                 return FALSE;
    271             }
    272         }
     261        if (!cs->hwndParent) {
     262            owner = NULL;
     263        }
     264        else
     265        {
     266            owner = GetWindowFromHandle(cs->hwndParent);
     267            if(owner == NULL)
     268            {
     269                dprintf(("HMHandleTranslateToOS2 couldn't find owner window %x!!!", cs->hwndParent));
     270                return FALSE;
     271            }
     272        }
    273273  }
    274274
    … …  
    279279
    280280  hwndLinkAfter = ((cs->style & (WS_CHILD|WS_MAXIMIZE)) == WS_CHILD)
    281                   ? HWND_BOTTOM : HWND_TOP;
     281                  ? HWND_BOTTOM : HWND_TOP;
    282282
    283283#if 0
    … …  
    288288    {
    289289    CBT_CREATEWNDA cbtc;
    290         LRESULT ret;
     290        LRESULT ret;
    291291
    292292    cbtc.lpcs = cs;
    293293    cbtc.hwndInsertAfter = hwndLinkAfter;
    294         ret = unicode ? HOOK_CallHooksW(WH_CBT, HCBT_CREATEWND, Win32Hwnd, (LPARAM)&cbtc)
    295                       : HOOK_CallHooksA(WH_CBT, HCBT_CREATEWND, Win32Hwnd, (LPARAM)&cbtc);
    296         if (ret)
     294        ret = unicode ? HOOK_CallHooksW(WH_CBT, HCBT_CREATEWND, Win32Hwnd, (LPARAM)&cbtc)
     295                      : HOOK_CallHooksA(WH_CBT, HCBT_CREATEWND, Win32Hwnd, (LPARAM)&cbtc);
     296        if (ret)
    297297    {
    298         TRACE_(win)("CBT-hook returned 0\n");
    299         wndPtr->pDriver->pFinalize(wndPtr);
    300             retvalue =  0;
    301             goto end;
     298        TRACE_(win)("CBT-hook returned 0\n");
     299        wndPtr->pDriver->pFinalize(wndPtr);
     300            retvalue =  0;
     301            goto end;
    302302    }
    303303    }
    … …  
    310310  if (!(cs->style & WS_CHILD))
    311311  {
    312         dwStyle |= WS_CLIPSIBLINGS;
    313         if (!(cs->style & WS_POPUP))
    314         {
    315             dwStyle |= WS_CAPTION;
    316             flags |= WIN_NEED_SIZE;
    317         }
     312        dwStyle |= WS_CLIPSIBLINGS;
     313        if (!(cs->style & WS_POPUP))
     314        {
     315            dwStyle |= WS_CAPTION;
     316            flags |= WIN_NEED_SIZE;
     317        }
    318318  }
    319319  if (cs->dwExStyle & WS_EX_DLGMODALFRAME) dwStyle &= ~WS_THICKFRAME;
    … …  
    330330  if ((cs->style & WS_THICKFRAME) || !(cs->style & (WS_POPUP | WS_CHILD)))
    331331  {
    332         GetMinMaxInfo(&maxSize, &maxPos, &minTrack, &maxTrack);
    333         if (maxSize.x < cs->cx) cs->cx = maxSize.x;
    334         if (maxSize.y < cs->cy) cs->cy = maxSize.y;
    335         if (cs->cx < minTrack.x ) cs->cx = minTrack.x;
    336         if (cs->cy < minTrack.y ) cs->cy = minTrack.y;
     332        GetMinMaxInfo(&maxSize, &maxPos, &minTrack, &maxTrack);
     333        if (maxSize.x < cs->cx) cs->cx = maxSize.x;
     334        if (maxSize.y < cs->cy) cs->cy = maxSize.y;
     335        if (cs->cx < minTrack.x ) cs->cx = minTrack.x;
     336        if (cs->cy < minTrack.y ) cs->cy = minTrack.y;
    337337  }
    338338
    339339  if(cs->style & WS_CHILD)
    340340  {
    341         if(cs->cx < 0) cs->cx = 0;
    342         if(cs->cy < 0) cs->cy = 0;
     341        if(cs->cx < 0) cs->cx = 0;
     342        if(cs->cy < 0) cs->cy = 0;
    343343  }
    344344  else
    345345  {
    346         if (cs->cx <= 0) cs->cx = 1;
    347         if (cs->cy <= 0) cs->cy = 1;
     346        if (cs->cx <= 0) cs->cx = 1;
     347        if (cs->cy <= 0) cs->cy = 1;
    348348  }
    349349
    … …  
    352352  rectWindow.right  = cs->x + cs->cx;
    353353  rectWindow.bottom = cs->y + cs->cy;
    354   rectClient        = rectWindow;
     354  rectClient        = rectWindow;
    355355
    356356  DWORD dwOSWinStyle, dwOSFrameStyle;
    … …  
    361361#if 1
    362362  if(cs->style & WS_CHILD) {
    363         dwOSFrameStyle = 0;
     363        dwOSFrameStyle = 0;
    364364  }
    365365#endif
    366366
    367367  OS2Hwnd = OSLibWinCreateWindow((getParent()) ? getParent()->getOS2WindowHandle() : OSLIB_HWND_DESKTOP,
    368                                 dwOSWinStyle, dwOSFrameStyle, (char *)cs->lpszName,
    369                                 (owner) ? owner->getOS2FrameWindowHandle() : OSLIB_HWND_DESKTOP,
    370                                 (hwndLinkAfter == HWND_BOTTOM) ? TRUE : FALSE,
    371                                 &OS2HwndFrame);
     368                                dwOSWinStyle, dwOSFrameStyle, (char *)cs->lpszName,
     369                                (owner) ? owner->getOS2FrameWindowHandle() : OSLIB_HWND_DESKTOP,
     370                                (hwndLinkAfter == HWND_BOTTOM) ? TRUE : FALSE,
     371                                &OS2HwndFrame);
    372372
    373373  if(OS2Hwnd == 0) {
    374         dprintf(("Window creation failed!!"));
    375         return FALSE;
     374        dprintf(("Window creation failed!!"));
     375        return FALSE;
    376376  }
    377377
    378378  if(OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32WNDPTR, (ULONG)this) == FALSE) {
    379         dprintf(("WM_CREATE: WinSetWindowULong %X failed!!", OS2Hwnd));
    380         return FALSE;
     379        dprintf(("WM_CREATE: WinSetWindowULong %X failed!!", OS2Hwnd));
     380        return FALSE;
    381381  }
    382382  if(OSLibWinSetWindowULong(OS2Hwnd, OFFSET_WIN32PM_MAGIC, WIN32PM_MAGIC) == FALSE) {
    383         dprintf(("WM_CREATE: WinSetWindowULong2 %X failed!!", OS2Hwnd));
    384         return FALSE;
     383        dprintf(("WM_CREATE: WinSetWindowULong2 %X failed!!", OS2Hwnd));
     384        return FALSE;
    385385  }
    386386#if 0
    387387  if(OS2Hwnd != OS2HwndFrame) {
    388388    if(OSLibWinSetWindowULong(OS2HwndFrame, OFFSET_WIN32WNDPTR, (ULONG)this) == FALSE) {
    389             dprintf(("WM_CREATE: WinSetWindowULong %X failed!!", OS2HwndFrame));
    390             return FALSE;
     389            dprintf(("WM_CREATE: WinSetWindowULong %X failed!!", OS2HwndFrame));
     390            return FALSE;
    391391    }
    392392    if(OSLibWinSetWindowULong(OS2HwndFrame, OFFSET_WIN32PM_MAGIC, WIN32PM_MAGIC) == FALSE) {
    393             dprintf(("WM_CREATE: WinSetWindowULong2 %X failed!!", OS2HwndFrame));
    394             return FALSE;
     393            dprintf(("WM_CREATE: WinSetWindowULong2 %X failed!!", OS2HwndFrame));
     394            return FALSE;
    395395    }
    396396  }
    … …  
    400400  if ((dwStyle & (WS_CAPTION | WS_CHILD)) == WS_CAPTION )
    401401  {
    402         if (cs->hMenu) SetMenu(cs->hMenu);
    403         else
    404         {
    405                 if (windowClass->getMenuNameA()) {
    406                         cs->hMenu = LoadMenuA(cs->hInstance, windowClass->getMenuNameA());
    407                         if (cs->hMenu) SetMenu(cs->hMenu );
    408                 }
    409         }
    410   }
    411   else  windowId = (UINT)cs->hMenu;
     402        if (cs->hMenu) SetMenu(cs->hMenu);
     403        else
     404        {
     405                if (windowClass->getMenuNameA()) {
     406                        cs->hMenu = LoadMenuA(cs->hInstance, windowClass->getMenuNameA());
     407                        if (cs->hMenu) SetMenu(cs->hMenu );
     408                }
     409        }
     410  }
     411  else  windowId = (UINT)cs->hMenu;
    412412
    413413  //Set icon from class
    414414  if(windowClass->getIcon())
    415         SetIcon(windowClass->getIcon());
     415        SetIcon(windowClass->getIcon());
    416416
    417417  if(getParent()) {
    418         SetWindowPos(getParent()->getWindowHandle(), rectClient.left, rectClient.top,
    419                      rectClient.right-rectClient.left,
    420                      rectClient.bottom-rectClient.top,
    421                      SWP_NOACTIVATE | SWP_NOZORDER);
     418        SetWindowPos(getParent()->getWindowHandle(), rectClient.left, rectClient.top,
     419                     rectClient.right-rectClient.left,
     420                     rectClient.bottom-rectClient.top,
     421                     SWP_NOACTIVATE | SWP_NOZORDER);
    422422  }
    423423  else {
    424         SetWindowPos(HWND_TOP, rectClient.left, rectClient.top,
    425                      rectClient.right-rectClient.left,
    426                      rectClient.bottom-rectClient.top,
    427                      SWP_NOACTIVATE);
     424        SetWindowPos(HWND_TOP, rectClient.left, rectClient.top,
     425                     rectClient.right-rectClient.left,
     426                     rectClient.bottom-rectClient.top,
     427                     SWP_NOACTIVATE);
    428428  }
    429429  //Get the client window rectangle
    … …  
    439439  if(SendInternalMessage(WM_NCCREATE, 0, (LPARAM)cs) )
    440440  {
    441         //doesn't work right, messes up client rectangle
     441        //doesn't work right, messes up client rectangle
    442442#if 0
    443         SendNCCalcSize(FALSE, &rectWindow, NULL, NULL, 0, &rectClient );
     443        SendNCCalcSize(FALSE, &rectWindow, NULL, NULL, 0, &rectClient );
    444444#endif
    445         OffsetRect(&rectWindow, maxPos.x - rectWindow.left, maxPos.y - rectWindow.top);
    446         dprintf(("Sending WM_CREATE"));
    447         if( (SendInternalMessage(WM_CREATE, 0, (LPARAM)cs )) != -1 )
    448         {
    449             if(!(flags & WIN_NEED_SIZE)) {
    450                 SendMessageA(WM_SIZE, SIZE_RESTORED,
    451                                 MAKELONG(rectClient.right-rectClient.left,
    452                                         rectClient.bottom-rectClient.top));
    453                 SendMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
    454             }
    455             if (cs->style & WS_VISIBLE) ShowWindow( sw );
     445        OffsetRect(&rectWindow, maxPos.x - rectWindow.left, maxPos.y - rectWindow.top);
     446        dprintf(("Sending WM_CREATE"));
     447        if( (SendInternalMessage(WM_CREATE, 0, (LPARAM)cs )) != -1 )
     448        {
     449            if(!(flags & WIN_NEED_SIZE)) {
     450                SendMessageA(WM_SIZE, SIZE_RESTORED,
     451                                MAKELONG(rectClient.right-rectClient.left,
     452                                        rectClient.bottom-rectClient.top));
     453                SendMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
     454            }
     455            if (cs->style & WS_VISIBLE) ShowWindow( sw );
    456456
    457457#if 0
    458             /* Call WH_SHELL hook */
    459 
    460             if (!(dwStyle & WS_CHILD) && !owner)
    461                 HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWCREATED, hwnd, 0 );
     458            /* Call WH_SHELL hook */
     459
     460            if (!(dwStyle & WS_CHILD) && !owner)
     461                HOOK_CallHooks16( WH_SHELL, HSHELL_WINDOWCREATED, hwnd, 0 );
    462462#endif
    463             SetLastError(0);
    464             return TRUE;
    465         }
     463            SetLastError(0);
     464            return TRUE;
     465        }
    466466  }
    467467  fCreated = FALSE;
    … …  
    473473#if 0
    474474/***********************************************************************
    475  *           WINPOS_MinMaximize
     475 *           WINPOS_MinMaximize
    476476 *
    477477 * Fill in lpRect and return additional flags to be used with SetWindowPos().
    … …  
    492492    if( dwStyle & WS_MINIMIZE )
    493493    {
    494         if( !SendInternalMessageA(WM_QUERYOPEN, 0, 0L ) )
    495         return (SWP_NOSIZE | SWP_NOMOVE);
    496         swpFlags |= SWP_NOCOPYBITS;
     494        if( !SendInternalMessageA(WM_QUERYOPEN, 0, 0L ) )
     495        return (SWP_NOSIZE | SWP_NOMOVE);
     496        swpFlags |= SWP_NOCOPYBITS;
    497497    }
    498498    switch( cmd )
    499499    {
    500         case SW_MINIMIZE:
    501         if( dwStyle & WS_MAXIMIZE)
    502         {
    503              flags |= WIN_RESTORE_MAX;
    504              dwStyle &= ~WS_MAXIMIZE;
    505                 }
    506                 else
    507              flags &= ~WIN_RESTORE_MAX;
    508              dwStyle |= WS_MINIMIZE;
     500        case SW_MINIMIZE:
     501        if( dwStyle & WS_MAXIMIZE)
     502        {
     503             flags |= WIN_RESTORE_MAX;
     504             dwStyle &= ~WS_MAXIMIZE;
     505                }
     506                else
     507             flags &= ~WIN_RESTORE_MAX;
     508             dwStyle |= WS_MINIMIZE;
    509509
    510510#if 0
    511         if( flags & WIN_NATIVE )
    512              if( pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, TRUE ) )
    513              swpFlags |= MINMAX_NOSWP;
     511        if( flags & WIN_NATIVE )
     512             if( pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, TRUE ) )
     513             swpFlags |= MINMAX_NOSWP;
    514514#endif
    515515
    516         lpPos->ptIconPos = WINPOS_FindIconPos( wndPtr, lpPos->ptIconPos );
    517 
    518         SetRect(lpRect, lpPos->ptIconPos.x, lpPos->ptIconPos.y,
    519              GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON) );
    520         swpFlags |= SWP_NOCOPYBITS;
    521         break;
    522 
    523         case SW_MAXIMIZE:
    524                 WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL );
    525 
    526         if( dwStyle & WS_MINIMIZE )
    527         {
    528              if( flags & WIN_NATIVE )
    529              if( pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, FALSE ) )
    530                 swpFlags |= MINMAX_NOSWP;
    531 
    532              WINPOS_ShowIconTitle( wndPtr, FALSE );
    533              dwStyle &= ~WS_MINIMIZE;
    534         }
    535                 dwStyle |= WS_MAXIMIZE;
    536 
    537         SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y,
    538                     size.x, size.y );
    539         break;
    540 
    541         case SW_RESTORE:
    542         if( dwStyle & WS_MINIMIZE )
    543         {
    544              if( flags & WIN_NATIVE )
    545              if( pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, FALSE ) )
    546                 swpFlags |= MINMAX_NOSWP;
    547 
    548              dwStyle &= ~WS_MINIMIZE;
    549              WINPOS_ShowIconTitle( wndPtr, FALSE );
    550 
    551              if( flags & WIN_RESTORE_MAX)
    552              {
    553              /* Restore to maximized position */
    554                         CONV_POINT16TO32( &lpPos->ptMaxPos, &pt );
    555                         WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL);
    556                         CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
    557              dwStyle |= WS_MAXIMIZE;
    558              SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y, size.x, size.y );
    559              break;
    560              }
    561         }
    562         else
    563              if( !(dwStyle & WS_MAXIMIZE) ) return (UINT16)(-1);
    564              else dwStyle &= ~WS_MAXIMIZE;
    565 
    566         /* Restore to normal position */
    567 
    568         *lpRect = lpPos->rectNormal;
    569         lpRect->right -= lpRect->left;
    570         lpRect->bottom -= lpRect->top;
    571 
    572         break;
     516        lpPos->ptIconPos = WINPOS_FindIconPos( wndPtr, lpPos->ptIconPos );
     517
     518        SetRect(lpRect, lpPos->ptIconPos.x, lpPos->ptIconPos.y,
     519             GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON) );
     520        swpFlags |= SWP_NOCOPYBITS;
     521        break;
     522
     523        case SW_MAXIMIZE:
     524                WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL );
     525
     526        if( dwStyle & WS_MINIMIZE )
     527        {
     528             if( flags & WIN_NATIVE )
     529             if( pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, FALSE ) )
     530                swpFlags |= MINMAX_NOSWP;
     531
     532             WINPOS_ShowIconTitle( wndPtr, FALSE );
     533             dwStyle &= ~WS_MINIMIZE;
     534        }
     535                dwStyle |= WS_MAXIMIZE;
     536
     537        SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y,
     538                    size.x, size.y );
     539        break;
     540
     541        case SW_RESTORE:
     542        if( dwStyle & WS_MINIMIZE )
     543        {
     544             if( flags & WIN_NATIVE )
     545             if( pDriver->pSetHostAttr( wndPtr, HAK_ICONICSTATE, FALSE ) )
     546                swpFlags |= MINMAX_NOSWP;
     547
     548             dwStyle &= ~WS_MINIMIZE;
     549             WINPOS_ShowIconTitle( wndPtr, FALSE );
     550
     551             if( flags & WIN_RESTORE_MAX)
     552             {
     553             /* Restore to maximized position */
     554                        CONV_POINT16TO32( &lpPos->ptMaxPos, &pt );
     555                        WINPOS_GetMinMaxInfo( wndPtr, &size, &pt, NULL, NULL);
     556                        CONV_POINT32TO16( &pt, &lpPos->ptMaxPos );
     557             dwStyle |= WS_MAXIMIZE;
     558             SetRect16( lpRect, lpPos->ptMaxPos.x, lpPos->ptMaxPos.y, size.x, size.y );
     559             break;
     560             }
     561        }
     562        else
     563             if( !(dwStyle & WS_MAXIMIZE) ) return (UINT16)(-1);
     564             else dwStyle &= ~WS_MAXIMIZE;
     565
     566        /* Restore to normal position */
     567
     568        *lpRect = lpPos->rectNormal;
     569        lpRect->right -= lpRect->left;
     570        lpRect->bottom -= lpRect->top;
     571
     572        break;
    573573    }
    574574    } else swpFlags |= SWP_NOSIZE | SWP_NOMOVE;
    … …  
    577577#endif
    578578/*******************************************************************
    579  *           GetMinMaxInfo
     579 *           GetMinMaxInfo
    580580 *
    581581 * Get the minimized and maximized information for a window.
    582582 */
    583583void Win32Window::GetMinMaxInfo(POINT *maxSize, POINT *maxPos,
    584                                 POINT *minTrack, POINT *maxTrack )
     584                                POINT *minTrack, POINT *maxTrack )
    585585{
    586586    MINMAXINFO MinMax;
    … …  
    599599    else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
    600600    {
    601         xinc = GetSystemMetrics(SM_CXDLGFRAME);
    602         yinc = GetSystemMetrics(SM_CYDLGFRAME);
     601        xinc = GetSystemMetrics(SM_CXDLGFRAME);
     602        yinc = GetSystemMetrics(SM_CYDLGFRAME);
    603603    }
    604604    else
    605605    {
    606         xinc = yinc = 0;
    607         if (HAS_THICKFRAME(dwStyle))
    608         {
    609             xinc += GetSystemMetrics(SM_CXFRAME);
    610             yinc += GetSystemMetrics(SM_CYFRAME);
    611         }
    612         if (dwStyle & WS_BORDER)
    613         {
    614             xinc += GetSystemMetrics(SM_CXBORDER);
    615             yinc += GetSystemMetrics(SM_CYBORDER);
    616         }
     606        xinc = yinc = 0;
     607        if (HAS_THICKFRAME(dwStyle))
     608        {
     609            xinc += GetSystemMetrics(SM_CXFRAME);
     610            yinc += GetSystemMetrics(SM_CYFRAME);
     611        }
     612        if (dwStyle & WS_BORDER)
     613        {
     614            xinc += GetSystemMetrics(SM_CXBORDER);
     615            yinc += GetSystemMetrics(SM_CYBORDER);
     616        }
    617617    }
    618618    MinMax.ptMaxSize.x += 2 * xinc;
    … …  
    622622    lpPos = (LPINTERNALPOS)GetPropA( hwndSelf, atomInternalPos );
    623623    if( lpPos && !EMPTYPOINT(lpPos->ptMaxPos) )
    624         CONV_POINT16TO32( &lpPos->ptMaxPos, &MinMax.ptMaxPosition );
     624        CONV_POINT16TO32( &lpPos->ptMaxPos, &MinMax.ptMaxPosition );
    625625    else
    626626    {
    627627#endif
    628         MinMax.ptMaxPosition.x = -xinc;
    629         MinMax.ptMaxPosition.y = -yinc;
     628        MinMax.ptMaxPosition.x = -xinc;
     629        MinMax.ptMaxPosition.y = -yinc;
    630630//    }
    631631
    … …  
    635635
    636636    dprintf(("GetMinMaxInfo: %ld %ld / %ld %ld / %ld %ld / %ld %ld\n",
    637                       MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
    638                       MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
    639                       MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
    640                       MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y));
     637                      MinMax.ptMaxSize.x, MinMax.ptMaxSize.y,
     638                      MinMax.ptMaxPosition.x, MinMax.ptMaxPosition.y,
     639                      MinMax.ptMaxTrackSize.x, MinMax.ptMaxTrackSize.y,
     640                      MinMax.ptMinTrackSize.x, MinMax.ptMinTrackSize.y));
    641641    MinMax.ptMaxTrackSize.x = MAX( MinMax.ptMaxTrackSize.x,
    642                                    MinMax.ptMinTrackSize.x );
     642                                   MinMax.ptMinTrackSize.x );
    643643    MinMax.ptMaxTrackSize.y = MAX( MinMax.ptMaxTrackSize.y,
    644                                    MinMax.ptMinTrackSize.y );
     644                                   MinMax.ptMinTrackSize.y );
    645645
    646646    if (maxSize)    *maxSize  = MinMax.ptMaxSize;
    … …  
    650650}
    651651/***********************************************************************
    652  *           WINPOS_SendNCCalcSize
     652 *           WINPOS_SendNCCalcSize
    653653 *
    654654 * Send a WM_NCCALCSIZE message to a window.
    … …  
    658658 */
    659659LONG Win32Window::SendNCCalcSize(BOOL calcValidRect, RECT *newWindowRect, RECT *oldWindowRect,
    660                                 RECT *oldClientRect, WINDOWPOS *winpos,
    661                                 RECT *newClientRect )
     660                                RECT *oldClientRect, WINDOWPOS *winpos,
     661                                RECT *newClientRect )
    662662{
    663663   NCCALCSIZE_PARAMS params;
    … …  
    668668   if (calcValidRect)
    669669   {
    670         winposCopy = *winpos;
    671         params.rgrc[1] = *oldWindowRect;
    672         params.rgrc[2] = *oldClientRect;
    673         params.lppos = &winposCopy;
     670        winposCopy = *winpos;
     671        params.rgrc[1] = *oldWindowRect;
     672        params.rgrc[2] = *oldClientRect;
     673        params.lppos = &winposCopy;
    674674   }
    675675   result = SendInternalMessageA(WM_NCCALCSIZE, calcValidRect,
    676                                 (LPARAM)&params );
     676                                (LPARAM)&params );
    677677   *newClientRect = params.rgrc[0];
    678678   return result;
    … …  
    696696{
    697697  if(SendInternalMessageA(WM_CLOSE, 0, 0) == 0) {
    698         return 0; //app handles this message
     698        return 0; //app handles this message
    699699  }
    700700  delete this;
    … …  
    726726//******************************************************************************
    727727//******************************************************************************
     728ULONG Win32Window::MsgPosChanging(LPARAM lp)
     729{
     730    dprintf(("MsgPosChanging"));
     731#if 1
     732    if(fCreated == FALSE) {
     733        return 1;
     734    }
     735#endif
     736    return SendInternalMessageA(WM_WINDOWPOSCHANGING, 0, lp);
     737}
     738//******************************************************************************
     739//******************************************************************************
     740ULONG Win32Window::MsgPosChanged(LPARAM lp)
     741{
     742    dprintf(("MsgPosChanged"));
     743#if 1
     744    if(fCreated == FALSE) {
     745        return 1;
     746    }
     747#endif
     748    return SendInternalMessageA(WM_WINDOWPOSCHANGED, 0, lp);
     749}
     750//******************************************************************************
     751//******************************************************************************
    728752ULONG Win32Window::MsgMove(ULONG x, ULONG y)
    729753{
    730754    dprintf(("MsgMove to (%d,%d)", x, y));
    731755    if(fCreated == FALSE) {
    732         return 1;
     756        return 1;
    733757    }
    734758
    … …  
    741765  switch(cmd) {
    742766    case CMD_MENU:
    743         return SendInternalMessageA(WM_COMMAND, MAKELONG(Id, 0), 0);
     767        return SendInternalMessageA(WM_COMMAND, MAKELONG(Id, 0), 0);
    744768    case CMD_CONTROL:
    745         return 0; //todo
     769        return 0; //todo
    746770    case CMD_ACCELERATOR:
    747         dprintf(("accelerator command"));
    748         return 0; //todo
     771        dprintf(("accelerator command"));
     772        return 0; //todo
    749773  }
    750774  return 0;
    … …  
    765789
    766790    if(fCreated == FALSE) {//Solitaire crashes if it receives a WM_SIZE during CreateWindowEx (normal or our fault?)
    767         return 1;
     791        return 1;
    768792    }
    769793
    770794    if(fMinimize) {
    771             fwSizeType = SIZE_MINIMIZED;
     795            fwSizeType = SIZE_MINIMIZED;
    772796    }
    773797    else
    774798    if(fMaximize) {
    775             fwSizeType = SIZE_MAXIMIZED;
     799            fwSizeType = SIZE_MAXIMIZED;
    776800    }
    777801    else    fwSizeType = SIZE_RESTORED;
    … …  
    785809    if(SendInternalMessageA(WM_NCACTIVATE, fActivate, 0) == FALSE)
    786810    {
    787         if(!fActivate) {
    788             return 1;
    789         }
     811        if(!fActivate) {
     812            return 1;
     813        }
    790814    }
    791815    return SendInternalMessageA(WM_ACTIVATE, (fActivate) ? WA_ACTIVE : WA_INACTIVE, hwnd);
    … …  
    807831    lParam |= (scancode << 16);
    808832    if(keyflags & KEY_ALTDOWN)
    809         lParam |= (1<<29);
     833        lParam |= (1<<29);
    810834    if(keyflags & KEY_PREVDOWN)
    811         lParam |= (1<<30);
     835        lParam |= (1<<30);
    812836    if(keyflags & KEY_UP)
    813         lParam |= (1<<31);
     837        lParam |= (1<<31);
    814838    if(keyflags & KEY_DEADKEY) {
    815         dprintf(("WM_DEADCHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
    816         return SendInternalMessageA(WM_DEADCHAR, cmd, lParam);
     839        dprintf(("WM_DEADCHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
     840        return SendInternalMessageA(WM_DEADCHAR, cmd, lParam);
    817841    }
    818842    else {
    819         dprintf(("WM_CHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
    820         return SendInternalMessageA(WM_CHAR, cmd, lParam);
     843        dprintf(("WM_CHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
     844        return SendInternalMessageA(WM_CHAR, cmd, lParam);
    821845    }
    822846}
    … …  
    826850{
    827851    if(hwnd == 0) {
    828         //other app lost focus
    829         SendInternalMessageA(WM_ACTIVATEAPP, TRUE, 0); //TODO: Need thread id from hwnd app
     852        //other app lost focus
     853        SendInternalMessageA(WM_ACTIVATEAPP, TRUE, 0); //TODO: Need thread id from hwnd app
    830854    }
    831855    return SendInternalMessageA(WM_SETFOCUS, hwnd, 0);
    … …  
    836860{
    837861    if(hwnd == 0) {
    838         //other app lost focus
    839         SendInternalMessageA(WM_ACTIVATEAPP, FALSE, 0); //TODO: Need thread id from hwnd app
     862        //other app lost focus
     863        SendInternalMessageA(WM_ACTIVATEAPP, FALSE, 0); //TODO: Need thread id from hwnd app
    840864    }
    841865    return SendInternalMessageA(WM_KILLFOCUS, hwnd, 0);
    … …  
    850874    dprintf(("MsgButton to (%d,%d)", ncx, ncy));
    851875    switch(msg) {
    852         case BUTTON_LEFTDOWN:
    853                 win32msg = WM_LBUTTONDOWN;
    854                 win32ncmsg = WM_NCLBUTTONDOWN;
    855                 break;
    856         case BUTTON_LEFTUP:
    857                 win32msg = WM_LBUTTONUP;
    858                 win32ncmsg = WM_NCLBUTTONUP;
    859                 break;
    860         case BUTTON_LEFTDBLCLICK:
    861                 win32msg = WM_LBUTTONDBLCLK;
    862                 win32ncmsg = WM_NCLBUTTONDBLCLK;
    863                 break;
    864         case BUTTON_RIGHTUP:
    865                 win32msg = WM_RBUTTONUP;
    866                 win32ncmsg = WM_NCRBUTTONUP;
    867                 break;
    868         case BUTTON_RIGHTDOWN:
    869                 win32msg = WM_RBUTTONDOWN;
    870                 win32ncmsg = WM_NCRBUTTONDOWN;
    871                 break;
    872         case BUTTON_RIGHTDBLCLICK:
    873                 win32msg = WM_RBUTTONDBLCLK;
    874                 win32ncmsg = WM_NCRBUTTONDBLCLK;
    875                 break;
    876         case BUTTON_MIDDLEUP:
    877                 win32msg = WM_MBUTTONUP;
    878                 win32ncmsg = WM_NCMBUTTONUP;
    879                 break;
    880         case BUTTON_MIDDLEDOWN:
    881                 win32msg = WM_MBUTTONDOWN;
    882                 win32ncmsg = WM_NCMBUTTONDOWN;
    883                 break;
    884         case BUTTON_MIDDLEDBLCLICK:
    885                 win32msg = WM_MBUTTONDBLCLK;
    886                 win32ncmsg = WM_NCMBUTTONDBLCLK;
    887                 break;
    888         default:
    889                 dprintf(("Win32Window::Button: invalid msg!!!!"));
    890                 return 1;
     876        case BUTTON_LEFTDOWN:
     877                win32msg = WM_LBUTTONDOWN;
     878                win32ncmsg = WM_NCLBUTTONDOWN;
     879                break;
     880        case BUTTON_LEFTUP:
     881                win32msg = WM_LBUTTONUP;
     882                win32ncmsg = WM_NCLBUTTONUP;
     883                break;
     884        case BUTTON_LEFTDBLCLICK:
     885                win32msg = WM_LBUTTONDBLCLK;
     886                win32ncmsg = WM_NCLBUTTONDBLCLK;
     887                break;
     888        case BUTTON_RIGHTUP:
     889                win32msg = WM_RBUTTONUP;
     890                win32ncmsg = WM_NCRBUTTONUP;
     891                break;
     892        case BUTTON_RIGHTDOWN:
     893                win32msg = WM_RBUTTONDOWN;
     894                win32ncmsg = WM_NCRBUTTONDOWN;
     895                break;
     896        case BUTTON_RIGHTDBLCLICK:
     897                win32msg = WM_RBUTTONDBLCLK;
     898                win32ncmsg = WM_NCRBUTTONDBLCLK;
     899                break;
     900        case BUTTON_MIDDLEUP:
     901                win32msg = WM_MBUTTONUP;
     902                win32ncmsg = WM_NCMBUTTONUP;
     903                break;
     904        case BUTTON_MIDDLEDOWN:
     905                win32msg = WM_MBUTTONDOWN;
     906                win32ncmsg = WM_NCMBUTTONDOWN;
     907                break;
     908        case BUTTON_MIDDLEDBLCLICK:
     909                win32msg = WM_MBUTTONDBLCLK;
     910                win32ncmsg = WM_NCMBUTTONDBLCLK;
     911                break;
     912        default:
     913                dprintf(("Win32Window::Button: invalid msg!!!!"));
     914                return 1;
    891915    }
    892916    if(win32msg == WM_MBUTTONDBLCLK || win32msg == WM_RBUTTONDBLCLK || win32msg == WM_LBUTTONDBLCLK) {
    893         if(!(windowClass->getClassLongA(GCL_STYLE) & CS_DBLCLKS)) {
    894             return 1;
    895         }
     917        if(!(windowClass->getClassLongA(GCL_STYLE) & CS_DBLCLKS)) {
     918            return 1;
     919        }
    896920    }
    897921    SendInternalMessageA(win32ncmsg, lastHitTestVal, MAKELONG(ncx, ncy)); //TODO:
    … …  
    905929
    906930    if(keystate & WMMOVE_LBUTTON)
    907         winstate |= MK_LBUTTON;
     931        winstate |= MK_LBUTTON;
    908932    if(keystate & WMMOVE_RBUTTON)
    909         winstate |= MK_RBUTTON;
     933        winstate |= MK_RBUTTON;
    910934    if(keystate & WMMOVE_MBUTTON)
    911         winstate |= MK_MBUTTON;
     935        winstate |= MK_MBUTTON;
    912936    if(keystate & WMMOVE_SHIFT)
    913         winstate |= MK_SHIFT;
     937        winstate |= MK_SHIFT;
    914938    if(keystate & WMMOVE_CTRL)
    915         winstate |= MK_CONTROL;
     939        winstate |= MK_CONTROL;
    916940
    917941    return SendInternalMessageA(WM_MOUSEMOVE, keystate, MAKELONG(x, y));
    … …  
    925949//******************************************************************************
    926950//TODO: Is the clipper region of the window DC equal to the invalidated rectangle?
    927 //      (or are we simply erasing too much here)
     951//      (or are we simply erasing too much here)
    928952//******************************************************************************
    929953ULONG Win32Window::MsgEraseBackGround(HDC hdc)
    930954{
    931955    if(isIcon) {
    932             return SendInternalMessageA(WM_ICONERASEBKGND, hdc, 0);
     956            return SendInternalMessageA(WM_ICONERASEBKGND, hdc, 0);
    933957    }
    934958    else    return SendInternalMessageA(WM_ERASEBKGND, hdc, 0);
    … …  
    939963{
    940964    if(isUnicode) {
    941             return SendInternalMessageW(WM_SETTEXT, 0, (LPARAM)lpsz);
     965            return SendInternalMessageW(WM_SETTEXT, 0, (LPARAM)lpsz);
    942966    }
    943967    else    return SendInternalMessageA(WM_SETTEXT, 0, (LPARAM)lpsz);
    … …  
    955979{
    956980    if(isUnicode) {
    957         SendInternalMessageW(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameW);
     981        SendInternalMessageW(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameW);
    958982    }
    959983    else {
    960         SendInternalMessageA(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameA);
     984        SendInternalMessageA(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameA);
    961985    }
    962986    return windowNameA;
    … …  
    969993    {
    970994    case WM_GETTEXTLENGTH:
    971         return wndNameLength;
     995        return wndNameLength;
    972996
    973997    case WM_GETTEXT:   //TODO: SS_ICON controls
    974         strncpy((LPSTR)lParam, windowNameA, wParam);
    975         return min(wndNameLength, wParam);
     998        strncpy((LPSTR)lParam, windowNameA, wParam);
     999        return min(wndNameLength, wParam);
    9761000
    9771001    case WM_SETTEXT:
    978         return 0;
     1002        return 0;
    9791003
    9801004    case WM_SETREDRAW:
    981         if(wParam)
    982                 SetWindowLongA (GWL_STYLE, GetWindowLongA (GWL_STYLE) | WS_VISIBLE);
    983         else    SetWindowLongA (GWL_STYLE, GetWindowLongA (GWL_STYLE) & ~WS_VISIBLE);
    984 
    985         return 0; //TODO
     1005        if(wParam)
     1006                SetWindowLongA (GWL_STYLE, GetWindowLongA (GWL_STYLE) | WS_VISIBLE);
     1007        else    SetWindowLongA (GWL_STYLE, GetWindowLongA (GWL_STYLE) & ~WS_VISIBLE);
     1008
     1009        return 0; //TODO
    9861010
    9871011    case WM_NCCREATE:
    988         return(TRUE);
     1012        return(TRUE);
    9891013
    9901014    case WM_CTLCOLORMSGBOX:
    … …  
    9951019    case WM_CTLCOLORSTATIC:
    9961020    case WM_CTLCOLORSCROLLBAR:
    997         SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
    998         SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
    999         return GetSysColorBrush(COLOR_BTNFACE);
     1021        SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
     1022        SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
     1023        return GetSysColorBrush(COLOR_BTNFACE);
    10001024
    10011025    case WM_PARENTNOTIFY:
    1002         return 0;
     1026        return 0;
    10031027
    10041028    case WM_MOUSEACTIVATE:
    10051029    {
    1006         DWORD dwStyle = GetWindowLongA(GWL_STYLE);
    1007         DWORD dwExStyle = GetWindowLongA(GWL_EXSTYLE);
    1008         dprintf(("DefWndProc: WM_MOUSEACTIVATE for %x Msg %s", Win32Hwnd, GetMsgText(HIWORD(lParam))));
    1009         if(dwStyle & WS_CHILD && !(dwExStyle & WS_EX_NOPARENTNOTIFY) )
    1010         {
    1011             if(getParent()) {
    1012                 LRESULT rc = getParent()->SendMessageA(WM_MOUSEACTIVATE, wParam, lParam );
    1013                 if(rc)  return rc;
    1014             }
    1015         }
    1016         return (LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE;
     1030        DWORD dwStyle = GetWindowLongA(GWL_STYLE);
     1031        DWORD dwExStyle = GetWindowLongA(GWL_EXSTYLE);
     1032        dprintf(("DefWndProc: WM_MOUSEACTIVATE for %x Msg %s", Win32Hwnd, GetMsgText(HIWORD(lParam))));
     1033        if(dwStyle & WS_CHILD && !(dwExStyle & WS_EX_NOPARENTNOTIFY) )
     1034        {
     1035            if(getParent()) {
     1036                LRESULT rc = getParent()->SendMessageA(WM_MOUSEACTIVATE, wParam, lParam );
     1037                if(rc)  return rc;
     1038            }
     1039        }
     1040        return (LOWORD(lParam) == HTCAPTION) ? MA_NOACTIVATE : MA_ACTIVATE;
    10171041    }
    10181042    case WM_SETCURSOR:
    10191043    {
    1020         DWORD dwStyle = GetWindowLongA(GWL_STYLE);
    1021         DWORD dwExStyle = GetWindowLongA(GWL_EXSTYLE);
    1022         dprintf(("DefWndProc: WM_SETCURSOR for %x Msg %s", Win32Hwnd, GetMsgText(HIWORD(lParam))));
    1023         if(dwStyle & WS_CHILD && !(dwExStyle & WS_EX_NOPARENTNOTIFY) )
    1024         {
    1025             if(getParent()) {
    1026                 LRESULT rc = getParent()->SendMessageA(WM_SETCURSOR, wParam, lParam);
    1027                 if(rc)  return rc;
    1028             }
    1029         }
    1030         return 1;
     1044        DWORD dwStyle = GetWindowLongA(GWL_STYLE);
     1045        DWORD dwExStyle = GetWindowLongA(GWL_EXSTYLE);
     1046        dprintf(("DefWndProc: WM_SETCURSOR for %x Msg %s", Win32Hwnd, GetMsgText(HIWORD(lParam))));
     1047        if(dwStyle & WS_CHILD && !(dwExStyle & WS_EX_NOPARENTNOTIFY) )
     1048        {
     1049            if(getParent()) {
     1050                LRESULT rc = getParent()->SendMessageA(WM_SETCURSOR, wParam, lParam);
     1051                if(rc)  return rc;
     1052            }
     1053        }
     1054        return 1;
    10311055    }
    10321056    case WM_MOUSEMOVE:
    1033         return 0;
    1034 
     1057        return 0;
     1058
     1059    case WM_WINDOWPOSCHANGED:
     1060    {
     1061
     1062/* undocumented SWP flags - from SDK 3.1 */
     1063#define SWP_NOCLIENTSIZE        0x0800
     1064#define SWP_NOCLIENTMOVE        0x1000
     1065
     1066        PWINDOWPOS wpos = (PWINDOWPOS)lParam;
     1067        WPARAM     wp   = SIZE_RESTORED;
     1068
     1069        if (!(wpos->flags & SWP_NOCLIENTMOVE))
     1070            SendMessageA(WM_MOVE, 0, MAKELONG(wpos->x, wpos->y));
     1071
     1072        if (!(wpos->flags & SWP_NOCLIENTSIZE))
     1073        {
     1074            if (dwStyle & WS_MAXIMIZE) wp = SIZE_MAXIMIZED;
     1075            else if (dwStyle & WS_MINIMIZE) wp = SIZE_MINIMIZED;
     1076
     1077            SendMessageA(WM_SIZE, wp, MAKELONG(wpos->cx,wpos->cy));
     1078        }
     1079        return 0;
     1080    }
    10351081    case WM_ERASEBKGND:
    10361082    case WM_ICONERASEBKGND:
    … …  
    10381084      RECT rect;
    10391085
    1040         if (!windowClass->getBackgroundBrush()) return 0;
    1041 
    1042         /*  Since WM_ERASEBKGND may receive either a window dc or a    */
    1043         /*  client dc, the area to be erased has to be retrieved from  */
    1044         /*  the device context.                                    */
    1045         GetClipBox( (HDC)wParam, &rect );
    1046 
    1047         FillRect( (HDC)wParam, &rect, windowClass->getBackgroundBrush());
    1048 
    1049         return 1;
     1086        if (!windowClass->getBackgroundBrush()) return 0;
     1087
     1088        /*  Since WM_ERASEBKGND may receive either a window dc or a    */
     1089        /*  client dc, the area to be erased has to be retrieved from  */
     1090        /*  the device context.                                    */
     1091        GetClipBox( (HDC)wParam, &rect );
     1092
     1093        FillRect( (HDC)wParam, &rect, windowClass->getBackgroundBrush());
     1094
     1095        return 1;
    10501096    }
    10511097
    … …  
    10591105    case WM_NCMBUTTONUP:
    10601106    case WM_NCMBUTTONDBLCLK:
    1061         return 0;           //TODO: Send WM_SYSCOMMAND if required
     1107        return 0;           //TODO: Send WM_SYSCOMMAND if required
    10621108
    10631109    case WM_NCHITTEST: //TODO:
    1064         return 0;
     1110        return 0;
    10651111
    10661112    default:
    1067         return 1;
     1113        return 1;
    10681114    }
    10691115}
    … …  
    10751121    {
    10761122    case WM_GETTEXTLENGTH:
    1077         return wndNameLength;
     1123        return wndNameLength;
    10781124
    10791125    case WM_GETTEXT:   //TODO: SS_ICON controls
    1080         lstrcpynW((LPWSTR)lParam, windowNameW, wParam);
    1081         return min(wndNameLength, wParam);
     1126        lstrcpynW((LPWSTR)lParam, windowNameW, wParam);
     1127        return min(wndNameLength, wParam);
    10821128
    10831129    default:
    1084         return DefWindowProcA(Msg, wParam, lParam);
     1130        return DefWindowProcA(Msg, wParam, lParam);
    10851131    }
    10861132}
    … …  
    10901136{
    10911137  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1092         dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1138        dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    10931139
    10941140  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1095         return(0);
     1141        return(0);
    10961142  }
    10971143  switch(Msg)
    10981144  {
    1099         case WM_CREATE:
    1100         {
    1101                 if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
    1102                         dprintf(("WM_NCCREATE returned FALSE\n"));
    1103                         return(-1); //don't create window
    1104                 }
    1105                 if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == -1) {
    1106                         dprintf(("WM_CREATE returned -1\n"));
    1107                         return(-1); //don't create window
    1108                 }
    1109                 NotifyParent(Msg, wParam, lParam);
    1110 
    1111                 return(0);
    1112         }
    1113         case WM_SETTEXT: //TODO: Nothing happens if passed to DefWindowProc
    1114                 return win32wndproc(getWindowHandle(), WM_SETTEXT, wParam, lParam);
    1115 
    1116         case WM_LBUTTONDOWN:
    1117         case WM_MBUTTONDOWN:
    1118         case WM_RBUTTONDOWN:
    1119                 NotifyParent(Msg, wParam, lParam);
    1120                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    1121 
    1122         case WM_DESTROY:
    1123                 win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
    1124                 NotifyParent(Msg, wParam, lParam);
    1125                 return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
    1126         default:
    1127                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1145        case WM_CREATE:
     1146        {
     1147                if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
     1148                        dprintf(("WM_NCCREATE returned FALSE\n"));
     1149                        return(-1); //don't create window
     1150                }
     1151                if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == -1) {
     1152                        dprintf(("WM_CREATE returned -1\n"));
     1153                        return(-1); //don't create window
     1154                }
     1155                NotifyParent(Msg, wParam, lParam);
     1156
     1157                return(0);
     1158        }
     1159        case WM_SETTEXT: //TODO: Nothing happens if passed to DefWindowProc
     1160                return win32wndproc(getWindowHandle(), WM_SETTEXT, wParam, lParam);
     1161
     1162        case WM_LBUTTONDOWN:
     1163        case WM_MBUTTONDOWN:
     1164        case WM_RBUTTONDOWN:
     1165                NotifyParent(Msg, wParam, lParam);
     1166                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1167
     1168        case WM_DESTROY:
     1169                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
     1170                NotifyParent(Msg, wParam, lParam);
     1171                return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
     1172        default:
     1173                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    11281174  }
    11291175}
    … …  
    11331179{
    11341180  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1135         dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1181        dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    11361182
    11371183  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1138         return(0);
     1184        return(0);
    11391185  }
    11401186  switch(Msg)
    11411187  {
    1142         case WM_CREATE:
    1143         {
    1144                 if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
    1145                         dprintf(("WM_NCCREATE returned FALSE\n"));
    1146                         return(0); //don't create window
    1147                 }
    1148                 if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == 0) {
    1149                         dprintf(("WM_CREATE returned FALSE\n"));
    1150                         return(0); //don't create window
    1151                 }
    1152                 NotifyParent(Msg, wParam, lParam);
    1153 
    1154                 return(1);
    1155         }
    1156         case WM_SETTEXT: //TODO: Nothing happens if passed to DefWindowProc
    1157                 return win32wndproc(getWindowHandle(), WM_SETTEXT, wParam, lParam);
    1158 
    1159         case WM_LBUTTONDOWN:
    1160         case WM_MBUTTONDOWN:
    1161         case WM_RBUTTONDOWN:
    1162                 NotifyParent(Msg, wParam, lParam);
    1163                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    1164 
    1165         case WM_DESTROY:
    1166                 win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
    1167                 NotifyParent(Msg, wParam, lParam);
    1168                 return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
    1169 
    1170         default:
    1171                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1188        case WM_CREATE:
     1189        {
     1190                if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
     1191                        dprintf(("WM_NCCREATE returned FALSE\n"));
     1192                        return(0); //don't create window
     1193                }
     1194                if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == 0) {
     1195                        dprintf(("WM_CREATE returned FALSE\n"));
     1196                        return(0); //don't create window
     1197                }
     1198                NotifyParent(Msg, wParam, lParam);
     1199
     1200                return(1);
     1201        }
     1202        case WM_SETTEXT: //TODO: Nothing happens if passed to DefWindowProc
     1203                return win32wndproc(getWindowHandle(), WM_SETTEXT, wParam, lParam);
     1204
     1205        case WM_LBUTTONDOWN:
     1206        case WM_MBUTTONDOWN:
     1207        case WM_RBUTTONDOWN:
     1208                NotifyParent(Msg, wParam, lParam);
     1209                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1210
     1211        case WM_DESTROY:
     1212                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
     1213                NotifyParent(Msg, wParam, lParam);
     1214                return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
     1215
     1216        default:
     1217                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    11721218  }
    11731219}
    … …  
    11781224{
    11791225  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1180         dprintf(("SendInternalMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1226        dprintf(("SendInternalMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    11811227
    11821228  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1183         return(0);
     1229        return(0);
    11841230  }
    11851231  switch(Msg)
    11861232  {
    1187         case WM_CREATE:
    1188         {
    1189                 if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
    1190                         dprintf(("WM_NCCREATE returned FALSE\n"));
    1191                         return(0); //don't create window
    1192                 }
    1193                 if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == 0) {
    1194                         dprintf(("WM_CREATE returned FALSE\n"));
    1195                         return(0); //don't create window
    1196                 }
    1197                 NotifyParent(Msg, wParam, lParam);
    1198 
    1199                 return(1);
    1200         }
    1201         case WM_LBUTTONDOWN:
    1202         case WM_MBUTTONDOWN:
    1203         case WM_RBUTTONDOWN:
    1204                 NotifyParent(Msg, wParam, lParam);
    1205                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    1206 
    1207         case WM_DESTROY:
    1208                 win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
    1209                 NotifyParent(Msg, wParam, lParam);
    1210                 return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
    1211         default:
    1212                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1233        case WM_CREATE:
     1234        {
     1235                if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
     1236                        dprintf(("WM_NCCREATE returned FALSE\n"));
     1237                        return(0); //don't create window
     1238                }
     1239                if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == 0) {
     1240                        dprintf(("WM_CREATE returned FALSE\n"));
     1241                        return(0); //don't create window
     1242                }
     1243                NotifyParent(Msg, wParam, lParam);
     1244
     1245                return(1);
     1246        }
     1247        case WM_LBUTTONDOWN:
     1248        case WM_MBUTTONDOWN:
     1249        case WM_RBUTTONDOWN:
     1250                NotifyParent(Msg, wParam, lParam);
     1251                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1252
     1253        case WM_DESTROY:
     1254                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
     1255                NotifyParent(Msg, wParam, lParam);
     1256                return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
     1257        default:
     1258                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    12131259  }
    12141260}
    … …  
    12201266{
    12211267  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1222         dprintf(("SendInternalMessageW %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1268        dprintf(("SendInternalMessageW %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    12231269
    12241270  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1225         return(0);
     1271        return(0);
    12261272  }
    12271273  switch(Msg)
    12281274  {
    1229         case WM_CREATE:
    1230         {
    1231                 if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
    1232                         dprintf(("WM_NCCREATE returned FALSE\n"));
    1233                         return(0); //don't create window
    1234                 }
    1235                 if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == 0) {
    1236                         dprintf(("WM_CREATE returned FALSE\n"));
    1237                         return(0); //don't create window
    1238                 }
    1239                 NotifyParent(Msg, wParam, lParam);
    1240 
    1241                 return(1);
    1242         }
    1243         case WM_LBUTTONDOWN:
    1244         case WM_MBUTTONDOWN:
    1245         case WM_RBUTTONDOWN:
    1246                 NotifyParent(Msg, wParam, lParam);
    1247                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    1248 
    1249         case WM_DESTROY:
    1250                 win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
    1251                 NotifyParent(Msg, wParam, lParam);
    1252                 return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
    1253         default:
    1254                 return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1275        case WM_CREATE:
     1276        {
     1277                if(win32wndproc(getWindowHandle(), WM_NCCREATE, 0, lParam) == 0) {
     1278                        dprintf(("WM_NCCREATE returned FALSE\n"));
     1279                        return(0); //don't create window
     1280                }
     1281                if(win32wndproc(getWindowHandle(), WM_CREATE, 0, lParam) == 0) {
     1282                        dprintf(("WM_CREATE returned FALSE\n"));
     1283                        return(0); //don't create window
     1284                }
     1285                NotifyParent(Msg, wParam, lParam);
     1286
     1287                return(1);
     1288        }
     1289        case WM_LBUTTONDOWN:
     1290        case WM_MBUTTONDOWN:
     1291        case WM_RBUTTONDOWN:
     1292                NotifyParent(Msg, wParam, lParam);
     1293                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
     1294
     1295        case WM_DESTROY:
     1296                win32wndproc(getWindowHandle(), WM_NCDESTROY, 0, 0);
     1297                NotifyParent(Msg, wParam, lParam);
     1298                return win32wndproc(getWindowHandle(), WM_DESTROY, 0, 0);
     1299        default:
     1300                return win32wndproc(getWindowHandle(), Msg, wParam, lParam);
    12551301  }
    12561302}
    … …  
    12661312    return 0;
    12671313  }
    1268   postmsg->Msg    = msg;
     1314  postmsg->Msg    = msg;
    12691315  postmsg->wParam = wParam;
    12701316  postmsg->lParam = lParam;
    … …  
    12821328    return 0;
    12831329  }
    1284   postmsg->Msg    = msg;
     1330  postmsg->Msg    = msg;
    12851331  postmsg->wParam = wParam;
    12861332  postmsg->lParam = lParam;
    … …  
    12971343   while(window)
    12981344   {
    1299         if(window->getStyle() & WS_CHILD && !(window->getExStyle() & WS_EX_NOPARENTNOTIFY) )
    1300         {
    1301                 /* Notify the parent window only */
    1302                 parentwindow = window->getParent();
    1303                 if(parentwindow) {
    1304                         if(Msg == WM_CREATE || Msg == WM_DESTROY) {
    1305                                 parentwindow->SendInternalMessageA(WM_PARENTNOTIFY, MAKEWPARAM(Msg, window->getWindowId()), (LPARAM)window->getWindowHandle());
    1306                         }
    1307                         else    parentwindow->SendInternalMessageA(WM_PARENTNOTIFY, MAKEWPARAM(Msg, window->getWindowId()), lParam );
    1308                 }
    1309         }
    1310         else    break;
    1311 
    1312         window = parentwindow;
     1345        if(window->getStyle() & WS_CHILD && !(window->getExStyle() & WS_EX_NOPARENTNOTIFY) )
     1346        {
     1347                /* Notify the parent window only */
     1348                parentwindow = window->getParent();
     1349                if(parentwindow) {
     1350                        if(Msg == WM_CREATE || Msg == WM_DESTROY) {
     1351                                parentwindow->SendInternalMessageA(WM_PARENTNOTIFY, MAKEWPARAM(Msg, window->getWindowId()), (LPARAM)window->getWindowHandle());
     1352                        }
     1353                        else    parentwindow->SendInternalMessageA(WM_PARENTNOTIFY, MAKEWPARAM(Msg, window->getWindowId()), lParam );
     1354                }
     1355        }
     1356        else    break;
     1357
     1358        window = parentwindow;
    13131359   }
    13141360}
    … …  
    13171363BOOL Win32Window::SetMenu(HMENU hMenu)
    13181364{
    1319  PVOID          menutemplate;
     1365 PVOID          menutemplate;
    13201366 Win32Resource *winres = (Win32Resource *)hMenu;
    13211367
    13221368    dprintf(("SetMenu %x", hMenu));
    13231369    if(HIWORD(winres) == 0) {
    1324         dprintf(("Win32Window:: Win32Resource *winres == 0"));
    1325         SetLastError(ERROR_INVALID_PARAMETER);
    1326         return FALSE;
     1370        dprintf(("Win32Window:: Win32Resource *winres == 0"));
     1371        SetLastError(ERROR_INVALID_PARAMETER);
     1372        return FALSE;
    13271373    }
    13281374    menutemplate = winres->lockOS2Resource();
    13291375    if(menutemplate == NULL)
    13301376    {
    1331         dprintf(("Win32Window::SetMenu menutemplate == 0"));
    1332         return FALSE;
     1377        dprintf(("Win32Window::SetMenu menutemplate == 0"));
     1378        return FALSE;
    13331379    }
    13341380    OS2HwndMenu = OSLibWinCreateMenu(OS2HwndFrame, menutemplate);
    13351381    if(OS2HwndMenu == 0) {
    1336         dprintf(("Win32Window::SetMenu OS2HwndMenu == 0"));
    1337         return FALSE;
     1382        dprintf(("Win32Window::SetMenu OS2HwndMenu == 0"));
     1383        return FALSE;
    13381384    }
    13391385    menuResource = winres;
    … …  
    13451391{
    13461392 Win32Resource *winres = (Win32Resource *)hAccel;
    1347  HANDLE         accelhandle;
     1393 HANDLE         accelhandle;
    13481394
    13491395    if(HIWORD(hAccel) == 0) {
    1350         dprintf(("SetAccelTable: hAccel %x invalid", hAccel));
    1351         SetLastError(ERROR_INVALID_PARAMETER);
    1352         return FALSE;
     1396        dprintf(("SetAccelTable: hAccel %x invalid", hAccel));
     1397        SetLastError(ERROR_INVALID_PARAMETER);
     1398        return FALSE;
    13531399    }
    13541400    acceltableResource = winres;
    … …  
    13721418    dprintf(("ShowWindow %x", nCmdShow));
    13731419    if(fFirstShow) {
    1374         if(isFrameWindow() && IS_OVERLAPPED(getStyle())) {
    1375                 SendMessageA(WM_SIZE, SIZE_RESTORED,
    1376                                 MAKELONG(rectClient.right-rectClient.left,
    1377                                         rectClient.bottom-rectClient.top));
    1378                 SendMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
    1379 
    1380         }
    1381         fFirstShow = FALSE;
     1420        if(isFrameWindow() && IS_OVERLAPPED(getStyle())) {
     1421                SendMessageA(WM_SIZE, SIZE_RESTORED,
     1422                                MAKELONG(rectClient.right-rectClient.left,
     1423                                        rectClient.bottom-rectClient.top));
     1424                SendMessageA(WM_MOVE, 0, MAKELONG( rectClient.left, rectClient.top ) );
     1425
     1426        }
     1427        fFirstShow = FALSE;
    13821428    }
    13831429    switch(nCmdShow)
    … …  
    13851431    case SW_SHOW:
    13861432    case SW_SHOWDEFAULT: //todo
    1387         showstate = SWPOS_SHOW | SWPOS_ACTIVATE;
    1388         break;
     1433        showstate = SWPOS_SHOW | SWPOS_ACTIVATE;
     1434        break;
    13891435    case SW_HIDE:
    1390         showstate = SWPOS_HIDE;
    1391         break;
     1436        showstate = SWPOS_HIDE;
     1437        break;
    13921438    case SW_RESTORE:
    1393         showstate = SWPOS_RESTORE | SWPOS_SHOW | SWPOS_ACTIVATE;
    1394         break;
     1439        showstate = SWPOS_RESTORE | SWPOS_SHOW | SWPOS_ACTIVATE;
     1440        break;
    13951441    case SW_MINIMIZE:
    1396         showstate = SWPOS_MINIMIZE;
    1397         break;
     1442        showstate = SWPOS_MINIMIZE;
     1443        break;
    13981444    case SW_SHOWMAXIMIZED:
    1399         showstate = SWPOS_MAXIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
    1400         break;
     1445        showstate = SWPOS_MAXIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
     1446        break;
    14011447    case SW_SHOWMINIMIZED:
    1402         showstate = SWPOS_MINIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
    1403         break;
     1448        showstate = SWPOS_MINIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
     1449        break;
    14041450    case SW_SHOWMINNOACTIVE:
    1405         showstate = SWPOS_MINIMIZE | SWPOS_SHOW;
    1406         break;
     1451        showstate = SWPOS_MINIMIZE | SWPOS_SHOW;
     1452        break;
    14071453    case SW_SHOWNA:
    1408         showstate = SWPOS_SHOW;
    1409         break;
     1454        showstate = SWPOS_SHOW;
     1455        break;
    14101456    case SW_SHOWNOACTIVATE:
    1411         showstate = SWPOS_SHOW;
    1412         break;
     1457        showstate = SWPOS_SHOW;
     1458        break;
    14131459    case SW_SHOWNORMAL:
    1414         showstate = SWPOS_RESTORE | SWPOS_ACTIVATE | SWPOS_SHOW;
    1415         break;
     1460        showstate = SWPOS_RESTORE | SWPOS_ACTIVATE | SWPOS_SHOW;
     1461        break;
    14161462    }
    14171463    return OSLibWinShowWindow(OS2HwndFrame, showstate);
    … …  
    14211467BOOL Win32Window::SetWindowPos(HWND hwndInsertAfter, int x, int y, int cx, int cy, UINT fuFlags)
    14221468{
    1423  Win32Window *window;
    1424  ULONG        setstate = 0;
    1425 
    1426     switch(hwndInsertAfter) {
    1427     case HWND_BOTTOM:
    1428         hwndInsertAfter = HWNDOS_BOTTOM;
    1429         break;
    1430     case HWND_TOPMOST: //TODO
    1431     case HWND_NOTOPMOST: //TODO:
    1432     case HWND_TOP:
    1433         hwndInsertAfter = HWNDOS_TOP;
    1434         break;
    1435     default:
    1436         window = GetWindowFromHandle(hwndInsertAfter);
    1437         if(window) {
    1438             hwndInsertAfter = window->getOS2WindowHandle();
    1439             PRECT clientRect = window->getClientRect();
    1440 
    1441 #if 1
    1442             if(x+cx > clientRect->right - clientRect->left) {
    1443                 dprintf(("Adjusting cx from %d to %d", cx, (clientRect->right - clientRect->left) - x));
    1444                 cx = (clientRect->right - clientRect->left) - x;
    1445             }
    1446             if(y+cy > clientRect->bottom - clientRect->top) {
    1447                 dprintf(("Adjusting cy from %d to %d", cy, (clientRect->bottom - clientRect->top) - y));
    1448                 cy = (clientRect->bottom - clientRect->top) - y;
    1449             }
    1450 #endif
    1451 #if 0
    1452             //Correct coordinates if parent is a frame window (border adjustment)
    1453             //TODO: Not quite right (Solitaire child window placement slightly wrong)
    1454             if (window->isFrameWindow() && !(fuFlags & SWP_NOMOVE)) {
    1455                 if (HAS_DLGFRAME(window->getStyle(), window->getExStyle() ))
    1456                 {
    1457                     x += GetSystemMetrics(SM_CXDLGFRAME);
    1458                     y -= GetSystemMetrics(SM_CYDLGFRAME);
    1459                 }
    1460                 else
    1461                 {
    1462                     if (HAS_THICKFRAME(window->getStyle()))
    1463                     {
    1464                         x += GetSystemMetrics(SM_CXFRAME);
    1465                         y -= GetSystemMetrics(SM_CYFRAME);
    1466                     }
    1467                     else
    1468                     if (window->getStyle() & WS_BORDER)
    1469                     {
    1470                         x += GetSystemMetrics(SM_CXBORDER);
    1471                         y -= GetSystemMetrics(SM_CYBORDER);
    1472                     }
    1473                 }
    1474             }
    1475 #endif
    1476         }
    1477         else {
    1478             dprintf(("Win32Window::SetWindowPos, unknown hwndInsertAfter %x", hwndInsertAfter));
    1479             hwndInsertAfter = 0;
    1480         }
    1481 
    1482         break;
    1483 
    1484     }
    1485     setstate = SWPOS_MOVE | SWPOS_SIZE | SWPOS_ACTIVATE | SWPOS_ZORDER;
    1486     if(fuFlags & SWP_DRAWFRAME)
    1487         setstate |= 0; //TODO
    1488     if(fuFlags & SWP_FRAMECHANGED)
    1489         setstate |= 0; //TODO
    1490     if(fuFlags & SWP_HIDEWINDOW)
    1491         setstate &= ~SWPOS_ZORDER;
    1492     if(fuFlags & SWP_NOACTIVATE)
    1493         setstate &= ~SWPOS_ACTIVATE;
    1494     if(fuFlags & SWP_NOCOPYBITS)
    1495         setstate |= 0;      //TODO
    1496     if(fuFlags & SWP_NOMOVE)
    1497         setstate &= ~SWPOS_MOVE;
    1498     if(fuFlags & SWP_NOSIZE)
    1499         setstate &= ~SWPOS_SIZE;
    1500     if(fuFlags & SWP_NOREDRAW)
    1501         setstate |= SWPOS_NOREDRAW;
    1502     if(fuFlags & SWP_NOZORDER)
    1503         setstate &= ~SWPOS_ZORDER;
    1504     if(fuFlags & SWP_SHOWWINDOW)
    1505         setstate |= SWPOS_SHOW;
    1506 
    1507     //TODO send NCCREATE if size changed or SWP_FRAMECHANGED flag specified.
    1508     return OSLibWinSetWindowPos(OS2HwndFrame, hwndInsertAfter, x, y, cx, cy, setstate);
     1469   BOOL rc = FALSE;
     1470   Win32Window *window;
     1471
     1472   dprintf (("SetWindowPos %x %x (%d,%d)(%d,%d) %x", Win32Hwnd, hwndInsertAfter, x, y, cx, cy, fuFlags));
     1473
     1474   /* Validate the flags passed in ...                   */
     1475   if ( fuFlags &
     1476        ~(SWP_NOSIZE     | SWP_NOMOVE     | SWP_NOZORDER     |
     1477          SWP_NOREDRAW   | SWP_NOACTIVATE | SWP_FRAMECHANGED |
     1478          SWP_SHOWWINDOW | SWP_HIDEWINDOW | SWP_NOCOPYBITS   |
     1479          SWP_NOOWNERZORDER) )
     1480   {
     1481      return FALSE;
     1482   }
     1483
     1484   WINDOWPOS wpos;
     1485   SWP swp, swpOld;
     1486   ULONG parentHeight;
     1487
     1488   //****************************
     1489   // Set up with Windows values.
     1490   //****************************
     1491   wpos.flags            = fuFlags;
     1492   wpos.cy               = cy;
     1493   wpos.cx               = cx;
     1494   wpos.x                = x;
     1495   wpos.y                = y;
     1496   wpos.hwndInsertAfter  = hwndInsertAfter;
     1497   wpos.hwnd             = getWindowHandle();
     1498
     1499   //**********************************************
     1500   // Convert from Windows to PM coords and flags.
     1501   //**********************************************
     1502   if(~fuFlags & (SWP_NOMOVE | SWP_NOSIZE)) {
     1503       OSLibWinQueryWindowPos(OS2Hwnd, &swpOld);
     1504       parentHeight = isChild() ?
     1505           OSLibGetWindowHeight(getParent()->getOS2WindowHandle())
     1506         : OSLibQueryScreenHeight();
     1507   }
     1508   OSLibMapWINDOWPOStoSWP(&wpos, &swp, &swpOld, parentHeight);
     1509
     1510   /* MapSWP can clear the SWP_MOVE and SWP_SIZE flags if the window is not
     1511    * being moved or sized.  If these were the only operations to be done
     1512    * and they have been cleared, return now.
     1513    */
     1514   if (swp.fl == 0)
     1515      return TRUE;
     1516
     1517   //*********************************************************************
     1518   //On Windows, a WM_GETMINMAXINFO is made to the app from within this API.
     1519   //We'll send a WM_QUERYTRACKINFO which is translated into a WM_GETMINMAXINFO
     1520   //and passed on to the app. Compare the values returned with the SWP cx and
     1521   //cy values.  They cannot be bigger than the max nor smaller than the min.
     1522   //*********************************************************************
     1523
     1524   if ((swp.fl & SWPOS_ZORDER) && (swp.hwndInsertBehind > HWNDOS_BOTTOM))
     1525   {
     1526      Win32Window *wndBehind = Win32Window::GetWindowFromHandle(swp.hwndInsertBehind);
     1527      swp.hwndInsertBehind   = wndBehind->getOS2WindowHandle();
     1528   }
     1529   if (isFrameWindow())
     1530   {
     1531      POINT maxSize, maxPos, minTrack, maxTrack;
     1532
     1533      GetMinMaxInfo(&maxSize, &maxPos, &minTrack, &maxTrack);
     1534
     1535      if (swp.cx > maxTrack.x) swp.cx = maxTrack.x;
     1536      if (swp.cy > maxTrack.y) swp.cy = maxTrack.y;
     1537      if (swp.cx < minTrack.x) swp.cx = minTrack.x;
     1538      if (swp.cy < minTrack.y) swp.cy = minTrack.y;
     1539      swp.hwnd = OS2HwndFrame;
     1540   } else
     1541      swp.hwnd = OS2Hwnd;
     1542   dprintf (("WinSetWindowPos %x %x (%d,%d)(%d,%d) %x", swp.hwnd, swp.hwndInsertBehind, swp.x, swp.y, swp.cx, swp.cy, swp.fl));
     1543
     1544   //*****************************************************************************
     1545   // Squibble the window.  (WinSetMultWindowPos is faster than WinSetWindowPos.)
     1546   //*****************************************************************************
     1547   rc = OSLibWinSetMultWindowPos(&swp, 1);
     1548
     1549   if (rc == FALSE)
     1550   {
     1551//      SET_ERROR_LAST();
     1552   }
     1553   else
     1554   {
     1555      /* To implement support for SWP_FRAMECHANGED_W correctly, we would need
     1556      ** to send a WM_NCCALCSIZE message. This means DAX would have to support
     1557      ** the WM_NCCALCSIZE message. I don't think DAX can support this
     1558      ** message because it is tightly bound with the architecture of
     1559      ** overlapped windows (the "just one window" architecture). However,
     1560      ** we *can* support the SWP_FRAMECHANGED flag by sending the window
     1561      ** a WM_UPDATEFRAME, which will provide the behavior of WM_NCCALCSIZE.
     1562      */
     1563//      if (fuFlags & SWP_FRAMECHANGED_W)
     1564//         WinSendMsg(hWindow, WM_UPDATEFRAME, (MPARAM)-1, 0);
     1565   }
     1566
     1567   return (rc);
    15091568}
    15101569//******************************************************************************
    … …  
    15221581    return getParent()->getWindowHandle();
    15231582  }
    1524   else  return 0;
     1583  else  return 0;
    15251584}
    15261585//******************************************************************************
    … …  
    15321591
    15331592   if(getParent()) {
    1534         oldhwnd = getParent()->getWindowHandle();
     1593        oldhwnd = getParent()->getWindowHandle();
    15351594   }
    15361595   else oldhwnd = 0;
    … …  
    15381597   if(hwndNewParent == 0) {//desktop window = parent
    15391598    setParent(NULL);
    1540         OSLibWinSetParent(getOS2WindowHandle(), OSLIB_HWND_DESKTOP);
    1541         return oldhwnd;
     1599        OSLibWinSetParent(getOS2WindowHandle(), OSLIB_HWND_DESKTOP);
     1600        return oldhwnd;
    15421601   }
    15431602   newparent = GetWindowFromHandle(hwndNewParent);
    15441603   if(newparent)
    15451604   {
    1546         setParent(newparent);
    1547         OSLibWinSetParent(getOS2WindowHandle(), getParent()->getOS2WindowHandle());
    1548         return oldhwnd;
     1605        setParent(newparent);
     1606        OSLibWinSetParent(getOS2WindowHandle(), getParent()->getOS2WindowHandle());
     1607        return oldhwnd;
    15491608   }
    15501609   SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    15581617    return getParent()->getWindowHandle() == hwndParent;
    15591618  }
    1560   else  return 0;
     1619  else  return 0;
    15611620}
    15621621//******************************************************************************
    … …  
    15771636    if(OSLibWinQueryUpdateRect(OS2Hwnd, &rect))
    15781637    {//update region not empty
    1579         SendInternalMessageA((isIcon) ? WM_PAINTICON : WM_PAINT, 0, 0);
     1638        SendInternalMessageA((isIcon) ? WM_PAINTICON : WM_PAINT, 0, 0);
    15801639    }
    15811640    return TRUE;
    … …  
    15931652{
    15941653 Win32Window  *win32wnd;
    1595  ULONG         magic;
    1596  ULONG         getcmd = 0;
    1597  HWND          hwndRelated;
     1654 ULONG         magic;
     1655 ULONG         getcmd = 0;
     1656 HWND          hwndRelated;
    15981657
    15991658    dprintf(("GetWindow %x %d NOT COMPLETE", getWindowHandle(), uCmd));
    16001659    switch(uCmd)
    16011660    {
    1602         case GW_CHILD:
    1603             getcmd = QWOS_TOP;
    1604             break;
    1605         case GW_HWNDFIRST:
    1606             if(getParent()) {
    1607                     getcmd = QWOS_TOP; //top of child windows
    1608             }
    1609             else    getcmd = QWOS_TOP; //TODO
    1610             break;
    1611         case GW_HWNDLAST:
    1612             if(getParent()) {
    1613                     getcmd = QWOS_BOTTOM; //bottom of child windows
    1614             }
    1615             else    getcmd = QWOS_BOTTOM; //TODO
    1616             break;
    1617         case GW_HWNDNEXT:
    1618             getcmd = QWOS_NEXT;
    1619             break;
    1620         case GW_HWNDPREV:
    1621             getcmd = QWOS_PREV;
    1622             break;
    1623         case GW_OWNER:
    1624             if(owner) {
    1625                     return owner->getWindowHandle();
    1626             }
    1627             else    return 0;
     1661        case GW_CHILD:
     1662            getcmd = QWOS_TOP;
     1663            break;
     1664        case GW_HWNDFIRST:
     1665            if(getParent()) {
     1666                    getcmd = QWOS_TOP; //top of child windows
     1667            }
     1668            else    getcmd = QWOS_TOP; //TODO
     1669            break;
     1670        case GW_HWNDLAST:
     1671            if(getParent()) {
     1672                    getcmd = QWOS_BOTTOM; //bottom of child windows
     1673            }
     1674            else    getcmd = QWOS_BOTTOM; //TODO
     1675            break;
     1676        case GW_HWNDNEXT:
     1677            getcmd = QWOS_NEXT;
     1678            break;
     1679        case GW_HWNDPREV:
     1680            getcmd = QWOS_PREV;
     1681            break;
     1682        case GW_OWNER:
     1683            if(owner) {
     1684                    return owner->getWindowHandle();
     1685            }
     1686            else    return 0;
    16281687    }
    16291688    hwndRelated = OSLibWinQueryWindow(OS2Hwnd, getcmd);
    16301689    if(hwndRelated)
    16311690    {
    1632         win32wnd = (Win32Window *)OSLibWinGetWindowULong(hwndRelated, OFFSET_WIN32WNDPTR);
    1633         magic    = OSLibWinGetWindowULong(hwndRelated, OFFSET_WIN32PM_MAGIC);
    1634         if(CheckMagicDword(magic) && win32wnd)
    1635         {
    1636             return win32wnd->getWindowHandle();
    1637         }
     1691        win32wnd = (Win32Window *)OSLibWinGetWindowULong(hwndRelated, OFFSET_WIN32WNDPTR);
     1692        magic    = OSLibWinGetWindowULong(hwndRelated, OFFSET_WIN32PM_MAGIC);
     1693        if(CheckMagicDword(magic) && win32wnd)
     1694        {
     1695            return win32wnd->getWindowHandle();
     1696        }
    16381697    }
    16391698    return 0;
    … …  
    16621721HWND Win32Window::GetActiveWindow()
    16631722{
    1664  HWND          hwndActive;
     1723 HWND          hwndActive;
    16651724 Win32Window  *win32wnd;
    1666  ULONG         magic;
     1725 ULONG         magic;
    16671726
    16681727  hwndActive = OSLibWinQueryActiveWindow();
    … …  
    17251784
    17261785   switch(index) {
    1727         case GWL_EXSTYLE:
    1728                 oldval = dwExStyle;
    1729                 dwExStyle = value;
    1730                 return oldval;
    1731         case GWL_STYLE:
    1732                 oldval = dwStyle;
    1733                 dwStyle = value;
    1734                 return oldval;
    1735         case GWL_WNDPROC:
    1736                 oldval = (LONG)getWindowProc();
    1737                 setWindowProc((WNDPROC)value);
    1738                 return oldval;
    1739         case GWL_HINSTANCE:
    1740                 oldval = hInstance;
    1741                 hInstance = value;
    1742                 return oldval;
    1743         case GWL_HWNDPARENT:
    1744         return SetParent((HWND)value);
    1745 
    1746         case GWL_ID:
    1747                 oldval = getWindowId();
    1748                 setWindowId(value);
    1749                 return oldval;
    1750         case GWL_USERDATA:
    1751                 oldval = userData;
    1752                 userData = value;
    1753                 return oldval;
    1754         default:
    1755                 if(index >= 0 && index/4 < nrUserWindowLong)
    1756                 {
    1757                         oldval = userWindowLong[index/4];
    1758                         userWindowLong[index/4] = value;
    1759                         return oldval;
    1760                 }
    1761                 SetLastError(ERROR_INVALID_PARAMETER);
    1762                 return 0;
     1786        case GWL_EXSTYLE:
     1787                oldval = dwExStyle;
     1788                dwExStyle = value;
     1789                return oldval;
     1790        case GWL_STYLE:
     1791                oldval = dwStyle;
     1792                dwStyle = value;
     1793                return oldval;
     1794        case GWL_WNDPROC:
     1795                oldval = (LONG)getWindowProc();
     1796                setWindowProc((WNDPROC)value);
     1797                return oldval;
     1798        case GWL_HINSTANCE:
     1799                oldval = hInstance;
     1800                hInstance = value;
     1801                return oldval;
     1802        case GWL_HWNDPARENT:
     1803        return SetParent((HWND)value);
     1804
     1805        case GWL_ID:
     1806                oldval = getWindowId();
     1807                setWindowId(value);
     1808                return oldval;
     1809        case GWL_USERDATA:
     1810                oldval = userData;
     1811                userData = value;
     1812                return oldval;
     1813        default:
     1814                if(index >= 0 && index/4 < nrUserWindowLong)
     1815                {
     1816                        oldval = userWindowLong[index/4];
     1817                        userWindowLong[index/4] = value;
     1818                        return oldval;
     1819                }
     1820                SetLastError(ERROR_INVALID_PARAMETER);
     1821                return 0;
    17631822   }
    17641823}
    … …  
    17681827{
    17691828   switch(index) {
    1770         case GWL_EXSTYLE:
    1771                 return dwExStyle;
    1772         case GWL_STYLE:
    1773                 return dwStyle;
    1774         case GWL_WNDPROC:
    1775                 return (ULONG)getWindowProc();
    1776         case GWL_HINSTANCE:
    1777                 return hInstance;
    1778         case GWL_HWNDPARENT:
    1779                 if(getParent()) {
    1780                         return getParent()->getWindowHandle();
    1781                 }
    1782                 else    return 0;
    1783         case GWL_ID:
    1784                 return getWindowId();
    1785         case GWL_USERDATA:
    1786                 return userData;
    1787         default:
    1788                 if(index >= 0 && index/4 < nrUserWindowLong)
    1789                 {
    1790                         return userWindowLong[index/4];
    1791                 }
    1792                 SetLastError(ERROR_INVALID_PARAMETER);
    1793                 return 0;
     1829        case GWL_EXSTYLE:
     1830                return dwExStyle;
     1831        case GWL_STYLE:
     1832                return dwStyle;
     1833        case GWL_WNDPROC:
     1834                return (ULONG)getWindowProc();
     1835        case GWL_HINSTANCE:
     1836                return hInstance;
     1837        case GWL_HWNDPARENT:
     1838                if(getParent()) {
     1839                        return getParent()->getWindowHandle();
     1840                }
     1841                else    return 0;
     1842        case GWL_ID:
     1843                return getWindowId();
     1844        case GWL_USERDATA:
     1845                return userData;
     1846        default:
     1847                if(index >= 0 && index/4 < nrUserWindowLong)
     1848                {
     1849                        return userWindowLong[index/4];
     1850                }
     1851                SetLastError(ERROR_INVALID_PARAMETER);
     1852                return 0;
    17941853   }
    17951854}
    … …  
    18021861   if(index >= 0 && index/4 < nrUserWindowLong)
    18031862   {
    1804         oldval = ((WORD *)userWindowLong)[index/2];
    1805         ((WORD *)userWindowLong)[index/2] = value;
    1806         return oldval;
     1863        oldval = ((WORD *)userWindowLong)[index/2];
     1864        ((WORD *)userWindowLong)[index/2] = value;
     1865        return oldval;
    18071866   }
    18081867   SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    18151874   if(index >= 0 && index/4 < nrUserWindowLong)
    18161875   {
    1817         return ((WORD *)userWindowLong)[index/2];
     1876        return ((WORD *)userWindowLong)[index/2];
    18181877   }
    18191878   SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    18401899{
    18411900 Win32Window *win32wnd;
    1842  DWORD        magic;
     1901 DWORD        magic;
    18431902
    18441903  win32wnd = (Win32Window *)OSLibWinGetWindowULong(hwnd, OFFSET_WIN32WNDPTR);
Note: See TracChangeset for help on using the changeset viewer.