Changeset 3662 for trunk/src/user32/pmwindow.cpp

Timestamp:

Jun 7, 2000, 4:51:33 PM (25 years ago)

Author:

sandervl

Message:

Major rewrite: frame/client -> frame

File:

• trunk/src/user32/pmwindow.cpp (modified) (15 diffs)

trunk/src/user32/pmwindow.cpp

@@ -1 @@
-/* $Id: pmwindow.cpp,v 1.91 2000-05-24 19:30:06 sandervl Exp $ */
+/* $Id: pmwindow.cpp,v 1.92 2000-06-07 14:51:27 sandervl Exp $ */
 /*
  * Win32 Window Managment Code for OS/2
@@ -15 +15 @@
 #define INCL_GPICONTROL         /* GPI control Functions        */
 #define INCL_DOSPROCESS
+#define INCL_WINTRACKRECT
 
 #include <os2wrap.h>
@@ -52 +53 @@
 MRESULT EXPENTRY Win32WindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2);
 
+PFNWP PMFrameWindowProc = 0;
+
 //******************************************************************************
 //Initialize PM; create hab, message queue and register special Win32 window classes
@@ -57 +60 @@
 BOOL InitPM()
 {
-  CLASSINFO FrameClassInfo;
-
+ 
   hab = WinInitialize(0);
   dprintf(("Winitialize returned %x", hab));
@@ -96 +98 @@
      (PSZ)WIN32_STDCLASS,               /* Window class name            */
      (PFNWP)Win32WindowProc,            /* Address of window procedure  */
-#ifdef ODIN_HITTEST
-     0,
-#else
      CS_HITTEST,
-#endif
      NROF_WIN32WNDBYTES)) {
         dprintf(("WinRegisterClass Win32BaseWindow failed"));
         return(FALSE);
-   }
+  }
+
+  CLASSINFO FrameClassInfo;
+  if(!WinQueryClassInfo (hab, WC_FRAME, &FrameClassInfo)) {
+     dprintf (("WinQueryClassInfo WC_FRAME failed"));
+     return (FALSE);
+  }
+  dprintf(("WC_FRAME style %x", FrameClassInfo.flClassStyle));
+
+  PMFrameWindowProc = FrameClassInfo.pfnWindowProc;
   if(!WinRegisterClass(                 /* Register window class        */
      hab,                               /* Anchor block handle          */
-     (PSZ)WIN32_STDCLASS2,              /* Window class name            */
+     (PSZ)WIN32_STDFRAMECLASS,          /* Window class name            */
      (PFNWP)Win32WindowProc,            /* Address of window procedure  */
-#ifdef ODIN_HITTEST
-     CS_SAVEBITS,
-#else
-     CS_SAVEBITS | CS_HITTEST,
-#endif
-     NROF_WIN32WNDBYTES)) {
-        dprintf(("WinRegisterClass Win32BaseWindow failed"));
+     CS_HITTEST | CS_FRAME,
+     FrameClassInfo.cbWindowData+NROF_WIN32WNDBYTES)) {
+        dprintf(("WinRegisterClass Win32BaseWindow failed %x", WinGetLastError(hab)));
         return(FALSE);
-   }
-   if (!WinQueryClassInfo (hab, WC_FRAME, &FrameClassInfo)) {
-     dprintf (("WinQueryClassInfo WC_FRAME failed"));
-     return (FALSE);
-   }
-   FrameClassInfo.flClassStyle &= ~(CS_PUBLIC | CS_CLIPSIBLINGS);
-   if (!WinRegisterClass (hab,
-                          WIN32_INNERFRAME,
-                          FrameClassInfo.pfnWindowProc,
-#ifdef ODIN_HITTEST
-                          FrameClassInfo.flClassStyle,
-#else
-                          FrameClassInfo.flClassStyle | CS_HITTEST,
-#endif
-                          FrameClassInfo.cbWindowData)) {
-     dprintf (("WinRegisterClass Win32InnerFrame failed"));
-     return (FALSE);
-   }
-
-   WinQueryWindowRect(HWND_DESKTOP, &desktopRectl);
-   ScreenWidth  = desktopRectl.xRight;
-   ScreenHeight = desktopRectl.yTop;
-
-
-   HDC   hdc;              /* Device-context handle                */
-   /* context data structure */
-   DEVOPENSTRUC dop = {NULL, "DISPLAY", NULL, NULL, NULL, NULL,
-                       NULL, NULL, NULL};
-
-   /* create memory device context */
-   hdc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE);
-   DevQueryCaps(hdc, CAPS_COLOR_BITCOUNT, 1, (PLONG)&ScreenBitsPerPel);
-   DevCloseDC(hdc);
-
-   dprintf(("InitPM: Desktop (%d,%d)", ScreenWidth, ScreenHeight));
-   return TRUE;
+  }
+
+  WinQueryWindowRect(HWND_DESKTOP, &desktopRectl);
+  ScreenWidth  = desktopRectl.xRight;
+  ScreenHeight = desktopRectl.yTop;
+
+  HDC   hdc;              /* Device-context handle                */
+  /* context data structure */
+  DEVOPENSTRUC dop = {NULL, "DISPLAY", NULL, NULL, NULL, NULL,
+                     NULL, NULL, NULL};
+
+  /* create memory device context */
+  hdc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE);
+  DevQueryCaps(hdc, CAPS_COLOR_BITCOUNT, 1, (PLONG)&ScreenBitsPerPel);
+  DevCloseDC(hdc);
+
+  dprintf(("InitPM: Desktop (%d,%d)", ScreenWidth, ScreenHeight));
+  return TRUE;
 } /* End of main */
 //******************************************************************************
@@ -223 +208 @@
         win32wnd = (Win32BaseWindow *)thdb->newWindow;
         thdb->newWindow = 0;
-
-        if(win32wnd->MsgCreate(WinQueryWindow(hwnd, QW_PARENT), hwnd) == FALSE)
+        if(win32wnd->MsgCreate(hwnd) == FALSE)
         {
             RestoreOS2TIB();
             return (MRESULT)TRUE; //discontinue window creation
         }
+        RestoreOS2TIB();
+        PMFrameWindowProc(hwnd, msg, mp1, mp2);
+        SetWin32TIB();
     createfail:
         RestoreOS2TIB();
@@ -247 +234 @@
         dprintf(("OS2: WM_DESTROY %x", hwnd));
         win32wnd->MsgDestroy();
-        break;
+        WinSetVisibleRegionNotify(hwnd, FALSE);
+        goto RunDefWndProc;
 
     case WM_ENABLE:
@@ -261 +249 @@
     case WM_ADJUSTWINDOWPOS:
     {
-      PSWP      pswp   = (PSWP)mp1;
-        dprintf(("PMWINDOW: WM_WINDOWPOSCHANGED (%x) %x %x (%d,%d) (%d,%d)", mp2, win32wnd->getWindowHandle(), pswp->fl, pswp->x, pswp->y, pswp->cx, pswp->cy));
-        goto RunDefWndProc;
+      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));
+
+        //CB: show dialog in front of owner
+        if (win32wnd->IsModalDialogOwner())
+        {
+          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();
+        }
+
+        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))
+        {
+          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));
+          pswp->fl |= SWP_NOADJUST;
+          pswp->hwndInsertBehind = hwndAfter;
+          pswp->hwnd = hwnd;
+
+          RestoreOS2TIB();
+          return (MRESULT)0xf;
+        }
+        RestoreOS2TIB();
+        return (MRESULT)0;
     }
 
     case WM_WINDOWPOSCHANGED:
     {
-        if(pWinMsg->message != 0)
-                win32wnd->MsgPosChanged((LPARAM)&thdb->wp);
-        goto RunDefWndProc;
+      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)
+        {
+                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);
+
+        if((pswp->fl & (SWP_MOVE | SWP_SIZE)) && !(win32wnd->getStyle() & WS_MINIMIZE_W))
+        {
+          //Note: Also updates the new window rectangle
+          win32wnd->MsgFormatFrame(&wp);
+
+          //CB: todo: use result for WM_CALCVALIDRECTS
+          mapWin32ToOS2RectFrame(win32wnd, win32wnd->getClientRectPtr(), (PRECTLOS2)&rect);
+
+          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 (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
+        {
+          if(win32wnd->CanReceiveSizeMsgs())
+            win32wnd->MsgPosChanged((LPARAM)&wp);
+        }
+
+PosChangedEnd:
+        RestoreOS2TIB();
+        return (MRESULT)FALSE;
     }
 
     case WM_ACTIVATE:
     {
+        USHORT flags = WinQueryWindowUShort(hwnd,QWS_FLAGS);
+
         dprintf(("OS2: WM_ACTIVATE %x %x %x", hwnd, mp1, mp2));
 
-        if(win32wnd->IsWindowCreated())
+        if(win32wnd->IsWindowCreated()) 
+        {
+          WinSetWindowUShort(hwnd,QWS_FLAGS,mp1 ? (flags | FF_ACTIVE):(flags & ~FF_ACTIVE));
           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);
+          }
+        }
+
         break;
     }
@@ -289 +469 @@
     }
 
+
     case WM_MINMAXFRAME:
     {
-        dprintf(("OS2: WM_MINMAXFRAME"));
-        break;
+      PSWP swp = (PSWP)mp1;
+
+      if (!win32wnd->IsWindowCreated()) goto RunDefFrameProc;
+      dprintf(("OS2: WM_MINMAXFRAME %x",hwnd));
+      if ((swp->fl & SWP_MAXIMIZE) == SWP_MAXIMIZE)
+      {
+        win32wnd->setStyle((win32wnd->getStyle() & ~WS_MINIMIZE_W) | WS_MAXIMIZE_W);
+
+        RECT rect;
+
+        rect.left = rect.top = rect.right = rect.bottom = 0;
+        win32wnd->AdjustMaximizedRect(&rect);
+        swp->x += rect.left;
+        swp->cx += rect.right-rect.left;
+        swp->y -= rect.bottom;
+        swp->cy += rect.bottom-rect.top;
+      }
+      else if ((swp->fl & SWP_MINIMIZE) == SWP_MINIMIZE)
+      {
+        win32wnd->setStyle((win32wnd->getStyle() & ~WS_MAXIMIZE_W) | WS_MINIMIZE_W);
+      }
+      else if ((swp->fl & SWP_RESTORE) == SWP_RESTORE)
+      {
+        win32wnd->setStyle(win32wnd->getStyle() & ~(WS_MINIMIZE_W | WS_MAXIMIZE_W));
+      }
+      goto RunDefFrameProc;
     }
 
@@ -322 +527 @@
     }
 #else
-      dprintf(("PMWINDOW: WM_CALCVALIDRECTS"));
+      dprintf(("PMWINDOW: WM_CALCVALIDRECTS %x", win32wnd->getWindowHandle()));
       RestoreOS2TIB();
       return (MRESULT)(CVR_ALIGNLEFT | CVR_ALIGNTOP);
 #endif
+
+    case WM_VRNENABLED:
+        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;
+        }
+        goto RunDefWndProc;
 
     case WM_SETFOCUS:
@@ -350 +576 @@
     //**************************************************************************
     case WM_HITTEST:
-        if(win32wnd->getWindowHandle() != pWinMsg->hwnd) {
-                win32wnd = Win32BaseWindow::GetWindowFromHandle(pWinMsg->hwnd);
-        }
-        if(win32wnd)
-                rc = win32wnd->MsgHitTest(pWinMsg);
-        break;
-
+    {
+        if(win32wnd->getWindowHandle() != pWinMsg->hwnd) {
+                win32wnd = Win32BaseWindow::GetWindowFromHandle(pWinMsg->hwnd);
+        }
+        if(win32wnd && win32wnd->IsWindowCreated())
+        {
+          MRESULT rc;
+
+          rc = (MRESULT)win32wnd->MsgHitTest(pWinMsg);
+          RestoreOS2TIB();
+          return rc;
+        }
+        return (MRESULT)HT_NORMAL;
+    }
 
     case WM_BUTTON1DOWN:
@@ -452 +685 @@
     case WM_PAINT:
     {
-//     RECTL rectl;
-
-        dprintf(("OS2: WM_PAINT"));
-        win32wnd->DispatchMsgA(pWinMsg);
+      RECTL rectl;
+
+        WinQueryUpdateRect(hwnd, &rectl);
+        dprintf(("OS2: WM_PAINT (%d,%d) (%d,%d)", rectl.xLeft, rectl.yBottom, rectl.xRight, rectl.yTop));
+        if(win32wnd->IsWindowCreated()) 
+        {
+                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);
+        }
         //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) {
@@ -465 +712 @@
 //      dprintf(("Update rectangle (%d,%d)(%d,%d) not empty, msg %x", rectl.xLeft, rectl.yTop, rectl.xRight, rectl.yBottom, pWinMsg->message));
         goto RunDefWndProc;
-    }
-
-    case WM_CONTEXTMENU:
-    {
-        win32wnd->DispatchMsgA(pWinMsg);
-
-        RestoreOS2TIB();
-        return (MRESULT)TRUE;
+//        break;
     }
 
@@ -482 +722 @@
     }
 
+#if 0
+    case WM_CONTEXTMENU:
+    {
+        win32wnd->DispatchMsgA(pWinMsg);
+
+        RestoreOS2TIB();
+        return (MRESULT)TRUE;
+    }
+#endif
+
     case WM_FOCUSCHANGE:
         dprintf(("OS2: WM_FOCUSCHANGE %x", win32wnd->getWindowHandle()));
         goto RunDefWndProc;
+
+    case WM_QUERYTRACKINFO:
+    {
+      PTRACKINFO trackInfo = (PTRACKINFO)mp2;
+
+        dprintf(("OS2: WM_QUERYTRACKINFO %x", win32wnd->getWindowHandle()));
+        RestoreOS2TIB();
+        PMFrameWindowProc(hwnd,msg,mp1,mp2);
+        SetWin32TIB();
+        trackInfo->cxBorder = 4;
+        trackInfo->cyBorder = 4;
+        win32wnd->AdjustTrackInfo((PPOINT)&trackInfo->ptlMinTrackSize,(PPOINT)&trackInfo->ptlMaxTrackSize);
+        RestoreOS2TIB();
+        return (MRESULT)TRUE;
+    }
+
+    case WM_QUERYBORDERSIZE:
+    {
+      PWPOINT size = (PWPOINT)mp1;
+
+      dprintf(("OS2: WM_QUERYBORDERSIZE %x", win32wnd->getWindowHandle()));
+
+      size->x = 0;
+      size->y = 0;
+      RestoreOS2TIB();
+      return (MRESULT)TRUE;
+    }
+
+    case WM_FORMATFRAME:
+        dprintf(("OS2: WM_FORMATFRAME %x", win32wnd->getWindowHandle()));
+        break;
+
+#if 0 
+    case WM_ADJUSTFRAMEPOS:
+        dprintf(("OS2: WM_ADJUSTFRAMEPOS %x", win32wnd->getWindowHandle()));
+        break;
+
+    case WM_QUERYFRAMEINFO:
+        dprintf(("OS2: WM_QUERYFRAMEINFO %x", win32wnd->getWindowHandle()));
+        return (MRESULT)(FI_FRAME|FI_ACTIVATEOK);
+
+    case WM_QUERYFOCUSCHAIN:
+    {
+      USHORT fsCmd = SHORT1FROMMP(mp1);
+
+        dprintf(("OS2: WM_QUERYFOCUSCHAIN %x %x %x", win32wnd->getWindowHandle(), mp1, mp2));
+        switch(fsCmd) {
+        case QFC_NEXTINCHAIN:
+                break;
+        case QFC_ACTIVE:
+        case QFC_FRAME:
+                if(win32wnd->GetTopParent()) {
+                        dprintf(("Frame = %x", win32wnd->GetTopParent()->getOS2WindowHandle()));
+                        return (MRESULT)win32wnd->GetTopParent()->getOS2WindowHandle();
+                }
+                break;
+        case QFC_SELECTACTIVE:
+                break;
+        case QFC_PARTOFCHAIN:
+                return (MRESULT)TRUE;
+        }
+        break;
+    }
+#endif
 
     case WM_INITMENU:
@@ -511 +825 @@
     case WM_SEMANTICEVENT:
     default:
-        //dprintf(("OS2: RunDefWndProc msg %x for %x", msg, hwnd));
+//        dprintf(("OS2: RunDefWndProc msg %x for %x", msg, hwnd));
         RestoreOS2TIB();
-        return WinDefWindowProc( hwnd, msg, mp1, mp2 );
+        return PMFrameWindowProc(hwnd, msg, mp1, mp2);
+//        return WinDefWindowProc( hwnd, msg, mp1, mp2 );
   }
   RestoreOS2TIB();
   return (MRESULT)rc;
 
+RunDefFrameProc:
+  RestoreOS2TIB();
+  return PMFrameWindowProc(hwnd, msg, mp1, mp2);
+
 RunDefWndProc:
 //  dprintf(("OS2: RunDefWndProc msg %x for %x", msg, hwnd));
   RestoreOS2TIB();
-
-  return WinDefWindowProc( hwnd, msg, mp1, mp2 );
+  return PMFrameWindowProc(hwnd, msg, mp1, mp2);
+//  return WinDefWindowProc( hwnd, msg, mp1, mp2 );
 } /* End of Win32WindowProc */
 //******************************************************************************
+//TODO: Quickly moving a window two times doesn't force a repaint (1st time)
 //******************************************************************************
+VOID FrameTrackFrame(Win32BaseWindow *win32wnd,DWORD flags)
+{
+  TRACKINFO track;
+  RECTL     rcl;
+  PRECT     pWindowRect;
+  HWND      hwndTracking;
+  HPS       hpsTrack;
+  LONG      parentHeight, parentWidth;
+
+   track.cxBorder = 4;
+   track.cyBorder = 4;  /* 4 pel wide lines used for rectangle */
+   track.cxGrid = 1;
+   track.cyGrid = 1;    /* smooth tracking with mouse */
+   track.cxKeyboard = 8;
+   track.cyKeyboard = 8; /* faster tracking using cursor keys */
+
+   pWindowRect = win32wnd->getWindowRect();
+   if(win32wnd->getParent()) {
+        parentHeight = win32wnd->getParent()->getWindowHeight();
+        parentWidth  = win32wnd->getParent()->getWindowWidth();
+        hwndTracking = win32wnd->getParent()->getOS2WindowHandle();
+        hpsTrack     = WinGetPS(hwndTracking);  
+   }
+   else {
+        parentHeight = OSLibQueryScreenHeight();
+        parentWidth  = OSLibQueryScreenWidth();
+        hwndTracking = HWND_DESKTOP;
+        hpsTrack     = NULL;
+   }
+
+   rcl.xLeft   = pWindowRect->left;
+   rcl.yTop    = OSLibQueryScreenHeight() - pWindowRect->top;
+   rcl.xRight  = pWindowRect->right;
+   rcl.yBottom = OSLibQueryScreenHeight() - pWindowRect->bottom;
+   if(hwndTracking != HWND_DESKTOP) {
+        WinMapWindowPoints(win32wnd->getOS2WindowHandle(), HWND_DESKTOP, (PPOINTL)&rcl, 2);
+   }
+   WinCopyRect(hab, &track.rclTrack, &rcl);   /* starting point */
+ 
+   WinSetRect(hab, &track.rclBoundary, 0, 0, parentWidth, parentHeight); /* bounding rectangle */
+ 
+   track.ptlMinTrackSize.x = 10;
+   track.ptlMinTrackSize.y = 10;  /* set smallest allowed size of rectangle */
+   track.ptlMaxTrackSize.x = parentWidth;
+   track.ptlMaxTrackSize.y = parentHeight; /* set largest allowed size of rectangle */
+
+   win32wnd->AdjustTrackInfo((PPOINT)&track.ptlMinTrackSize, (PPOINT)&track.ptlMaxTrackSize);
+ 
+   track.fs = flags;
+ 
+   if(WinTrackRect(HWND_DESKTOP, NULL, &track) )
+   {
+        if(hpsTrack)    WinReleasePS(hpsTrack);
+
+        /* if successful copy final position back */
+        if(!WinEqualRect(0, &rcl, &track.rclTrack)) {
+                if(flags == TF_MOVE) {
+                        WinSetWindowPos(win32wnd->getOS2WindowHandle(), 
+                                        0, track.rclTrack.xLeft, track.rclTrack.yBottom, 
+                                        0, 0, SWP_MOVE);
+                }
+                else {
+                        WinSetWindowPos(win32wnd->getOS2WindowHandle(), 
+                                        0, track.rclTrack.xLeft, track.rclTrack.yBottom, 
+                                        track.rclTrack.xRight - track.rclTrack.xLeft, 
+                                        track.rclTrack.yTop - track.rclTrack.yBottom, 
+                                        SWP_SIZE|SWP_MOVE);
+                }
+        }
+        return;
+   }
+   if(hpsTrack) WinReleasePS(hpsTrack);
+   return;
+}
+//******************************************************************************
+//******************************************************************************