Ignore:
Timestamp:
Aug 22, 1999, 8:29:38 PM (26 years ago)
Author:
dengert
Message:

create windows with correct parent and z-order.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r614 r628  
    1 /* $Id: win32wnd.cpp,v 1.27 1999-08-22 08:30:52 sandervl Exp $ */
     1/* $Id: win32wnd.cpp,v 1.28 1999-08-22 18:29:38 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
    367   OS2Hwnd = OSLibWinCreateWindow((getParent()) ? getParent()->getOS2FrameWindowHandle() : OSLIB_HWND_DESKTOP,
    368                                 dwOSWinStyle, dwOSFrameStyle, (char *)cs->lpszName,
    369                                 (owner) ? owner->getOS2FrameWindowHandle() : OSLIB_HWND_DESKTOP,
    370                                 (hwndLinkAfter == HWND_BOTTOM) ? TRUE : FALSE,
    371                                 &OS2HwndFrame);
     367  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);
    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);
     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;
    … …  
    730730    dprintf(("MsgMove to (%d,%d)", x, y));
    731731    if(fCreated == FALSE) {
    732         return 1;
     732        return 1;
    733733    }
    734734
    … …  
    741741  switch(cmd) {
    742742    case CMD_MENU:
    743         return SendInternalMessageA(WM_COMMAND, MAKELONG(Id, 0), 0);
     743        return SendInternalMessageA(WM_COMMAND, MAKELONG(Id, 0), 0);
    744744    case CMD_CONTROL:
    745         return 0; //todo
     745        return 0; //todo
    746746    case CMD_ACCELERATOR:
    747         dprintf(("accelerator command"));
    748         return 0; //todo
     747        dprintf(("accelerator command"));
     748        return 0; //todo
    749749  }
    750750  return 0;
    … …  
    765765
    766766    if(fCreated == FALSE) {//Solitaire crashes if it receives a WM_SIZE during CreateWindowEx (normal or our fault?)
    767         return 1;
     767        return 1;
    768768    }
    769769
    770770    if(fMinimize) {
    771             fwSizeType = SIZE_MINIMIZED;
     771            fwSizeType = SIZE_MINIMIZED;
    772772    }
    773773    else
    774774    if(fMaximize) {
    775             fwSizeType = SIZE_MAXIMIZED;
     775            fwSizeType = SIZE_MAXIMIZED;
    776776    }
    777777    else    fwSizeType = SIZE_RESTORED;
    … …  
    785785    if(SendInternalMessageA(WM_NCACTIVATE, fActivate, 0) == FALSE)
    786786    {
    787         if(!fActivate) {
    788             return 1;
    789         }
     787        if(!fActivate) {
     788            return 1;
     789        }
    790790    }
    791791    return SendInternalMessageA(WM_ACTIVATE, (fActivate) ? WA_ACTIVE : WA_INACTIVE, hwnd);
    … …  
    807807    lParam |= (scancode << 16);
    808808    if(keyflags & KEY_ALTDOWN)
    809         lParam |= (1<<29);
     809        lParam |= (1<<29);
    810810    if(keyflags & KEY_PREVDOWN)
    811         lParam |= (1<<30);
     811        lParam |= (1<<30);
    812812    if(keyflags & KEY_UP)
    813         lParam |= (1<<31);
     813        lParam |= (1<<31);
    814814    if(keyflags & KEY_DEADKEY) {
    815         dprintf(("WM_DEADCHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
    816         return SendInternalMessageA(WM_DEADCHAR, cmd, lParam);
     815        dprintf(("WM_DEADCHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
     816        return SendInternalMessageA(WM_DEADCHAR, cmd, lParam);
    817817    }
    818818    else {
    819         dprintf(("WM_CHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
    820         return SendInternalMessageA(WM_CHAR, cmd, lParam);
     819        dprintf(("WM_CHAR: %x %x %08x", OS2Hwnd, cmd, lParam));
     820        return SendInternalMessageA(WM_CHAR, cmd, lParam);
    821821    }
    822822}
    … …  
    826826{
    827827    if(hwnd == 0) {
    828         //other app lost focus
    829         SendInternalMessageA(WM_ACTIVATEAPP, TRUE, 0); //TODO: Need thread id from hwnd app
     828        //other app lost focus
     829        SendInternalMessageA(WM_ACTIVATEAPP, TRUE, 0); //TODO: Need thread id from hwnd app
    830830    }
    831831    return SendInternalMessageA(WM_SETFOCUS, hwnd, 0);
    … …  
    836836{
    837837    if(hwnd == 0) {
    838         //other app lost focus
    839         SendInternalMessageA(WM_ACTIVATEAPP, FALSE, 0); //TODO: Need thread id from hwnd app
     838        //other app lost focus
     839        SendInternalMessageA(WM_ACTIVATEAPP, FALSE, 0); //TODO: Need thread id from hwnd app
    840840    }
    841841    return SendInternalMessageA(WM_KILLFOCUS, hwnd, 0);
    … …  
    850850    dprintf(("MsgButton to (%d,%d)", ncx, ncy));
    851851    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;
     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;
    891891    }
    892892    if(win32msg == WM_MBUTTONDBLCLK || win32msg == WM_RBUTTONDBLCLK || win32msg == WM_LBUTTONDBLCLK) {
    893         if(!(windowClass->getClassLongA(GCL_STYLE) & CS_DBLCLKS)) {
    894             return 1;
    895         }
     893        if(!(windowClass->getClassLongA(GCL_STYLE) & CS_DBLCLKS)) {
     894            return 1;
     895        }
    896896    }
    897897    SendInternalMessageA(win32ncmsg, lastHitTestVal, MAKELONG(ncx, ncy)); //TODO:
    … …  
    905905
    906906    if(keystate & WMMOVE_LBUTTON)
    907         winstate |= MK_LBUTTON;
     907        winstate |= MK_LBUTTON;
    908908    if(keystate & WMMOVE_RBUTTON)
    909         winstate |= MK_RBUTTON;
     909        winstate |= MK_RBUTTON;
    910910    if(keystate & WMMOVE_MBUTTON)
    911         winstate |= MK_MBUTTON;
     911        winstate |= MK_MBUTTON;
    912912    if(keystate & WMMOVE_SHIFT)
    913         winstate |= MK_SHIFT;
     913        winstate |= MK_SHIFT;
    914914    if(keystate & WMMOVE_CTRL)
    915         winstate |= MK_CONTROL;
     915        winstate |= MK_CONTROL;
    916916
    917917    return SendInternalMessageA(WM_MOUSEMOVE, keystate, MAKELONG(x, y));
    … …  
    925925//******************************************************************************
    926926//TODO: Is the clipper region of the window DC equal to the invalidated rectangle?
    927 //      (or are we simply erasing too much here)
     927//      (or are we simply erasing too much here)
    928928//******************************************************************************
    929929ULONG Win32Window::MsgEraseBackGround()
    930930{
    931931    if(isIcon) {
    932             return SendInternalMessageA(WM_ICONERASEBKGND, GetDC(getWindowHandle()), 0);
     932            return SendInternalMessageA(WM_ICONERASEBKGND, GetDC(getWindowHandle()), 0);
    933933    }
    934934    else    return SendInternalMessageA(WM_ERASEBKGND, GetDC(getWindowHandle()), 0);
    … …  
    939939{
    940940    if(isUnicode) {
    941             return SendInternalMessageW(WM_SETTEXT, 0, (LPARAM)lpsz);
     941            return SendInternalMessageW(WM_SETTEXT, 0, (LPARAM)lpsz);
    942942    }
    943943    else    return SendInternalMessageA(WM_SETTEXT, 0, (LPARAM)lpsz);
    … …  
    955955{
    956956    if(isUnicode) {
    957         SendInternalMessageW(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameW);
     957        SendInternalMessageW(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameW);
    958958    }
    959959    else {
    960         SendInternalMessageA(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameA);
     960        SendInternalMessageA(WM_GETTEXT, MAX_WINDOW_NAMELENGTH, (LPARAM)windowNameA);
    961961    }
    962962    return windowNameA;
    … …  
    969969    {
    970970    case WM_GETTEXTLENGTH:
    971         return wndNameLength;
     971        return wndNameLength;
    972972
    973973    case WM_GETTEXT:   //TODO: SS_ICON controls
    974         strncpy((LPSTR)lParam, windowNameA, wParam);
    975         return min(wndNameLength, wParam);
     974        strncpy((LPSTR)lParam, windowNameA, wParam);
     975        return min(wndNameLength, wParam);
    976976
    977977    case WM_SETTEXT:
    978         return 0;
     978        return 0;
    979979
    980980    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
     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
    986986
    987987    case WM_NCCREATE:
    988         return(TRUE);
     988        return(TRUE);
    989989
    990990    case WM_CTLCOLORMSGBOX:
    … …  
    995995    case WM_CTLCOLORSTATIC:
    996996    case WM_CTLCOLORSCROLLBAR:
    997         SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
    998         SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
    999         return GetSysColorBrush(COLOR_BTNFACE);
     997        SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
     998        SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
     999        return GetSysColorBrush(COLOR_BTNFACE);
    10001000
    10011001    case WM_PARENTNOTIFY:
    1002         return 0;
     1002        return 0;
    10031003
    10041004    case WM_MOUSEACTIVATE:
    10051005    {
    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;
     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;
    10171017    }
    10181018    case WM_SETCURSOR:
    10191019    {
    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;
     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;
    10311031    }
    10321032    case WM_MOUSEMOVE:
    1033         return 0;
     1033        return 0;
    10341034
    10351035    case WM_ERASEBKGND:
    … …  
    10401040        if (!windowClass->getBackgroundBrush()) return 0;
    10411041
    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());
     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());
    10481048
    10491049        return 1;
    … …  
    10591059    case WM_NCMBUTTONUP:
    10601060    case WM_NCMBUTTONDBLCLK:
    1061         return 0;           //TODO: Send WM_SYSCOMMAND if required
     1061        return 0;           //TODO: Send WM_SYSCOMMAND if required
    10621062
    10631063    case WM_NCHITTEST: //TODO:
    1064         return 0;
     1064        return 0;
    10651065
    10661066    default:
    1067         return 1;
     1067        return 1;
    10681068    }
    10691069}
    … …  
    10751075    {
    10761076    case WM_GETTEXTLENGTH:
    1077         return wndNameLength;
     1077        return wndNameLength;
    10781078
    10791079    case WM_GETTEXT:   //TODO: SS_ICON controls
    1080         lstrcpynW((LPWSTR)lParam, windowNameW, wParam);
    1081         return min(wndNameLength, wParam);
     1080        lstrcpynW((LPWSTR)lParam, windowNameW, wParam);
     1081        return min(wndNameLength, wParam);
    10821082
    10831083    default:
    1084         return DefWindowProcA(Msg, wParam, lParam);
     1084        return DefWindowProcA(Msg, wParam, lParam);
    10851085    }
    10861086}
    … …  
    10901090{
    10911091  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1092         dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1092        dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    10931093
    10941094  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1095         return(0);
     1095        return(0);
    10961096  }
    10971097  switch(Msg)
    10981098  {
    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);
     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);
    11281128  }
    11291129}
    … …  
    11331133{
    11341134  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1135         dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1135        dprintf(("SendMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    11361136
    11371137  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1138         return(0);
     1138        return(0);
    11391139  }
    11401140  switch(Msg)
    11411141  {
    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);
     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);
    11721172  }
    11731173}
    … …  
    11781178{
    11791179  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1180         dprintf(("SendInternalMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1180        dprintf(("SendInternalMessageA %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    11811181
    11821182  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1183         return(0);
     1183        return(0);
    11841184  }
    11851185  switch(Msg)
    11861186  {
    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);
     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);
    12131213  }
    12141214}
    … …  
    12201220{
    12211221  if(PostSpyMessage(getWindowHandle(), Msg, wParam, lParam) == FALSE)
    1222         dprintf(("SendInternalMessageW %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
     1222        dprintf(("SendInternalMessageW %s for %x %x %x", GetMsgText(Msg), getWindowHandle(), wParam, lParam));
    12231223
    12241224  if(HkCBT::OS2HkCBTProc(getWindowHandle(), Msg, wParam, lParam) == TRUE) {//hook swallowed msg
    1225         return(0);
     1225        return(0);
    12261226  }
    12271227  switch(Msg)
    12281228  {
    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);
     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);
    12551255  }
    12561256}
    … …  
    12661266    return 0;
    12671267  }
    1268   postmsg->Msg    = msg;
     1268  postmsg->Msg    = msg;
    12691269  postmsg->wParam = wParam;
    12701270  postmsg->lParam = lParam;
    … …  
    12821282    return 0;
    12831283  }
    1284   postmsg->Msg    = msg;
     1284  postmsg->Msg    = msg;
    12851285  postmsg->wParam = wParam;
    12861286  postmsg->lParam = lParam;
    … …  
    12971297   while(window)
    12981298   {
    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;
     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;
    13131313   }
    13141314}
    … …  
    13171317BOOL Win32Window::SetMenu(HMENU hMenu)
    13181318{
    1319  PVOID          menutemplate;
     1319 PVOID          menutemplate;
    13201320 Win32Resource *winres = (Win32Resource *)hMenu;
    13211321
    13221322    dprintf(("SetMenu %x", hMenu));
    13231323    if(HIWORD(winres) == 0) {
    1324         dprintf(("Win32Window:: Win32Resource *winres == 0"));
    1325         SetLastError(ERROR_INVALID_PARAMETER);
    1326         return FALSE;
     1324        dprintf(("Win32Window:: Win32Resource *winres == 0"));
     1325        SetLastError(ERROR_INVALID_PARAMETER);
     1326        return FALSE;
    13271327    }
    13281328    menutemplate = winres->lockOS2Resource();
    13291329    if(menutemplate == NULL)
    13301330    {
    1331         dprintf(("Win32Window::SetMenu menutemplate == 0"));
    1332         return FALSE;
     1331        dprintf(("Win32Window::SetMenu menutemplate == 0"));
     1332        return FALSE;
    13331333    }
    13341334    OS2HwndMenu = OSLibWinCreateMenu(OS2HwndFrame, menutemplate);
    13351335    if(OS2HwndMenu == 0) {
    1336         dprintf(("Win32Window::SetMenu OS2HwndMenu == 0"));
    1337         return FALSE;
     1336        dprintf(("Win32Window::SetMenu OS2HwndMenu == 0"));
     1337        return FALSE;
    13381338    }
    13391339    menuResource = winres;
    … …  
    13451345{
    13461346 Win32Resource *winres = (Win32Resource *)hAccel;
    1347  HANDLE         accelhandle;
     1347 HANDLE         accelhandle;
    13481348
    13491349    if(HIWORD(hAccel) == 0) {
    1350         dprintf(("SetAccelTable: hAccel %x invalid", hAccel));
    1351         SetLastError(ERROR_INVALID_PARAMETER);
    1352         return FALSE;
     1350        dprintf(("SetAccelTable: hAccel %x invalid", hAccel));
     1351        SetLastError(ERROR_INVALID_PARAMETER);
     1352        return FALSE;
    13531353    }
    13541354    acceltableResource = winres;
    … …  
    13721372    dprintf(("ShowWindow %x", nCmdShow));
    13731373    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;
     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;
    13821382    }
    13831383    switch(nCmdShow)
    … …  
    13851385    case SW_SHOW:
    13861386    case SW_SHOWDEFAULT: //todo
    1387         showstate = SWPOS_SHOW | SWPOS_ACTIVATE;
    1388         break;
     1387        showstate = SWPOS_SHOW | SWPOS_ACTIVATE;
     1388        break;
    13891389    case SW_HIDE:
    1390         showstate = SWPOS_HIDE;
    1391         break;
     1390        showstate = SWPOS_HIDE;
     1391        break;
    13921392    case SW_RESTORE:
    1393         showstate = SWPOS_RESTORE | SWPOS_SHOW | SWPOS_ACTIVATE;
    1394         break;
     1393        showstate = SWPOS_RESTORE | SWPOS_SHOW | SWPOS_ACTIVATE;
     1394        break;
    13951395    case SW_MINIMIZE:
    1396         showstate = SWPOS_MINIMIZE;
    1397         break;
     1396        showstate = SWPOS_MINIMIZE;
     1397        break;
    13981398    case SW_SHOWMAXIMIZED:
    1399         showstate = SWPOS_MAXIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
    1400         break;
     1399        showstate = SWPOS_MAXIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
     1400        break;
    14011401    case SW_SHOWMINIMIZED:
    1402         showstate = SWPOS_MINIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
    1403         break;
     1402        showstate = SWPOS_MINIMIZE | SWPOS_SHOW | SWPOS_ACTIVATE;
     1403        break;
    14041404    case SW_SHOWMINNOACTIVE:
    1405         showstate = SWPOS_MINIMIZE | SWPOS_SHOW;
    1406         break;
     1405        showstate = SWPOS_MINIMIZE | SWPOS_SHOW;
     1406        break;
    14071407    case SW_SHOWNA:
    1408         showstate = SWPOS_SHOW;
    1409         break;
     1408        showstate = SWPOS_SHOW;
     1409        break;
    14101410    case SW_SHOWNOACTIVATE:
    1411         showstate = SWPOS_SHOW;
    1412         break;
     1411        showstate = SWPOS_SHOW;
     1412        break;
    14131413    case SW_SHOWNORMAL:
    1414         showstate = SWPOS_RESTORE | SWPOS_ACTIVATE | SWPOS_SHOW;
    1415         break;
     1414        showstate = SWPOS_RESTORE | SWPOS_ACTIVATE | SWPOS_SHOW;
     1415        break;
    14161416    }
    14171417    return OSLibWinShowWindow(OS2HwndFrame, showstate);
    … …  
    14221422{
    14231423 Win32Window *window;
    1424  ULONG        setstate = 0;
     1424 ULONG        setstate = 0;
    14251425
    14261426    switch(hwndInsertAfter) {
    14271427    case HWND_BOTTOM:
    1428         hwndInsertAfter = HWNDOS_BOTTOM;
    1429         break;
     1428        hwndInsertAfter = HWNDOS_BOTTOM;
     1429        break;
    14301430    case HWND_TOPMOST: //TODO
    14311431    case HWND_NOTOPMOST: //TODO:
    14321432    case HWND_TOP:
    1433         hwndInsertAfter = HWNDOS_TOP;
    1434         break;
     1433        hwndInsertAfter = HWNDOS_TOP;
     1434        break;
    14351435    default:
    1436         window = GetWindowFromHandle(hwndInsertAfter);
    1437         if(window) {
    1438             hwndInsertAfter = window->getOS2WindowHandle();
    1439             PRECT clientRect = window->getClientRect();
     1436        window = GetWindowFromHandle(hwndInsertAfter);
     1437        if(window) {
     1438            hwndInsertAfter = window->getOS2WindowHandle();
     1439            PRECT clientRect = window->getClientRect();
    14401440
    14411441#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             }
     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            }
    14501450#endif
    1451             //Correct coordinates if parent is a frame window (border adjustment)
    1452             //TODO: Not quite right (Solitaire child window placement slightly wrong)
    1453             if (window->isFrameWindow() && !(fuFlags & SWP_NOMOVE)) {
    1454                 if (HAS_DLGFRAME(window->getStyle(), window->getExStyle() ))
    1455                 {
    1456                     x += GetSystemMetrics(SM_CXDLGFRAME);
    1457                     y -= GetSystemMetrics(SM_CYDLGFRAME);
    1458                 }
    1459                 else
    1460                 {
    1461                     if (HAS_THICKFRAME(window->getStyle()))
    1462                     {
    1463                         x += GetSystemMetrics(SM_CXFRAME);
    1464                         y -= GetSystemMetrics(SM_CYFRAME);
    1465                     }
    1466                     else
    1467                     if (window->getStyle() & WS_BORDER)
    1468                     {
    1469                         x += GetSystemMetrics(SM_CXBORDER);
    1470                         y -= GetSystemMetrics(SM_CYBORDER);
    1471                     }
    1472                 }
    1473             }
    1474         }
    1475         else {
    1476             dprintf(("Win32Window::SetWindowPos, unknown hwndInsertAfter %x", hwndInsertAfter));
    1477             hwndInsertAfter = 0;
    1478         }
    1479 
    1480         break;
     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;
    14811483
    14821484    }
    14831485    setstate = SWPOS_MOVE | SWPOS_SIZE | SWPOS_ACTIVATE | SWPOS_ZORDER;
    14841486    if(fuFlags & SWP_DRAWFRAME)
    1485         setstate |= 0; //TODO
     1487        setstate |= 0; //TODO
    14861488    if(fuFlags & SWP_FRAMECHANGED)
    1487         setstate |= 0; //TODO
     1489        setstate |= 0; //TODO
    14881490    if(fuFlags & SWP_HIDEWINDOW)
    1489         setstate &= ~SWPOS_ZORDER;
     1491        setstate &= ~SWPOS_ZORDER;
    14901492    if(fuFlags & SWP_NOACTIVATE)
    1491         setstate &= ~SWPOS_ACTIVATE;
     1493        setstate &= ~SWPOS_ACTIVATE;
    14921494    if(fuFlags & SWP_NOCOPYBITS)
    1493         setstate |= 0;      //TODO
     1495        setstate |= 0;      //TODO
    14941496    if(fuFlags & SWP_NOMOVE)
    1495         setstate &= ~SWPOS_MOVE;
     1497        setstate &= ~SWPOS_MOVE;
    14961498    if(fuFlags & SWP_NOSIZE)
    1497         setstate &= ~SWPOS_SIZE;
     1499        setstate &= ~SWPOS_SIZE;
    14981500    if(fuFlags & SWP_NOREDRAW)
    1499         setstate |= SWPOS_NOREDRAW;
     1501        setstate |= SWPOS_NOREDRAW;
    15001502    if(fuFlags & SWP_NOZORDER)
    1501         setstate &= ~SWPOS_ZORDER;
     1503        setstate &= ~SWPOS_ZORDER;
    15021504    if(fuFlags & SWP_SHOWWINDOW)
    1503         setstate |= SWPOS_SHOW;
     1505        setstate |= SWPOS_SHOW;
    15041506
    15051507    //TODO send NCCREATE if size changed or SWP_FRAMECHANGED flag specified.
    … …  
    15201522    return getParent()->getWindowHandle();
    15211523  }
    1522   else  return 0;
     1524  else  return 0;
    15231525}
    15241526//******************************************************************************
    … …  
    15301532
    15311533   if(getParent()) {
    1532         oldhwnd = getParent()->getWindowHandle();
     1534        oldhwnd = getParent()->getWindowHandle();
    15331535   }
    15341536   else oldhwnd = 0;
    … …  
    15361538   if(hwndNewParent == 0) {//desktop window = parent
    15371539    setParent(NULL);
    1538         OSLibWinSetParent(getOS2WindowHandle(), OSLIB_HWND_DESKTOP);
    1539         return oldhwnd;
     1540        OSLibWinSetParent(getOS2WindowHandle(), OSLIB_HWND_DESKTOP);
     1541        return oldhwnd;
    15401542   }
    15411543   newparent = GetWindowFromHandle(hwndNewParent);
    15421544   if(newparent)
    15431545   {
    1544         setParent(newparent);
    1545         OSLibWinSetParent(getOS2WindowHandle(), getParent()->getOS2WindowHandle());
    1546         return oldhwnd;
     1546        setParent(newparent);
     1547        OSLibWinSetParent(getOS2WindowHandle(), getParent()->getOS2WindowHandle());
     1548        return oldhwnd;
    15471549   }
    15481550   SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    15561558    return getParent()->getWindowHandle() == hwndParent;
    15571559  }
    1558   else  return 0;
     1560  else  return 0;
    15591561}
    15601562//******************************************************************************
    … …  
    15751577    if(OSLibWinQueryUpdateRect(OS2Hwnd, &rect))
    15761578    {//update region not empty
    1577         SendInternalMessageA((isIcon) ? WM_PAINTICON : WM_PAINT, 0, 0);
     1579        SendInternalMessageA((isIcon) ? WM_PAINTICON : WM_PAINT, 0, 0);
    15781580    }
    15791581    return TRUE;
    … …  
    15911593{
    15921594 Win32Window  *win32wnd;
    1593  ULONG         magic;
    1594  ULONG         getcmd = 0;
    1595  HWND          hwndRelated;
     1595 ULONG         magic;
     1596 ULONG         getcmd = 0;
     1597 HWND          hwndRelated;
    15961598
    15971599    dprintf(("GetWindow %x %d NOT COMPLETE", getWindowHandle(), uCmd));
    15981600    switch(uCmd)
    15991601    {
    1600         case GW_CHILD:
    1601             getcmd = QWOS_TOP;
    1602             break;
    1603         case GW_HWNDFIRST:
    1604             if(getParent()) {
    1605                     getcmd = QWOS_TOP; //top of child windows
    1606             }
    1607             else    getcmd = QWOS_TOP; //TODO
    1608             break;
    1609         case GW_HWNDLAST:
    1610             if(getParent()) {
    1611                     getcmd = QWOS_BOTTOM; //bottom of child windows
    1612             }
    1613             else    getcmd = QWOS_BOTTOM; //TODO
    1614             break;
    1615         case GW_HWNDNEXT:
    1616             getcmd = QWOS_NEXT;
    1617             break;
    1618         case GW_HWNDPREV:
    1619             getcmd = QWOS_PREV;
    1620             break;
    1621         case GW_OWNER:
    1622             if(owner) {
    1623                     return owner->getWindowHandle();
    1624             }
    1625             else    return 0;
     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;
    16261628    }
    16271629    hwndRelated = OSLibWinQueryWindow(OS2Hwnd, getcmd);
    16281630    if(hwndRelated)
    16291631    {
    1630         win32wnd = (Win32Window *)OSLibWinGetWindowULong(hwndRelated, OFFSET_WIN32WNDPTR);
    1631         magic    = OSLibWinGetWindowULong(hwndRelated, OFFSET_WIN32PM_MAGIC);
    1632         if(CheckMagicDword(magic) && win32wnd)
    1633         {
    1634             return win32wnd->getWindowHandle();
    1635         }
     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        }
    16361638    }
    16371639    return 0;
    … …  
    16601662HWND Win32Window::GetActiveWindow()
    16611663{
    1662  HWND          hwndActive;
     1664 HWND          hwndActive;
    16631665 Win32Window  *win32wnd;
    1664  ULONG         magic;
     1666 ULONG         magic;
    16651667
    16661668  hwndActive = OSLibWinQueryActiveWindow();
    … …  
    17231725
    17241726   switch(index) {
    1725         case GWL_EXSTYLE:
    1726                 oldval = dwExStyle;
    1727                 dwExStyle = value;
    1728                 return oldval;
    1729         case GWL_STYLE:
    1730                 oldval = dwStyle;
    1731                 dwStyle = value;
    1732                 return oldval;
    1733         case GWL_WNDPROC:
    1734                 oldval = (LONG)getWindowProc();
    1735                 setWindowProc((WNDPROC)value);
    1736                 return oldval;
    1737         case GWL_HINSTANCE:
    1738                 oldval = hInstance;
    1739                 hInstance = value;
    1740                 return oldval;
    1741         case GWL_HWNDPARENT:
    1742         return SetParent((HWND)value);
    1743 
    1744         case GWL_ID:
    1745                 oldval = getWindowId();
    1746                 setWindowId(value);
    1747                 return oldval;
    1748         case GWL_USERDATA:
    1749                 oldval = userData;
    1750                 userData = value;
    1751                 return oldval;
    1752         default:
    1753                 if(index >= 0 && index/4 < nrUserWindowLong)
    1754                 {
    1755                         oldval = userWindowLong[index/4];
    1756                         userWindowLong[index/4] = value;
    1757                         return oldval;
    1758                 }
    1759                 SetLastError(ERROR_INVALID_PARAMETER);
    1760                 return 0;
     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;
    17611763   }
    17621764}
    … …  
    17661768{
    17671769   switch(index) {
    1768         case GWL_EXSTYLE:
    1769                 return dwExStyle;
    1770         case GWL_STYLE:
    1771                 return dwStyle;
    1772         case GWL_WNDPROC:
    1773                 return (ULONG)getWindowProc();
    1774         case GWL_HINSTANCE:
    1775                 return hInstance;
    1776         case GWL_HWNDPARENT:
    1777                 if(getParent()) {
    1778                         return getParent()->getWindowHandle();
    1779                 }
    1780                 else    return 0;
    1781         case GWL_ID:
    1782                 return getWindowId();
    1783         case GWL_USERDATA:
    1784                 return userData;
    1785         default:
    1786                 if(index >= 0 && index/4 < nrUserWindowLong)
    1787                 {
    1788                         return userWindowLong[index/4];
    1789                 }
    1790                 SetLastError(ERROR_INVALID_PARAMETER);
    1791                 return 0;
     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;
    17921794   }
    17931795}
    … …  
    18001802   if(index >= 0 && index/4 < nrUserWindowLong)
    18011803   {
    1802         oldval = ((WORD *)userWindowLong)[index/2];
    1803         ((WORD *)userWindowLong)[index/2] = value;
    1804         return oldval;
     1804        oldval = ((WORD *)userWindowLong)[index/2];
     1805        ((WORD *)userWindowLong)[index/2] = value;
     1806        return oldval;
    18051807   }
    18061808   SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    18131815   if(index >= 0 && index/4 < nrUserWindowLong)
    18141816   {
    1815         return ((WORD *)userWindowLong)[index/2];
     1817        return ((WORD *)userWindowLong)[index/2];
    18161818   }
    18171819   SetLastError(ERROR_INVALID_PARAMETER);
    … …  
    18381840{
    18391841 Win32Window *win32wnd;
    1840  DWORD        magic;
     1842 DWORD        magic;
    18411843
    18421844  win32wnd = (Win32Window *)OSLibWinGetWindowULong(hwnd, OFFSET_WIN32WNDPTR);
Note: See TracChangeset for help on using the changeset viewer.