Changeset 5685 for trunk/src

Timestamp:

May 11, 2001, 10:39:46 AM (24 years ago)

Author:

sandervl

Message:

client/frame rewrite

Location:

trunk/src/user32

Files:

• Makefile (modified) (2 diffs)
• caret.cpp (modified) (3 diffs)
• dc.cpp (modified) (39 diffs)
• dc.h (modified) (2 diffs)
• dcrgn.cpp (modified) (6 diffs)
• oslibgdi.cpp (modified) (3 diffs)
• oslibgdi.h (modified) (2 diffs)
• oslibmsgtranslate.cpp (modified) (14 diffs)
• oslibwin.cpp (modified) (20 diffs)
• oslibwin.h (modified) (3 diffs)
• pmwindow.cpp (modified) (31 diffs)
• static.cpp (modified) (2 diffs)
• win32dlg.cpp (modified) (4 diffs)
• win32wbase.cpp (modified) (40 diffs)
• win32wbase.h (modified) (9 diffs)
• win32wbasepos.cpp (modified) (2 diffs)
• win32wdesktop.cpp (modified) (2 diffs)
• win32wndhandle.cpp (modified) (2 diffs)
• window.cpp (modified) (7 diffs)

trunk/src/user32/Makefile

@@ -1 @@
-# $Id: Makefile,v 1.82 2001-04-12 14:04:32 sandervl Exp $
+# $Id: Makefile,v 1.83 2001-05-11 08:39:41 sandervl Exp $
 
 #
@@ -18 +18 @@
 #
 !ifndef WAT
-CDEFINES = $(CDEFINES) -DINVERT -DODIN_HITTEST
+CDEFINES = $(CDEFINES) -DINVERT -DCLIENTFRAME
 !else
-CDEFINES += -DINVERT -DODIN_HITTEST
+CDEFINES += -DINVERT -DCLIENTFRAME
 !endif
 

trunk/src/user32/caret.cpp

@@ -1 @@
-/* $Id: caret.cpp,v 1.16 2001-01-19 23:03:45 sandervl Exp $ */
+/* $Id: caret.cpp,v 1.17 2001-05-11 08:39:41 sandervl Exp $ */
 
 /*
@@ -157 +157 @@
         else
         {
-           long height = wnd->getWindowHeight();
-           caretPos.y = height - (caretPos.y + wnd->getClientRectPtr()->top) - 1;
-           xNew = caretPos.x + wnd->getClientRectPtr()->left;
+           long height = wnd->getClientHeight();
+           caretPos.y = height - caretPos.y;
+           xNew = caretPos.x;
            yNew = caretPos.y - cursorInfo.cy;
         }
@@ -208 +208 @@
          } 
          else {
-            long height   = wnd->getWindowHeight();
+            long height   = wnd->getClientHeight();
             caretPos.y   += cursorInfo.cy;
-            cursorInfo.y  = height - caretPos.y - wnd->getClientRectPtr()->top - 1;
-            cursorInfo.x -= wnd->getClientRectPtr()->left;
+            cursorInfo.y  = height - caretPos.y;
          }
       }

trunk/src/user32/dc.cpp

@@ -1 @@
-/* $Id: dc.cpp,v 1.98 2001-05-04 17:02:50 sandervl Exp $ */
+/* $Id: dc.cpp,v 1.99 2001-05-11 08:39:41 sandervl Exp $ */
 
 /*
@@ -387 +387 @@
 VOID removeClientArea(Win32BaseWindow *window, pDCData pHps)
 {
- POINTL point;
-
-   // This function checks to see if a client area is currently selected, if
-   // it is the origin plus the visible region of the frame are restored.
-
    pHps->isClient = FALSE;
-
-////   dprintfOrigin(pHps->hps);
-
-   if(pHps->isClientArea)
-   {
-        dprintf2(("removeClientArea %x: (%d,%d) -> (%d,%d)", window->getWindowHandle(), point.x, point.y, pHps->ptlOrigin.x, pHps->ptlOrigin.y));
-        pHps->isClientArea = FALSE;
-        GreSetupDC(pHps->hps,
-                   pHps->hrgnVis,
-                   pHps->ptlOrigin.x,
-                   pHps->ptlOrigin.y,
-                   0,
-                   SETUPDC_ORIGIN | SETUPDC_VISRGN | SETUPDC_RECALCCLIP);
-   }
-////   else dprintf2(("removeClientArea: %x (%d,%d) (%d,%d)", window->getWindowHandle(), point.x, point.y, pHps->ptlOrigin.x, pHps->ptlOrigin.y));
-
+   pHps->isClientArea = FALSE;
 }
 //******************************************************************************
@@ -414 +394 @@
 void selectClientArea(Win32BaseWindow *window, pDCData pHps)
 {
-   // This function checks to see if the DC needs to be adjusted to a client
-   // area and makes the adjustment.
-   RECTL rcl, rcltemp;
-   HRGN  hrgnRect, hrgnClip, hrgnOldClip = 0;
-   HWND  hwnd;
-   LONG  rc;
-   PRECT pClient = window->getClientRectPtr();
-   PRECT pWindow = window->getWindowRect();
-   RECT  rectWindow;
-   RECTL rectWindowOS2;
-
-   if(!window->isOwnDCDirty() && (pClient->left == 0 && pClient->top == 0 &&
-      window->getClientHeight() == window->getWindowHeight() &&
-      window->getClientWidth()  == window->getWindowWidth()))
-   {
-        //client rectangle = frame rectangle -> no change necessary
-        return;
-   }
    pHps->isClient = TRUE;
-
-   hwnd = window->getOS2WindowHandle();
-
-   mapWin32ToOS2Rect(window->getWindowHeight(), window->getClientRectPtr(), (PRECTLOS2)&rcl);
-
-   GetWindowRect(window->getWindowHandle(), &rectWindow);
-   mapWin32ToOS2Rect(GetScreenHeight(), &rectWindow, (PRECTLOS2)&rectWindowOS2);
-   dprintf2(("frame (%d,%d)(%d,%d) hps height %d", rectWindowOS2.xLeft, rectWindowOS2.yBottom, rectWindowOS2.xRight, rectWindowOS2.yTop, pHps->height));
-
-   //convert to screen coordinates
-   GreGetDCOrigin(pHps->hps, (PPOINTL)&rcltemp);
-
-   if(pHps->isClientArea)
-   {
-        //TODO: counter
-        dprintf2(("WARNING: selectClientArea %x; already selected! origin (%d,%d) original origin (%d,%d)", window->getWindowHandle(), rcltemp.xLeft, rcltemp.yBottom, pHps->ptlOrigin.x, pHps->ptlOrigin.y));
-        GetWindowRect(window->getWindowHandle(), &rectWindow);
-        mapWin32ToOS2Rect(GetScreenHeight(), &rectWindow, (PRECTLOS2)&rectWindowOS2);
-        if(rectWindowOS2.xLeft + rcl.xLeft != rcltemp.xLeft ||
-           rectWindowOS2.yBottom + rcl.yBottom != rcltemp.yBottom)
-        {
-                dprintf2(("WARNING: origin changed (%d,%d) instead of (%d,%d)!", rcltemp.xLeft, rcltemp.yBottom, rectWindowOS2.xLeft + rcl.xLeft, rectWindowOS2.yBottom + rcl.yBottom));
-                rcl.xLeft   += rectWindowOS2.xLeft;
-                rcl.xRight  += rectWindowOS2.xLeft;
-                rcl.yTop    += rectWindowOS2.yBottom;
-                rcl.yBottom += rectWindowOS2.yBottom;
-        }
-        else    return;
-   }
-   else {
-        rcl.xLeft   += rcltemp.xLeft;
-        rcl.xRight  += rcltemp.xLeft;
-        rcl.yTop    += rcltemp.yBottom;
-        rcl.yBottom += rcltemp.yBottom;
-
-        pHps->ptlOrigin.x = rcltemp.xLeft;
-        pHps->ptlOrigin.y = rcltemp.yBottom;
-   }
-   dprintf2(("selectClientArea %x: (%d,%d) -> (%d,%d)", window->getWindowHandle(), rcltemp.xLeft, rcltemp.yBottom, rcl.xLeft, rcl.yBottom));
-
-   if(pHps->hrgnVis == 0)
-        pHps->hrgnVis = GreCreateRectRegion(pHps->hps, &rcl, 1);
-
-   hrgnRect = GreCreateRectRegion(pHps->hps, &rcl, 1);
-#if 0
-   if(window->getParent())
-   {
-     HRGN hrgnParentClip;
-
-        pClient = window->getParent()->getClientRectPtr();
-        GetWindowRect(window->getParent()->getWindowHandle(), &rectWindow);
-        rectWindow.right   = rectWindow.left + pClient->right;
-        rectWindow.left   += pClient->left;
-        rectWindow.bottom  = rectWindow.top + pClient->bottom;
-        rectWindow.top    += pClient->top;
-        mapWin32ToOS2Rect(GetScreenHeight(), &rectWindow, (PRECTLOS2)&rectWindowOS2);
-
-        hrgnParentClip = GreCreateRectRegion(pHps->hps, &rectWindowOS2, 1);
-#ifdef DEBUG
-        dprintf(("Combining client & parent client regions"));
-        dprintfRegion1(pHps->hps, window->getWindowHandle(), hrgnParentClip);
-        dprintfRegion1(pHps->hps, window->getWindowHandle(), hrgnRect);
-#endif
-
-        GreCombineRegion(pHps->hps, hrgnRect, hrgnParentClip, hrgnRect, CRGN_AND);
-        GreDestroyRegion(pHps->hps, hrgnParentClip);
-   }
-#endif
-
-   // Query the visible region
-   GreCopyClipRegion(pHps->hps, pHps->hrgnVis, 0, COPYCRGN_VISRGN);
-   GpiQueryRegionBox(pHps->hps, pHps->hrgnVis, &rcltemp);
-   // And the visible region of the frame with the client rectangle
-   // to get the new visible region
-   GreCombineRegion(pHps->hps, hrgnRect, pHps->hrgnVis, hrgnRect, CRGN_AND);
-#ifdef DEBUG
-   dprintfRegion1(pHps->hps, window->getWindowHandle(), hrgnRect);
-#endif
-
-   // Set the new origin plus visible region in the DC
-   GreSetupDC(pHps->hps,
-              hrgnRect,
-              rcl.xLeft,
-              rcl.yBottom,
-              NULL,
-              SETUPDC_ORIGIN | SETUPDC_VISRGN | SETUPDC_RECALCCLIP);
-
-   // Destroy the region now we have finished with it.
-   GreDestroyRegion(pHps->hps, hrgnRect);
-
    pHps->isClientArea = TRUE;
-
-   if(pClient->left == 0 && pClient->top == 0 &&
-      window->getClientHeight() == window->getWindowHeight() &&
-      window->getClientWidth()  == window->getWindowWidth())
-   {
-       //client = frame, so no changes are necessary when switching between the two
-       pHps->isClient = FALSE;
-       pHps->isClientArea = FALSE;
-   }
-   if(window->isOwnDCDirty()) {
-       window->validateOwnDC();
-       setPageXForm(window, pHps);
-   }
-
-//testestest
-#if 0
-   GpiQueryViewingLimits(pHps->hps, &rectWindowOS2);
-   dprintf2(("view limits (%d,%d)(%d,%d)", rectWindowOS2.xLeft, rectWindowOS2.yBottom, rectWindowOS2.xRight, rectWindowOS2.yTop));
-   GpiQueryDefViewingLimits(pHps->hps, &rectWindowOS2);
-   dprintf2(("def view limits (%d,%d)(%d,%d)", rectWindowOS2.xLeft, rectWindowOS2.yBottom, rectWindowOS2.xRight, rectWindowOS2.yTop));
-   GpiQueryPageViewport(pHps->hps, &rectWindowOS2);
-   dprintf2(("page viewport (%d,%d)(%d,%d)", rectWindowOS2.xLeft, rectWindowOS2.yBottom, rectWindowOS2.xRight, rectWindowOS2.yTop));
-
-   GpiQueryBoundaryData(pHps->hps, &rectWindowOS2);
-   dprintf2(("boundary data (%d,%d)(%d,%d)", rectWindowOS2.xLeft, rectWindowOS2.yBottom, rectWindowOS2.xRight, rectWindowOS2.yTop));
-
-   GpiQueryGraphicsField(pHps->hps, &rectWindowOS2);
-   dprintf2(("graphics field (%d,%d)(%d,%d)", rectWindowOS2.xLeft, rectWindowOS2.yBottom, rectWindowOS2.xRight, rectWindowOS2.yTop));
-
-   SIZEL size;
-   GpiQueryPickApertureSize(pHps->hps, &size);
-   dprintf2(("page viewport (%d,%d)", size.cx, size.cy));
-
-   GpiQueryPS(pHps->hps, &size);
-   dprintf2(("page space (%d,%d)", size.cx, size.cy));
-#endif
-//testestest
-
 }
 //******************************************************************************
@@ -576 +410 @@
 LONG clientHeight(Win32BaseWindow *wnd, HWND hwnd, pDCData pHps)
 {
-   if ((hwnd == 0) && (pHps != 0))
-      hwnd = pHps->hwnd;
-
-   if ((hwnd != 0) || (pHps == 0))
-   {
+    if ((hwnd == 0) && (pHps != 0))
+        hwnd = pHps->hwnd;
+
+    if ((hwnd != 0) || (pHps == 0))
+    {
         if(wnd) {
-                if(pHps && !pHps->isClientArea) {
-                        return (wnd->getWindowHeight());
-                }
-                else    return (wnd->getClientHeight());
-        }
-        else    return OSLibQueryScreenHeight();
-   }
-   else if (pHps->bitmapHandle)
-   {
-      return pHps->bitmapHeight;
-   }
-   else if (pHps->isMetaPS)
-   {
-      return 0;
-   }
-   else if (pHps->isPrinter)
-   {
-      return pHps->printPageHeight;
-   }
-   else
-   {
-      return MEM_HPS_MAX;
-   }
-}
-//******************************************************************************
-//******************************************************************************
-BOOL   WIN32API changePageXForm(pDCData pHps, PPOINTL pValue, int x, int y, PPOINTL pPrev)
+            if(pHps && !pHps->isClientArea) {
+                return (wnd->getWindowHeight());
+            }
+            else return (wnd->getClientHeight());
+        }
+        else return OSLibQueryScreenHeight();
+    }
+    else if (pHps->bitmapHandle)
+    {
+        return pHps->bitmapHeight;
+    }
+    else if (pHps->isMetaPS)
+    {
+        return 0;
+    }
+    else if (pHps->isPrinter)
+    {
+        return pHps->printPageHeight;
+    }
+    else
+    {
+        return MEM_HPS_MAX;
+    }
+}
+//******************************************************************************
+//******************************************************************************
+BOOL WIN32API changePageXForm(pDCData pHps, PPOINTL pValue, int x, int y, PPOINTL pPrev)
 {
  Win32BaseWindow *wnd;
 
-   wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   if(pHps->isClient) {
+        wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   }
+   else wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(pHps->hwnd);
    return changePageXForm(wnd, pHps, pValue, x, y, pPrev);
 }
 //******************************************************************************
 //******************************************************************************
-BOOL   WIN32API setPageXForm(pDCData pHps)
+BOOL WIN32API setPageXForm(pDCData pHps)
 {
  Win32BaseWindow *wnd;
 
-   wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   if(pHps->isClient) {
+        wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   }
+   else wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(pHps->hwnd);
    return setPageXForm(wnd, pHps);
 }
 //******************************************************************************
 //******************************************************************************
-VOID   WIN32API removeClientArea(pDCData pHps)
+VOID WIN32API removeClientArea(pDCData pHps)
 {
  Win32BaseWindow *wnd;
 
-   wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   if(pHps->isClient) {
+        wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   }
+   else wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(pHps->hwnd);
    if(wnd) {
       removeClientArea(wnd, pHps);
@@ -641 +484 @@
  Win32BaseWindow *wnd;
 
-   wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   if(pHps->isClient) {
+        wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   }
+   else wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(pHps->hwnd);
    if(wnd) {
       selectClientArea(wnd, pHps);
@@ -652 +498 @@
  Win32BaseWindow *wnd;
 
-   wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   if(pHps->isClient) {
+        wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   }
+   else wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(pHps->hwnd);
    if(wnd) {
-      dprintfOrigin(pHps->hps);
       if(pHps->isClient)
           selectClientArea(wnd, pHps);
@@ -661 +509 @@
 //******************************************************************************
 //******************************************************************************
-LONG   WIN32API clientHeight(HWND hwnd, pDCData pHps)
+LONG WIN32API clientHeight(HWND hwnd, pDCData pHps)
 {
  Win32BaseWindow *wnd;
 
-   wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
+   if(pHps->isClient) {
+        wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   }
+   else wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(pHps->hwnd);
    return clientHeight(wnd, hwnd, pHps);
 }
 //******************************************************************************
 //******************************************************************************
-int  WIN32API setMapMode(pDCData pHps, int mode)
+int WIN32API setMapMode(pDCData pHps, int mode)
 {
  Win32BaseWindow *wnd;
 
-   wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   if(pHps->isClient) {
+        wnd = Win32BaseWindow::GetWindowFromOS2Handle(pHps->hwnd);
+   }
+   else wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(pHps->hwnd);
    return setMapMode(wnd, pHps, mode);
 }
@@ -790 +644 @@
  RECTL    rectlClip;
 
-   if(lpps == NULL) {
+    if(lpps == NULL) {
         //BeginPaint does NOT change last error in this case
         //(verified in NT4, SP6)
         dprintf (("USER32: BeginPaint %x NULL PAINTSTRUCT pointer", hWnd));
         return 0;
-   }
-   memset(lpps, 0, sizeof(*lpps));
-
-   Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
-   if(!wnd) {
+    }
+    memset(lpps, 0, sizeof(*lpps));
+
+    Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
+    if(!wnd) {
         dprintf (("USER32: BeginPaint %x %x: invalid window handle!!", hWnd, lpps));
         SetLastError(ERROR_INVALID_WINDOW_HANDLE_W); //(verified in NT4, SP6)
         return (HDC)0;
-   }
-   HWND hwndClient = wnd->getOS2WindowHandle();
-
-   if(hwnd != HWND_DESKTOP && wnd->isOwnDC())
-   {
+    }
+    HWND hwndClient = wnd->getOS2WindowHandle();
+
+    if(hwnd != HWND_DESKTOP && wnd->isOwnDC())
+    {
         hPS_ownDC = wnd->getOwnDC();
         //SvL: Hack for memory.exe (doesn't get repainted properly otherwise)
         if(hPS_ownDC) {
-                pHps = (pDCData)GpiQueryDCData(hPS_ownDC);
-                if (!pHps)
-                {
-                        dprintf (("USER32: BeginPaint %x invalid parameter %x", hWnd, lpps));
-                        SetLastError(ERROR_INVALID_PARAMETER_W);
-                        return (HDC)NULLHANDLE;
-                }
-                hpsPaint = hPS_ownDC;
-        }
-   }
-   if(!hpsPaint) {
-        hpsPaint = GetDCEx(hwnd, 0, (DCX_CACHE_W|DCX_WINDOW_W|DCX_USESTYLE_W));
+            pHps = (pDCData)GpiQueryDCData(hPS_ownDC);
+            if (!pHps)
+            {
+                dprintf (("USER32: BeginPaint %x invalid parameter %x", hWnd, lpps));
+                SetLastError(ERROR_INVALID_PARAMETER_W);
+                return (HDC)NULLHANDLE;
+            }
+            hpsPaint = hPS_ownDC;
+        }
+    }
+    if(!hpsPaint) {
+        hpsPaint = GetDCEx(hwnd, 0, (DCX_CACHE_W|DCX_USESTYLE_W));
         pHps = (pDCData)GpiQueryDCData(hpsPaint);
         if (!pHps)
         {
-                dprintf (("USER32: BeginPaint %x invalid parameter %x", hWnd, lpps));
-                SetLastError(ERROR_INVALID_PARAMETER_W);
-                return (HDC)NULLHANDLE;
-        }
-   }
-
-   if(WinQueryUpdateRect(hwndClient, &rectl) == FALSE) {
+            dprintf (("USER32: BeginPaint %x invalid parameter %x", hWnd, lpps));
+            SetLastError(ERROR_INVALID_PARAMETER_W);
+            return (HDC)NULLHANDLE;
+        }
+    }
+
+    if(WinQueryUpdateRect(hwndClient, &rectl) == FALSE)
+    {
         memset(&rectl, 0, sizeof(rectl));
         dprintf (("USER32: WARNING: WinQueryUpdateRect failed (error or no update rectangle)!!"));
@@ -844 +699 @@
         wnd->SetClipRegion(hrgnOldClip);
         lComplexity = RGN_NULL;
-   }
-   else {
+    }
+    else {
         rectlClip.yBottom = rectlClip.xLeft = 0;
         rectlClip.yTop = rectlClip.xRight = 1;
@@ -854 +709 @@
         WinValidateRegion(hwndClient, hrgnClip, FALSE);
 
-        mapWin32ToOS2Rect(wnd->getWindowHeight(), wnd->getClientRectPtr(), (PRECTLOS2)&rectlClient);
-        WinIntersectRect(NULL, &rectlClip, &rectl, &rectlClient);
-        WinOffsetRect(NULL, &rectlClip, -rectlClient.xLeft, -rectlClient.yBottom);
-
-        //clip update region with client window rectangle
-        HRGN hrgnClient = GpiCreateRegion(pHps->hps, 1, &rectlClient);
-        GpiCombineRegion(pHps->hps, hrgnClip, hrgnClip, hrgnClient, CRGN_AND);
-        GpiDestroyRegion(pHps->hps, hrgnClient);
-
-        //change origin of clip region (window -> client)
-        POINTL point = {-rectlClient.xLeft, -rectlClient.yBottom};
-        GpiOffsetRegion(pHps->hps, hrgnClip, &point);
+        dprintfRegion(pHps->hps, wnd->getWindowHandle(), hrgnClip);
+
 #ifdef DEBUG
-        dprintfRegion1(pHps->hps, hWnd, hrgnClip);
+        lComplexity = GpiQueryClipBox(pHps->hps, &rectlClip);
+        dprintf(("ClipBox (%d): (%d,%d)(%d,%d)", lComplexity, rectlClip.xLeft, rectlClip.yBottom, rectlClip.xRight, rectlClip.yTop));
 #endif
+
         //set clip region
         lComplexity = GpiSetClipRegion(pHps->hps, hrgnClip, &hrgnOldClip);
 
-        //change presentation space for client window
-        //NOTE: MUST do this after GpiSetClipRegion call!
-        //      When a window with CS_OWNDC looses focus, for some reason
-        //      GpiSetClipRegion resets the window dc origin back to (0,0)
+        if(lComplexity == RGN_NULL) {
+            dprintf (("BeginPaint %x: EMPTY update rectangle (show=%d/%d vis=%d/%d", hWnd,  WinIsWindowVisible(wnd->getOS2FrameWindowHandle()), WinIsWindowVisible(wnd->getOS2WindowHandle()),  WinIsWindowShowing(wnd->getOS2FrameWindowHandle()), WinIsWindowShowing(wnd->getOS2WindowHandle())));
+        }
         selectClientArea(wnd, pHps);
 
-        GpiQueryClipBox(pHps->hps, &rectl);
-        dprintf(("ClipBox (%d): (%d,%d)(%d,%d)", lComplexity, rectl.xLeft, rectl.yBottom, rectl.xRight, rectl.yTop));
-
+#ifdef DEBUG
+        GpiQueryClipBox(pHps->hps, &rectlClip);
+        dprintf(("ClipBox (%d): (%d,%d)(%d,%d)", lComplexity, rectlClip.xLeft, rectlClip.yBottom, rectlClip.xRight, rectlClip.yTop));
+#endif
         //save old clip region (restored for CS_OWNDC windows in EndPaint)
         wnd->SetClipRegion(hrgnOldClip);
-        memcpy(&rectl, &rectlClip, sizeof(RECTL));
-        lComplexity = RGN_RECT;
-   }
-
-   if(hPS_ownDC == 0)
-      setMapMode (wnd, pHps, MM_TEXT_W);
-   else
-      setPageXForm(wnd, pHps);
-
-   pHps->hdcType = TYPE_3;
-
-   HideCaret(hwnd);
-   WinShowTrackRect(wnd->getOS2WindowHandle(), FALSE);
-
-   if(wnd->needsEraseBkgnd() && lComplexity != RGN_NULL) {
+    }
+
+    if(hPS_ownDC == 0)
+        setMapMode (wnd, pHps, MM_TEXT_W);
+    else
+        setPageXForm(wnd, pHps);
+
+    pHps->hdcType = TYPE_3;
+
+    HideCaret(hwnd);
+    WinShowTrackRect(wnd->getOS2WindowHandle(), FALSE);
+
+    if((wnd->needsEraseBkgnd() || wnd->IsVisibleRegionChanged()) && lComplexity != RGN_NULL) {
         wnd->setEraseBkgnd(FALSE);
+        wnd->SetVisibleRegionChanged(FALSE);
         lpps->fErase = (wnd->MsgEraseBackGround(pHps->hps) == 0);
-   }
-   else lpps->fErase = TRUE;
-
-   dprintfOrigin(pHps->hps);
-
-   lpps->hdc    = (HDC)pHps->hps;
-
-   if(lComplexity != RGN_NULL) {
+    }
+    else lpps->fErase = TRUE;
+
+    lpps->hdc    = (HDC)pHps->hps;
+
+    if(lComplexity != RGN_NULL) {
         long height  = wnd->getClientHeight();
         lpps->rcPaint.top    = height - rectl.yTop;
@@ -913 +757 @@
         lpps->rcPaint.bottom = height - rectl.yBottom;
         lpps->rcPaint.right  = rectl.xRight;
-   }
-   else {
+    }
+    else {
         lpps->rcPaint.bottom = lpps->rcPaint.top = 0;
         lpps->rcPaint.right = lpps->rcPaint.left = 0;
-   }
-
-   SetLastError(0);
-   dprintf(("USER32: BeginPaint %x -> hdc %x (%d,%d)(%d,%d)", hWnd, pHps->hps, lpps->rcPaint.left, lpps->rcPaint.top, lpps->rcPaint.right, lpps->rcPaint.bottom));
-   return (HDC)pHps->hps;
+    }
+
+    SetLastError(0);
+    dprintf(("USER32: BeginPaint %x -> hdc %x (%d,%d)(%d,%d)", hWnd, pHps->hps, lpps->rcPaint.left, lpps->rcPaint.top, lpps->rcPaint.right, lpps->rcPaint.bottom));
+    return (HDC)pHps->hps;
 }
 //******************************************************************************
@@ -931 +775 @@
   pDCData pHps;
 
-   dprintf (("USER32: EndPaint(%x)", hwnd));
-
-   if (!pPaint || !pPaint->hdc )
-      return TRUE;
-
-   Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
-
-   if (!wnd) goto exit;
-
-   pHps = (pDCData)GpiQueryDCData((HPS)pPaint->hdc);
-   if (pHps && (pHps->hdcType == TYPE_3))
-   {
-        dprintfOrigin(pHps->hps);
-
+    dprintf (("USER32: EndPaint(%x)", hwnd));
+
+    if (!pPaint || !pPaint->hdc )
+        return TRUE;
+
+    Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
+
+    if (!wnd) goto exit;
+
+    pHps = (pDCData)GpiQueryDCData((HPS)pPaint->hdc);
+    if (pHps && (pHps->hdcType == TYPE_3))
+    {
         GpiSetClipRegion(pHps->hps, wnd->GetClipRegion(), &hrgnOld);
         wnd->SetClipRegion(0);
         if(hrgnOld) {
-                GpiDestroyRegion(pHps->hps, hrgnOld);
+            GpiDestroyRegion(pHps->hps, hrgnOld);
         }
         pHps->hdcType = TYPE_1; //otherwise Open32's ReleaseDC fails
         ReleaseDC(hwnd, pPaint->hdc);
-   }
-   else {
+    }
+    else {
         dprintf(("EndPaint: wrong hdc %x!!", pPaint->hdc));
-   }
-   wnd->setEraseBkgnd(TRUE);
-   ShowCaret(hwnd);
-   WinShowTrackRect(wnd->getOS2WindowHandle(), TRUE);
+    }
+    wnd->setEraseBkgnd(TRUE);
+    ShowCaret(hwnd);
+    WinShowTrackRect(wnd->getOS2WindowHandle(), TRUE);
 
 exit:
-   SetLastError(0);
-   return TRUE;
+    SetLastError(0);
+    return TRUE;
 }
 //******************************************************************************
@@ -971 +813 @@
    int rc;
 
-   if (hwnd)
-   {
+    if (hwnd)
+    {
         Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
         if(wnd == NULL) {
-                dprintf(("ERROR: ReleaseDC %x %x failed", hwnd, hdc));
-                return 0;
+            dprintf(("ERROR: ReleaseDC %x %x failed", hwnd, hdc));
+            return 0;
         }
         isOwnDC = wnd->isOwnDC() && (wnd->getOwnDC() == hdc);
         if(!isOwnDC)
         {
-                pDCData  pHps = (pDCData)GpiQueryDCData((HPS)hdc);
-                if(pHps && pHps->psType == MICRO_CACHED) {
-                        removeClientArea(wnd, pHps);
-                        if(pHps->hrgnVis) {
-                                GreDestroyRegion(pHps->hps, pHps->hrgnVis);
-                                pHps->hrgnVis = 0;
-                        }
+            pDCData  pHps = (pDCData)GpiQueryDCData((HPS)hdc);
+            if(pHps && pHps->psType == MICRO_CACHED) {
+                removeClientArea(wnd, pHps);
+                if(pHps->hrgnVis) {
+                    GreDestroyRegion(pHps->hps, pHps->hrgnVis);
+                    pHps->hrgnVis = 0;
                 }
-                else {
-                        dprintf(("ERROR: ReleaseDC: pHps == NULL!!"));
-                        DebugInt3();
-                }
+            }
+            else {
+                dprintf(("ERROR: ReleaseDC: pHps == NULL!!"));
+                DebugInt3();
+            }
         }
         else {
-                dprintf2(("ReleaseDC: CS_OWNDC, not released"));
-        }
-   }
-
-   if(isOwnDC) {
+            dprintf2(("ReleaseDC: CS_OWNDC, not released"));
+        }
+    }
+
+    if(isOwnDC) {
         rc = TRUE;
-   }
-   else {
+    }
+    else {
         UnselectGDIObjects(hdc);
         rc = O32_ReleaseDC (0, hdc);
-   }
-
-   dprintf(("ReleaseDC %x %x", hwnd, hdc));
-   return (rc);
+    }
+
+    dprintf(("ReleaseDC %x %x", hwnd, hdc));
+    return (rc);
 }
 //******************************************************************************
@@ -1035 +877 @@
    PS_Type  psType;
 
-   if(hwnd == 0) {
+    if(hwnd == 0) {
         dprintf(("error: GetDCEx window %x not found", hwnd));
         SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
         return 0;
-   }
-
-   if (hwnd)
-   {
+    }
+
+    if(hwnd)
+    {
         wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
         if(wnd == NULL) {
@@ -1049 +891 @@
                 return 0;
         }
-        hWindow = wnd->getOS2WindowHandle();
-   }
-
-   isWindowOwnDC = (((hWindow == HWND_DESKTOP) ? FALSE : (wnd->isOwnDC()))
-                 && !(flags & (DCX_CACHE_W|DCX_WINDOW_W)));
-
-   if(isWindowOwnDC) //own dc always for client area
-   {
-      hps = wnd->getOwnDC();
-      if (hps)
-      {
-        pDCData pHps = (pDCData)GpiQueryDCData (hps);
-        if (!pHps)
-            goto error;
-
-        selectClientArea(wnd, pHps);
-
-        //TODO: Is this always necessary??
-        setPageXForm (wnd, pHps);
-        pHps->hdcType = TYPE_1;
-
-        //TODO: intersect/exclude clip region?
-        dprintf (("User32: GetDCEx hwnd %x (%x %x) -> wnd %x hdc %x", hwnd, hrgn, flags, wnd, hps));
-        return (HDC)hps;
-      }
-      else
-        creatingOwnDC = TRUE;
-   }
-
-   if(isWindowOwnDC)
-   {
-      SIZEL sizel = {0,0};
-      hps = GpiCreatePS (WinQueryAnchorBlock (hWindow),
-                         WinOpenWindowDC (hWindow),
-                         &sizel, PU_PELS | GPIT_MICRO | GPIA_ASSOC );
-      psType = MICRO;
-      // default cp is OS/2 one: set to windows default (ODIN.INI)
-      GpiSetCp(hps, GetDisplayCodepage());
-   }
-   else
-   {
-      if (hWindow == HWND_DESKTOP) {
-         hps = WinGetScreenPS (hWindow);
-      }
-      else {
-        int clipstyle = 0;
-        int clipwnd   = HWND_TOP;
-        if(flags & (DCX_USESTYLE_W)) {
+        if(flags & DCX_WINDOW_W) {
+             hWindow = wnd->getOS2FrameWindowHandle();
+        }
+        else hWindow = wnd->getOS2WindowHandle();
+    }
+
+    isWindowOwnDC = (((hWindow == HWND_DESKTOP) ? FALSE : (wnd->isOwnDC()))
+                    && !(flags & (DCX_CACHE_W|DCX_WINDOW_W)));
+
+    if(isWindowOwnDC) //own dc always for client area
+    {
+        hps = wnd->getOwnDC();
+        if (hps)
+        {
+            pDCData pHps = (pDCData)GpiQueryDCData (hps);
+            if (!pHps)
+                goto error;
+
+            selectClientArea(wnd, pHps);
+
+            //TODO: Is this always necessary??
+            setPageXForm (wnd, pHps);
+            pHps->hdcType = TYPE_1;
+
+            //TODO: intersect/exclude clip region?
+            dprintf (("User32: GetDCEx hwnd %x (%x %x) -> wnd %x hdc %x", hwnd, hrgn, flags, wnd, hps));
+            return (HDC)hps;
+        }
+        else creatingOwnDC = TRUE;
+    }
+
+    if(isWindowOwnDC)
+    {
+        SIZEL sizel = {0,0};
+        hps = GpiCreatePS (WinQueryAnchorBlock (hWindow),
+                           WinOpenWindowDC (hWindow),
+                           &sizel, PU_PELS | GPIT_MICRO | GPIA_ASSOC );
+        psType = MICRO;
+        // default cp is OS/2 one: set to windows default (ODIN.INI)
+        GpiSetCp(hps, GetDisplayCodepage());
+    }
+    else
+    {
+        if (hWindow == HWND_DESKTOP) {
+            hps = WinGetScreenPS (hWindow);
+        }
+        else {
+            int clipstyle = 0;
+            int clipwnd   = HWND_TOP;
+            if(flags & (DCX_USESTYLE_W)) {
                 int style = wnd->getStyle();
                 if(style & WS_CLIPCHILDREN_W) {
-                        clipstyle |= PSF_CLIPCHILDREN;
+                    clipstyle |= PSF_CLIPCHILDREN;
                 }
                 if(style & WS_CLIPSIBLINGS_W) {
-                        clipstyle |= PSF_CLIPSIBLINGS;
+                    clipstyle |= PSF_CLIPSIBLINGS;
                 }
                 if(wnd->fHasParentDC()) {
-                        clipstyle |= PSF_PARENTCLIP;
+                    clipstyle |= PSF_PARENTCLIP;
                 }
-        }
-        if(flags & DCX_CLIPSIBLINGS_W) {
+            }
+            if(flags & DCX_CLIPSIBLINGS_W) {
                 clipstyle |= PSF_CLIPSIBLINGS;
-        }
-        if(flags & DCX_CLIPCHILDREN_W) {
+            }
+            if(flags & DCX_CLIPCHILDREN_W) {
                 clipstyle |= PSF_CLIPCHILDREN;
-        }
-        if(flags & DCX_PARENTCLIP_W) {
+            }
+            if(flags & DCX_PARENTCLIP_W) {
                 clipstyle |= PSF_PARENTCLIP;
-        }
-        if(clipstyle) {
-                dprintf2(("WinGetClipPS style %x", clipstyle));
-                hps = WinGetClipPS(hWindow, clipwnd, clipstyle);
-        }
-        else    hps = WinGetPS (hWindow);
-
-        // default cp is OS/2 one: set to windows default (ODIN.INI)
-        GpiSetCp(hps, GetDisplayCodepage());
-      }
-      psType = MICRO_CACHED;
-   }
-
-   if (!hps)
-      goto error;
-
-   HPSToHDC (hWindow, hps, NULL, NULL);
-   pHps = (pDCData)GpiQueryDCData (hps);
-
-   if(!(flags & DCX_WINDOW_W))
-   {
-        selectClientArea(wnd, pHps);
-   }
-   else removeClientArea(wnd, pHps);
-
-   setMapMode(wnd, pHps, MM_TEXT_W);
-
-   if ((flags & DCX_EXCLUDERGN_W) || (flags & DCX_INTERSECTRGN_W))
-   {
-      ULONG BytesNeeded;
-      PRGNDATA RgnData;
-      PRECT pr;
-      int i;
-      RECTL rectl;
-
-      if (!hrgn)
-         goto error;
-
-      success = TRUE;
-      if (flags & DCX_EXCLUDERGN_W)
-      {
+            }
+            if(clipstyle) {
+                 dprintf2(("WinGetClipPS style %x", clipstyle));
+                 hps = WinGetClipPS(hWindow, clipwnd, clipstyle);
+            }
+            else hps = WinGetPS (hWindow);
+
+            // default cp is OS/2 one: set to windows default (ODIN.INI)
+            GpiSetCp(hps, GetDisplayCodepage());
+        }
+        psType = MICRO_CACHED;
+    }
+
+    if (!hps)
+        goto error;
+
+    HPSToHDC (hWindow, hps, NULL, NULL);
+    pHps = (pDCData)GpiQueryDCData (hps);
+
+    if(flags & DCX_WINDOW_W) {
+         removeClientArea(wnd, pHps);
+    }
+    else selectClientArea(wnd, pHps);
+
+    setMapMode(wnd, pHps, MM_TEXT_W);
+
+    if ((flags & DCX_EXCLUDERGN_W) || (flags & DCX_INTERSECTRGN_W))
+    {
+        ULONG BytesNeeded;
+        PRGNDATA RgnData;
+        PRECT pr;
+        int i;
+        RECTL rectl;
+
+        if (!hrgn)
+            goto error;
+
+        success = TRUE;
+        if (flags & DCX_EXCLUDERGN_W)
+        {
 #if 0 //CB: todo
          long height;
@@ -1181 +1024 @@
          }
 #endif
-      }
-      else //DCX_INTERSECTRGN_W
-      {
-         //SvL: I'm getting paint problems when clipping a dc created in GetDCEx
-         //     with a region that covers the entire window (RealPlayer 7 Update 1)
-         //     Using SelectClipRgn here doesn't make any difference.
-         if(ExtSelectClipRgn(pHps->hps, hrgn, RGN_AND_W) == ERROR_W) {
+        }
+        else //DCX_INTERSECTRGN_W
+        {
+            //SvL: I'm getting paint problems when clipping a dc created in GetDCEx
+            //     with a region that covers the entire window (RealPlayer 7 Update 1)
+            //     Using SelectClipRgn here doesn't make any difference.
+            if(ExtSelectClipRgn(pHps->hps, hrgn, RGN_AND_W) == ERROR_W) {
                 dprintf(("ExtSelectClipRgn failed!!"));
-         }
-      }
-      if (!success)
-         goto error;
-   }
-
-   if (creatingOwnDC)
-      wnd->setOwnDC ((HDC)hps);
-
-   pHps->psType  = psType;
-   pHps->hdcType = TYPE_1;
-   //TODO: WM_SETREDRAW affects drawingAllowed flag!!
-   GpiSetDrawControl (hps, DCTL_DISPLAY, drawingAllowed ? DCTL_ON : DCTL_OFF);
-
-   dprintf (("User32: GetDCEx hwnd %x (%x %x) -> hdc %x", hwnd, hrgn, flags, pHps->hps));
-   return (HDC)pHps->hps;
+            }
+        }
+        if (!success)
+            goto error;
+    }
+
+    if (creatingOwnDC)
+        wnd->setOwnDC ((HDC)hps);
+
+    pHps->psType  = psType;
+    pHps->hdcType = TYPE_1;
+    //TODO: WM_SETREDRAW affects drawingAllowed flag!!
+    GpiSetDrawControl (hps, DCTL_DISPLAY, drawingAllowed ? DCTL_ON : DCTL_OFF);
+
+    dprintf (("User32: GetDCEx hwnd %x (%x %x) -> hdc %x", hwnd, hrgn, flags, pHps->hps));
+    return (HDC)pHps->hps;
 
 error:
-   /* Something went wrong; clean up
-    */
-   dprintf(("ERROR: GetDCEx hwnd %x (%x %x) FAILED!", hwnd, hrgn, flags));
-   DebugInt3();
-   if (pHps)
-   {
-      if (pHps->hps)
-      {
-         if(pHps->psType == MICRO_CACHED)
-            WinReleasePS(pHps->hps);
-         else
-            GpiDestroyPS(pHps->hps);
-      }
-
-      if (pHps->hdc)     DevCloseDC(pHps->hdc);
-      if (pHps->hrgnHDC) GpiDestroyRegion(pHps->hps, pHps->hrgnHDC);
-
-      O32_DeleteObject (pHps->nullBitmapHandle);
-   }
-   SetLastError(ERROR_INVALID_PARAMETER_W);
-   return NULL;
+    /* Something went wrong; clean up
+     */
+    dprintf(("ERROR: GetDCEx hwnd %x (%x %x) FAILED!", hwnd, hrgn, flags));
+    DebugInt3();
+    if (pHps)
+    {
+        if (pHps->hps)
+        {
+            if(pHps->psType == MICRO_CACHED)
+                WinReleasePS(pHps->hps);
+            else
+                GpiDestroyPS(pHps->hps);
+        }
+
+        if (pHps->hdc)     DevCloseDC(pHps->hdc);
+        if (pHps->hrgnHDC) GpiDestroyRegion(pHps->hps, pHps->hrgnHDC);
+
+        O32_DeleteObject (pHps->nullBitmapHandle);
+    }
+    SetLastError(ERROR_INVALID_PARAMETER_W);
+    return NULL;
 }
 //******************************************************************************
@@ -1233 +1076 @@
 HDC WIN32API GetDC (HWND hwnd)
 {
-  if(!hwnd)
-       return GetDCEx( GetDesktopWindow(), 0, DCX_CACHE_W | DCX_WINDOW_W );
-  return GetDCEx (hwnd, NULL, 0);
+    if(!hwnd)
+        return GetDCEx( GetDesktopWindow(), 0, DCX_CACHE_W | DCX_WINDOW_W );
+
+    return GetDCEx (hwnd, NULL, 0);
 }
 //******************************************************************************
@@ -1241 +1085 @@
 HDC WIN32API GetWindowDC (HWND hwnd)
 {
-  if (!hwnd) hwnd = GetDesktopWindow();
-  return GetDCEx (hwnd, NULL, DCX_WINDOW_W);
+    if (!hwnd) hwnd = GetDesktopWindow();
+    return GetDCEx (hwnd, NULL, DCX_WINDOW_W);
 }
 //******************************************************************************
@@ -1249 +1093 @@
 LRESULT WIN32API RedrawChildEnumProc(HWND hwnd, LPARAM lParam)
 {
-  RedrawWindow(hwnd, NULL, 0, lParam);
-  return TRUE;
+    RedrawWindow(hwnd, NULL, 0, lParam);
+    return TRUE;
 }
 //******************************************************************************
@@ -1265 +1109 @@
 //
 //TODO: Works ok for RDW_FRAME??
+//      SDK docs say RDW_FRAME is only valid for RDW_INVALIDATE...
 //******************************************************************************
 BOOL WIN32API RedrawWindow(HWND hwnd, const RECT* pRect, HRGN hrgn, DWORD redraw)
 {
-   Win32BaseWindow *wnd;
-
-   if(pRect) {
-          dprintf(("RedrawWindow %x (%d,%d)(%d,%d) %x %x", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom, hrgn, redraw));
-   }
-   else   dprintf(("RedrawWindow %x %x %x %x", hwnd, pRect, hrgn, redraw));
-
-   if (hwnd == NULLHANDLE)
-   {
+    Win32BaseWindow *wnd;
+
+    if(pRect) {
+         dprintf(("RedrawWindow %x (%d,%d)(%d,%d) %x %x", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom, hrgn, redraw));
+    }
+    else dprintf(("RedrawWindow %x %x %x %x", hwnd, pRect, hrgn, redraw));
+
+    if (hwnd == NULLHANDLE)
+    {
 #if 1
         // Don't do this for now (causes lots of desktop repaints in WordPad)
-         SetLastError(ERROR_INVALID_PARAMETER_W);
-         return FALSE;
+        SetLastError(ERROR_INVALID_PARAMETER_W);
+        return FALSE;
 #else
         hwnd = HWND_DESKTOP;
@@ -1293 +1138 @@
         }
 #endif
-   }
-   else
-   {
+    }
+    else
+    {
         wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
 
@@ -1305 +1150 @@
             return FALSE;
         }
-        hwnd = wnd->getOS2WindowHandle();
-   }
-
-   BOOL  IncludeChildren = (redraw & RDW_ALLCHILDREN_W) ? TRUE : FALSE;
-   BOOL  success = TRUE;
-   HPS   hpsTemp = NULLHANDLE;
-   HRGN  hrgnTemp = NULLHANDLE;
-   RECTL rectl;
-
-   if (hrgn)
-   {
-      ULONG BytesNeeded;
-      PRGNDATA RgnData;
-      PRECTL pr;
-      int i;
-      LONG height;
-
-      if(wnd) {
-                height = (redraw & RDW_FRAME_W) ? wnd->getWindowHeight() : wnd->getClientHeight();
-      }
-      else      height = OSLibQueryScreenHeight();
-
-      if (!hrgn)
-         goto error;
-
-      BytesNeeded = GetRegionData (hrgn, 0, NULL);
-      RgnData = (PRGNDATA)_alloca (BytesNeeded);
-      if (RgnData == NULL)
+        if(redraw & RDW_FRAME_W) {
+             hwnd = wnd->getOS2FrameWindowHandle();
+        }
+        else hwnd = wnd->getOS2WindowHandle();
+    }
+
+    BOOL  IncludeChildren = (redraw & RDW_ALLCHILDREN_W) ? TRUE : FALSE;
+    BOOL  success = TRUE;
+    HPS   hpsTemp = NULLHANDLE;
+    HRGN  hrgnTemp = NULLHANDLE;
+    RECTL rectl;
+
+    if (hrgn)
+    {
+        ULONG BytesNeeded;
+        PRGNDATA RgnData;
+        PRECTL pr;
+        int i;
+        LONG height;
+
+        if(wnd) {
+             height = (redraw & RDW_FRAME_W) ? wnd->getWindowHeight() : wnd->getClientHeight();
+        }
+        else height = OSLibQueryScreenHeight();
+
+        if (!hrgn)
+            goto error;
+
+        BytesNeeded = GetRegionData (hrgn, 0, NULL);
+        RgnData = (PRGNDATA)_alloca (BytesNeeded);
+        if (RgnData == NULL)
           goto error;
-      GetRegionData (hrgn, BytesNeeded, RgnData);
-
-      pr = (PRECTL)(RgnData->Buffer);
-      for (i = RgnData->rdh.nCount; i > 0; i--, pr++) {
-         LONG temp = pr->yTop;
-         pr->yTop = height - pr->yBottom;
-         pr->yBottom = height - temp;
-         dprintf2(("RedrawWindow: region (%d,%d) (%d,%d)", pr->xLeft, pr->yBottom, pr->xRight, pr->yTop));
-      }
-
-      hpsTemp = WinGetScreenPS (HWND_DESKTOP);
-      hrgnTemp = GpiCreateRegion (hpsTemp, RgnData->rdh.nCount, (PRECTL)(RgnData->Buffer));
-      if (!hrgnTemp) goto error;
-   }
-   else if (pRect)
-   {
-      if(wnd) {
-                if(redraw & RDW_FRAME_W) {
-                        mapWin32ToOS2Rect(wnd->getWindowHeight(), (PRECT)pRect, (PRECTLOS2)&rectl);
-                }
-                else    mapWin32ToOS2RectClientToFrame(wnd, (PRECT)pRect, (PRECTLOS2)&rectl);
-      }
-      else      mapWin32ToOS2Rect(OSLibQueryScreenHeight(), (PRECT)pRect, (PRECTLOS2)&rectl);
-   }
-
-   if (redraw & RDW_INVALIDATE_W)
-   {
+        GetRegionData (hrgn, BytesNeeded, RgnData);
+
+        pr = (PRECTL)(RgnData->Buffer);
+        for (i = RgnData->rdh.nCount; i > 0; i--, pr++) {
+            LONG temp = pr->yTop;
+            pr->yTop = height - pr->yBottom;
+            pr->yBottom = height - temp;
+            dprintf2(("RedrawWindow: region (%d,%d) (%d,%d)", pr->xLeft, pr->yBottom, pr->xRight, pr->yTop));
+        }
+
+        hpsTemp = WinGetScreenPS (HWND_DESKTOP);
+        hrgnTemp = GpiCreateRegion (hpsTemp, RgnData->rdh.nCount, (PRECTL)(RgnData->Buffer));
+        if (!hrgnTemp) goto error;
+    }
+    else if (pRect)
+    {
+        if(wnd) {
+            if(redraw & RDW_FRAME_W) {
+                 mapWin32ToOS2Rect(wnd->getWindowHeight(), (PRECT)pRect, (PRECTLOS2)&rectl);
+            }
+            else mapWin32ToOS2Rect(wnd->getClientHeight(), (PRECT)pRect, (PRECTLOS2)&rectl);
+        }
+        else mapWin32ToOS2Rect(OSLibQueryScreenHeight(), (PRECT)pRect, (PRECTLOS2)&rectl);
+    }
+
+    if (redraw & RDW_INVALIDATE_W)
+    {
         //TODO: SvL: pingpong.exe doesn't have RDW_NOERASE, but doesn't want WM_ERASEBKGND msgs
         if (redraw & RDW_ERASE_W) {
              wnd->setEraseBkgnd(TRUE);
         }
-        else
-        if (redraw & RDW_NOERASE_W)
-            wnd->setEraseBkgnd(FALSE);
+        else wnd->setEraseBkgnd(FALSE);
 
         if (!pRect && !hrgn)
@@ -1403 +1249 @@
 
         if (!success) goto error;
-   }
-   else if (redraw & RDW_VALIDATE_W)
-   {
+    }
+    else if (redraw & RDW_VALIDATE_W)
+    {
         if (redraw & RDW_NOERASE_W)
             wnd->setEraseBkgnd(FALSE);
@@ -1423 +1269 @@
             if(!success) goto error;
         }
-   }
-
-   if(WinQueryUpdateRect(hwnd, NULL))
-   {
+    }
+
+    if(WinQueryUpdateRect(hwnd, &rectl))
+    {
         //TODO: Does this work if RDW_ALLCHILDREN is set??
         if(redraw & RDW_UPDATENOW_W) {
-                wnd->MsgNCPaint();
-                wnd->MsgPaint(0, FALSE);
+            RECT rectUpdate;
+
+            if(redraw & RDW_FRAME_W) {
+                mapOS2ToWin32Rect(wnd->getWindowHeight(), (PRECTLOS2)&rectl, &rectUpdate);
+                wnd->MsgNCPaint(&rectUpdate);
+            }
+
+            wnd->MsgPaint(0, FALSE);
         }
         else
 //        if((redraw & RDW_ERASE_W) && (redraw & RDW_ERASENOW_W))
         if(redraw & RDW_ERASENOW_W && wnd->needsEraseBkgnd())
-                wnd->setEraseBkgnd(sendEraseBkgnd(wnd) == 0);
+            wnd->setEraseBkgnd(sendEraseBkgnd(wnd) == 0);
 //      if(redraw & RDW_ALLCHILDREN_W) {
 //              EnumChildWindows(wnd->getWindowHandle(), RedrawChildEnumProc, redraw);
 //      }
-   }
-   else if((redraw & RDW_INTERNALPAINT_W) && !(redraw & RDW_INVALIDATE_W))
-   {
+    }
+    else if((redraw & RDW_INTERNALPAINT_W) && !(redraw & RDW_INVALIDATE_W))
+    {
         if(redraw & RDW_UPDATENOW_W) {
-                wnd->MsgNCPaint();
-                wnd->MsgPaint (0, FALSE);
-        }
-        else    PostMessageA(hwnd, WINWM_PAINT, 0, 0);
-   }
+            wnd->MsgPaint(0, FALSE);
+        }
+        else PostMessageA(hwnd, WINWM_PAINT, 0, 0);
+    }
 
 error:
-   /* clean up */
-   if (hrgnTemp)
-      GpiDestroyRegion (hpsTemp, hrgnTemp);
-
-   if (hpsTemp)
-      WinReleasePS (hpsTemp);
-
-   if (!success) {
+    /* clean up */
+    if (hrgnTemp)
+        GpiDestroyRegion (hpsTemp, hrgnTemp);
+
+    if (hpsTemp)
+        WinReleasePS (hpsTemp);
+
+    if (!success) {
         dprintf(("RedrawWindow failure!"));
         SetLastError(ERROR_INVALID_PARAMETER_W);
-   }
-   return (success);
+    }
+    return (success);
 }
 //******************************************************************************
@@ -1468 +1319 @@
 {
   Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
-
-   if(!wnd) {
+  RECTL rectl;
+  BOOL  rc;
+
+    if(!wnd) {
+        dprintf (("ERROR: User32: UpdateWindow INVALID hwnd %x", hwnd));
         SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
         return FALSE;
-   }
-
-   dprintf (("User32: UpdateWindow hwnd %x", hwnd));
-//SvL: This doesn't work right (Wine uses RDW_NOCHILDREN_W -> doesn't work here)
-//     Breaks vpbuddy
-//   return RedrawWindow(hwnd, NULL, 0, RDW_UPDATENOW_W | RDW_ALLCHILDREN_W);
-//   -> RDW_UPDATENOW causes WM_PAINT messages to be directy posted to window
-//   handler; possibly bypassing queued WM_PAINT messages for parent window(s)
-//   -> out of sync painting (i.e. parent paints over child)
-   WinUpdateWindow(wnd->getOS2WindowHandle());
-   return TRUE;
+    }
+
+#ifdef DEBUG
+    if(WinQueryUpdateRect(wnd->getOS2WindowHandle(), &rectl))
+    {
+         RECT rectUpdate;
+         mapOS2ToWin32Rect(wnd->getClientHeight(), (PRECTLOS2)&rectl, &rectUpdate);
+
+         dprintf (("User32: UpdateWindow hwnd %x: update rectangle (%d,%d)(%d,%d)", hwnd, rectUpdate.left, rectUpdate.top, rectUpdate.right, rectUpdate.bottom));
+    }
+    else dprintf (("User32: UpdateWindow hwnd %x; EMPTY update rectangle (vis=%d/%d)", hwnd, WinIsWindowVisible(wnd->getOS2FrameWindowHandle()), WinIsWindowVisible(wnd->getOS2WindowHandle())));
+#endif
+    //SvL: This doesn't work right (Wine uses RDW_NOCHILDREN_W -> doesn't work here)
+    //     Breaks vpbuddy
+    //rc = RedrawWindow(hwnd, NULL, 0, RDW_UPDATENOW_W | RDW_ALLCHILDREN_W);
+    //   -> RDW_UPDATENOW causes WM_PAINT messages to be directy posted to window
+    //   handler; possibly bypassing queued WM_PAINT messages for parent window(s)
+    //   -> out of sync painting (i.e. parent paints over child)
+
+//    if(!WinIsWindowShowing(wnd->getOS2FrameWindowHandle()) || !WinIsWindowShowing(wnd->getOS2WindowHandle())) {
+//        dprintf(("UpdateWindow: window not showing %d/%d", WinIsWindowShowing(wnd->getOS2FrameWindowHandle()), WinIsWindowShowing(wnd->getOS2WindowHandle()) ));
+//        return FALSE;
+//    }
+    //Must use frame window here. If the frame window has a valid update region and we call
+    //WinUpdateWindow for the client window, then no WM_PAINT messages will be sent.
+    rc = WinUpdateWindow(wnd->getOS2FrameWindowHandle());
+#ifdef DEBUG
+    if(WinQueryUpdateRect(wnd->getOS2WindowHandle(), NULL))
+    {
+        //if parent has valid update region then WinUpdateWindow will still fail..
+        //might be harmless and happen even in windows
+        dprintf (("ERROR: User32: UpdateWindow didn't send WM_PAINT messages!!"));
+    }
+#endif
+    return rc;
 }
 //******************************************************************************
@@ -1508 +1386 @@
    BOOL result;
 
-   if(pRect) {
+    if(pRect) {
         dprintf(("InvalidateRect %x (%d,%d)(%d,%d) erase=%d", hwnd, pRect->left, pRect->top, pRect->right, pRect->bottom, erase));
-   }
-   else dprintf(("InvalidateRect %x NULL erase=%d", hwnd, erase));
+    }
+    else dprintf(("InvalidateRect %x NULL erase=%d", hwnd, erase));
 #if 1
-   result = RedrawWindow (hwnd, pRect, NULLHANDLE,
-                          RDW_ALLCHILDREN_W | RDW_INVALIDATE_W |
+    result = RedrawWindow (hwnd, pRect, NULLHANDLE,
+                           RDW_INVALIDATE_W |
+                           (erase ? RDW_ERASE_W : 0) |
+                           (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
+#else
+    result = RedrawWindow (hwnd, pRect, NULLHANDLE,
+                           RDW_ALLCHILDREN_W | RDW_INVALIDATE_W |
+                           (erase ? RDW_ERASE_W : RDW_NOERASE_W) |
+                           (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
+#endif
+    return (result);
+}
+//******************************************************************************
+//******************************************************************************
+BOOL WIN32API InvalidateRgn (HWND hwnd, HRGN hrgn, BOOL erase)
+{
+    BOOL result;
+
+    dprintf(("InvalidateRgn %x %x erase=%d", hwnd, hrgn, erase));
+#if 1
+    result = RedrawWindow (hwnd, NULL, hrgn,
+                          RDW_INVALIDATE_W |
                           (erase ? RDW_ERASE_W : 0) |
                           (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
 #else
-   result = RedrawWindow (hwnd, pRect, NULLHANDLE,
+    result = RedrawWindow (hwnd, NULL, hrgn,
                           RDW_ALLCHILDREN_W | RDW_INVALIDATE_W |
                           (erase ? RDW_ERASE_W : RDW_NOERASE_W) |
                           (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
 #endif
-   return (result);
-}
-//******************************************************************************
-//******************************************************************************
-BOOL WIN32API InvalidateRgn (HWND hwnd, HRGN hrgn, BOOL erase)
-{
-   BOOL result;
-
-   dprintf(("InvalidateRgn %x %x erase=%d", hwnd, hrgn, erase));
-#if 1
-   result = RedrawWindow (hwnd, NULL, hrgn,
-                          RDW_ALLCHILDREN_W | RDW_INVALIDATE_W |
-                          (erase ? RDW_ERASE_W : 0) |
-                          (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
-#else
-   result = RedrawWindow (hwnd, NULL, hrgn,
-                          RDW_ALLCHILDREN_W | RDW_INVALIDATE_W |
-                          (erase ? RDW_ERASE_W : RDW_NOERASE_W) |
-                          (hwnd == NULLHANDLE ? RDW_UPDATENOW_W : 0));
-#endif
-   return (result);
+    return (result);
 }
 //******************************************************************************
@@ -1625 +1503 @@
    Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle (hwnd);
 
-   if ((hwnd == NULLHANDLE) || !wnd)
+   if((hwnd == NULLHANDLE) || !wnd)
    {
       return (FALSE);
@@ -1702 +1580 @@
    RECTL  rectlUpdate;
    HRGN   hrgn;
-   RECTL  clientRect;
    RECTL  clipOS2;
    RECTL  scrollOS2;
@@ -1708 +1585 @@
    PRECTL pClipOS2   = NULL;
 
-   mapWin32ToOS2Rect(wnd->getWindowHeight(), wnd->getClientRectPtr(), (PRECTLOS2)&clientRect);
-
    if(pScroll) {
-        mapWin32ToOS2RectClientToFrame(wnd, &scrollRect, (PRECTLOS2)&scrollOS2);
+        mapWin32ToOS2Rect(wnd->getClientHeight(), &scrollRect, (PRECTLOS2)&scrollOS2);
         pScrollOS2 = &scrollOS2;
-
-        //Scroll rectangle relative to client area
-        WinIntersectRect ((HAB) 0, pScrollOS2, pScrollOS2, &clientRect);
-   }
-   else {
-        pScrollOS2 = &clientRect;
    }
 
    if(pClip) {
-         mapWin32ToOS2RectClientToFrame(wnd, &clipRect, (PRECTLOS2)&clipOS2);
-         pClipOS2 = &clipOS2;
-
-         //Clip rectangle relative to client area
-         WinIntersectRect((HAB) 0, pClipOS2, pClipOS2, &clientRect);
-   }
-   else {
-         pClipOS2 = &clientRect;
+        mapWin32ToOS2Rect(wnd->getClientHeight(), &clipRect, (PRECTLOS2)&clipOS2);
+        pClipOS2 = &clipOS2;
    }
 
@@ -1741 +1604 @@
    RECT winRectUpdate;
 
-   mapOS2ToWin32Rect(wnd->getWindowHeight(), (PRECTLOS2)&rectlUpdate, &winRectUpdate);
+   mapOS2ToWin32Rect(wnd->getClientHeight(), (PRECTLOS2)&rectlUpdate, &winRectUpdate);
 
    if (pRectUpdate)
@@ -1747 +1610 @@
 
    if (hrgnUpdate)
-      rc = setPMRgnIntoWinRgn(hrgn, hrgnUpdate, wnd->getWindowHeight());
+      rc = setPMRgnIntoWinRgn(hrgn, hrgnUpdate, wnd->getClientHeight());
 
    return (rc);
 }
 //******************************************************************************
-//SvL: Using WinScrollWindow to scroll child windows is better (smoother).
+//Using WinScrollWindow to scroll child windows is better (smoother).
 //******************************************************************************
 INT WIN32API ScrollWindowEx(HWND hwnd, int dx, int dy, const RECT *pScroll, const RECT *pClip,
@@ -1759 +1622 @@
  Win32BaseWindow *window;
  APIRET  rc;
- RECTL   clientRect;
  RECTL   scrollRect;
  RECTL   clipRect;
@@ -1781 +1643 @@
     if (scrollFlag & SW_SCROLLCHILDREN_W)  scrollFlagsOS2 |= SW_SCROLLCHILDREN;
 
-    mapWin32ToOS2Rect(window->getWindowHeight(), window->getClientRectPtr(), (PRECTLOS2)&clientRect);
-
     if(pScroll) {
-        mapWin32ToOS2RectClientToFrame(window,(RECT *)pScroll, (PRECTLOS2)&scrollRect);
+        mapWin32ToOS2Rect(window->getClientHeight(), (RECT *)pScroll, (PRECTLOS2)&scrollRect);
         pScrollOS2 = &scrollRect;
-
-        //Scroll rectangle relative to client area
-        WinIntersectRect ((HAB) 0, pScrollOS2, pScrollOS2, &clientRect);
-    }
-    else {
-        pScrollOS2 = &clientRect;
     }
 
     if(pClip) {
-         mapWin32ToOS2RectClientToFrame(window,(RECT *)pClip, (PRECTLOS2)&clipRect);
-         pClipOS2 = &clipRect;
-
-         //Clip rectangle relative to client area
-         WinIntersectRect ((HAB) 0, pClipOS2, pClipOS2, &clientRect);
-    }
-    else {
-         pClipOS2 = &clientRect;
+        mapWin32ToOS2Rect(window->getClientHeight(), (RECT *)pClip, (PRECTLOS2)&clipRect);
+        pClipOS2 = &clipRect;
     }
 
@@ -1816 +1664 @@
     }
 
-    LONG lComplexity = WinScrollWindow (window->getOS2WindowHandle(), dx, dy,
-                                        pScrollOS2,
-                                        pClipOS2,
-                                        hrgn, &rectlUpdate, scrollFlagsOS2);
+    LONG lComplexity = WinScrollWindow(window->getOS2WindowHandle(), dx, dy,
+                                       pScrollOS2, pClipOS2,
+                                       hrgn, &rectlUpdate, scrollFlagsOS2);
     if (lComplexity == RGN_ERROR)
     {
@@ -1850 +1697 @@
                 }
                 rectChild = *child->getWindowRect();
-                if(!pRectUpdate || IntersectRect(&rectChild, &rectChild, &rc))
+                if(!pScroll || IntersectRect(&rectChild, &rectChild, &rc))
                 {
                      dprintf(("ScrollWindowEx: Scroll child window %x", hwndChild));
@@ -1862 +1709 @@
     RECT winRectUpdate;
 
-    mapOS2ToWin32Rect(window->getWindowHeight(), (PRECTLOS2)&rectlUpdate, &winRectUpdate);
+    mapOS2ToWin32Rect(window->getClientHeight(), (PRECTLOS2)&rectlUpdate, &winRectUpdate);
 
     if (pRectUpdate)
@@ -1868 +1715 @@
 
     if (hrgnUpdate)
-       rc = setPMRgnIntoWinRgn (hrgn, hrgnUpdate, window->getWindowHeight());
+       rc = setPMRgnIntoWinRgn(hrgn, hrgnUpdate, window->getClientHeight());
 
 #if 0
@@ -1891 +1738 @@
     switch (lComplexity)
     {
-       case RGN_NULL:
-         regionType = NULLREGION_W;
-         break;
-       case RGN_RECT:
-         regionType = SIMPLEREGION_W;
-         break;
-       case RGN_COMPLEX:
-         regionType = COMPLEXREGION_W;
-         break;
-       default:
-         regionType = ERROR_W;
-         break;
+    case RGN_NULL:
+        regionType = NULLREGION_W;
+        break;
+    case RGN_RECT:
+        regionType = SIMPLEREGION_W;
+        break;
+    case RGN_COMPLEX:
+        regionType = COMPLEXREGION_W;
+        break;
+    default:
+        regionType = ERROR_W;
+        break;
     }
 
@@ -1937 +1784 @@
 //******************************************************************************
 //******************************************************************************
-#ifdef DEBUG
-void dprintfOrigin(HDC hdc)
-{
-   POINTL point;
-
-    pDCData  pHps = (pDCData)GpiQueryDCData((HPS)hdc);
-    if(!pHps)
-    {
-        return;
-    }
-
-    GreGetDCOrigin(pHps->hps, &point);
-    dprintf(("HDC %x origin (%d,%d) org (%d,%d)", hdc, point.x, point.y, pHps->ptlOrigin.x, pHps->ptlOrigin.y));
-}
-#endif
-//******************************************************************************
-//******************************************************************************
+

trunk/src/user32/dc.h

@@ -1 @@
-/* $Id: dc.h,v 1.16 2001-02-18 14:18:38 sandervl Exp $ */
+/* $Id: dc.h,v 1.17 2001-05-11 08:39:42 sandervl Exp $ */
 /*
  * public dc functions
@@ -16 +16 @@
 extern HDC sendEraseBkgnd (Win32BaseWindow *wnd);
 extern void releaseOwnDC (HDC hps);
+BOOL setPageXForm(Win32BaseWindow *wnd, struct _DCData * pHps);
 
 void selectClientArea(Win32BaseWindow *wnd, HDC hdc);

trunk/src/user32/dcrgn.cpp

@@ -1 @@
-/* $Id: dcrgn.cpp,v 1.3 2000-06-17 11:56:14 sandervl Exp $ */
+/* $Id: dcrgn.cpp,v 1.4 2001-05-11 08:39:42 sandervl Exp $ */
 
 /*
@@ -46 +46 @@
 BOOL WIN32API GetUpdateRect(HWND hwnd, LPRECT pRect, BOOL erase)
 {
-   if (!hwnd)
-   {
-        dprintf(("GetUpdateRect %x %x %d -> invalid handle!!", hwnd, pRect, erase));
-        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
-        return FALSE;
-   }
-
-   RECTL rectl, rectlClient;
-   Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
-
-   if (!wnd)
-   {
-        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
-        dprintf(("GetUpdateRect %x %x %d -> invalid handle!!", hwnd, pRect, erase));
-        return FALSE;
-   }
-
-   dprintf(("GetUpdateRect %x %x %d", hwnd, pRect, erase));
-
-   BOOL updateRegionExists = WinQueryUpdateRect (wnd->getOS2WindowHandle(), pRect ? &rectl : NULL);
-   if (!pRect) {
-      return (updateRegionExists);
-   }
-
-   if(updateRegionExists)
-   {
+    if (!hwnd)
+    {
+        dprintf(("GetUpdateRect %x %x %d -> invalid handle!!", hwnd, pRect, erase));
+        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
+        return FALSE;
+    }
+
+    RECTL rectl, rectlClient;
+    Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
+
+    if (!wnd)
+    {
+        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
+        dprintf(("GetUpdateRect %x %x %d -> invalid handle!!", hwnd, pRect, erase));
+        return FALSE;
+    }
+
+    dprintf(("GetUpdateRect %x %x %d", hwnd, pRect, erase));
+
+    BOOL updateRegionExists = WinQueryUpdateRect(wnd->getOS2WindowHandle(), pRect ? &rectl : NULL);
+    if (!pRect) {
+        return (updateRegionExists);
+    }
+
+    if(updateRegionExists)
+    {
         //CB: for PM empty rect is valid
         if ((rectl.xLeft == rectl.xRight) || (rectl.yTop == rectl.yBottom)) {
-                if(pRect) {
-                        pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
-                }
-                return FALSE;
-        }
-        mapWin32ToOS2Rect(wnd->getWindowHeight(), wnd->getClientRectPtr(), (PRECTLOS2)&rectlClient);
-        WinIntersectRect(NULL, &rectl, &rectl, &rectlClient);
-        mapOS2ToWin32RectFrameToClient(wnd, (PRECTLOS2)&rectl, pRect);
+            if(pRect) {
+                pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
+            }
+            return FALSE;
+        }
+        mapOS2ToWin32Rect(wnd->getClientHeight(), (PRECTLOS2)&rectl, pRect);
 
         if(wnd->isOwnDC() && GetMapMode(wnd->getOwnDC()) != MM_TEXT_W)
         {
-                DPtoLP(wnd->getOwnDC(), (LPPOINT)pRect, 2);
+            DPtoLP(wnd->getOwnDC(), (LPPOINT)pRect, 2);
         }
         if (erase)
-                sendEraseBkgnd (wnd);
+            sendEraseBkgnd (wnd);
    }
    else
    {
         if(pRect) {
-                pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
+            pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
         }
    }
@@ -100 +98 @@
 }
 //******************************************************************************
-//******************************************************************************
-BOOL GetOS2UpdateRect(Win32BaseWindow *window, LPRECT pRect)
-{
-   RECTL rectl;
-   BOOL updateRegionExists = WinQueryUpdateRect(window->getOS2WindowHandle(),pRect ? &rectl:NULL);
-
-   if (!pRect)
-     return (updateRegionExists);
-
-   if (updateRegionExists)
-   {
-     //CB: for PM empty rect is valid
-     if ((rectl.xLeft == rectl.xRight) || (rectl.yTop == rectl.yBottom)) return FALSE;
-     mapOS2ToWin32Rect(window->getWindowHeight(), (PRECTLOS2)&rectl,pRect);
-   }
-   else
-       pRect->left = pRect->top = pRect->right = pRect->bottom = 0;
-
-   return updateRegionExists;
-}
-//******************************************************************************
 //TODO: Seems to return region in window coordinates instead of client coordinates
 //******************************************************************************
 int WIN32API GetUpdateRgn(HWND hwnd, HRGN hrgn, BOOL erase)
 {
-   LONG lComplexity;
-   Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
-
-   hrgn = ObjWinToOS2Region(hrgn);
-   if(!wnd || !hrgn)
-   {
-        dprintf(("WARNING: GetUpdateRgn %x %x %d; invalid handle", hwnd, hrgn, erase));
-        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
-        return ERROR_W;
-   }
-   lComplexity = WinQueryUpdateRegion(wnd->getOS2WindowHandle(), hrgn);
-   if(lComplexity == RGN_ERROR) {
-        dprintf(("WARNING: GetUpdateRgn %x %x %d; RGN_ERROR", hwnd, hrgn, erase));
-        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
-        return ERROR_W;
-   }
-
-   if(lComplexity != RGN_NULL)
-   {
-        if(!setWinDeviceRegionFromPMDeviceRegion(hrgn, hrgn, NULL, wnd->getOS2WindowHandle()))
-        {
-                dprintf(("WARNING: GetUpdateRgn %x %x %d; setWinDeviceRegionFromPMDeviceRegion failed!", hwnd, hrgn, erase));
-                SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
-                return ERROR_W;
-        }
-
+    LONG lComplexity;
+    Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
+
+    hrgn = ObjWinToOS2Region(hrgn);
+    if(!wnd || !hrgn)
+    {
+        dprintf(("WARNING: GetUpdateRgn %x %x %d; invalid handle", hwnd, hrgn, erase));
+        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
+        return ERROR_W;
+    }
+    lComplexity = WinQueryUpdateRegion(wnd->getOS2WindowHandle(), hrgn);
+    if(lComplexity == RGN_ERROR) {
+        dprintf(("WARNING: GetUpdateRgn %x %x %d; RGN_ERROR", hwnd, hrgn, erase));
+        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
+        return ERROR_W;
+    }
+
+    if(lComplexity != RGN_NULL)
+    {
+        if(!setWinDeviceRegionFromPMDeviceRegion(hrgn, hrgn, NULL, wnd->getOS2WindowHandle()))
+        {
+            dprintf(("WARNING: GetUpdateRgn %x %x %d; setWinDeviceRegionFromPMDeviceRegion failed!", hwnd, hrgn, erase));
+            SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
+            return ERROR_W;
+        }
         if(erase) sendEraseBkgnd(wnd);
-   }
-
-   return lComplexity;
+    }
+    return lComplexity;
 }
 //******************************************************************************
@@ -161 +136 @@
 INT WIN32API ExcludeUpdateRgn(HDC hdc, HWND hwnd)
 {
-   Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
-   pDCData          pHps = (pDCData)GpiQueryDCData((HPS)hdc);
-   LONG             lComplexity;
-
-   if(!wnd || !pHps)
-   {
-        dprintf(("WARNING: ExcludeUpdateRgn %x %x; invalid handle", hdc, hwnd));
-        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
-        return ERROR_W;
-   }
-   dprintf(("USER32: ExcludeUpdateRgn %x %x", hdc, hwnd));
-
-   lComplexity = WinExcludeUpdateRegion(pHps->hps, wnd->getOS2WindowHandle());
-   if(lComplexity == RGN_ERROR) {
-        SetLastError(ERROR_INVALID_HANDLE_W); //todo: correct error
-   }
-   else SetLastError(ERROR_SUCCESS_W); 
-   return lComplexity;      // windows and PM values are identical
+    Win32BaseWindow *wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
+    pDCData          pHps = (pDCData)GpiQueryDCData((HPS)hdc);
+    LONG             lComplexity;
+
+    if(!wnd || !pHps)
+    {
+        dprintf(("WARNING: ExcludeUpdateRgn %x %x; invalid handle", hdc, hwnd));
+        SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
+        return ERROR_W;
+    }
+    dprintf(("USER32: ExcludeUpdateRgn %x %x", hdc, hwnd));
+
+    lComplexity = WinExcludeUpdateRegion(pHps->hps, wnd->getOS2WindowHandle());
+    if(lComplexity == RGN_ERROR) {
+         SetLastError(ERROR_INVALID_HANDLE_W); //todo: correct error
+    }
+    else SetLastError(ERROR_SUCCESS_W);
+    return lComplexity;      // windows and PM values are identical
 }
 /*****************************************************************************
@@ -195 +170 @@
 int WIN32API GetWindowRgn(HWND hwnd, HRGN hRgn)
 {
-  Win32BaseWindow *window;
-  HRGN hWindowRegion;
+    Win32BaseWindow *window;
+    HRGN hWindowRegion;
 
     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
@@ -234 +209 @@
                           BOOL bRedraw)
 {
-  Win32BaseWindow *window;
-  HRGN hWindowRegion;
+    Win32BaseWindow *window;
+    HRGN hWindowRegion;
 
     window = Win32BaseWindow::GetWindowFromHandle(hwnd);

trunk/src/user32/oslibgdi.cpp

@@ -1 @@
-/* $Id: oslibgdi.cpp,v 1.13 2000-06-08 18:10:10 sandervl Exp $ */
+/* $Id: oslibgdi.cpp,v 1.14 2001-05-11 08:39:42 sandervl Exp $ */
 /*
  * Window GDI wrapper functions for OS/2
@@ -120 +120 @@
   return TRUE;
 }
+#ifndef CLIENTFRAME
 //******************************************************************************
 //Win32 rectangle in client coordinates (relative to upper left corner of client window)
@@ -172 +173 @@
   return TRUE;
 }
+#endif //CLIENTFRAME
 //******************************************************************************
 //******************************************************************************

trunk/src/user32/oslibgdi.h

@@ -1 @@
-/* $Id: oslibgdi.h,v 1.8 2000-11-19 11:52:39 sandervl Exp $ */
+/* $Id: oslibgdi.h,v 1.9 2001-05-11 08:39:43 sandervl Exp $ */
 /*
  * Window GDI wrapper functions for OS/2
@@ -80 +80 @@
 BOOL mapWin32ToOS2Rect(int height, PRECT rectWin32,PRECTLOS2 rectOS2);
 
+#ifndef CLIENTFRAME
 BOOL mapWin32ToOS2RectClientToFrame(Win32BaseWindow *window, PRECT rectWin32,PRECTLOS2 rectOS2);
 BOOL mapOS2ToWin32RectFrameToClient(Win32BaseWindow *window, PRECTLOS2 rectOS2, PRECT rectWin32);
+#endif
 
 #define mapWin32ToOS2RectFrame(window, rectWin32, rectOS2) \

trunk/src/user32/oslibmsgtranslate.cpp

@@ -1 @@
-/* $Id: oslibmsgtranslate.cpp,v 1.49 2001-04-28 13:35:52 sandervl Exp $ */
+/* $Id: oslibmsgtranslate.cpp,v 1.50 2001-05-11 08:39:43 sandervl Exp $ */
 /*
  * Window message translation functions for OS/2
@@ -194 +194 @@
   int i;
 
-  memset(winMsg, 0, sizeof(MSG));
-  win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(os2Msg->hwnd);
-
-  //PostThreadMessage posts WIN32APP_POSTMSG msg without window handle
-  //Realplayer starts a timer with hwnd 0 & proc 0; check this here
-  if(win32wnd == 0 && (os2Msg->msg != WM_CREATE && os2Msg->msg != WM_QUIT && os2Msg->msg != WM_TIMER && os2Msg->msg != WIN32APP_POSTMSG))
-  {
+    memset(winMsg, 0, sizeof(MSG));
+    win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(os2Msg->hwnd);
+    if(!win32wnd) {
+        win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(os2Msg->hwnd);
+    }
+
+    //PostThreadMessage posts WIN32APP_POSTMSG msg without window handle
+    //Realplayer starts a timer with hwnd 0 & proc 0; check this here
+    if(win32wnd == 0 && (os2Msg->msg != WM_CREATE && os2Msg->msg != WM_QUIT && os2Msg->msg != WM_TIMER && os2Msg->msg != WIN32APP_POSTMSG))
+    {
         goto dummymessage; //not a win32 client window
-  }
-  winMsg->time = os2Msg->time;
-  //CB: PM bug or undocumented feature? ptl.x highword is set!
-  winMsg->pt.x = os2Msg->ptl.x & 0xFFFF;
-  winMsg->pt.y = mapScreenY(os2Msg->ptl.y);
-
-  if(win32wnd) //==0 for WM_CREATE/WM_QUIT
-    winMsg->hwnd = win32wnd->getWindowHandle();
-
-  switch(os2Msg->msg)
-  {
+    }
+    winMsg->time = os2Msg->time;
+    //CB: PM bug or undocumented feature? ptl.x highword is set!
+    winMsg->pt.x = os2Msg->ptl.x & 0xFFFF;
+    winMsg->pt.y = mapScreenY(os2Msg->ptl.y);
+
+    if(win32wnd) //==0 for WM_CREATE/WM_QUIT
+        winMsg->hwnd = win32wnd->getWindowHandle();
+
+    switch(os2Msg->msg)
+    {
     case WIN32APP_POSTMSG:
     {
@@ -273 +276 @@
       LONG      xDelta = pswp->cx - swpOld.cx;
 
-        dprintf(("OS2: WM_WINDOWPOSCHANGED %x %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-
         if ((pswp->fl & (SWP_SIZE | SWP_MOVE | SWP_ZORDER)) == 0) goto dummymessage;
 
@@ -286 +287 @@
         }
         if(win32wnd->getParent()) {
-              OSLibMapSWPtoWINDOWPOS(pswp, &teb->o.odin.wp, &swpOld, win32wnd->getParent()->getWindowHeight(),
-                                     win32wnd->getParent()->getClientRectPtr()->left,
-                                     win32wnd->getParent()->getClientRectPtr()->top,
+              OSLibMapSWPtoWINDOWPOS(pswp, &teb->o.odin.wp, &swpOld, win32wnd->getParent()->getClientHeight(),
                                      win32wnd->getOS2WindowHandle());
         }
-        else  OSLibMapSWPtoWINDOWPOS(pswp, &teb->o.odin.wp, &swpOld, OSLibQueryScreenHeight(), 0, 0, win32wnd->getOS2WindowHandle());
+        else  OSLibMapSWPtoWINDOWPOS(pswp, &teb->o.odin.wp, &swpOld, OSLibQueryScreenHeight(), win32wnd->getOS2WindowHandle());
 
         if (!win32wnd->CanReceiveSizeMsgs())    goto dummymessage;
@@ -320 +319 @@
         hwndActivate = OS2ToWin32Handle(hwndActivate);
         if(hwndActivate == 0) {
-                //another (non-win32) application's window
-                //set to desktop window handle
-                hwndActivate = windowDesktop->getWindowHandle();
+            //another (non-win32) application's window
+            //set to desktop window handle
+            hwndActivate = windowDesktop->getWindowHandle();
         }
 
@@ -361 +360 @@
     //Mouse messages (OS/2 Window coordinates -> Win32 coordinates relative to screen
     //**************************************************************************
-#ifndef ODIN_HITTEST
-    case WM_HITTEST:
-      winMsg->message = WINWM_NCHITTEST;
-      winMsg->wParam  = 0;
-      winMsg->lParam  = MAKELONG(winMsg->pt.x,winMsg->pt.y);
-      if(!IsWindowEnabled(win32wnd->getWindowHandle())) {
-                if(win32wnd->getParent()) {
-                        winMsg->hwnd = win32wnd->getParent()->getWindowHandle();
-                }
-                else    goto dummymessage; //don't send mouse messages to disabled windows
-      }
-      break;
-#endif
-
     case WM_BUTTON1DOWN:
     case WM_BUTTON1UP:
@@ -387 +372 @@
         //WM_NC*BUTTON* is posted when the cursor is in a non-client area of the window
 
-#ifdef ODIN_HITTEST
         HWND hwnd;
 
         DisableLogging();
-        if(GetCapture() != winMsg->hwnd) 
+        if(GetCapture() != winMsg->hwnd)
         {
             hwnd = WindowFromPoint(winMsg->pt);
@@ -404 +388 @@
             }
         }
-#endif
 
         //if a window is disabled, it's parent receives the mouse messages
@@ -420 +403 @@
         }
         else {
-#ifdef ODIN_HITTEST
             ClientPoint.x = winMsg->pt.x;
             ClientPoint.y = winMsg->pt.y;
             MapWindowPoints(0, win32wnd->getWindowHandle(), (LPPOINT)&ClientPoint, 1);
-#else
-            point.x         = (*(POINTS *)&os2Msg->mp1).x;
-            point.y         = (*(POINTS *)&os2Msg->mp1).y;
-            ClientPoint.x   = mapOS2ToWin32X(win32wnd, point.x);
-            ClientPoint.y   = mapOS2ToWin32Y(win32wnd, point.y);
-#endif
             winMsg->message = WINWM_LBUTTONDOWN + (os2Msg->msg - WM_BUTTON1DOWN);
             winMsg->wParam  = GetMouseKeyState();
             winMsg->lParam  = MAKELONG(ClientPoint.x, ClientPoint.y); //client coordinates
         }
-#ifdef ODIN_HITTEST
         EnableLogging();
-#endif
         if((fMsgRemoved == MSG_REMOVE) && ISMOUSE_CAPTURED())
         {
@@ -472 +446 @@
         //WM_NCMOUSEMOVE is posted when the cursor moves into a non-client area of the window
 
-#ifdef ODIN_HITTEST
         HWND hwnd;
 
         dprintf2(("WM_NCMOUSEMOVE (%d,%d)", winMsg->pt.x, winMsg->pt.y));
         DisableLogging();
-        if(GetCapture() != winMsg->hwnd) 
+        if(GetCapture() != winMsg->hwnd)
         {
             hwnd = WindowFromPoint(winMsg->pt);
@@ -490 +463 @@
             }
         }
-#endif
 
         //if a window is disabled, it's parent receives the mouse messages
@@ -507 +479 @@
         else
         {
-#ifdef ODIN_HITTEST
             ClientPoint.x = winMsg->pt.x;
             ClientPoint.y = winMsg->pt.y;
             MapWindowPoints(0, win32wnd->getWindowHandle(), (LPPOINT)&ClientPoint, 1);
-#else
-            point.x         = (*(POINTS *)&os2Msg->mp1).x;
-            point.y         = (*(POINTS *)&os2Msg->mp1).y;
-            ClientPoint.x   = mapOS2ToWin32X(win32wnd, point.x);
-            ClientPoint.y   = mapOS2ToWin32Y(win32wnd, point.y);
-#endif
 
             winMsg->message = WINWM_MOUSEMOVE;
@@ -522 +487 @@
             winMsg->lParam  = MAKELONG(ClientPoint.x, ClientPoint.y); //client coordinates
         }
-#ifdef ODIN_HITTEST
         EnableLogging();
-#endif
         if((fMsgRemoved == MSG_REMOVE) && ISMOUSE_CAPTURED())
         {
@@ -822 +785 @@
         winMsg->lParam  = 0;
         return FALSE;
-  }
-  return TRUE;
+    }
+    return TRUE;
 }
 //******************************************************************************

trunk/src/user32/oslibwin.cpp

@@ -1 @@
-/* $Id: oslibwin.cpp,v 1.91 2001-04-15 17:05:29 sandervl Exp $ */
+/* $Id: oslibwin.cpp,v 1.92 2001-05-11 08:39:43 sandervl Exp $ */
 /*
  * Window API wrappers for OS/2
@@ -53 +53 @@
 //******************************************************************************
 HWND OSLibWinCreateWindow(HWND hwndParent,ULONG dwWinStyle,
-                          char *pszName, HWND Owner, ULONG fHWND_BOTTOM, 
+                          char *pszName, HWND Owner, ULONG fHWND_BOTTOM,
                           ULONG id, BOOL fTaskList,BOOL fShellPosition,
-                          int classStyle)
+                          int classStyle, HWND *hwndFrame)
 {
  HWND  hwndClient;
  ULONG dwFrameStyle = 0;
 
-  if(pszName && *pszName == 0) {
+    if(pszName && *pszName == 0) {
         pszName = NULL;
-  }
-  if(hwndParent == OSLIB_HWND_DESKTOP) {
+    }
+    if(hwndParent == OSLIB_HWND_DESKTOP) {
         hwndParent = HWND_DESKTOP;
-  }
-  if(Owner == OSLIB_HWND_DESKTOP) {
+    }
+    if(Owner == OSLIB_HWND_DESKTOP) {
         Owner = HWND_DESKTOP;
-  }
-
-  if(classStyle & CS_SAVEBITS_W) dwWinStyle |= WS_SAVEBITS;
-  if(classStyle & CS_PARENTDC_W) dwWinStyle |= WS_PARENTCLIP;
-
-  dwWinStyle = dwWinStyle & ~(WS_TABSTOP | WS_GROUP);
-
-  if(fTaskList)
-  {
-        dwFrameStyle |= FCF_NOMOVEWITHOWNER;
-  }
-  if (fShellPosition) dwFrameStyle |= FCF_SHELLPOSITION;
-
-  FRAMECDATA FCData = {sizeof (FRAMECDATA), 0, 0, 0};
-  FCData.flCreateFlags = dwFrameStyle;
-
-  dprintf(("WinCreateWindow %x %s %x task %d shell %d classstyle %x winstyle %x bottom %d", hwndParent, pszName, id, fTaskList, fShellPosition, classStyle, dwWinStyle, fHWND_BOTTOM));
-
-  return WinCreateWindow (hwndParent,
-                          (hwndParent == HWND_DESKTOP) ? WIN32_STDFRAMECLASS : WIN32_STDCLASS,
-                          pszName, dwWinStyle, 0, 0, 0, 0,
-                          Owner, (fHWND_BOTTOM) ? HWND_BOTTOM : HWND_TOP,
-                          id, NULL, NULL);
+    }
+
+    if(classStyle & CS_SAVEBITS_W) dwWinStyle |= WS_SAVEBITS;
+    if(classStyle & CS_PARENTDC_W) dwWinStyle |= WS_PARENTCLIP;
+
+    dwWinStyle = dwWinStyle & ~(WS_TABSTOP | WS_GROUP);
+
+    if(fTaskList)
+    {
+        dwFrameStyle |= FCF_NOMOVEWITHOWNER;
+    }
+    if (fShellPosition) dwFrameStyle |= FCF_SHELLPOSITION;
+
+    FRAMECDATA FCData = {sizeof (FRAMECDATA), 0, 0, 0};
+    FCData.flCreateFlags = dwFrameStyle;
+
+    dprintf(("WinCreateWindow %x %s %x task %d shell %d classstyle %x winstyle %x bottom %d", hwndParent, pszName, id, fTaskList, fShellPosition, classStyle, dwWinStyle, fHWND_BOTTOM));
+
+    //Must not use WS_CLIPCHILDREN style with frame window. Transparency won't work otherwise.
+    //Eg: dialog parent, groupbox; invalidate part of groupbox -> painting algorithm stops when it finds
+    //    a window with WS_CLIPCHILDREN -> result: dialog window won't update groupbox background as groupbox only draws the border
+    *hwndFrame = WinCreateWindow(hwndParent,
+                           WIN32_STDFRAMECLASS,
+                           pszName, (dwWinStyle & ~WS_CLIPCHILDREN), 0, 0, 0, 0,
+                           Owner, (fHWND_BOTTOM) ? HWND_BOTTOM : HWND_TOP,
+                           id, NULL, NULL);
+    hwndClient = WinCreateWindow (*hwndFrame, WIN32_STDCLASS,
+                              NULL, dwWinStyle | WS_VISIBLE, 0, 0, 0, 0,
+                              *hwndFrame, HWND_TOP, FID_CLIENT, NULL, NULL);
+    return hwndClient;
 }
 //******************************************************************************
@@ -294 +301 @@
   rc = WinSetActiveWindow(HWND_DESKTOP, hwnd);
   if(rc == FALSE) {
-        dprintf(("WinSetActiveWindow %x failure: %x", hwnd, OSLibWinGetLastError()));
+    dprintf(("WinSetActiveWindow %x failure: %x", hwnd, OSLibWinGetLastError()));
   }
   return rc;
@@ -394 +401 @@
 //******************************************************************************
 //******************************************************************************
-void OSLibMapSWPtoWINDOWPOS(PSWP pswp, PWINDOWPOS pwpos, PSWP pswpOld, 
-                            int parentHeight, int clientOrgX, int clientOrgY, 
-                            HWND hwnd)
+void OSLibMapSWPtoWINDOWPOS(PSWP pswp, PWINDOWPOS pwpos, PSWP pswpOld,
+                            int parentHeight, HWND hwnd)
 {
    HWND hWindow            = pswp->hwnd;
    HWND hWndInsertAfter    = pswp->hwndInsertBehind;
-   long x                  = pswp->x - clientOrgX;
-   long y                  = pswp->y + clientOrgY;
+   long x                  = pswp->x;
+   long y                  = pswp->y;
    long cx                 = pswp->cx;
    long cy                 = pswp->cy;
@@ -467 +473 @@
 //******************************************************************************
 //******************************************************************************
-void OSLibMapWINDOWPOStoSWP(struct tagWINDOWPOS *pwpos, PSWP pswp, PSWP pswpOld, 
-                            int parentHeight, int clientOrgX, int clientOrgY, HWND hFrame)
+void OSLibMapWINDOWPOStoSWP(struct tagWINDOWPOS *pwpos, PSWP pswp, PSWP pswpOld,
+                            int parentHeight, HWND hFrame)
 {
  BOOL fCvt = FALSE;
@@ -474 +480 @@
    HWND hWnd            = pwpos->hwnd;
    HWND hWndInsertAfter = pwpos->hwndInsertAfter;
-   long x               = pwpos->x + clientOrgX;
-   long y               = pwpos->y + clientOrgY;
+   long x               = pwpos->x;
+   long y               = pwpos->y;
    long cx              = pwpos->cx;
    long cy              = pwpos->cy;
@@ -546 +552 @@
 }
 //******************************************************************************
-//Position in screen coordinates
+//******************************************************************************
+void OSLibWinSetClientPos(HWND hwnd, int x, int y, int cx, int cy, int parentHeight)
+{
+ SWP swp;
+ BOOL rc;
+
+   swp.hwnd = hwnd;
+   swp.hwndInsertBehind = 0;
+   swp.x  = x;
+   swp.y  = parentHeight - y - cy;
+   swp.cx = cx;
+   swp.cy = cy;
+   swp.fl = SWP_MOVE | SWP_SIZE;
+
+   dprintf(("OSLibWinSetClientPos (%d,%d) (%d,%d) -> (%d,%d) (%d,%d)", x, y, x+cx, y+cy, swp.x, swp.y, swp.x+swp.cx, swp.y+swp.cy));
+
+   rc = WinSetMultWindowPos(GetThreadHAB(), &swp, 1);
+   if(rc == FALSE) {
+        dprintf(("OSLibWinSetClientPos: WinSetMultWindowPos %x failed %x", hwnd, WinGetLastError(GetThreadHAB())));
+   }
+}
+//******************************************************************************
 //******************************************************************************
 BOOL OSLibWinCalcFrameRect(HWND hwndFrame, RECT *pRect, BOOL fClient)
@@ -716 +743 @@
 //******************************************************************************
 //******************************************************************************
-void OSLibSetWindowStyle(HWND hwnd, ULONG dwStyle, ULONG dwExStyle)
-{
-  ULONG dwWinStyle = WinQueryWindowULong(hwnd, QWL_STYLE);
-  ULONG dwOldWinStyle = dwWinStyle;
-
-  if(dwStyle & WS_DISABLED_W) {
-        dwWinStyle |= WS_DISABLED;
-  }
-  else  dwWinStyle &= ~WS_DISABLED;
-
-  if(dwStyle & WS_CLIPSIBLINGS_W) {
-        dwWinStyle |= WS_CLIPSIBLINGS;
-  }
-  else  dwWinStyle &= ~WS_CLIPSIBLINGS;
-
-  if(dwStyle & WS_CLIPCHILDREN_W) {
-        dwWinStyle |= WS_CLIPCHILDREN;
-  }
-  else  dwWinStyle &= ~WS_CLIPCHILDREN;
-
-  if(dwWinStyle != dwOldWinStyle) {
-      WinSetWindowULong(hwnd, QWL_STYLE, dwWinStyle);
-  }
+void OSLibSetWindowStyle(HWND hwndFrame, HWND hwndClient, ULONG dwStyle, ULONG dwExStyle)
+{
+    ULONG dwWinStyle;
+    ULONG dwOldWinStyle;
+
+    //client window:
+    dwWinStyle    = WinQueryWindowULong(hwndClient, QWL_STYLE);
+    dwOldWinStyle = dwWinStyle;
+
+    if(dwStyle & WS_CLIPCHILDREN_W) {
+         dwWinStyle |= WS_CLIPCHILDREN;
+    }
+    else dwWinStyle &= ~WS_CLIPCHILDREN;
+
+    if(dwWinStyle != dwOldWinStyle) {
+        WinSetWindowULong(hwndClient, QWL_STYLE, dwWinStyle);
+    }
+
+    //Frame window
+    dwWinStyle    = WinQueryWindowULong(hwndFrame, QWL_STYLE);
+    dwOldWinStyle = dwWinStyle;
+    if(dwStyle & WS_DISABLED_W) {
+         dwWinStyle |= WS_DISABLED;
+    }
+    else dwWinStyle &= ~WS_DISABLED;
+
+    if(dwStyle & WS_CLIPSIBLINGS_W) {
+         dwWinStyle |= WS_CLIPSIBLINGS;
+    }
+    else dwWinStyle &= ~WS_CLIPSIBLINGS;
+
+    if(dwWinStyle != dwOldWinStyle) {
+      WinSetWindowULong(hwndFrame, QWL_STYLE, dwWinStyle);
+    }
 }
 //******************************************************************************
@@ -744 +782 @@
 DWORD OSLibQueryWindowStyle(HWND hwnd)
 {
-  return WinQueryWindowULong(hwnd, QWL_STYLE);
+    return WinQueryWindowULong(hwnd, QWL_STYLE);
 }
 //******************************************************************************
@@ -750 +788 @@
 void OSLibWinSetVisibleRegionNotify(HWND hwnd, BOOL fNotify)
 {
-  WinSetVisibleRegionNotify(hwnd, fNotify);
+    WinSetVisibleRegionNotify(hwnd, fNotify);
 }
 //******************************************************************************
@@ -756 +794 @@
 HWND OSLibWinQueryCapture()
 {
-  return WinQueryCapture(HWND_DESKTOP);
+    return WinQueryCapture(HWND_DESKTOP);
 }
 //******************************************************************************
@@ -762 +800 @@
 BOOL OSLibWinSetCapture(HWND hwnd)
 {
-  return WinSetCapture(HWND_DESKTOP, hwnd);
+    return WinSetCapture(HWND_DESKTOP, hwnd);
 }
 //******************************************************************************
@@ -768 +806 @@
 BOOL OSLibWinRemoveFromTasklist(HANDLE hTaskList)
 {
-  return (WinRemoveSwitchEntry(hTaskList)) ? FALSE : TRUE;
+    return (WinRemoveSwitchEntry(hTaskList)) ? FALSE : TRUE;
 }
 //******************************************************************************
@@ -774 +812 @@
 HANDLE OSLibWinAddToTaskList(HWND hwndFrame, char *title, BOOL fVisible)
 {
- SWCNTRL swctrl;
- ULONG   tid;
-
-  swctrl.hwnd          = hwndFrame;
-  swctrl.hwndIcon      = 0;
-  swctrl.hprog         = 0;
-  WinQueryWindowProcess(hwndFrame, (PPID)&swctrl.idProcess, (PTID)&tid);
-  swctrl.idSession     = 0;
-  swctrl.uchVisibility = (fVisible) ? SWL_VISIBLE : SWL_INVISIBLE;
-  swctrl.fbJump        = SWL_JUMPABLE;
-  swctrl.bProgType     = PROG_PM;
-  if(title) {
-        strncpy(swctrl.szSwtitle, title, MAXNAMEL+4);
-        swctrl.szSwtitle[MAXNAMEL+4-1] = 0;
-  }
-  else {
-        swctrl.szSwtitle[0] = 0;
-        swctrl.uchVisibility    = SWL_INVISIBLE;
-  }
-  return WinAddSwitchEntry(&swctrl);
+    SWCNTRL swctrl;
+    ULONG   tid;
+
+    swctrl.hwnd          = hwndFrame;
+    swctrl.hwndIcon      = 0;
+    swctrl.hprog         = 0;
+    WinQueryWindowProcess(hwndFrame, (PPID)&swctrl.idProcess, (PTID)&tid);
+    swctrl.idSession     = 0;
+    swctrl.uchVisibility = (fVisible) ? SWL_VISIBLE : SWL_INVISIBLE;
+    swctrl.fbJump        = SWL_JUMPABLE;
+    swctrl.bProgType     = PROG_PM;
+    if(title) {
+        strncpy(swctrl.szSwtitle, title, MAXNAMEL+4);
+        swctrl.szSwtitle[MAXNAMEL+4-1] = 0;
+    }
+    else {
+        swctrl.szSwtitle[0] = 0;
+        swctrl.uchVisibility    = SWL_INVISIBLE;
+    }
+    return WinAddSwitchEntry(&swctrl);
 }
 //******************************************************************************
@@ -799 +837 @@
 BOOL OSLibWinChangeTaskList(HANDLE hTaskList, HWND hwndFrame, char *title, BOOL fVisible)
 {
- SWCNTRL swctrl;
- ULONG   tid;
- 
-  swctrl.hwnd          = hwndFrame;
-  swctrl.hwndIcon      = 0;
-  swctrl.hprog         = 0;
-  WinQueryWindowProcess(hwndFrame, (PPID)&swctrl.idProcess, (PTID)&tid);
-  swctrl.idSession     = 0;
-  swctrl.uchVisibility = (fVisible) ? SWL_VISIBLE : SWL_INVISIBLE;
-  swctrl.fbJump        = SWL_JUMPABLE;
-  swctrl.bProgType     = PROG_PM;
-  if(title) {
-        strncpy(swctrl.szSwtitle, title, MAXNAMEL+4);
-        swctrl.szSwtitle[MAXNAMEL+4-1] = 0;
-  }
-  else {
-        swctrl.szSwtitle[0] = 0;
-        swctrl.uchVisibility    = SWL_INVISIBLE;
-  }
-  return (WinChangeSwitchEntry(hTaskList, &swctrl)) ? FALSE : TRUE;
+    SWCNTRL swctrl;
+    ULONG   tid;
+
+    swctrl.hwnd          = hwndFrame;
+    swctrl.hwndIcon      = 0;
+    swctrl.hprog         = 0;
+    WinQueryWindowProcess(hwndFrame, (PPID)&swctrl.idProcess, (PTID)&tid);
+    swctrl.idSession     = 0;
+    swctrl.uchVisibility = (fVisible) ? SWL_VISIBLE : SWL_INVISIBLE;
+    swctrl.fbJump        = SWL_JUMPABLE;
+    swctrl.bProgType     = PROG_PM;
+    if(title) {
+        strncpy(swctrl.szSwtitle, title, MAXNAMEL+4);
+        swctrl.szSwtitle[MAXNAMEL+4-1] = 0;
+    }
+    else {
+        swctrl.szSwtitle[0] = 0;
+        swctrl.uchVisibility    = SWL_INVISIBLE;
+    }
+    return (WinChangeSwitchEntry(hTaskList, &swctrl)) ? FALSE : TRUE;
 }
 //******************************************************************************
@@ -824 +862 @@
 BOOL OSLibWinLockWindowUpdate(HWND hwnd)
 {
-  return WinLockWindowUpdate(HWND_DESKTOP, (HWND)hwnd);
+    return WinLockWindowUpdate(HWND_DESKTOP, (HWND)hwnd);
 }
 //******************************************************************************
@@ -830 +868 @@
 ULONG OSLibGetScreenHeight()
 {
-  return ScreenHeight;
+    return ScreenHeight;
 }
 //******************************************************************************
@@ -836 +874 @@
 ULONG OSLibGetScreenWidth()
 {
-  return ScreenWidth;
+    return ScreenWidth;
 }
 //******************************************************************************
@@ -845 +883 @@
 {
  SWP  swp;
- 
-  if(!WinGetMaxPosition(hwndOS2, &swp)) {
-        dprintf(("WARNING: WinGetMaxPosition %x returned FALSE", hwndOS2));
-        return FALSE;
-  }
-  rect->left   = swp.x;
-  rect->right  = swp.x + swp.cx;
-  rect->top    = ScreenHeight - (swp.y + swp.cy);
-  rect->bottom = ScreenHeight - swp.y;
-  return TRUE;
+
+    if(!WinGetMaxPosition(hwndOS2, &swp)) {
+        dprintf(("WARNING: WinGetMaxPosition %x returned FALSE", hwndOS2));
+        return FALSE;
+    }
+    rect->left   = swp.x;
+    rect->right  = swp.x + swp.cx;
+    rect->top    = ScreenHeight - (swp.y + swp.cy);
+    rect->bottom = ScreenHeight - swp.y;
+    return TRUE;
 }
 //******************************************************************************
@@ -860 +898 @@
 BOOL OSLibWinShowPointer(BOOL fShow)
 {
-  return WinShowPointer(HWND_DESKTOP, fShow);
-}
-//******************************************************************************
-//******************************************************************************
+    return WinShowPointer(HWND_DESKTOP, fShow);
+}
+//******************************************************************************
+//******************************************************************************

trunk/src/user32/oslibwin.h

@@ -1 @@
-/* $Id: oslibwin.h,v 1.53 2001-04-15 17:05:29 sandervl Exp $ */
+/* $Id: oslibwin.h,v 1.54 2001-05-11 08:39:43 sandervl Exp $ */
 /*
  * Window API wrappers for OS/2
@@ -40 +40 @@
 HWND  OSLibWinCreateWindow(HWND hwndParent,ULONG dwWinStyle,
                            char *pszName, HWND Owner, ULONG fBottom,
-                           ULONG id, BOOL fTaskList,BOOL fShellPosition, int classStyle);
+                           ULONG id, BOOL fTaskList,BOOL fShellPosition, 
+                           int classStyle, HWND *hwndFrame);
 
 BOOL  OSLibWinConvertStyle(ULONG dwStyle, ULONG dwExStyle, ULONG *OSWinStyle);
-void  OSLibSetWindowStyle(HWND hwnd, ULONG dwStyle, ULONG dwExStyle);
+void  OSLibSetWindowStyle(HWND hwndFrame, HWND hwndClient, ULONG dwStyle, ULONG dwExStyle);
 DWORD OSLibQueryWindowStyle(HWND hwnd);
 
@@ -250 +251 @@
 BOOL  OSLibWinQueryWindowPos (HWND hwnd, PSWP pswp);
 void  OSLibMapSWPtoWINDOWPOS(PSWP pswp, PWINDOWPOS pwpos, PSWP pswpOld, 
-                            int parentHeight, int clientOrgX, int clientOrgY, 
-                            HWND hwnd);
+                            int parentHeight, HWND hwnd);
 void  OSLibMapWINDOWPOStoSWP(struct tagWINDOWPOS *pwpos, PSWP pswp, PSWP pswpOld, 
-                             int parentHeight, int clientOrgX, int clientOrgY, HWND hFrame);
+                             int parentHeight, HWND hFrame);
+
+void  OSLibWinSetClientPos(HWND hwnd, int x, int y, int cx, int cy, int parentHeight);
 
 HWND  OSLibWinBeginEnumWindows(HWND hwnd);

trunk/src/user32/pmwindow.cpp

@@ -1 @@
-/* $Id: pmwindow.cpp,v 1.124 2001-05-04 17:02:51 sandervl Exp $ */
+/* $Id: pmwindow.cpp,v 1.125 2001-05-11 08:39:44 sandervl Exp $ */
 /*
  * Win32 Window Managment Code for OS/2
@@ -34 +34 @@
 #include "oslibgdi.h"
 #include "oslibmsg.h"
+#define INCLUDED_BY_DC
 #include "dc.h"
 #include <thread.h>
@@ -59 +60 @@
 MRESULT EXPENTRY Win32WindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
 MRESULT EXPENTRY Win32FrameWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
-MRESULT ProcessPMMessage(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, Win32BaseWindow *win32wnd,
-                         MSG *pWinMsg, TEB *teb, BOOL isFrame);
 
 //******************************************************************************
@@ -105 +104 @@
         (PSZ)WIN32_STDCLASS,               /* Window class name            */
         (PFNWP)Win32WindowProc,            /* Address of window procedure  */
-#ifdef ODIN_HITTEST
         0,
-#else
-        CS_HITTEST,
-#endif
         NROF_WIN32WNDBYTES))
     {
@@ -129 +124 @@
         (PSZ)WIN32_STDFRAMECLASS,          /* Window class name            */
         (PFNWP)Win32FrameWindowProc,       /* Address of window procedure  */
-#ifdef ODIN_HITTEST
         CS_FRAME,
-#else
-        CS_HITTEST | CS_FRAME,
-#endif
         FrameClassInfo.cbWindowData+NROF_WIN32WNDBYTES))
     {
@@ -166 +157 @@
  MSG              winMsg, *pWinMsg;
  MRESULT          rc = 0;
+ POSTMSG_PACKET  *postmsg;
+ OSLIBPOINT       point, ClientPoint;
 
     //Restore our FS selector
@@ -175 +168 @@
 
     if(!teb || (msg != WM_CREATE && win32wnd == NULL)) {
-        dprintf(("Invalid win32wnd pointer for window %x msg %x", hwnd, msg));
+        dprintf(("OS2: Invalid win32wnd pointer for window %x msg %x", hwnd, msg));
         goto RunDefWndProc;
     }
@@ -205 +198 @@
     }
     //NOTE-------------->>>>>> If this is changed, also change Win32WindowProc!! <<<<<<<<<<<-------------------- END
-    rc = ProcessPMMessage(hwnd, msg, mp1, mp2, win32wnd, pWinMsg, teb, FALSE);
-    RestoreOS2TIB();
-    return rc;
-
-RunDefWndProc:
-    RestoreOS2TIB();
-    return WinDefWindowProc( hwnd, msg, mp1, mp2 );
-}
-//******************************************************************************
-//******************************************************************************
-MRESULT ProcessPMMessage(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, Win32BaseWindow *win32wnd, MSG *pWinMsg, TEB *teb, BOOL isFrame)
-{
- POSTMSG_PACKET  *postmsg;
- OSLIBPOINT       point, ClientPoint;
- MRESULT          rc = 0;
-
-  if(msg == WIN32APP_POSTMSG) {
+
+    if(msg == WIN32APP_POSTMSG) {
         //probably win32 app user message
         if((ULONG)mp1 == WIN32MSG_MAGICA) {
@@ -230 +208 @@
             return (MRESULT)win32wnd->DispatchMsgW(pWinMsg);
         }
-  }
-  else
-  if(msg == WIN32APP_SETFOCUSMSG) {
+    }
+    else
+    if(msg == WIN32APP_SETFOCUSMSG) {
       //PM doesn't allow SetFocus calls during WM_SETFOCUS message processing;
       //must delay this function call
@@ -240 +218 @@
       teb->o.odin.hwndFocus = 0;
       WinFocusChange(HWND_DESKTOP, hwnd, mp2 ? FC_NOLOSEACTIVE : 0);
-  }
-
-  switch( msg )
-  {
+    }
+
+    switch( msg )
+    {
     //OS/2 msgs
     case WM_CREATE:
@@ -280 +258 @@
     case WM_ENABLE:
         dprintf(("OS2: WM_ENABLE %x", hwnd));
-        win32wnd->MsgEnable(SHORT1FROMMP(mp1));
         break;
 
     case WM_SHOW:
         dprintf(("OS2: WM_SHOW %x %d", hwnd, mp1));
-        win32wnd->MsgShow((ULONG)mp1);
-        break;
-
-    case WM_ADJUSTWINDOWPOS:
-    {
-      PSWP     pswp = (PSWP)mp1;
-      SWP      swpOld;
-      WINDOWPOS wp,wpOld;
-      HWND      hParent = NULLHANDLE, hwndAfter;
-
-        dprintf(("OS2: WM_ADJUSTWINDOWPOS %x %x %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), pswp->hwnd, pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-
-        if(pswp->fl & SWP_NOADJUST) {
-            //ignore weird messages (TODO: why are they sent?)
-            break;
-        }
-        //CB: show dialog in front of owner
-        if (win32wnd->IsModalDialogOwner())
-        {
-            dprintf(("win32wnd->IsModalDialogOwner %x", win32wnd->getWindowHandle()));
-            pswp->fl |= SWP_ZORDER;
-            pswp->hwndInsertBehind = win32wnd->getOS2HwndModalDialog();
-            if (pswp->fl & SWP_ACTIVATE)
-            {
-                pswp->fl &= ~SWP_ACTIVATE;
-                WinSetWindowPos(win32wnd->getOS2HwndModalDialog(),0,0,0,0,0,SWP_ACTIVATE);
-            }
-        }
-
-        if ((pswp->fl & (SWP_SIZE | SWP_MOVE | SWP_ZORDER)) == 0)
-            goto RunDefWndProc;
-
-        if(!win32wnd->CanReceiveSizeMsgs())
-            break;
-
-        WinQueryWindowPos(hwnd, &swpOld);
-        if(pswp->fl & (SWP_MOVE | SWP_SIZE)) {
-            if (win32wnd->isChild()) {
-                if(win32wnd->getParent()) {
-                        hParent = win32wnd->getParent()->getOS2WindowHandle();
-                }
-                else    goto RunDefWndProc;
-            }
-        }
-        hwndAfter = pswp->hwndInsertBehind;
-        if(win32wnd->getParent()) {
-            OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, win32wnd->getParent()->getWindowHeight(),
-                                   win32wnd->getParent()->getClientRectPtr()->left,
-                                   win32wnd->getParent()->getClientRectPtr()->top,
-                                   hwnd);
-        }
-        else OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, OSLibQueryScreenHeight(), 0, 0, hwnd);
-
-        wp.hwnd = win32wnd->getWindowHandle();
-        if ((pswp->fl & SWP_ZORDER) && (pswp->hwndInsertBehind > HWND_BOTTOM))
-        {
-           Win32BaseWindow *wndAfter = Win32BaseWindow::GetWindowFromOS2Handle(pswp->hwndInsertBehind);
-           if(wndAfter) {
-                wp.hwndInsertAfter = wndAfter->getWindowHandle();
-           }
-           else wp.hwndInsertAfter = HWND_TOP_W;
-        }
-
-        wpOld = wp;
-        win32wnd->MsgPosChanging((LPARAM)&wp);
-
-        if ((wp.hwndInsertAfter != wpOld.hwndInsertAfter) ||
-            (wp.x != wpOld.x) || (wp.y != wpOld.y) || (wp.cx != wpOld.cx) || (wp.cy != wpOld.cy) || (wp.flags != wpOld.flags))
-        {
-            ULONG flags = pswp->fl;      //make a backup copy; OSLibMapWINDOWPOStoSWP will modify it
-
-            dprintf(("OS2: WM_ADJUSTWINDOWPOS, app changed windowpos struct"));
-            dprintf(("%x (%d,%d), (%d,%d)", pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-
-            if(win32wnd->getParent()) {
-                  OSLibMapWINDOWPOStoSWP(&wp, pswp, &swpOld, win32wnd->getParent()->getWindowHeight(),
-                                         win32wnd->getParent()->getClientRectPtr()->left,
-                                         win32wnd->getParent()->getClientRectPtr()->top,
-                                         hwnd);
-            }
-            else  OSLibMapWINDOWPOStoSWP(&wp, pswp, &swpOld, OSLibQueryScreenHeight(), 0, 0, hwnd);
-
-            dprintf(("%x (%d,%d), (%d,%d)", pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-
-            //OSLibMapWINDOWPOStoSWP can add flags, but we must not let it remove flags!
-            if(pswp->fl & SWP_SIZE)
-                flags |= SWP_SIZE;
-
-            if(pswp->fl & SWP_MOVE)
-                flags |= SWP_MOVE;
-
-            pswp->fl = flags;   //restore flags
-
-            pswp->fl |= SWP_NOADJUST;
-            pswp->hwndInsertBehind = hwndAfter;
-            pswp->hwnd = hwnd;
-
-            return (MRESULT)0xf;
-        }
-        return (MRESULT)0;
-    }
-
-    case WM_WINDOWPOSCHANGED:
-    {
-      PSWP      pswp   = (PSWP)mp1,pswpOld = pswp+1;
-      SWP       swpOld = *(pswp + 1);
-      WINDOWPOS wp;
-      HWND      hParent = NULLHANDLE;
-      RECTL     rect;
-
-        dprintf(("OS2: WM_WINDOWPOSCHANGED (%x) %x %x (%d,%d) (%d,%d)", mp2, win32wnd->getWindowHandle(), pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-
-        if ((pswp->fl & (SWP_SIZE | SWP_MOVE | SWP_ZORDER)) == 0)
-        {
-            if(pswp->fl & SWP_ACTIVATE)
-            {
-                //Only send PM WM_ACTIVATE to top-level windows (frame windows)
-                if(!(WinQueryWindowULong(hwnd, OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE))
-                {
-                        WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)TRUE, (MPARAM)hwnd);
-                }
-            }
-            else
-            if(pswp->fl & SWP_DEACTIVATE)
-            {
-                //Only send PM WM_ACTIVATE to top-level windows (frame windows)
-                if(WinQueryWindowULong(hwnd, OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE)
-                {
-                        WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)FALSE, (MPARAM)hwnd);
-                }
-            }
-            goto RunDefWndProc;
-        }
-
-        if(pswp->fl & (SWP_MOVE | SWP_SIZE))
-        {
-            if(win32wnd->isChild())
-            {
-                if(win32wnd->getParent()) {
-                        hParent = win32wnd->getParent()->getOS2WindowHandle();
-                }
-                else    goto PosChangedEnd; //parent has just been destroyed
-            }
-        }
-
-
-        if(win32wnd->getParent()) {
-             OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, win32wnd->getParent()->getWindowHeight(),
-                                    win32wnd->getParent()->getClientRectPtr()->left,
-                                    win32wnd->getParent()->getClientRectPtr()->top,
-                                    hwnd);
-        }
-        else OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, OSLibQueryScreenHeight(), 0, 0, hwnd);
-
-        wp.hwnd = win32wnd->getWindowHandle();
-        if ((pswp->fl & SWP_ZORDER) && (pswp->hwndInsertBehind > HWND_BOTTOM))
-        {
-            Win32BaseWindow *wndAfter = Win32BaseWindow::GetWindowFromOS2Handle(pswp->hwndInsertBehind);
-            if(wndAfter) {
-                 wp.hwndInsertAfter = wndAfter->getWindowHandle();
-            }
-            else wp.hwndInsertAfter = HWND_TOP_W;
-        }
-
-#ifndef USE_CALCVALIDRECT
-        if((pswp->fl & (SWP_MOVE | SWP_SIZE)))
-        {
-            //CB: todo: use result for WM_CALCVALIDRECTS
-            //Get old client rectangle (for invalidation of frame window parts later on)
-            //Use new window height to calculate the client area
-            mapWin32ToOS2Rect(pswp->cy, win32wnd->getClientRectPtr(), (PRECTLOS2)&rect);
-
-            //Note: Also updates the new window rectangle
-            win32wnd->MsgFormatFrame(&wp);
-
-            if(win32wnd->isOwnDC()) {
-                dprintf(("Mark owndc of %x as dirty", win32wnd->getWindowHandle()));
-                win32wnd->invalidateOwnDC(); //mark DC as dirty. origin & visible region must be reinitialized
-            }
-            if(win32wnd->CanReceiveSizeMsgs())
-                win32wnd->MsgPosChanged((LPARAM)&wp);
-
-            if((pswp->fl & SWP_SIZE) && ((pswp->cx != pswpOld->cx) || (pswp->cy != pswpOld->cy)))
-            {
-                //redraw the frame (to prevent unnecessary client updates)
-                BOOL redrawAll = FALSE;
-
-                if (win32wnd->getWindowClass())
-                {
-                    DWORD dwStyle = win32wnd->getWindowClass()->getClassLongA(GCL_STYLE_W);
-
-                    if ((dwStyle & CS_HREDRAW_W) && (pswp->cx != pswpOld->cx))
-                        redrawAll = TRUE;
-                    else
-                    if ((dwStyle & CS_VREDRAW_W) && (pswp->cy != pswpOld->cy))
-                        redrawAll = TRUE;
-                }
-                else redrawAll = TRUE;
-
-                if(win32wnd->IsMixMaxStateChanging()) {
-                    dprintf(("WM_CALCVALIDRECT: window changed min/max/restore state, invalidate entire window"));
-                    redrawAll = TRUE;
-                }
-
-                if (redrawAll)
-                {
-                    //CB: redraw all children for now
-                    //    -> problems with update region if we don't do it
-                    //       todo: rewrite whole handling
-                    WinInvalidateRect(hwnd,NULL,TRUE);
-                }
-                else
-                {
-                    HPS hps = WinGetPS(hwnd);
-                    RECTL frame,client,arcl[4];
-
-                    WinQueryWindowRect(hwnd,&frame);
-
-                    //top
-                    arcl[0].xLeft = 0;
-                    arcl[0].xRight = frame.xRight;
-                    arcl[0].yBottom = rect.yTop;
-                    arcl[0].yTop = frame.yTop;
-                    //right
-                    arcl[1].xLeft = rect.xRight;
-                    arcl[1].xRight = frame.xRight;
-                    arcl[1].yBottom = 0;
-                    arcl[1].yTop = frame.yTop;
-                    //left
-                    arcl[2].xLeft = 0;
-                    arcl[2].xRight = rect.xLeft;
-                    arcl[2].yBottom = 0;
-                    arcl[2].yTop = frame.yTop;
-                    //bottom
-                    arcl[3].xLeft = 0;
-                    arcl[3].xRight = frame.xRight;
-                    arcl[3].yBottom = 0;
-                    arcl[3].yTop = rect.yBottom;
-
-                    HRGN hrgn = GpiCreateRegion(hps,4,(PRECTL)&arcl);
-
-                    WinInvalidateRegion(hwnd,hrgn,FALSE);
-                    GpiDestroyRegion(hps,hrgn);
-                    WinReleasePS(hps);
-                }
-            }
-        }
-        else
-        {
-#endif //USE_CALCVALIDRECT
-            if(win32wnd->CanReceiveSizeMsgs())
-                win32wnd->MsgPosChanged((LPARAM)&wp);
-#ifndef USE_CALCVALIDRECT
-        }
-#endif
-
-        if(pswp->fl & SWP_ACTIVATE)
-        {
-             //Only send PM WM_ACTIVATE to top-level windows (frame windows)
-             if(!(WinQueryWindowULong(hwnd, OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE))
-             {
-                WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)TRUE, (MPARAM)hwnd);
-             }
-        }
-        else
-        if(pswp->fl & SWP_DEACTIVATE)
-        {
-            //Only send PM WM_ACTIVATE to top-level windows (frame windows)
-            if(WinQueryWindowULong(hwnd, OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE)
-            {
-                    WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)FALSE, (MPARAM)hwnd);
-            }
-        }
-
-PosChangedEnd:
-        return (MRESULT)FALSE;
-    }
+        break;
 
     case WM_ACTIVATE:
@@ -568 +269 @@
 
         dprintf(("OS2: WM_ACTIVATE %x %x %x", hwnd, mp1, mp2));
-
         WinSetWindowULong(hwnd, OFFSET_WIN32FLAGS, SHORT1FROMMP(mp1) ? (flags | WINDOWFLAG_ACTIVE):(flags & ~WINDOWFLAG_ACTIVE));
         if(win32wnd->IsWindowCreated())
         {
             win32wnd->MsgActivate((LOWORD(pWinMsg->wParam) == WA_ACTIVE_W) ? 1 : 0, HIWORD(pWinMsg->wParam), pWinMsg->lParam, (HWND)mp2);
-
-            //CB: show owner behind the dialog
-            if(win32wnd->IsModalDialog())
-            {
-                Win32BaseWindow *topOwner = win32wnd->getOwner()->GetTopParent();
-
-                if(topOwner) WinSetWindowPos(topOwner->getOS2WindowHandle(),hwnd,0,0,0,0,SWP_ZORDER);
-            }
-        }
-        return 0;
+        }
+        break;
     }
 
     case WM_SIZE:
     {
-        dprintf(("OS2: WM_SIZE (%d,%d) (%d,%d)", SHORT1FROMMP(mp2), SHORT2FROMMP(mp2), SHORT1FROMMP(mp1), SHORT2FROMMP(mp2)));
+        dprintf(("OS2: WM_SIZE (%d,%d) (%d,%d)", SHORT1FROMMP(mp2), SHORT2FROMMP(mp2), SHORT1FROMMP(mp1), SHORT2FROMMP(mp1)));
+        win32wnd->SetVisibleRegionChanged(TRUE);
         goto RunDefWndProc;
     }
 
-    case WM_CALCVALIDRECTS:
-#ifdef USE_CALCVALIDRECT
-    {
-        PRECTL    oldRect = (PRECTL)mp1, newRect = oldRect+1;
-        PSWP      pswp = (PSWP)mp2;
-        SWP       swpOld;
-        WINDOWPOS wp;
-        RECTL     newClientRect, oldClientRect;
-        ULONG     nccalcret;
-//        UINT      res = CVR_ALIGNLEFT | CVR_ALIGNTOP;
-        UINT      res = 0;
-
-        dprintf(("PMWINDOW: WM_CALCVALIDRECTS %x", win32wnd->getWindowHandle()));
-
-        //Get old position info
-        WinQueryWindowPos(hwnd, &swpOld);
-
-        if(win32wnd->getParent()) {
-             OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, win32wnd->getParent()->getWindowHeight(),
-                                    win32wnd->getParent()->getClientRectPtr()->left,
-                                    win32wnd->getParent()->getClientRectPtr()->top,
-                                    hwnd);
-        }
-        else OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, OSLibQueryScreenHeight(), 0, 0, hwnd);
-
-        wp.hwnd = win32wnd->getWindowHandle();
-        if ((pswp->fl & SWP_ZORDER) && (pswp->hwndInsertBehind > HWND_BOTTOM))
-        {
-            Win32BaseWindow *wndAfter = Win32BaseWindow::GetWindowFromOS2Handle(pswp->hwndInsertBehind);
-            if(wndAfter) {
-                 wp.hwndInsertAfter = wndAfter->getWindowHandle();
-            }
-            else wp.hwndInsertAfter = HWND_TOP_W;
-        }
-
-        //Get old client rectangle
-        mapWin32ToOS2Rect(oldRect->yTop - oldRect->yBottom, win32wnd->getClientRectPtr(), (PRECTLOS2)&oldClientRect);
-
-        //Note: Also updates the new window rectangle
-        nccalcret = win32wnd->MsgFormatFrame(&wp);
-
-        //Get new client rectangle
-        mapWin32ToOS2Rect(pswp->cy, win32wnd->getClientRectPtr(), (PRECTLOS2)&newClientRect);
-
-        if(nccalcret == 0) {
-            res = CVR_ALIGNTOP | CVR_ALIGNLEFT;
-        }
-        else {
-            if(nccalcret & WVR_ALIGNTOP_W) {
-                res |= CVR_ALIGNTOP;
-            }
-            else
-            if(nccalcret & WVR_ALIGNBOTTOM_W) {
-                res |= CVR_ALIGNBOTTOM;
-            }
-
-            if(nccalcret & WVR_ALIGNLEFT_W) {
-                res |= CVR_ALIGNLEFT;
-            }
-            else
-            if(nccalcret & WVR_ALIGNRIGHT_W) {
-                res |= CVR_ALIGNRIGHT;
-            }
-
-            if(nccalcret & WVR_REDRAW_W) {//WVR_REDRAW_W = (WVR_HREDRAW | WVR_VREDRAW)
-                res |= CVR_REDRAW;
-            }
-            else
-            if(nccalcret & WVR_VALIDRECTS_W) {
-                //TODO:
-                //res = 0;
-            }
-        }
-        if(win32wnd->IsMixMaxStateChanging()) {
-            dprintf(("WM_CALCVALIDRECT: window changed min/max/restore state, invalidate entire window"));
-            res |= CVR_REDRAW;
-        }
-        if(res == (CVR_ALIGNTOP|CVR_ALIGNLEFT)) {
-            oldRect->xRight  -= oldClientRect.xLeft;
-            oldRect->yBottom += oldClientRect.yBottom;
-            newRect->xRight  -= newClientRect.xLeft;
-            newRect->yBottom += newClientRect.yBottom;
-        }
-
-#if 0
-            if((pswp->fl & SWP_SIZE) && ((pswp->cx != pswpOld->cx) || (pswp->cy != pswpOld->cy)))
-            {
-                //redraw the frame (to prevent unnecessary client updates)
-                BOOL redrawAll = FALSE;
-
-                if (win32wnd->getWindowClass())
-                {
-                    DWORD dwStyle = win32wnd->getWindowClass()->getClassLongA(GCL_STYLE_W);
-
-                    if ((dwStyle & CS_HREDRAW_W) && (pswp->cx != pswpOld->cx))
-                        redrawAll = TRUE;
-                    else
-                    if ((dwStyle & CS_VREDRAW_W) && (pswp->cy != pswpOld->cy))
-                        redrawAll = TRUE;
-                }
-                else redrawAll = TRUE;
-
-                if (redrawAll)
-                {
-                    //CB: redraw all children for now
-                    //    -> problems with update region if we don't do it
-                    //       todo: rewrite whole handling
-                    WinInvalidateRect(hwnd,NULL,TRUE);
-                }
-                else
-                {
-                    HPS hps = WinGetPS(hwnd);
-                    RECTL frame,client,arcl[4];
-
-                    WinQueryWindowRect(hwnd,&frame);
-
-                    //top
-                    arcl[0].xLeft = 0;
-                    arcl[0].xRight = frame.xRight;
-                    arcl[0].yBottom = rect.yTop;
-                    arcl[0].yTop = frame.yTop;
-                    //right
-                    arcl[1].xLeft = rect.xRight;
-                    arcl[1].xRight = frame.xRight;
-                    arcl[1].yBottom = 0;
-                    arcl[1].yTop = frame.yTop;
-                    //left
-                    arcl[2].xLeft = 0;
-                    arcl[2].xRight = rect.xLeft;
-                    arcl[2].yBottom = 0;
-                    arcl[2].yTop = frame.yTop;
-                    //bottom
-                    arcl[3].xLeft = 0;
-                    arcl[3].xRight = frame.xRight;
-                    arcl[3].yBottom = 0;
-                    arcl[3].yTop = rect.yBottom;
-
-                    HRGN hrgn = GpiCreateRegion(hps,4,(PRECTL)&arcl);
-
-                    WinInvalidateRegion(hwnd,hrgn,FALSE);
-                    GpiDestroyRegion(hps,hrgn);
-                    WinReleasePS(hps);
-                }
-            }
-
-        }
-#endif
-
-        return (MRESULT)res;
-    }
-#else
-      dprintf(("PMWINDOW: WM_CALCVALIDRECTS %x", win32wnd->getWindowHandle()));
-      return (MRESULT)(CVR_ALIGNLEFT | CVR_ALIGNTOP);
-#endif
 
     case WM_VRNENABLED:
@@ -750 +289 @@
         if(!win32wnd->isComingToTop() && ((win32wnd->getExStyle() & WS_EX_TOPMOST_W) == WS_EX_TOPMOST_W))
         {
-                HWND hwndrelated;
-                Win32BaseWindow *topwindow;
-
-                win32wnd->setComingToTop(TRUE);
-
-                hwndrelated = WinQueryWindow(hwnd, QW_PREV);
-                dprintf(("WM_VRNENABLED hwndrelated = %x (hwnd=%x)", hwndrelated, hwnd));
-                topwindow = Win32BaseWindow::GetWindowFromOS2Handle(hwndrelated);
-                if(topwindow == NULL || ((win32wnd->getExStyle() & WS_EX_TOPMOST_W) == 0)) {
-                        //put window at the top of z order
-                        WinSetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER );
-                }
-
-                win32wnd->setComingToTop(FALSE);
-                break;
-        }
-        //Restore window origin of window with CS_OWNDC style
-        //(fixes paint offset problems in Opera windows)
-        if(win32wnd->isOwnDC()) {
-                dprintfOrigin(win32wnd->getOwnDC());
-                selectClientArea(win32wnd, win32wnd->getOwnDC());
+            HWND hwndrelated;
+            Win32BaseWindow *topwindow;
+
+            win32wnd->setComingToTop(TRUE);
+
+            hwndrelated = WinQueryWindow(hwnd, QW_PREV);
+            dprintf(("WM_VRNENABLED hwndrelated = %x (hwnd=%x)", hwndrelated, hwnd));
+            topwindow = Win32BaseWindow::GetWindowFromOS2Handle(hwndrelated);
+            if(topwindow == NULL || ((win32wnd->getExStyle() & WS_EX_TOPMOST_W) == 0)) {
+                //put window at the top of z order
+                WinSetWindowPos( hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER );
+            }
+
+            win32wnd->setComingToTop(FALSE);
+            break;
         }
         goto RunDefWndProc;
@@ -776 +309 @@
     case WM_VRNDISABLED:
         dprintf(("OS2: WM_VRNDISABLED %x %x %x", win32wnd->getWindowHandle(), mp1, mp2));
-        if(win32wnd->isOwnDC()) {
-                dprintfOrigin(win32wnd->getOwnDC());
-        }
         goto RunDefWndProc;
 
@@ -808 +338 @@
     }
 
-#if 0
-    //is sent to both windows gaining and loosing the focus
-    case WM_FOCUSCHANGE:
-    {
-     HWND   hwndFocus = (HWND)mp1;
-     HWND   hwndLoseFocus, hwndGainFocus;
-     USHORT usSetFocus = SHORT1FROMMP(mp2);
-     USHORT fsFocusChange = SHORT2FROMMP(mp2);
-
-        rc = 0;
-        dprintf(("OS2: WM_FOCUSCHANGE (start) %x %x %x %x", win32wnd->getWindowHandle(), hwndFocus, usSetFocus, fsFocusChange));
-        if(usSetFocus) {
-            hwndGainFocus = hwnd;
-            hwndLoseFocus = hwndFocus;
-        }
-        else {
-            hwndGainFocus = hwndFocus;
-            hwndLoseFocus = hwnd;
-        }
-
-        if(usSetFocus)
-        {
-          Win32BaseWindow *winfocus = Win32BaseWindow::GetWindowFromOS2Handle(hwndLoseFocus);
-          if(!(fsFocusChange & FC_NOSETACTIVE))
-          {
-            if(!winfocus || (winfocus->GetTopParent() != win32wnd->GetTopParent()))
-            {
-              if(winfocus)
-                WinSendMsg(winfocus->GetTopParent()->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)0, (MPARAM)hwndGainFocus);
-              else
-                WinSendMsg(hwndLoseFocus, WM_ACTIVATE, (MPARAM)0, (MPARAM)hwndGainFocus);
-            }
-          }
-          //SvL: Check if window is still valid
-          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
-          if(win32wnd == NULL)
-            return (MRESULT)rc;
-
-          if(!(fsFocusChange & FC_NOSETACTIVE))
-          {
-            Win32BaseWindow *topparent = win32wnd->GetTopParent();
-            if(!winfocus || (winfocus->GetTopParent() != topparent))
-            {
-              if(!(fsFocusChange & FC_NOBRINGTOTOP))
-              {
-                if(topparent) {
-                  //put window at the top of z order
-                  WinSetWindowPos(topparent->getOS2WindowHandle(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER);
-                }
-              }
-
-              // PH 2000/09/01 Netscape 4.7
-              // check if topparent is valid
-              if (topparent)
-                WinSendMsg(topparent->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)1, (MPARAM)hwndLoseFocus);
-            }
-          }
-          //SvL: Check if window is still valid
-          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
-          if(win32wnd == NULL)
-            return (MRESULT)rc;
-
-      //TODO: Don't send WM_SETSELECTION to child window if frame already has selection
-      if(!(fsFocusChange & FC_NOSETSELECTION)) {
-            WinSendMsg(hwndGainFocus, WM_SETSELECTION, (MPARAM)1, (MPARAM)0);
-      }
-
-      if(!(fsFocusChange & FC_NOSETFOCUS)) {
-            WinSendMsg(hwndGainFocus, WM_SETFOCUS, (MPARAM)hwndLoseFocus, (MPARAM)1);
-      }
-        }
-        else /* no usSetFocus */
-        {
-      if(!(fsFocusChange & FC_NOLOSEFOCUS)) {
-            WinSendMsg(hwndLoseFocus, WM_SETFOCUS, (MPARAM)hwndGainFocus, (MPARAM)0);
-      }
-      //TODO: Don't send WM_SETSELECTION to child window if frame already has selection
-      if(!(fsFocusChange & FC_NOLOSESELECTION)) {
-            WinSendMsg(hwndLoseFocus, WM_SETSELECTION, (MPARAM)0, (MPARAM)0);
-      }
-          //SvL: Check if window is still valid
-          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
-          if(win32wnd == NULL) {
-                return (MRESULT)rc;
-          }
-
-          Win32BaseWindow *winfocus = Win32BaseWindow::GetWindowFromOS2Handle(hwndGainFocus);
-          if(!(fsFocusChange & FC_NOLOSEACTIVE))
-          {
-            Win32BaseWindow *topparent = win32wnd->GetTopParent();
-
-            if(!winfocus || (winfocus->GetTopParent() != topparent))
-            {
-              // PH 2000/09/01 Netscape 4.7
-              // check if topparent is valid
-              if (topparent)
-                WinSendMsg(topparent->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)0, (MPARAM)hwndGainFocus);
-            }
-          }
-          //SvL: Check if window is still valid
-          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
-          if(win32wnd == NULL)
-            return (MRESULT)rc;
-
-          if(!(fsFocusChange & FC_NOSETACTIVE))
-          {
-            if(!winfocus || (winfocus->GetTopParent() != win32wnd->GetTopParent()))
-            {
-              if(winfocus)
-              {
-                // PH 2000/09/01 Netscape 4.7
-                // check if topparent is valid
-                Win32BaseWindow *topparent = winfocus->GetTopParent();
-                if (topparent)
-                  WinSendMsg(topparent->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)1, (MPARAM)hwndLoseFocus);
-              }
-              else
-                WinSendMsg(hwndGainFocus, WM_ACTIVATE, (MPARAM)1, (MPARAM)hwndLoseFocus);
-            }
-          }
-        }
-
-
-#ifdef DEBUG
-        SetWin32TIB();
-        dprintf(("OS2: WM_FOCUSCHANGE (end) %x %x %x", win32wnd->getWindowHandle(), mp1, mp2));
-#endif
-        return (MRESULT)rc;
-    }
-#endif
-
     //**************************************************************************
     //Mouse messages (OS/2 Window coordinates -> Win32 coordinates relative to screen
     //**************************************************************************
-#ifndef ODIN_HITTEST
-    case WM_HITTEST:
-    {
-        if(win32wnd->getWindowHandle() != pWinMsg->hwnd) {
-            win32wnd = Win32BaseWindow::GetWindowFromHandle(pWinMsg->hwnd);
-        }
-        if(win32wnd && win32wnd->IsWindowCreated())
-        {
-            MRESULT rc;
-
-            rc = (MRESULT)win32wnd->MsgHitTest(pWinMsg);
-            return rc;
-        }
-        return (MRESULT)HT_NORMAL;
-    }
-#endif
 
     case WM_BUTTON1DOWN:
@@ -991 +374 @@
     case WM_MOUSEMOVE:
     {
-    if(win32wnd->getWindowHandle() != pWinMsg->hwnd) {
-        win32wnd = Win32BaseWindow::GetWindowFromHandle(pWinMsg->hwnd);
-    }
+        if(win32wnd->getWindowHandle() != pWinMsg->hwnd) {
+            win32wnd = Win32BaseWindow::GetWindowFromHandle(pWinMsg->hwnd);
+        }
         if(win32wnd)
             win32wnd->MsgMouseMove(pWinMsg);
@@ -1068 +451 @@
            rectl.yBottom != rectl.yTop))
         {
-            PRECT pClient = win32wnd->getClientRectPtr();
-            PRECT pWindow = win32wnd->getWindowRect();
-
-            if(!(pClient->left == 0 && pClient->top == 0 &&
-               win32wnd->getClientHeight() == win32wnd->getWindowHeight() &&
-               win32wnd->getClientWidth()  == win32wnd->getWindowWidth()))
-            {
-                win32wnd->MsgNCPaint();
-            }
-            win32wnd->DispatchMsgA(pWinMsg);
+                win32wnd->DispatchMsgA(pWinMsg);
         }
         else    goto RunDefWndProc;
-
-        //SvL: Not calling the default window procedure causes all sorts of
-        //     strange problems (redraw & hanging app)
-        //     -> check what WinBeginPaint does what we're forgetting in BeginPaint
-//      WinQueryUpdateRect(hwnd, &rectl);
-//        if(rectl.xLeft == 0 && rectl.yTop == 0 && rectl.xRight == 0 && rectl.yBottom == 0) {
-//          RestoreOS2TIB();
-//          return (MRESULT)FALSE;
-//  }
-//  dprintf(("Update rectangle (%d,%d)(%d,%d) not empty, msg %x", rectl.xLeft, rectl.yTop, rectl.xRight, rectl.yBottom, pWinMsg->message));
-//  goto RunDefWndProc;
         break;
     }
@@ -1100 +463 @@
     }
 
-#if 0
-    case WM_CONTEXTMENU:
-    {
-        win32wnd->DispatchMsgA(pWinMsg);
-
-        return (MRESULT)TRUE;
-    }
-#endif
-
-    case WM_QUERYTRACKINFO:
-    {
-      PTRACKINFO trackInfo = (PTRACKINFO)mp2;
-
-        dprintf(("OS2: WM_QUERYTRACKINFO %x", win32wnd->getWindowHandle()));
-        trackInfo->cxBorder = 4;
-        trackInfo->cyBorder = 4;
-        win32wnd->AdjustTrackInfo((PPOINT)&trackInfo->ptlMinTrackSize,(PPOINT)&trackInfo->ptlMaxTrackSize);
-        return (MRESULT)TRUE;
-    }
-
-    case WM_QUERYBORDERSIZE:
-    {
-      PWPOINT size = (PWPOINT)mp1;
-
-      dprintf(("OS2: WM_QUERYBORDERSIZE %x", win32wnd->getWindowHandle()));
-
-      size->x = 0;
-      size->y = 0;
-      return (MRESULT)TRUE;
-    }
+    case WM_CALCVALIDRECTS:
+      dprintf(("OS2: WM_CALCVALIDRECTS %x", win32wnd->getWindowHandle()));
+      return (MRESULT)(CVR_ALIGNLEFT | CVR_ALIGNTOP);
 
     case WM_REALIZEPALETTE:
@@ -1163 +499 @@
     default:
         dprintf2(("OS2: RunDefWndProc hwnd %x msg %x mp1 %x mp2 %x", hwnd, msg, mp1, mp2));
-        RestoreOS2TIB();
-        if(isFrame) {
-             return pfnFrameWndProc(hwnd, msg, mp1, mp2);
-        }
-        else return WinDefWindowProc( hwnd, msg, mp1, mp2 );
-  }
-  return (MRESULT)rc;
+        goto RunDefWndProc;
+    }
+    return (MRESULT)rc;
 
 RunDefWndProc:
 //  dprintf(("OS2: RunDefWndProc msg %x for %x", msg, hwnd));
-  RestoreOS2TIB();
-  if(isFrame) {
-       return pfnFrameWndProc(hwnd, msg, mp1, mp2);
-  }
-  else return WinDefWindowProc( hwnd, msg, mp1, mp2 );
+    RestoreOS2TIB();
+    return WinDefWindowProc( hwnd, msg, mp1, mp2 );
 } /* End of Win32WindowProc */
 //******************************************************************************
@@ -1195 +524 @@
     //NOTE-------------->>>>>> If this is changed, also change Win32WindowProc!! <<<<<<<<<<<-------------------- BEGIN
     teb = GetThreadTEB();
-    win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
+    win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwnd);
 
     if(!teb || (msg != WM_CREATE && win32wnd == NULL)) {
-        dprintf(("Invalid win32wnd pointer for window %x msg %x", hwnd, msg));
+        dprintf(("PMFRAME: Invalid win32wnd pointer for window %x msg %x", hwnd, msg));
         goto RunDefFrameWndProc;
     }
@@ -1233 +562 @@
     case WM_CREATE:
     {
-        RestoreOS2TIB();
-        pfnFrameWndProc(hwnd, msg, mp1, mp2);
-        SetWin32TIB();
-        rc = ProcessPMMessage(hwnd, msg, mp1, mp2, win32wnd, pWinMsg, teb, TRUE);
-        break;
-    }
+        //WM_CREATE handled during client window creation
+        goto RunDefFrameWndProc;
+    }
+
+    case WM_PAINT:
+    {
+      RECTL rectl;
+
+
+        HPS hps = WinBeginPaint(hwnd, NULL, &rectl);
+        dprintf(("PMFRAME: WM_PAINT %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), rectl.xLeft, rectl.yBottom, rectl.xRight, rectl.yTop));
+
+        if(win32wnd->IsWindowCreated() && (rectl.xLeft != rectl.xRight &&
+           rectl.yBottom != rectl.yTop))
+        {
+            PRECT pClient = win32wnd->getClientRectPtr();
+            PRECT pWindow = win32wnd->getWindowRect();
+
+            if(!(pClient->left == 0 && pClient->top == 0 &&
+               win32wnd->getClientHeight() == win32wnd->getWindowHeight() &&
+               win32wnd->getClientWidth()  == win32wnd->getWindowWidth()))
+            {
+                RECT rectUpdate;
+
+                mapOS2ToWin32Rect(win32wnd->getWindowHeight(), (PRECTLOS2)&rectl, &rectUpdate);
+                win32wnd->MsgNCPaint(&rectUpdate);
+            }
+        }
+        WinEndPaint(hps);
+        break;
+    }
+
+    case WM_ERASEBACKGROUND:
+    {
+        dprintf(("PMFRAME:WM_ERASEBACKGROUND %x", win32wnd->getWindowHandle()));
+        return (MRESULT)FALSE;
+    }
+
+    //**************************************************************************
+    //Mouse messages (OS/2 Window coordinates -> Win32 coordinates relative to screen
+    //**************************************************************************
+
+    case WM_BUTTON1DOWN:
+    case WM_BUTTON1UP:
+    case WM_BUTTON1DBLCLK:
+    case WM_BUTTON2DOWN:
+    case WM_BUTTON2UP:
+    case WM_BUTTON2DBLCLK:
+    case WM_BUTTON3DOWN:
+    case WM_BUTTON3UP:
+    case WM_BUTTON3DBLCLK:
+        if(win32wnd->getWindowHandle() != pWinMsg->hwnd) {
+            win32wnd = Win32BaseWindow::GetWindowFromHandle(pWinMsg->hwnd);
+        }
+        if(win32wnd)
+            win32wnd->MsgButton(pWinMsg);
+
+        rc = (MRESULT)TRUE;
+        break;
+
+    case WM_BUTTON2MOTIONSTART:
+    case WM_BUTTON2MOTIONEND:
+    case WM_BUTTON2CLICK:
+    case WM_BUTTON1MOTIONSTART:
+    case WM_BUTTON1MOTIONEND:
+    case WM_BUTTON1CLICK:
+    case WM_BUTTON3MOTIONSTART:
+    case WM_BUTTON3MOTIONEND:
+    case WM_BUTTON3CLICK:
+        rc = (MRESULT)TRUE;
+        break;
+
+    case WM_MOUSEMOVE:
+    {
+        if(win32wnd->getWindowHandle() != pWinMsg->hwnd) {
+            win32wnd = Win32BaseWindow::GetWindowFromHandle(pWinMsg->hwnd);
+        }
+        if(win32wnd)
+            win32wnd->MsgMouseMove(pWinMsg);
+        break;
+    }
+
+    case WM_ADJUSTWINDOWPOS:
+    {
+      PSWP     pswp = (PSWP)mp1;
+      SWP      swpOld;
+      WINDOWPOS wp,wpOld;
+      HWND      hParent = NULLHANDLE, hwndAfter;
+
+        dprintf(("PMFRAME:WM_ADJUSTWINDOWPOS %x %x %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), pswp->hwnd, pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
+
+        if(pswp->fl & SWP_NOADJUST) {
+            //ignore weird messages (TODO: why are they sent?)
+            break;
+        }
+        //CB: show dialog in front of owner
+        if (win32wnd->IsModalDialogOwner())
+        {
+            dprintf(("win32wnd->IsModalDialogOwner %x", win32wnd->getWindowHandle()));
+            pswp->fl |= SWP_ZORDER;
+            pswp->hwndInsertBehind = win32wnd->getOS2HwndModalDialog();
+            if (pswp->fl & SWP_ACTIVATE)
+            {
+                pswp->fl &= ~SWP_ACTIVATE;
+                WinSetWindowPos(win32wnd->getOS2HwndModalDialog(),0,0,0,0,0,SWP_ACTIVATE);
+            }
+        }
+
+        if ((pswp->fl & (SWP_SIZE | SWP_MOVE | SWP_ZORDER)) == 0)
+            goto RunDefWndProc;
+
+        if(!win32wnd->CanReceiveSizeMsgs())
+            break;
+
+        WinQueryWindowPos(hwnd, &swpOld);
+        if(pswp->fl & (SWP_MOVE | SWP_SIZE)) {
+            if (win32wnd->isChild()) {
+                if(win32wnd->getParent()) {
+                        hParent = win32wnd->getParent()->getOS2WindowHandle();
+                }
+                else    goto RunDefWndProc;
+            }
+        }
+        hwndAfter = pswp->hwndInsertBehind;
+        if(win32wnd->getParent()) {
+             OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, win32wnd->getParent()->getClientHeight(), hwnd);
+        }
+        else OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, OSLibQueryScreenHeight(), hwnd);
+
+        wp.hwnd = win32wnd->getWindowHandle();
+        if ((pswp->fl & SWP_ZORDER) && (pswp->hwndInsertBehind > HWND_BOTTOM))
+        {
+           Win32BaseWindow *wndAfter = Win32BaseWindow::GetWindowFromOS2Handle(pswp->hwndInsertBehind);
+           if(wndAfter) {
+                wp.hwndInsertAfter = wndAfter->getWindowHandle();
+           }
+           else wp.hwndInsertAfter = HWND_TOP_W;
+        }
+
+        wpOld = wp;
+        win32wnd->MsgPosChanging((LPARAM)&wp);
+
+        if ((wp.hwndInsertAfter != wpOld.hwndInsertAfter) ||
+            (wp.x != wpOld.x) || (wp.y != wpOld.y) || (wp.cx != wpOld.cx) || (wp.cy != wpOld.cy) || (wp.flags != wpOld.flags))
+        {
+            ULONG flags = pswp->fl;      //make a backup copy; OSLibMapWINDOWPOStoSWP will modify it
+
+            dprintf(("PMFRAME:WM_ADJUSTWINDOWPOS, app changed windowpos struct"));
+            dprintf(("%x (%d,%d), (%d,%d)", pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
+
+            if(win32wnd->getParent()) {
+                  OSLibMapWINDOWPOStoSWP(&wp, pswp, &swpOld, win32wnd->getParent()->getClientHeight(),
+                                         hwnd);
+            }
+            else  OSLibMapWINDOWPOStoSWP(&wp, pswp, &swpOld, OSLibQueryScreenHeight(), hwnd);
+
+            dprintf(("%x (%d,%d), (%d,%d)", pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
+
+            //OSLibMapWINDOWPOStoSWP can add flags, but we must not let it remove flags!
+            if(pswp->fl & SWP_SIZE)
+                flags |= SWP_SIZE;
+
+            if(pswp->fl & SWP_MOVE)
+                flags |= SWP_MOVE;
+
+            pswp->fl = flags;   //restore flags
+
+            pswp->fl |= SWP_NOADJUST;
+            pswp->hwndInsertBehind = hwndAfter;
+            pswp->hwnd = hwnd;
+
+            return (MRESULT)0xf;
+        }
+        return (MRESULT)0;
+    }
+
+    case WM_WINDOWPOSCHANGED:
+    {
+      PSWP      pswp   = (PSWP)mp1,pswpOld = pswp+1;
+      SWP       swpOld = *(pswp + 1);
+      WINDOWPOS wp;
+      HWND      hParent = NULLHANDLE;
+      RECTL     rect;
+
+        dprintf(("PMFRAME:WM_WINDOWPOSCHANGED (%x) %x %x (%d,%d) (%d,%d)", mp2, win32wnd->getWindowHandle(), pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
+
+        if ((pswp->fl & (SWP_SIZE | SWP_MOVE | SWP_ZORDER)) == 0)
+        {
+            if(pswp->fl & SWP_ACTIVATE)
+            {
+                //Only send PM WM_ACTIVATE to top-level windows (frame windows)
+                if(!(WinQueryWindowULong(WinWindowFromID(hwnd,FID_CLIENT), OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE))
+                {
+                    WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)TRUE, (MPARAM)hwnd);
+                }
+            }
+            else
+            if(pswp->fl & SWP_DEACTIVATE)
+            {
+                //Only send PM WM_ACTIVATE to top-level windows (frame windows)
+                if(WinQueryWindowULong(WinWindowFromID(hwnd,FID_CLIENT), OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE)
+                {
+                    WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)FALSE, (MPARAM)hwnd);
+                }
+            }
+            goto RunDefWndProc;
+        }
+
+        if(pswp->fl & (SWP_MOVE | SWP_SIZE))
+        {
+            if(win32wnd->isChild())
+            {
+                if(win32wnd->getParent()) {
+                        hParent = win32wnd->getParent()->getOS2WindowHandle();
+                }
+                else    goto PosChangedEnd; //parent has just been destroyed
+            }
+        }
+
+
+        if(win32wnd->getParent()) {
+             OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, win32wnd->getParent()->getClientHeight(),
+                                    hwnd);
+        }
+        else OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, OSLibQueryScreenHeight(), hwnd);
+
+        wp.hwnd = win32wnd->getWindowHandle();
+        if ((pswp->fl & SWP_ZORDER) && (pswp->hwndInsertBehind > HWND_BOTTOM))
+        {
+            Win32BaseWindow *wndAfter = Win32BaseWindow::GetWindowFromOS2Handle(pswp->hwndInsertBehind);
+            if(wndAfter) {
+                 wp.hwndInsertAfter = wndAfter->getWindowHandle();
+            }
+            else wp.hwndInsertAfter = HWND_TOP_W;
+        }
+
+        if(pswp->fl & SWP_SHOW) {
+            WinShowWindow(win32wnd->getOS2WindowHandle(), 1);
+        }
+#ifndef USE_CALCVALIDRECT
+        if((pswp->fl & (SWP_MOVE | SWP_SIZE)))
+        {
+            //CB: todo: use result for WM_CALCVALIDRECTS
+            //Get old client rectangle (for invalidation of frame window parts later on)
+            //Use new window height to calculate the client area
+            mapWin32ToOS2Rect(pswp->cy, win32wnd->getClientRectPtr(), (PRECTLOS2)&rect);
+
+            //Note: Also updates the new window rectangle
+            win32wnd->MsgFormatFrame(&wp);
+
+            if(win32wnd->isOwnDC()) {
+                setPageXForm(win32wnd, (pDCData)GpiQueryDCData(win32wnd->getOwnDC()));
+            }
+
+            if(win32wnd->CanReceiveSizeMsgs())
+                win32wnd->MsgPosChanged((LPARAM)&wp);
+
+            if((pswp->fl & SWP_SIZE) && ((pswp->cx != pswpOld->cx) || (pswp->cy != pswpOld->cy)))
+            {
+                //redraw the frame (to prevent unnecessary client updates)
+                BOOL redrawAll = FALSE;
+
+                dprintf2(("WM_WINDOWPOSCHANGED: redraw frame"));
+                if (win32wnd->getWindowClass())
+                {
+                    DWORD dwStyle = win32wnd->getWindowClass()->getClassLongA(GCL_STYLE_W);
+
+                    if ((dwStyle & CS_HREDRAW_W) && (pswp->cx != pswpOld->cx))
+                        redrawAll = TRUE;
+                    else
+                    if ((dwStyle & CS_VREDRAW_W) && (pswp->cy != pswpOld->cy))
+                        redrawAll = TRUE;
+                }
+                else redrawAll = TRUE;
+
+                if(win32wnd->IsMixMaxStateChanging()) {
+                    dprintf(("WM_CALCVALIDRECT: window changed min/max/restore state, invalidate entire window"));
+                    redrawAll = TRUE;
+                }
+
+                if (redrawAll)
+                {
+                    //CB: redraw all children for now
+                    //    -> problems with update region if we don't do it
+                    //       todo: rewrite whole handling
+                    WinInvalidateRect(hwnd,NULL,TRUE);
+                }
+                else
+                {
+                    HPS hps = WinGetPS(hwnd);
+                    RECTL frame,client,arcl[4];
+
+                    WinQueryWindowRect(hwnd,&frame);
+
+                    //top
+                    arcl[0].xLeft = 0;
+                    arcl[0].xRight = frame.xRight;
+                    arcl[0].yBottom = rect.yTop;
+                    arcl[0].yTop = frame.yTop;
+                    //right
+                    arcl[1].xLeft = rect.xRight;
+                    arcl[1].xRight = frame.xRight;
+                    arcl[1].yBottom = 0;
+                    arcl[1].yTop = frame.yTop;
+                    //left
+                    arcl[2].xLeft = 0;
+                    arcl[2].xRight = rect.xLeft;
+                    arcl[2].yBottom = 0;
+                    arcl[2].yTop = frame.yTop;
+                    //bottom
+                    arcl[3].xLeft = 0;
+                    arcl[3].xRight = frame.xRight;
+                    arcl[3].yBottom = 0;
+                    arcl[3].yTop = rect.yBottom;
+
+                    HRGN hrgn = GpiCreateRegion(hps,4,(PRECTL)&arcl);
+
+                    WinInvalidateRegion(hwnd,hrgn,FALSE);
+                    GpiDestroyRegion(hps,hrgn);
+                    WinReleasePS(hps);
+                }
+            }
+        }
+        else
+        {
+#endif //USE_CALCVALIDRECT
+            if(win32wnd->CanReceiveSizeMsgs())
+                win32wnd->MsgPosChanged((LPARAM)&wp);
+#ifndef USE_CALCVALIDRECT
+        }
+#endif
+
+        if(pswp->fl & SWP_ACTIVATE)
+        {
+             //Only send PM WM_ACTIVATE to top-level windows (frame windows)
+             if(!(WinQueryWindowULong(WinWindowFromID(hwnd,FID_CLIENT), OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE))
+             {
+                WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)TRUE, (MPARAM)hwnd);
+             }
+        }
+        else
+        if(pswp->fl & SWP_DEACTIVATE)
+        {
+            //Only send PM WM_ACTIVATE to top-level windows (frame windows)
+            if(WinQueryWindowULong(WinWindowFromID(hwnd,FID_CLIENT), OFFSET_WIN32FLAGS) & WINDOWFLAG_ACTIVE)
+            {
+                    WinSendMsg(hwnd, WM_ACTIVATE, (MPARAM)FALSE, (MPARAM)hwnd);
+            }
+        }
+
+PosChangedEnd:
+        return (MRESULT)FALSE;
+    }
+
+    case WM_CALCVALIDRECTS:
+#ifdef USE_CALCVALIDRECT
+    {
+        PRECTL    oldRect = (PRECTL)mp1, newRect = oldRect+1;
+        PSWP      pswp = (PSWP)mp2;
+        SWP       swpOld;
+        WINDOWPOS wp;
+        RECTL     newClientRect, oldClientRect;
+        ULONG     nccalcret;
+//        UINT      res = CVR_ALIGNLEFT | CVR_ALIGNTOP;
+        UINT      res = 0;
+
+        dprintf(("PMWINDOW: WM_CALCVALIDRECTS %x", win32wnd->getWindowHandle()));
+
+        //Get old position info
+        WinQueryWindowPos(hwnd, &swpOld);
+
+        if(win32wnd->getParent()) {
+             OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, win32wnd->getParent()->getClientHeight(),
+                                    win32wnd->getParent()->getClientRectPtr()->left,
+                                    win32wnd->getParent()->getClientRectPtr()->top,
+                                    hwnd);
+        }
+        else OSLibMapSWPtoWINDOWPOS(pswp, &wp, &swpOld, OSLibQueryScreenHeight(), 0, 0, hwnd);
+
+        wp.hwnd = win32wnd->getWindowHandle();
+        if ((pswp->fl & SWP_ZORDER) && (pswp->hwndInsertBehind > HWND_BOTTOM))
+        {
+            Win32BaseWindow *wndAfter = Win32BaseWindow::GetWindowFromOS2Handle(pswp->hwndInsertBehind);
+            if(wndAfter) {
+                 wp.hwndInsertAfter = wndAfter->getWindowHandle();
+            }
+            else wp.hwndInsertAfter = HWND_TOP_W;
+        }
+
+        //Get old client rectangle
+        mapWin32ToOS2Rect(oldRect->yTop - oldRect->yBottom, win32wnd->getClientRectPtr(), (PRECTLOS2)&oldClientRect);
+
+        //Note: Also updates the new window rectangle
+        nccalcret = win32wnd->MsgFormatFrame(&wp);
+
+        //Get new client rectangle
+        mapWin32ToOS2Rect(pswp->cy, win32wnd->getClientRectPtr(), (PRECTLOS2)&newClientRect);
+
+        if(nccalcret == 0) {
+            res = CVR_ALIGNTOP | CVR_ALIGNLEFT;
+        }
+        else {
+            if(nccalcret & WVR_ALIGNTOP_W) {
+                res |= CVR_ALIGNTOP;
+            }
+            else
+            if(nccalcret & WVR_ALIGNBOTTOM_W) {
+                res |= CVR_ALIGNBOTTOM;
+            }
+
+            if(nccalcret & WVR_ALIGNLEFT_W) {
+                res |= CVR_ALIGNLEFT;
+            }
+            else
+            if(nccalcret & WVR_ALIGNRIGHT_W) {
+                res |= CVR_ALIGNRIGHT;
+            }
+
+            if(nccalcret & WVR_REDRAW_W) {//WVR_REDRAW_W = (WVR_HREDRAW | WVR_VREDRAW)
+                res |= CVR_REDRAW;
+            }
+            else
+            if(nccalcret & WVR_VALIDRECTS_W) {
+                //TODO:
+                //res = 0;
+            }
+        }
+        if(win32wnd->IsMixMaxStateChanging()) {
+            dprintf(("WM_CALCVALIDRECT: window changed min/max/restore state, invalidate entire window"));
+            res |= CVR_REDRAW;
+        }
+        if(res == (CVR_ALIGNTOP|CVR_ALIGNLEFT)) {
+            oldRect->xRight  -= oldClientRect.xLeft;
+            oldRect->yBottom += oldClientRect.yBottom;
+            newRect->xRight  -= newClientRect.xLeft;
+            newRect->yBottom += newClientRect.yBottom;
+        }
+        return (MRESULT)res;
+    }
+#else
+        dprintf(("PMWINDOW: WM_CALCVALIDRECTS %x", win32wnd->getWindowHandle()));
+        return (MRESULT)(CVR_ALIGNLEFT | CVR_ALIGNTOP);
+#endif
 
     case WM_CALCFRAMERECT:
-        dprintf(("OS2: WM_CALCFRAMERECT %x", win32wnd->getWindowHandle()));
+        dprintf(("PMFRAME:WM_CALCFRAMERECT %x", win32wnd->getWindowHandle()));
         rc = (MRESULT)TRUE;
         break;
@@ -1247 +1013 @@
     case WM_QUERYCTLTYPE:
         // This is a frame window
-        dprintf(("OS2: WM_QUERYCTLTYPE %x", win32wnd->getWindowHandle()));
+        dprintf(("PMFRAME:WM_QUERYCTLTYPE %x", win32wnd->getWindowHandle()));
         rc = (MRESULT)CCT_FRAME;
         break;
 
+#ifdef DEBUG
     case WM_QUERYFOCUSCHAIN:
-        dprintf(("OS2: WM_QUERYFOCUSCHAIN %x fsCmd %x parent %x", win32wnd->getWindowHandle(), SHORT1FROMMP(mp1), mp2));
-        
-        RestoreOS2TIB();
-        rc = pfnFrameWndProc(hwnd, msg, mp1, mp2);
-        SetWin32TIB();
-        dprintf(("OS2: WM_QUERYFOCUSCHAIN %x fsCmd %x parent %x returned %x", win32wnd->getWindowHandle(), SHORT1FROMMP(mp1), mp2, rc));
-        break;
-
+        dprintf(("PMFRAME:WM_QUERYFOCUSCHAIN %x fsCmd %x parent %x", win32wnd->getWindowHandle(), SHORT1FROMMP(mp1), mp2));
+
+//        RestoreOS2TIB();
+//        rc = pfnFrameWndProc(hwnd, msg, mp1, mp2);
+//        SetWin32TIB();
+//        dprintf(("PMFRAME:WM_QUERYFOCUSCHAIN %x fsCmd %x parent %x returned %x", win32wnd->getWindowHandle(), SHORT1FROMMP(mp1), mp2, rc));
+//        break;
+        goto RunDefFrameWndProc;
+#endif
+
+#if 0
+    //is sent to both windows gaining and loosing the focus
+    case WM_FOCUSCHANGE:
+    {
+     HWND   hwndFocus = (HWND)mp1;
+     HWND   hwndLoseFocus, hwndGainFocus;
+     USHORT usSetFocus = SHORT1FROMMP(mp2);
+     USHORT fsFocusChange = SHORT2FROMMP(mp2);
+
+        rc = 0;
+        dprintf(("PMFRAME:WM_FOCUSCHANGE (start) %x %x %x %x", win32wnd->getWindowHandle(), hwndFocus, usSetFocus, fsFocusChange));
+        if(usSetFocus) {
+            hwndGainFocus = hwnd;
+            hwndLoseFocus = hwndFocus;
+        }
+        else {
+            hwndGainFocus = hwndFocus;
+            hwndLoseFocus = hwnd;
+        }
+
+        if(usSetFocus)
+        {
+          Win32BaseWindow *winfocus = Win32BaseWindow::GetWindowFromOS2Handle(hwndLoseFocus);
+          if(!(fsFocusChange & FC_NOSETACTIVE))
+          {
+            if(!winfocus || (winfocus->GetTopParent() != win32wnd->GetTopParent()))
+            {
+              if(winfocus)
+                WinSendMsg(winfocus->GetTopParent()->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)0, (MPARAM)hwndGainFocus);
+              else
+                WinSendMsg(hwndLoseFocus, WM_ACTIVATE, (MPARAM)0, (MPARAM)hwndGainFocus);
+            }
+          }
+          //SvL: Check if window is still valid
+          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
+          if(win32wnd == NULL)
+            return (MRESULT)rc;
+
+          if(!(fsFocusChange & FC_NOSETACTIVE))
+          {
+            Win32BaseWindow *topparent = win32wnd->GetTopParent();
+            if(!winfocus || (winfocus->GetTopParent() != topparent))
+            {
+              if(!(fsFocusChange & FC_NOBRINGTOTOP))
+              {
+                if(topparent) {
+                  //put window at the top of z order
+                  WinSetWindowPos(topparent->getOS2WindowHandle(), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER);
+                }
+              }
+
+              // PH 2000/09/01 Netscape 4.7
+              // check if topparent is valid
+              if (topparent)
+                WinSendMsg(topparent->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)1, (MPARAM)hwndLoseFocus);
+            }
+          }
+          //SvL: Check if window is still valid
+          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
+          if(win32wnd == NULL)
+            return (MRESULT)rc;
+
+      //TODO: Don't send WM_SETSELECTION to child window if frame already has selection
+      if(!(fsFocusChange & FC_NOSETSELECTION)) {
+            WinSendMsg(hwndGainFocus, WM_SETSELECTION, (MPARAM)1, (MPARAM)0);
+      }
+
+      if(!(fsFocusChange & FC_NOSETFOCUS)) {
+            WinSendMsg(hwndGainFocus, WM_SETFOCUS, (MPARAM)hwndLoseFocus, (MPARAM)1);
+      }
+        }
+        else /* no usSetFocus */
+        {
+      if(!(fsFocusChange & FC_NOLOSEFOCUS)) {
+            WinSendMsg(hwndLoseFocus, WM_SETFOCUS, (MPARAM)hwndGainFocus, (MPARAM)0);
+      }
+      //TODO: Don't send WM_SETSELECTION to child window if frame already has selection
+      if(!(fsFocusChange & FC_NOLOSESELECTION)) {
+            WinSendMsg(hwndLoseFocus, WM_SETSELECTION, (MPARAM)0, (MPARAM)0);
+      }
+          //SvL: Check if window is still valid
+          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
+          if(win32wnd == NULL) {
+                return (MRESULT)rc;
+          }
+
+          Win32BaseWindow *winfocus = Win32BaseWindow::GetWindowFromOS2Handle(hwndGainFocus);
+          if(!(fsFocusChange & FC_NOLOSEACTIVE))
+          {
+            Win32BaseWindow *topparent = win32wnd->GetTopParent();
+
+            if(!winfocus || (winfocus->GetTopParent() != topparent))
+            {
+              // PH 2000/09/01 Netscape 4.7
+              // check if topparent is valid
+              if (topparent)
+                WinSendMsg(topparent->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)0, (MPARAM)hwndGainFocus);
+            }
+          }
+          //SvL: Check if window is still valid
+          win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(hwnd);
+          if(win32wnd == NULL)
+            return (MRESULT)rc;
+
+          if(!(fsFocusChange & FC_NOSETACTIVE))
+          {
+            if(!winfocus || (winfocus->GetTopParent() != win32wnd->GetTopParent()))
+            {
+              if(winfocus)
+              {
+                // PH 2000/09/01 Netscape 4.7
+                // check if topparent is valid
+                Win32BaseWindow *topparent = winfocus->GetTopParent();
+                if (topparent)
+                  WinSendMsg(topparent->getOS2WindowHandle(), WM_ACTIVATE, (MPARAM)1, (MPARAM)hwndLoseFocus);
+              }
+              else
+                WinSendMsg(hwndGainFocus, WM_ACTIVATE, (MPARAM)1, (MPARAM)hwndLoseFocus);
+            }
+          }
+        }
+
+
+#ifdef DEBUG
+        dprintf(("PMFRAME:WM_FOCUSCHANGE (end) %x %x %x", win32wnd->getWindowHandle(), mp1, mp2));
+#endif
+        return (MRESULT)rc;
+    }
+#endif
+
+#ifdef DEBUG
     case WM_FOCUSCHANGE:
     {
@@ -1267 +1167 @@
         USHORT fsFocusChange = SHORT2FROMMP(mp2);
 
-        dprintf(("OS2: WM_FOCUSCHANGE %x %x %x %x", win32wnd->getWindowHandle(), hwndFocus, usSetFocus, fsFocusChange));
+        dprintf(("PMFRAME:WM_FOCUSCHANGE %x %x %x %x", win32wnd->getWindowHandle(), hwndFocus, usSetFocus, fsFocusChange));
         goto RunDefFrameWndProc;
     }
+#endif
 
     case WM_ACTIVATE:
+    {
+        HWND hwndTitle;
+        USHORT flags = WinQueryWindowUShort(hwnd,QWS_FLAGS);
+
+        dprintf(("PMFRAME: WM_ACTIVATE %x %x %x", hwnd, mp1, mp2));
+        if (win32wnd->IsWindowCreated())
+        {
+            WinSendMsg(WinWindowFromID(hwnd,FID_CLIENT),WM_ACTIVATE,mp1,mp2);
+            WinSetWindowUShort(hwnd,QWS_FLAGS,mp1 ? (flags | FF_ACTIVE):(flags & ~FF_ACTIVE));
+
+            //CB: show owner behind the dialog
+            if (win32wnd->IsModalDialog())
+            {
+                Win32BaseWindow *topOwner = win32wnd->getOwner()->GetTopParent();
+
+                if (topOwner) WinSetWindowPos(topOwner->getOS2FrameWindowHandle(),hwnd,0,0,0,0,SWP_ZORDER);
+            }
+        }
+        else
+        {
+            WinSetWindowUShort(hwnd,QWS_FLAGS,mp1 ? (flags | FF_ACTIVE):(flags & ~FF_ACTIVE));
+        }
+        RestoreOS2TIB();
+        return 0;
+    }
+
+    case WM_ENABLE:
+        dprintf(("OS2: WM_ENABLE %x", hwnd));
+        win32wnd->MsgEnable(SHORT1FROMMP(mp1));
+        break;
+
+    case WM_SHOW:
+        dprintf(("OS2: WM_SHOW %x %d", hwnd, mp1));
+        //show client window
+        WinShowWindow(win32wnd->getOS2WindowHandle(), (BOOL)mp1);
+        win32wnd->MsgShow((ULONG)mp1);
+        break;
+
     case WM_SETFOCUS:
     {
-        rc = ProcessPMMessage(hwnd, msg, mp1, mp2, win32wnd, pWinMsg, teb, TRUE);
         goto RunDefFrameWndProc;
     }
 
-#if 0
-//just a test
-    case WM_ADJUSTWINDOWPOS:
-    case WM_WINDOWPOSCHANGED:
-    {
-        rc = ProcessPMMessage(hwnd, msg, mp1, mp2, win32wnd, pWinMsg, teb, TRUE);
+    case WM_QUERYTRACKINFO:
+    {
+        PTRACKINFO trackInfo = (PTRACKINFO)mp2;
+
+        dprintf(("PMFRAME:WM_QUERYTRACKINFO %x", win32wnd->getWindowHandle()));
+        trackInfo->cxBorder = 4;
+        trackInfo->cyBorder = 4;
+        win32wnd->AdjustTrackInfo((PPOINT)&trackInfo->ptlMinTrackSize,(PPOINT)&trackInfo->ptlMaxTrackSize);
+        return (MRESULT)TRUE;
+    }
+
+    case WM_QUERYBORDERSIZE:
+    {
+        PWPOINT size = (PWPOINT)mp1;
+
+        dprintf(("PMFRAME:WM_QUERYBORDERSIZE %x", win32wnd->getWindowHandle()));
+
+        size->x = 0;
+        size->y = 0;
+        return (MRESULT)TRUE;
+    }
+
+    case WM_QUERYFRAMEINFO:
+        dprintf(("PMFRAME:WM_QUERYFRAMEINFO %x", win32wnd->getWindowHandle()));
         goto RunDefFrameWndProc;
-    }
-#endif
-
-    case WM_QUERYFRAMEINFO:
-        dprintf(("OS2: WM_QUERYFRAMEINFO %x", win32wnd->getWindowHandle()));
+
+    case WM_FORMATFRAME:
+        dprintf(("PMFRAME:WM_FORMATFRAME %x", win32wnd->getWindowHandle()));
+        break;
+
+    case WM_ADJUSTFRAMEPOS:
+    {
+        PSWP pswp   = (PSWP)mp1;
+
+        dprintf(("PMFRAME:WM_ADJUSTFRAMEPOS %x %x %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), pswp->hwnd, pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
         goto RunDefFrameWndProc;
-
-    case WM_FORMATFRAME:
-        dprintf(("OS2: WM_FORMATFRAME %x", win32wnd->getWindowHandle()));
+    }
+
+    case WM_OWNERPOSCHANGE:
+    {
+        PSWP pswp   = (PSWP)mp1;
+
+        dprintf(("PMFRAME:WM_OWNERPOSCHANGE %x %x %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), pswp->hwnd, pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
         goto RunDefFrameWndProc;
-
-    case WM_ADJUSTFRAMEPOS:
-    {
-        PSWP pswp   = (PSWP)mp1;
-
-        dprintf(("OS2: WM_ADJUSTFRAMEPOS %x %x %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), pswp->hwnd, pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-        goto RunDefFrameWndProc;
-    }
-
-    case WM_OWNERPOSCHANGE:
-    {
-        PSWP pswp   = (PSWP)mp1;
-
-        dprintf(("OS2: WM_OWNERPOSCHANGE %x %x %x (%d,%d) (%d,%d)", win32wnd->getWindowHandle(), pswp->hwnd, pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-        goto RunDefFrameWndProc;
     }
 
@@ -1318 +1268 @@
         if (!win32wnd->IsWindowCreated()) goto RunDefWndProc;
 
-        dprintf(("OS2: WM_MINMAXFRAME %x",hwnd));
+        dprintf(("PMFRAME:WM_MINMAXFRAME %x",hwnd));
         if ((swp->fl & SWP_MAXIMIZE) == SWP_MAXIMIZE)
         {
@@ -1346 +1296 @@
 
     case WM_UPDATEFRAME:
-        dprintf(("OS2: WM_UPDATEFRAME %x", win32wnd->getWindowHandle()));
+        dprintf(("PMFRAME:WM_UPDATEFRAME %x", win32wnd->getWindowHandle()));
         goto RunDefFrameWndProc;
 
     default:
-        rc = ProcessPMMessage(hwnd, msg, mp1, mp2, win32wnd, pWinMsg, teb, TRUE);
-        break;
+        goto RunDefFrameWndProc;
     }
     RestoreOS2TIB();
@@ -1362 +1311 @@
 RunDefWndProc:
     RestoreOS2TIB();
-    return Win32WindowProc(hwnd, msg, mp1, mp2);
+    return WinDefWindowProc( hwnd, msg, mp1, mp2 );
 }
 //******************************************************************************
@@ -1373 +1322 @@
   PRECT     pWindowRect, pClientRect;
   HWND      hwndTracking;
-  HPS       hpsTrack;
   LONG      parentHeight, parentWidth;
-  LONG      clientOrgX, clientOrgY;
 
     dprintf(("FrameTrackFrame: %x %x", win32wnd->getWindowHandle(), flags));
@@ -1387 +1334 @@
     pWindowRect = win32wnd->getWindowRect();
     if(win32wnd->getParent()) {
-        parentHeight = win32wnd->getParent()->getWindowHeight();
-        parentWidth  = win32wnd->getParent()->getWindowWidth();
+        parentHeight = win32wnd->getParent()->getClientHeight();
+        parentWidth  = win32wnd->getParent()->getClientWidth();
         hwndTracking = win32wnd->getParent()->getOS2WindowHandle();
-        hpsTrack     = WinGetPS(hwndTracking);
-        clientOrgX   = win32wnd->getParent()->getClientRectPtr()->left;
-        clientOrgY   = win32wnd->getParent()->getClientRectPtr()->top;
     }
     else {
@@ -1398 +1342 @@
         parentWidth  = OSLibQueryScreenWidth();
         hwndTracking = HWND_DESKTOP;
-        hpsTrack     = NULL;
-        clientOrgX   = 0;
-        clientOrgY   = 0;
     }
 
     mapWin32ToOS2Rect(parentHeight, pWindowRect, (PRECTLOS2)&track.rclTrack);
-    track.rclTrack.xLeft += clientOrgX;
-    track.rclTrack.yTop  -= clientOrgY;
     rcl = track.rclTrack;
     WinQueryWindowRect(hwndTracking, &track.rclBoundary);
@@ -1420 +1359 @@
     if(WinTrackRect(hwndTracking, NULL, &track) )
     {
-        if(hpsTrack)    WinReleasePS(hpsTrack);
-
         /* if successful copy final position back */
         if(!WinEqualRect(0, &rcl, &track.rclTrack)) {
             dprintf(("FrameTrackFrame: new (os/2) window rect: (%d,%d)(%d,%d)", track.rclTrack.xLeft, track.rclTrack.yBottom, track.rclTrack.xRight - track.rclTrack.xLeft, track.rclTrack.yTop - track.rclTrack.yBottom));
             if(flags == TF_MOVE) {
-                WinSetWindowPos(win32wnd->getOS2WindowHandle(),
+                WinSetWindowPos(win32wnd->getOS2FrameWindowHandle(),
                                 0, track.rclTrack.xLeft, track.rclTrack.yBottom,
                                 0, 0, SWP_MOVE);
             }
             else {
-////              SetWindowPos(win32wnd->getWindowHandle(), 0, track.rclTrack.xLeft,
-////                           parentHeight - track.rclTrack.yTop,
-////                           track.rclTrack.xRight - track.rclTrack.xLeft,
-////                           track.rclTrack.yTop - track.rclTrack.yBottom,
-////                           SWP_NOACTIVATE_W | SWP_NOZORDER_W | SWP_NOACTIVATE_W);
-                WinSetWindowPos(win32wnd->getOS2WindowHandle(),
+                WinSetWindowPos(win32wnd->getOS2FrameWindowHandle(),
                                 0, track.rclTrack.xLeft, track.rclTrack.yBottom,
                                 track.rclTrack.xRight - track.rclTrack.xLeft,
@@ -1445 +1377 @@
         return;
    }
-   if(hpsTrack) WinReleasePS(hpsTrack);
    return;
 }

trunk/src/user32/static.cpp

@@ -1 @@
-/* $Id: static.cpp,v 1.23 2001-03-30 11:14:36 sandervl Exp $ */
+/* $Id: static.cpp,v 1.24 2001-05-11 08:39:44 sandervl Exp $ */
 /*
  * Static control
@@ -413 +413 @@
   DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
   LRESULT lResult;
-
-#ifndef ODIN_HITTEST
-  //SvL: If a static window has children, then we can't return HTTRANSPARENT
-  //     here. For some reason PM then sends all mouse messages to the parent
-  //     of the static window; even if they are intended for the children of
-  //     the static window.
-  //     TODO: This could break some win32 apps (parent not receiving mouse
-  //           message for static window (non-child) area)
-  if(GetWindow(hwnd, GW_HWNDFIRST) != 0) {
-       return HTCLIENT;
-  }
-#endif
 
   if (dwStyle & SS_NOTIFY)

trunk/src/user32/win32dlg.cpp

@@ -1 @@
-/* $Id: win32dlg.cpp,v 1.61 2001-04-04 09:32:25 sandervl Exp $ */
+/* $Id: win32dlg.cpp,v 1.62 2001-05-11 08:39:44 sandervl Exp $ */
 /*
  * Win32 Dialog Code for OS/2
  *
- * Copyright 1999 Sander van Leeuwen (sandervl@xs4all.nl) (Wine port & OS/2 adaption)
+ * Copyright 1999-2001 Sander van Leeuwen (sandervl@xs4all.nl) (Wine port & OS/2 adaption)
  *
  * Based on Wine code (990815; windows\dialog.c)
@@ -24 +24 @@
 #include "controls.h"
 #include "syscolor.h"
+#include "hook.h"
 #include <math.h>
 #include <unicode.h>
@@ -317 +318 @@
         topOwner->setModalDialogOwner(TRUE);
         hwndOldDialog = topOwner->getOS2HwndModalDialog();
-        topOwner->setOS2HwndModalDialog(OS2Hwnd);
+        topOwner->setOS2HwndModalDialog(OS2HwndFrame);
         ShowWindow(SW_SHOW);
 
@@ -328 +329 @@
         while (TRUE)
         {
-          if (!OSLibWinPeekMsg(&msg,0,0,0,PM_NOREMOVE))
+          if (!PeekMessageA(&msg,0,0,0,PM_NOREMOVE))
           {
                 if(!(getStyle() & DS_NOIDLEMSG))
                     topOwner->SendMessageA(WM_ENTERIDLE,MSGF_DIALOGBOX,getWindowHandle());
-                OSLibWinGetMsg(&msg,0,0,0);
+                GetMessageA(&msg,0,0,0);
           }
-          else  OSLibWinPeekMsg(&msg,0,0,0,PM_REMOVE);
+          else  PeekMessageA(&msg,0,0,0,PM_REMOVE);
+
+          /* Call message filters */
+          if (HOOK_IsHooked( WH_SYSMSGFILTER ) || HOOK_IsHooked( WH_MSGFILTER ))
+          {
+            LPMSG pmsg = (LPMSG)HeapAlloc( GetProcessHeap(), 0, sizeof(MSG) );
+            if (pmsg)
+            {
+                BOOL ret;
+                *pmsg = msg;
+                ret = (HOOK_CallHooksA( WH_SYSMSGFILTER, MSGF_DIALOGBOX, 0,
+                                          (LPARAM) pmsg ) ||
+                       HOOK_CallHooksA( WH_MSGFILTER, MSGF_DIALOGBOX, 0,
+                                          (LPARAM) pmsg ));
+                       
+                HeapFree( GetProcessHeap(), 0, pmsg );
+                if (ret)
+                {
+                    /* Message filtered -> remove it from the queue */
+                    /* if it's still there. */
+                    continue;
+                }
+            }
+          }
 
           if(msg.message == WM_QUIT)

trunk/src/user32/win32wbase.cpp

@@ -1 @@
-/* $Id: win32wbase.cpp,v 1.254 2001-05-03 17:51:01 sandervl Exp $ */
+/* $Id: win32wbase.cpp,v 1.255 2001-05-11 08:39:45 sandervl Exp $ */
 /*
  * Win32 Window Base Class for OS/2
  *
- * Copyright 1998-2000 Sander van Leeuwen (sandervl@xs4all.nl)
+ * Copyright 1998-2001 Sander van Leeuwen (sandervl@xs4all.nl)
  * Copyright 1999      Daniela Engert (dani@ngrt.de)
  * Copyright 1999-2000 Christoph Bratschi (cbratschi@datacomm.ch)
@@ -106 +106 @@
   fCreationFinished= FALSE;
   fMinMaxChange    = FALSE;
-  fOwnDCDirty      = FALSE;
+  fVisibleRegionChanged = FALSE;
+  fEraseBkgndFlag  = TRUE;
 
   windowNameA      = NULL;
@@ -116 +117 @@
   magic            = WIN32PM_MAGIC;
   OS2Hwnd          = 0;
+  OS2HwndFrame     = 0;
   hSysMenu         = 0;
   Win32Hwnd        = 0;
@@ -146 +148 @@
   hIcon              = 0;
   hIconSm            = 0;
-
-  EraseBkgndFlag     = TRUE;
 
   horzScrollInfo     = NULL;
@@ -467 +467 @@
                                    (owner) ? owner->getOS2WindowHandle() : ((getParent()) ? getParent()->getOS2WindowHandle() : OSLIB_HWND_DESKTOP),
                                    (hwndLinkAfter == HWND_BOTTOM) ? TRUE : FALSE,
-                                   0, fTaskList,fXDefault | fCXDefault,windowClass->getStyle());
+                                   0, fTaskList,fXDefault | fCXDefault,windowClass->getStyle(), &OS2HwndFrame);
     if(OS2Hwnd == 0) {
         dprintf(("Window creation failed!! OS LastError %0x", OSLibWinGetLastError()));
@@ -688 +688 @@
 
     if(fTaskList) {
-        hTaskList = OSLibWinAddToTaskList(OS2Hwnd, windowNameA, (cs->style & WS_VISIBLE) ? 1 : 0);
+        hTaskList = OSLibWinAddToTaskList(OS2HwndFrame, windowNameA, (cs->style & WS_VISIBLE) ? 1 : 0);
     }
 
@@ -871 +871 @@
     else setStyle(getStyle() & ~WS_VISIBLE);
 
-    return SendInternalMessageA(WM_SHOWWINDOW, fShow, 0);
+    //already sent from ShowWindow
+////    return SendInternalMessageA(WM_SHOWWINDOW, fShow, 0);
+    return 0;
 }
 //******************************************************************************
@@ -897 +899 @@
 //******************************************************************************
 //******************************************************************************
-#if 0
-ULONG Win32BaseWindow::MsgMinMax()
-{
-
-}
-#endif
-//******************************************************************************
-//******************************************************************************
 ULONG Win32BaseWindow::MsgScroll(ULONG msg, ULONG scrollCode, ULONG scrollPos)
 {
@@ -911 +905 @@
   return SendInternalMessageA(msg, MAKELONG(scrollCode, scrollPos), 0);
 }
-//******************************************************************************
-//******************************************************************************
-#ifndef ODIN_HITTEST
-ULONG Win32BaseWindow::MsgHitTest(MSG *msg)
-{
-  lastHitTestVal = DispatchMsgA(msg);
-
-  dprintf2(("MsgHitTest %x (%d,%d) (%d,%d) (%d,%d) returned %x", getWindowHandle(), LOWORD(msg->lParam), HIWORD(msg->lParam), rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom, lastHitTestVal));
-
-  if (lastHitTestVal == HTTRANSPARENT)
-    return HTOS_TRANSPARENT;
-  else
-    return HTOS_NORMAL;
-}
-#endif
 //******************************************************************************
 //******************************************************************************
@@ -957 +936 @@
 
     if(hwndOS2Win) {
-            threadidhwnd = O32_GetWindowThreadProcessId(hwndOS2Win, &procidhwnd);
-    }
-//Warning: temporary hack to force focus to newly created window
-//RealPlayer 8 does not pass WM_ACTIVATE to defwindowproc and doesn't call
-//setfocus -> keyboard focus not set
-//TODO: Find real cause!!
+        threadidhwnd = O32_GetWindowThreadProcessId(hwndOS2Win, &procidhwnd);
+    }
+    //Warning: temporary hack to force focus to newly created window
+    //RealPlayer 8 does not pass WM_ACTIVATE to defwindowproc and doesn't call
+    //setfocus -> keyboard focus not set
+    //TODO: Find real cause!!
     if(GetFocus() == 0 && fActivate) {
         if(!(getStyle() & WS_MINIMIZE))
             SetFocus(getWindowHandle());
     }
-//Warning: temporary hack to force focus to newly created window
+    //Warning: temporary hack to force focus to newly created window
 
     if(fActivate) {
-            SendInternalMessageA(WM_ACTIVATEAPP, 1, dwThreadId);    //activate; specify window thread id
-    }
-    else    SendInternalMessageA(WM_ACTIVATEAPP, 0, threadidhwnd);  //deactivate; specify thread id of other process
+         SendInternalMessageA(WM_ACTIVATEAPP, 1, dwThreadId);    //activate; specify window thread id
+    }
+    else SendInternalMessageA(WM_ACTIVATEAPP, 0, threadidhwnd);  //deactivate; specify thread id of other process
     return rc;
 }
@@ -1067 +1046 @@
 
                     //SvL: Calling OSLibSetActiveWindow(hwndTop); causes focus problems
-                    if (win32top) OSLibWinSetFocus(win32top->getOS2WindowHandle());
+                    if (win32top) OSLibWinSetFocus(win32top->getOS2FrameWindowHandle());
                 }
         }
@@ -1122 +1101 @@
 }
 //******************************************************************************
-//******************************************************************************
-ULONG Win32BaseWindow::MsgNCPaint()
-{
-  RECT rect;
-
-  if(GetOS2UpdateRect(this,&rect))
-  {
+//TODO: Should use update region, not rectangle
+//******************************************************************************
+ULONG Win32BaseWindow::MsgNCPaint(PRECT pUpdateRect)
+{
     HRGN hrgn;
     ULONG rc;
     RECT client = rectClient;
 
-        if ((rect.left >= client.left) && (rect.left < client.right) &&
-           (rect.right >= client.left) && (rect.right < client.right) &&
-           (rect.top  >= client.top) && (rect.top < client.bottom) &&
-           (rect.bottom >= client.top) && (rect.bottom < client.bottom))
-        {
-                return 0;
-        }
-
-        dprintf(("MsgNCPaint (%d,%d)(%d,%d)", rect.left, rect.top, rect.right, rect.bottom));
-        hrgn = CreateRectRgnIndirect(&rect);
-        if (!hrgn) return 0;
-
-        rc = SendInternalMessageA(WM_NCPAINT, hrgn, 0);
-
-        DeleteObject(hrgn);
-
-        return rc;
-  }
-  else  return 0;
+    if ((pUpdateRect->left >= client.left) && (pUpdateRect->left < client.right) &&
+       (pUpdateRect->right >= client.left) && (pUpdateRect->right < client.right) &&
+       (pUpdateRect->top  >= client.top) && (pUpdateRect->top < client.bottom) &&
+       (pUpdateRect->bottom >= client.top) && (pUpdateRect->bottom < client.bottom))
+    {
+        return 0;
+    }
+
+    dprintf(("MsgNCPaint (%d,%d)(%d,%d)", pUpdateRect->left, pUpdateRect->top, pUpdateRect->right, pUpdateRect->bottom));
+    hrgn = CreateRectRgnIndirect(pUpdateRect);
+
+    rc = SendInternalMessageA(WM_NCPAINT, hrgn, 0);
+
+    DeleteObject(hrgn);
+
+    return rc;
 }
 //******************************************************************************
@@ -1164 +1137 @@
   ULONG rc;
 
-  if(lpWndPos)
-  {
+    if(lpWndPos)
+    {
         //set new window rectangle
         setWindowRect(lpWndPos->x, lpWndPos->y, lpWndPos->x+lpWndPos->cx,
                       lpWndPos->y+lpWndPos->cy);
         newWindowRect = rectWindow;
-  }
-  else {
+    }
+    else {
         wndPos.hwnd  = getWindowHandle();
         wndPos.hwndInsertAfter = 0;
@@ -1181 +1154 @@
         wndPos.flags = SWP_FRAMECHANGED;
         lpWndPos     = &wndPos;
-  }
-
-  newClientRect = rectClient;
-  rc = SendNCCalcSize(TRUE, &newWindowRect,  &oldWindowRect, &client, lpWndPos, &newClientRect);
-  rectClient = newClientRect; //must update rectClient here
-
-  dprintf(("MsgFormatFrame: old client rect (%d,%d)(%d,%d), new client (%d,%d)(%d,%d)", client.left, client.top, client.right, client.bottom, rectClient.left, rectClient.top, rectClient.right, rectClient.bottom));
-  dprintf(("MsgFormatFrame: old window rect (%d,%d)(%d,%d), new window (%d,%d)(%d,%d)", oldWindowRect.left, oldWindowRect.top, oldWindowRect.right, oldWindowRect.bottom, rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
+    }
+
+    newClientRect = rectClient;
+    rc = SendNCCalcSize(TRUE, &newWindowRect,  &oldWindowRect, &client, lpWndPos, &newClientRect);
+    rectClient = newClientRect; //must update rectClient here
+
+    dprintf(("MsgFormatFrame: old client rect (%d,%d)(%d,%d), new client (%d,%d)(%d,%d)", client.left, client.top, client.right, client.bottom, rectClient.left, rectClient.top, rectClient.right, rectClient.bottom));
+    dprintf(("MsgFormatFrame: old window rect (%d,%d)(%d,%d), new window (%d,%d)(%d,%d)", oldWindowRect.left, oldWindowRect.top, oldWindowRect.right, oldWindowRect.bottom, rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
+
+    if(fNoSizeMsg || !EqualRect(&client, &rectClient)) {
+        OSLibWinSetClientPos(getOS2WindowHandle(), rectClient.left, rectClient.top, getClientWidth(), getClientHeight(), getWindowHeight());
+    }
 
 #if 1
@@ -1430 +1407 @@
             HandleNCPaint((HRGN)1);
             if(hTaskList) {
-                OSLibWinChangeTaskList(hTaskList, OS2Hwnd, getWindowNameA(), (getStyle() & WS_VISIBLE) ? 1 : 0);
+                OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), (getStyle() & WS_VISIBLE) ? 1 : 0);
             }
         }
@@ -1590 +1567 @@
           return 1;
         }
-       
+
         if (!windowClass || !windowClass->getBackgroundBrush()) return 0;
 
@@ -1917 +1894 @@
         if ((dwStyle & WS_CAPTION) == WS_CAPTION)
         {
-          HandleNCPaint((HRGN)1);
-          if(hTaskList) {
-        OSLibWinChangeTaskList(hTaskList, OS2Hwnd, getWindowNameA(), (getStyle() & WS_VISIBLE) ? 1 : 0);
-      }
+            HandleNCPaint((HRGN)1);
+            if(hTaskList) {
+                OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), (getStyle() & WS_VISIBLE) ? 1 : 0);
+            }
         }
 
@@ -2231 +2208 @@
     case SW_HIDE:
         if (!wasVisible) goto END;
-            swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |
-        SWP_NOACTIVATE | SWP_NOZORDER;
+
+        swp |= SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER;
         break;
 
@@ -2242 +2219 @@
         /* fall through */
     case SW_MINIMIZE:
-        if(!(getStyle() & WS_CHILD))
-        {
-            if( !(getStyle() & WS_MINIMIZE) )
-                 swp |= MinMaximize(SW_MINIMIZE, &newPos );
-
-            swp |= SWP_NOSIZE | SWP_NOMOVE | SWP_HIDEWINDOW;
-        }
-        else {
-            swp |= SWP_FRAMECHANGED;
-            if( !(getStyle() & WS_MINIMIZE) ) {
-                 swp |= MinMaximize(SW_MINIMIZE, &newPos );
-                 fMinMaxChange = TRUE; //-> invalidate entire window in WM_CALCINVALIDRECT
-            }
-            else swp |= SWP_NOSIZE | SWP_NOMOVE;
-        }
+        swp |= SWP_FRAMECHANGED;
+        if( !(getStyle() & WS_MINIMIZE) ) {
+             swp |= MinMaximize(SW_MINIMIZE, &newPos );
+             fMinMaxChange = TRUE; //-> invalidate entire window in WM_CALCINVALIDRECT
+        }
+        else swp |= SWP_NOSIZE | SWP_NOMOVE;
         break;
 
@@ -2317 +2285 @@
 
     if(!(swp & SWP_NOACTIVATE)) {
-        OSLibWinSetActiveWindow(OS2Hwnd);
+        OSLibWinSetActiveWindow(OS2HwndFrame);
     }
 
@@ -2454 +2422 @@
             }
         }
-        OSLibWinQueryWindowPos(OS2Hwnd, &swpOld);
+        OSLibWinQueryWindowPos(OS2HwndFrame, &swpOld);
     }
 
     if(getParent()) {
-          OSLibMapWINDOWPOStoSWP(&wpos, &swp, &swpOld, getParent()->getWindowHeight(),
-                                 getParent()->getClientRectPtr()->left,
-                                 getParent()->getClientRectPtr()->top,
-                                 OS2Hwnd);
-    }
-    else  OSLibMapWINDOWPOStoSWP(&wpos, &swp, &swpOld, OSLibQueryScreenHeight(), 0, 0, OS2Hwnd);
+          OSLibMapWINDOWPOStoSWP(&wpos, &swp, &swpOld, getParent()->getClientHeight(),
+                                      OS2HwndFrame);
+    }
+    else  OSLibMapWINDOWPOStoSWP(&wpos, &swp, &swpOld, OSLibQueryScreenHeight(), OS2HwndFrame);
+
     if (swp.fl == 0) {
         if(fuFlags & SWP_FRAMECHANGED)
@@ -2477 +2444 @@
         Win32BaseWindow *wndBehind = Win32BaseWindow::GetWindowFromHandle(swp.hwndInsertBehind);
         if(wndBehind) {
-            swp.hwndInsertBehind   = wndBehind->getOS2WindowHandle();
+            swp.hwndInsertBehind   = wndBehind->getOS2FrameWindowHandle();
         }
         else {
@@ -2484 +2451 @@
         }
     }
-    swp.hwnd = OS2Hwnd;
+    swp.hwnd = OS2HwndFrame;
 
     if(fuFlags & SWP_SHOWWINDOW && !IsWindowVisible(getWindowHandle())) {
@@ -2490 +2457 @@
         if(hTaskList) {
             dprintf(("Adding window %x to tasklist", getWindowHandle()));
-            OSLibWinChangeTaskList(hTaskList, OS2Hwnd, getWindowNameA(), 1);
+            OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), 1);
         }
     }
@@ -2498 +2465 @@
         if(hTaskList && !(getStyle() & WS_MINIMIZE)) {
             dprintf(("Removing window %x from tasklist", getWindowHandle()));
-            OSLibWinChangeTaskList(hTaskList, OS2Hwnd, getWindowNameA(), 0);
+            OSLibWinChangeTaskList(hTaskList, OS2HwndFrame, getWindowNameA(), 0);
         }
     }
@@ -2510 +2477 @@
     }
 
-    //Restore window origin of parent window with CS_OWNDC style
-    //(fixes paint offset problems in Opera windows)
-    if(getParent() && getParent()->isOwnDC()) {
-        dprintfOrigin(getParent()->getOwnDC());
-        selectClientArea(getParent(), getParent()->getOwnDC());
-    }
-
     if((fuFlags & SWP_FRAMECHANGED) && (fuFlags & (SWP_NOMOVE | SWP_NOSIZE) == (SWP_NOMOVE | SWP_NOSIZE)))
     {
-            NotifyFrameChanged(&wpos, &oldClientRect);
+        NotifyFrameChanged(&wpos, &oldClientRect);
     }
     return (rc);
@@ -2713 +2673 @@
 
     fDestroyWindowCalled = TRUE;
-    return OSLibWinDestroyWindow(OS2Hwnd);
+    return OSLibWinDestroyWindow(OS2HwndFrame);
 }
 //******************************************************************************
@@ -2770 +2730 @@
         setParent(newparent);
         getParent()->addChild(this);
-        OSLibWinSetParent(getOS2WindowHandle(), getParent()->getOS2WindowHandle());
+        OSLibWinSetParent(getOS2FrameWindowHandle(), getParent()->getOS2WindowHandle());
         if(!(getStyle() & WS_CHILD))
         {
@@ -2776 +2736 @@
             setStyle(getStyle() | WS_CHILD);
             if(getWindowId())
-                {
-                        DestroyMenu( (HMENU) getWindowId() );
-                        setWindowId(0);
-                }
+            {
+                DestroyMenu( (HMENU) getWindowId() );
+                setWindowId(0);
+            }
         }
    }
@@ -2785 +2745 @@
         setParent(windowDesktop);
         windowDesktop->addChild(this);
-        OSLibWinSetParent(getOS2WindowHandle(), OSLIB_HWND_DESKTOP);
+        OSLibWinSetParent(getOS2FrameWindowHandle(), OSLIB_HWND_DESKTOP);
 
     //TODO: Send WM_STYLECHANGED msg?
@@ -2824 +2784 @@
 
     hwndTop = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_TOP);
-    if(!isDesktopWindow()) {
-    topwindow = GetWindowFromOS2Handle(hwndTop);
-    if(topwindow) {
-        return topwindow->getWindowHandle();
-    }
-    return 0;
+    if(!isDesktopWindow())
+    {
+        topwindow = GetWindowFromOS2FrameHandle(hwndTop);
+        if(topwindow) {
+            return topwindow->getWindowHandle();
+        }
+        return 0;
     }
     while(hwndTop) {
-    topwindow = GetWindowFromOS2Handle(hwndTop);
-    if(topwindow) {
-        return topwindow->getWindowHandle();
-    }
+        topwindow = GetWindowFromOS2FrameHandle(hwndTop);
+        if(topwindow) {
+            return topwindow->getWindowHandle();
+        }
         hwndTop = OSLibWinQueryWindow(hwndTop, QWOS_NEXT);
     }
@@ -3011 +2972 @@
         while(hwnd)
         {
-            wnd = GetWindowFromOS2Handle(hwnd);
+            wnd = GetWindowFromOS2FrameHandle(hwnd);
             if(wnd == NULL) {
                 hwnd = OSLibWinQueryClientWindow(hwnd);
@@ -3041 +3002 @@
  Win32BaseWindow *window;
 
-#if 1
     switch(uCmd)
     {
@@ -3049 +3009 @@
             window = (Win32BaseWindow *)getParent();
             hwndRelated = OSLibWinQueryWindow(window->getOS2WindowHandle(), QWOS_TOP);
-            window = GetWindowFromOS2Handle(hwndRelated);
+            window = GetWindowFromOS2FrameHandle(hwndRelated);
             if(window) {
-                  hwndRelated = window->getWindowHandle();
+                 hwndRelated = window->getWindowHandle();
             }
             else hwndRelated = 0;
         }
-        else hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
+        else {
+            dprintf(("WARNING: GW_HWNDFIRST not correctly implemented for toplevel/most windows!"));
+            hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
+        }
         break;
 
     case GW_HWNDLAST:
-        hwndRelated = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_BOTTOM);
-        window = GetWindowFromOS2Handle(hwndRelated);
-        if(window) {
-             hwndRelated = window->getWindowHandle();
-        }
-        else hwndRelated = 0;
+        if(getParent()) {
+            window = (Win32BaseWindow *)getParent();
+            hwndRelated = OSLibWinQueryWindow(window->getOS2WindowHandle(), QWOS_BOTTOM);
+            dprintf(("os2 handle %x", hwndRelated));
+            window = GetWindowFromOS2FrameHandle(hwndRelated);
+            if(window) {
+                 hwndRelated = window->getWindowHandle();
+            }
+            else hwndRelated = 0;
+        }
+        else {
+            dprintf(("WARNING: GW_HWNDLAST not correctly implemented for toplevel/most windows!"));
+            hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
+        }
         break;
 
     case GW_HWNDNEXT:
-        hwndRelated = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_NEXT);
-        window = GetWindowFromOS2Handle(hwndRelated);
-        if(window) {
-             hwndRelated = window->getWindowHandle();
-        }
-        else hwndRelated = 0;
+        if(getParent()) {
+            hwndRelated = OSLibWinQueryWindow(getOS2FrameWindowHandle(), QWOS_NEXT);
+            window = GetWindowFromOS2FrameHandle(hwndRelated);
+            if(window) {
+                 hwndRelated = window->getWindowHandle();
+            }
+            else hwndRelated = 0;
+        }
+        else {
+            dprintf(("WARNING: GW_HWNDNEXT not correctly implemented for toplevel/most windows!"));
+            hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
+        }
         break;
 
     case GW_HWNDPREV:
-        hwndRelated = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_PREV);
-        window = GetWindowFromOS2Handle(hwndRelated);
-        if(window) {
-             hwndRelated = window->getWindowHandle();
-        }
-        else hwndRelated = 0;
+        if(getParent()) {
+            hwndRelated = OSLibWinQueryWindow(getOS2FrameWindowHandle(), QWOS_PREV);
+            window = GetWindowFromOS2FrameHandle(hwndRelated);
+            if(window) {
+                 hwndRelated = window->getWindowHandle();
+            }
+            else hwndRelated = 0;
+        }
+        else {
+            dprintf(("WARNING: GW_HWNDPREV not correctly implemented for toplevel/most windows!"));
+            hwndRelated = 0; //TODO: not correct; should get first child in z-order of desktop
+        }
         break;
 
@@ -3093 +3076 @@
     case GW_CHILD:
         hwndRelated = OSLibWinQueryWindow(getOS2WindowHandle(), QWOS_TOP);
-        window = GetWindowFromOS2Handle(hwndRelated);
+        window = GetWindowFromOS2FrameHandle(hwndRelated);
         if(window) {
              hwndRelated = window->getWindowHandle();
@@ -3100 +3083 @@
         break;
     }
-#else
-    switch(uCmd)
-    {
-    case GW_HWNDFIRST:
-        if(getParent()) {
-            window = (Win32BaseWindow *)getParent()->getFirstChild();
-            hwndRelated = window->getWindowHandle();
-        }
-        break;
-
-    case GW_HWNDLAST:
-        if(!getParent())
-        {
-            goto end;
-        }
-
-        window = this;
-        while(window->getNextChild())
-        {
-            window = (Win32BaseWindow *)window->getNextChild();
-        }
-        hwndRelated = window->getWindowHandle();
-        break;
-
-    case GW_HWNDNEXT:
-        window = (Win32BaseWindow *)getNextChild();
-        if(window) {
-            hwndRelated = window->getWindowHandle();
-        }
-        break;
-
-    case GW_HWNDPREV:
-        if(!getParent())
-        {
-            goto end;
-        }
-        window = (Win32BaseWindow *)(getParent()->getFirstChild()); /* First sibling */
-        if(window == this)
-        {
-            hwndRelated = 0;  /* First in list */
-            goto end;
-        }
-        while(window->getNextChild())
-        {
-            if (window->getNextChild() == this)
-            {
-                hwndRelated = window->getWindowHandle();
-                goto end;
-            }
-            window = (Win32BaseWindow *)window->getNextChild();
-        }
-        break;
-
-    case GW_OWNER:
-        if(getOwner()) {
-            hwndRelated = getOwner()->getWindowHandle();
-        }
-        break;
-
-    case GW_CHILD:
-        if(getFirstChild()) {
-            hwndRelated = ((Win32BaseWindow *)getFirstChild())->getWindowHandle();
-        }
-        break;
-    }
-#endif
 end:
     dprintf(("GetWindow %x %d returned %x", getWindowHandle(), uCmd, hwndRelated));
@@ -3227 +3144 @@
         SendMessageA(WM_CANCELMODE, 0, 0);
   }
-  OSLibWinEnableWindow(OS2Hwnd, fEnable);
+  OSLibWinEnableWindow(OS2HwndFrame, fEnable);
   if(fEnable == FALSE) {
         //SvL: No need to clear focus as PM already does this
@@ -3436 +3353 @@
                 setStyle(ss.styleNew);
                 SendInternalMessageA(WM_STYLECHANGED,GWL_STYLE,(LPARAM)&ss);
-                OSLibSetWindowStyle(getOS2WindowHandle(), getStyle(), getExStyle());
+                OSLibSetWindowStyle(getOS2FrameWindowHandle(), getOS2WindowHandle(), getStyle(), getExStyle());
 #ifdef DEBUG
                 PrintWindowStyle(ss.styleNew, 0);
@@ -3607 +3524 @@
 //  dprintf2(("Win32BaseWindow::GetWindowFromOS2Handle: not an Odin os2 window %x", hwnd));
     return 0;
+}
+//******************************************************************************
+//******************************************************************************
+Win32BaseWindow *Win32BaseWindow::GetWindowFromOS2FrameHandle(HWND hwnd)
+{
+    return GetWindowFromOS2Handle(OSLibWinWindowFromID(hwnd,OSLIB_FID_CLIENT));
 }
 //******************************************************************************
@@ -3808 +3731 @@
             return window->getWindowHandle();
     }
+    window = Win32BaseWindow::GetWindowFromOS2FrameHandle(hwnd);
+    if(window) {
+            return window->getWindowHandle();
+    }
+
 //    dprintf2(("Win32BaseWindow::OS2ToWin32Handle: not a win32 window %x", hwnd));
     return 0;

trunk/src/user32/win32wbase.h

@@ -1 @@
-/* $Id: win32wbase.h,v 1.115 2001-04-27 17:36:39 sandervl Exp $ */
+/* $Id: win32wbase.h,v 1.116 2001-05-11 08:39:45 sandervl Exp $ */
 /*
  * Win32 Window Base Class for OS/2
@@ -134 +134 @@
          ULONG  MsgPaint(ULONG tmp1, BOOL select = TRUE);
          ULONG  MsgEraseBackGround(HDC hdc);
-#ifndef ODIN_HITTEST
-         ULONG  MsgHitTest(MSG *msg);
-#endif
-         ULONG  MsgNCPaint();
+         ULONG  MsgNCPaint(PRECT pUpdateRect);
          ULONG  MsgFormatFrame(WINDOWPOS *lpWndPos);
          ULONG  DispatchMsgA(MSG *msg);
@@ -160 +157 @@
          HWND   getWindowHandle()               { return Win32Hwnd; };
          HWND   getOS2WindowHandle()            { return OS2Hwnd; };
+         HWND   getOS2FrameWindowHandle()       { return OS2HwndFrame; };
 
  Win32WndClass *getWindowClass()                { return windowClass; };
@@ -260 +258 @@
          BOOL   IsMixMaxStateChanging()       { return fMinMaxChange; };
 
+         void   SetVisibleRegionChanged(BOOL changed) { fVisibleRegionChanged = changed; };
+         BOOL   IsVisibleRegionChanged()              { return fVisibleRegionChanged; };
+
          int    GetWindowTextLength(BOOL fUnicode);
          int    GetWindowTextLengthA() { return GetWindowTextLength(FALSE); };
@@ -317 +318 @@
 static Win32BaseWindow *GetWindowFromHandle(HWND hwnd);
 static Win32BaseWindow *GetWindowFromOS2Handle(HWND hwnd);
+static Win32BaseWindow *GetWindowFromOS2FrameHandle(HWND hwnd);
 
     static void DestroyAll();
@@ -334 +336 @@
     PROPERTY   *findWindowProperty(LPCSTR str);
 
-        HWND    OS2Hwnd;
+        HWND    OS2Hwnd, OS2HwndFrame;
         HMENU   hSysMenu;
         HWND    Win32Hwnd;
@@ -358 +360 @@
         HWND    OS2HwndModalDialog;
 
-        unsigned fFirstShow:1;
-        unsigned fIsDialog:1;
-        unsigned fIsModalDialog:1;
-        unsigned fIsModalDialogOwner:1;
-        unsigned fInternalMsg:1;         //Used to distinguish between messages
+        ULONG    fFirstShow:1,
+                 fIsDialog:1,
+                 fIsModalDialog:1,
+                 fIsModalDialogOwner:1,
+                 fInternalMsg:1,         //Used to distinguish between messages
                                          //sent by PM and those sent by apps
-        unsigned fNoSizeMsg:1;
-        unsigned fIsDestroyed:1;
-        unsigned fDestroyWindowCalled:1; //DestroyWindow was called for this window
-        unsigned fCreated:1;
-        unsigned fCreationFinished:1;    //True when window or dialog has been created successfully
+                 fNoSizeMsg:1,
+                 fIsDestroyed:1,
+                 fDestroyWindowCalled:1, //DestroyWindow was called for this window
+                 fCreated:1,
+                 fCreationFinished:1,    //True when window or dialog has been created successfully
                                          //Needed to prevent DestroyWindow from deleting the window
                                          //object during construction
-        unsigned fTaskList:1;            //should be listed in PM tasklist or not
-        unsigned fXDefault:1;
-        unsigned fCXDefault:1;
-        unsigned fParentDC:1;
-        unsigned fComingToTop:1;
-        unsigned fCreateSetWindowPos:1;  //FALSE -> SetWindowPos in Win32BaseWindow::MsgCreate not yet called
-        unsigned isUnicode:1;
-        unsigned fMinMaxChange:1;        //set when switching between min/max/restored state
-        unsigned fOwnDCDirty:1;          //set when selectClientArea must reset the origin + visible region
+                 fTaskList:1,            //should be listed in PM tasklist or not
+                 fXDefault:1,
+                 fCXDefault:1,
+                 fParentDC:1,
+                 fComingToTop:1,
+                 fCreateSetWindowPos:1,  //FALSE -> SetWindowPos in Win32BaseWindow::MsgCreate not yet called
+                 isUnicode:1,
+                 fMinMaxChange:1,        //set when switching between min/max/restored state
+                 fVisibleRegionChanged:1, //set when visible region has changed -> erase background must be sent during next BeginPaint
+                 fEraseBkgndFlag:1;
 
         HRGN    hWindowRegion;
@@ -469 +472 @@
          BOOL   isOwnDC() { return (windowClass && windowClass->getStyle() & CS_OWNDC_W); }
 #endif
-         void   invalidateOwnDC() { fOwnDCDirty = TRUE; };
-         void   validateOwnDC()   { fOwnDCDirty = FALSE; };
-         BOOL   isOwnDCDirty()    { return fOwnDCDirty; };
 
          HDC    getOwnDC() { return ownDC; }
@@ -478 +478 @@
          HDC    ownDC;
 
-         ULONG  EraseBkgndFlag:1,
-                filler:31;
 public:
-         VOID   setEraseBkgnd (BOOL erase)      { EraseBkgndFlag = erase; }
-         BOOL   needsEraseBkgnd()               { return EraseBkgndFlag; }
+         VOID   setEraseBkgnd (BOOL erase)      { fEraseBkgndFlag = erase; }
+         BOOL   needsEraseBkgnd()               { return fEraseBkgndFlag; }
 };
 

trunk/src/user32/win32wbasepos.cpp

@@ -1 @@
-/* $Id: win32wbasepos.cpp,v 1.23 2001-05-04 17:02:52 sandervl Exp $ */
+/* $Id: win32wbasepos.cpp,v 1.24 2001-05-11 08:39:45 sandervl Exp $ */
 /*
  * Win32 Window Base Class for OS/2 (nonclient/position methods)
@@ -59 +59 @@
     if(!(getStyle() & (WS_POPUP | WS_CHILD))) {
         RECT rect;
-        OSLibWinGetMaxPosition(getOS2WindowHandle(), &rect);
+        OSLibWinGetMaxPosition(getOS2FrameWindowHandle(), &rect);
         MinMax.ptMaxPosition.x = rect.left;
         MinMax.ptMaxPosition.y = rect.top;

trunk/src/user32/win32wdesktop.cpp

@@ -1 @@
-/* $Id: win32wdesktop.cpp,v 1.15 2000-12-05 13:05:52 sandervl Exp $ */
+/* $Id: win32wdesktop.cpp,v 1.16 2001-05-11 08:39:46 sandervl Exp $ */
 /*
  * Win32 Desktop Window for OS/2
@@ -52 +52 @@
 
   OS2Hwnd      = OSLIB_HWND_DESKTOP;
+  OS2HwndFrame = OSLIB_HWND_DESKTOP;
   rectClient   = rectWindow;
 

trunk/src/user32/win32wndhandle.cpp

@@ -1 @@
-/* $Id: win32wndhandle.cpp,v 1.8 2001-01-02 18:14:59 sandervl Exp $ */
+/* $Id: win32wndhandle.cpp,v 1.9 2001-05-11 08:39:46 sandervl Exp $ */
 /*
  * Win32 Handle Management Code for OS/2
@@ -64 +64 @@
   WindowHandleTable[lastIndex] = dwUserData;
 
+  lastIndex++;
   tableMutex.leave(&hGlobalTableMutex);
   return TRUE;

trunk/src/user32/window.cpp

@@ -1 @@
-/* $Id: window.cpp,v 1.94 2001-04-25 20:53:39 sandervl Exp $ */
+/* $Id: window.cpp,v 1.95 2001-05-11 08:39:46 sandervl Exp $ */
 /*
  * Win32 window apis for OS/2
@@ -404 +404 @@
 
     if(hwnd == HWND_DESKTOP) {
-    window = windowDesktop;
+        window = windowDesktop;
     }
     else {
@@ -412 +412 @@
             SetLastError(ERROR_INVALID_WINDOW_HANDLE);
             return 0;
-    }
+        }
     }
     hwndTop = window->GetTopWindow();
@@ -947 +947 @@
     if (!pRect)
     {
-      SetLastError(ERROR_INVALID_PARAMETER);
-      return FALSE;
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return FALSE;
     }
     window = Win32BaseWindow::GetWindowFromHandle(hwnd);
@@ -973 +973 @@
     if(style == 0 && menu == FALSE && exStyle == 0) {
         dprintf(("AdjustWindowRectEx %x %x %d (%d,%d)(%d,%d) -> no change required", style, exStyle, menu, rect->left, rect->top, rect->right, rect->bottom));
-    return TRUE;    //nothing needs to be changed (VERIFIED in NT 4)
+        return TRUE;    //nothing needs to be changed (VERIFIED in NT 4)
     }
     dprintf(("AdjustWindowRectEx %x %x %d (%d,%d)(%d,%d)\n", style, exStyle, menu, rect->left, rect->top, rect->right, rect->bottom));
@@ -988 +988 @@
     //Adjust rect outer (Win32BaseWindow::AdjustRectOuter)
     if (HAS_THICKFRAME(style,exStyle))
-      InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
+        InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
     else
-      if (HAS_DLGFRAME(style,exStyle))
+    if (HAS_DLGFRAME(style,exStyle))
         InflateRect(rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
-      else
-        if (HAS_THINFRAME(style))
-          InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
+    else
+    if (HAS_THINFRAME(style))
+        InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
 
     if ((style & WS_CAPTION) == WS_CAPTION)
     {
-      if (exStyle & WS_EX_TOOLWINDOW)
-        rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
-      else
-        rect->top -= GetSystemMetrics(SM_CYCAPTION);
+        if (exStyle & WS_EX_TOOLWINDOW)
+            rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
+        else
+            rect->top -= GetSystemMetrics(SM_CYCAPTION);
     }
 
     if (menu)
-      rect->top -= GetSystemMetrics(SM_CYMENU);
+        rect->top -= GetSystemMetrics(SM_CYMENU);
 
     //Adjust rect inner (Win32BaseWindow::AdjustRectInner)
     if(!(style & WS_ICONIC)) {
-    if (exStyle & WS_EX_CLIENTEDGE)
+        if (exStyle & WS_EX_CLIENTEDGE)
             InflateRect (rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
 
-    if (exStyle & WS_EX_STATICEDGE)
+        if (exStyle & WS_EX_STATICEDGE)
             InflateRect (rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
 
-    //SvL: scrollbars aren't checked *UNLESS* the style includes a border (any border)
+        //SvL: scrollbars aren't checked *UNLESS* the style includes a border (any border)
         //     --> VERIFIED IN NT4, SP6 (fixes MFC apps with scrollbars + bar controls)
-    if(style & (WS_THICKFRAME|WS_BORDER|WS_DLGFRAME)) {
+        if(style & (WS_THICKFRAME|WS_BORDER|WS_DLGFRAME)) {
             if (style & WS_VSCROLL) rect->right  += GetSystemMetrics(SM_CXVSCROLL);
             if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
-    }
+        }
     }
 
@@ -1687 +1687 @@
         return FALSE;
   }
-  dprintf(("USER32: ShowOwnedPopups %x %d", hwnd, fShow));
+  dprintf(("USER32: ShowOwnedPopups %x %d", hwndOwner, fShow));
 
   hwnd = GetWindow(GetDesktopWindow(), GW_CHILD);