]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/window.cpp
added native wxColourDialog for GTK2
[wxWidgets.git] / src / os2 / window.cpp
index c9ad0104c27ed19901f3da7c8c9873b9de1ac86b..0c448ce6f5a53462b371a0857d4a20e1ad11ef47 100644 (file)
     #include "wx/app.h"
     #include "wx/panel.h"
     #include "wx/layout.h"
+    #include "wx/checkbox.h"
+    #include "wx/combobox.h"
     #include "wx/dialog.h"
     #include "wx/frame.h"
     #include "wx/listbox.h"
     #include "wx/button.h"
+    #include "wx/bmpbuttn.h"
     #include "wx/msgdlg.h"
     #include "wx/scrolwin.h"
     #include "wx/radiobox.h"
+    #include "wx/radiobut.h"
     #include "wx/slider.h"
+    #include "wx/statbox.h"
     #include "wx/statusbr.h"
     #include "wx/toolbar.h"
     #include "wx/settings.h"
     #include "wx/tooltip.h"
 #endif
 
+#if wxUSE_NOTEBOOK
+    #include "wx/notebook.h"
+#endif
+
 #if wxUSE_CARET
     #include "wx/caret.h"
 #endif // wxUSE_CARET
@@ -285,21 +294,16 @@ bool wxWindowOS2::OS2Command(
 
 void wxWindowOS2::Init()
 {
-    //
-    // Generic
-    //
-    InitBase();
-
     //
     // PM specific
     //
     m_bWinCaptured = FALSE;
 
-    m_isBeingDeleted        = FALSE;
     m_fnOldWndProc          = NULL;
     m_bUseCtl3D             = FALSE;
     m_bMouseInWindow        = FALSE;
     m_bLastKeydownProcessed = FALSE;
+    m_pChildrenDisabled     = NULL;
 
     //
     // wxWnd
@@ -352,9 +356,6 @@ wxWindowOS2::~wxWindowOS2()
 
     DestroyChildren();
 
-    if (m_parent)
-        m_parent->RemoveChild(this);
-
     if (m_hWnd)
     {
         if(!::WinDestroyWindow(GetHWND()))
@@ -364,6 +365,7 @@ wxWindowOS2::~wxWindowOS2()
         //
         wxRemoveHandleAssociation(this);
     }
+    delete m_pChildrenDisabled;
 } // end of wxWindowOS2::~wxWindowOS2
 
 // real construction (Init() must have been called before!)
@@ -407,8 +409,6 @@ bool wxWindowOS2::Create(
 
     if (pParent)
     {
-        int                         nTempy;
-
         pParent->AddChild(this);
         hParent = GetWinHwnd(pParent);
 
@@ -423,7 +423,7 @@ bool wxWindowOS2::Create(
     // set in those class create procs.  PM's basic windows styles are
     // very limited.
     //
-    ulCreateFlags |=  WS_VISIBLE | OS2GetCreateWindowFlags(&dwExStyle);
+    ulCreateFlags |=  OS2GetCreateWindowFlags(&dwExStyle);
 
 
 #ifdef __WXUNIVERSAL__
@@ -432,29 +432,27 @@ bool wxWindowOS2::Create(
 #endif // !wxUniversal
     if (lStyle & wxPOPUP_WINDOW)
     {
-        // a popup window floats on top of everything
-        // it is also created hidden as other top level windows
         ulCreateFlags &= ~WS_VISIBLE;
         m_isShown = FALSE;
     }
+    else
+    {
+        ulCreateFlags |= WS_VISIBLE;
+    }
 
     //
     // Generic OS/2 Windows have no Control Data but other classes
     // that call OS2Create may have some.
     //
-    bool                            bRetVal = OS2Create( (PSZ)wxCanvasClassName
-                                                        ,rName.c_str()
-                                                        ,ulCreateFlags
-                                                        ,rPos
-                                                        ,rSize
-                                                        ,NULL         // Control Data
-                                                        ,dwExStyle
-                                                        ,TRUE         // Child
-                                                       );
-
-    if (bRetVal)
-        ::WinSubclassWindow(m_hWnd, (PFNWP)wxWndProc);
-    return(bRetVal);
+    return(OS2Create( (PSZ)wxCanvasClassName
+                     ,rName.c_str()
+                     ,ulCreateFlags
+                     ,rPos
+                     ,rSize
+                     ,NULL         // Control Data
+                     ,dwExStyle
+                     ,TRUE         // Child
+                    ));
 } // end of wxWindowOS2::Create
 
 // ---------------------------------------------------------------------------
@@ -501,15 +499,58 @@ bool wxWindowOS2::Enable(
     if ( hWnd )
         ::WinEnableWindow(hWnd, (BOOL)bEnable);
 
+    //
+    // The logic below doesn't apply to the top level windows -- otherwise
+    // showing a modal dialog would result in total greying out (and ungreying
+    // out later) of everything which would be really ugly
+    //
+    if (IsTopLevel())
+        return TRUE;
+
     wxWindowList::Node*             pNode = GetChildren().GetFirst();
 
     while (pNode)
     {
         wxWindow*                   pChild = pNode->GetData();
 
-        pChild->Enable(bEnable);
+        if (bEnable)
+        {
+            //
+            // Enable the child back unless it had been disabled before us
+            //
+            if (!m_pChildrenDisabled || !m_pChildrenDisabled->Find(pChild))
+                pChild->Enable();
+        }
+        else // we're being disabled
+        {
+            if (pChild->IsEnabled())
+            {
+                //
+                // Disable it as children shouldn't stay enabled while the
+                // parent is not
+                //
+                pChild->Disable();
+            }
+            else // child already disabled, remember it
+            {
+                //
+                // Have we created the list of disabled children already?
+                //
+                if (!m_pChildrenDisabled)
+                    m_pChildrenDisabled = new wxWindowList;
+                m_pChildrenDisabled->Append(pChild);
+            }
+        }
         pNode = pNode->GetNext();
     }
+    if (bEnable && m_pChildrenDisabled)
+    {
+        //
+        // We don't need this list any more, don't keep unused memory
+        //
+        delete m_pChildrenDisabled;
+        m_pChildrenDisabled = NULL;
+    }
     return TRUE;
 } // end of wxWindowOS2::Enable
 
@@ -639,81 +680,11 @@ void wxWindowOS2::WarpPointer(
     ::WinSetPointerPos(HWND_DESKTOP, (LONG)nX, (LONG)(nY));
 } // end of wxWindowOS2::WarpPointer
 
-#if WXWIN_COMPATIBILITY
-void wxWindowOS2::OS2DeviceToLogical (float *x, float *y) const
-{
-}
-#endif // WXWIN_COMPATIBILITY
 
 // ---------------------------------------------------------------------------
 // scrolling stuff
 // ---------------------------------------------------------------------------
 
-#if WXWIN_COMPATIBILITY
-void wxWindowOS2::SetScrollRange(
-  int                               nOrient
-, int                               nRange
-, bool                              bRefresh
-)
-{
-    int                             nRange1 = nRange;
-    int                             nPageSize = GetScrollPage(nOrient);
-
-    if (nPpageSize > 1 && nRange > 0)
-    {
-        nRange1 += (nPageSize - 1);
-    }
-
-    if (nOrient == wxHORIZONTAL)
-    {
-        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
-        ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
-    }
-    else
-    {
-        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)0, MPFROM2SHORT(0, (SHORT)nRange1));
-        ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
-    }
-} // end of wxWindowOS2::SetScrollRange
-
-void wxWindowOS2::SetScrollPage(
-  int                               nOrient
-, int                               nPage
-, bool                              bRefresh
-)
-{
-    if (nOrient == wxHORIZONTAL )
-        m_nXThumbSize = nPage;
-    else
-        m_nYThumbSize = nPage;
-} // end of wxWindowOS2::SetScrollPage
-
-int wxWindowOS2::OldGetScrollRange(
-  int                               nOrient
-) const
-{
-    MRESULT                         mRc;
-    HWND                            hWnd = GetHwnd();
-
-    if (hWnd)
-    {
-        mRc = WinSendMsg(hWnd, SBM_QUERYRANGE, (MPARAM)0L, (MPARAM)0L);
-        return(SHORT2FROMMR(mRc));
-     }
-     return 0;
-} // end of wxWindowOS2::OldGetScrollRange
-
-int  wxWindowOS2::GetScrollPage(
-  int                               nOrient
-) const
-{
-    if (nOrient == wxHORIZONTAL)
-        return m_nXThumbSize;
-    else
-        return m_nYThumbSize;
-} // end of wxWindowOS2::GetScrollPage
-#endif // WXWIN_COMPATIBILITY
-
 int  wxWindowOS2::GetScrollPos(
   int                               nOrient
 ) const
@@ -776,7 +747,6 @@ void wxWindowOS2::SetScrollbar(
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     SWP                             vSwp;
     SWP                             vSwpOwner;
-    RECTL                           vRect;
     HWND                            hWndParent;
     HWND                            hWndClient;
     wxWindow*                       pParent = GetParent();
@@ -968,9 +938,6 @@ void wxWindowOS2::ScrollWindow(
 )
 {
     RECTL                           vRect;
-    RECTL                           vRectHorz;
-    RECTL                           vRectVert;
-    RECTL                           vRectChild;
 
     if (pRect)
     {
@@ -1120,7 +1087,7 @@ WXDWORD wxWindowOS2::OS2GetStyle(
 } // end of wxWindowMSW::MSWGetStyle
 
 //
-// Make a Windows extended style from the given wxWindows window style
+// Make a Windows extended style from the given wxWidgets window style
 //
 WXDWORD wxWindowOS2::MakeExtendedStyle(
   long                              lStyle
@@ -1150,118 +1117,6 @@ WXDWORD wxWindowOS2::MakeExtendedStyle(
     return dwStyle;
 } // end of wxWindowOS2::MakeExtendedStyle
 
-//
-// Determines whether simulated 3D effects or CTL3D should be used,
-// applying a default border style if required, and returning an extended
-// style to pass to OS2Create.
-//
-WXDWORD wxWindowOS2::Determine3DEffects(
-  WXDWORD                           dwDefaultBorderStyle
-, bool*                             pbWant3D
-) const
-{
-    WXDWORD                         dwStyle = 0L;
-
-    //
-    // Native PM does not have any specialize 3D effects like WIN32 does,
-    // so we have to try and invent them.
-    //
-
-    //
-    // If matches certain criteria, then assume no 3D effects
-    // unless specifically requested (dealt with in MakeExtendedStyle)
-    //
-    if (!GetParent()                    ||
-        !IsKindOf(CLASSINFO(wxControl)) ||
-        (m_windowStyle & wxNO_BORDER)
-       )
-    {
-        *pbWant3D = FALSE;
-        return MakeExtendedStyle(m_windowStyle, FALSE);
-    }
-
-    //
-    // 1) App can specify global 3D effects
-    //
-    *pbWant3D = wxTheApp->GetAuto3D();
-
-    //
-    // 2) If the parent is being drawn with user colours, or simple border
-    //    specified, switch effects off.
-    //
-    if (GetParent() &&
-        (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS) ||
-        (m_windowStyle & wxSIMPLE_BORDER)
-       )
-        *pbWant3D = FALSE;
-
-    //
-    // 3) Control can override this global setting by defining
-    //    a border style, e.g. wxSUNKEN_BORDER
-    //
-    if ((m_windowStyle & wxDOUBLE_BORDER) ||
-        (m_windowStyle & wxRAISED_BORDER) ||
-        (m_windowStyle & wxSTATIC_BORDER) ||
-        (m_windowStyle & wxSUNKEN_BORDER)
-       )
-        *pbWant3D = TRUE;
-
-    dwStyle = MakeExtendedStyle( m_windowStyle
-                                ,FALSE
-                               );
-
-    //
-    // If we want 3D, but haven't specified a border here,
-    // apply the default border style specified.
-    //
-    if (dwDefaultBorderStyle && (*pbWant3D) &&
-        !((m_windowStyle & wxDOUBLE_BORDER) ||
-          (m_windowStyle & wxRAISED_BORDER) ||
-          (m_windowStyle & wxSTATIC_BORDER) ||
-          (m_windowStyle & wxSIMPLE_BORDER)
-         )
-        )
-        dwStyle |= dwDefaultBorderStyle;
-    return dwStyle;
-} // end of wxWindowOS2::Determine3DEffects
-
-#if WXWIN_COMPATIBILITY
-void wxWindowOS2::OnCommand(
-  wxWindow&                         rWin
-, wxCommandEvent&                   rEvent
-)
-{
-    if (GetEventHandler()->ProcessEvent(rEvent))
-        return;
-    if (m_parent)
-        m_parent->GetEventHandler()->OnCommand( rWin
-                                               ,rEvent
-                                              );
-} // end of wxWindowOS2::OnCommand
-
-wxObject* wxWindowOS2::GetChild(
-  int                               nNumber
-) const
-{
-    //
-    // Return a pointer to the Nth object in the Panel
-    //
-    wxNode*                         pNode = GetChildren().First();
-    int                             n = nNumber;
-
-    while (pNode && n--)
-        pNode = pNode->Next();
-    if (pNode)
-    {
-        wxObject*                   pObj = (wxObject*)pNode->Data();
-        return(pObj);
-    }
-    else
-        return NULL;
-} // end of wxWindowOS2::GetChild
-
-#endif // WXWIN_COMPATIBILITY
-
 //
 // Setup background and foreground colours correctly
 //
@@ -1297,10 +1152,10 @@ void wxWindowOS2::OnIdle(
             //
             int                     nState = 0;
 
-            if (::WinGetKeyState(HWND_DESKTOP, VK_SHIFT) != 0)
-                nState |= VK_SHIFT;
-            if (::WinGetKeyState(HWND_DESKTOP, VK_CTRL) != 0);
-                nState |= VK_CTRL;
+            if (IsShiftDown())
+                nState |= KC_SHIFT;
+            if (IsCtrlDown())
+                nState |= KC_CTRL;
 
             wxMouseEvent            rEvent(wxEVT_LEAVE_WINDOW);
 
@@ -1312,7 +1167,8 @@ void wxWindowOS2::OnIdle(
             (void)GetEventHandler()->ProcessEvent(rEvent);
         }
     }
-    UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
 } // end of wxWindowOS2::OnIdle
 
 //
@@ -1332,17 +1188,6 @@ bool wxWindowOS2::Reparent(
     return TRUE;
 } // end of wxWindowOS2::Reparent
 
-void wxWindowOS2::Clear()
-{
-    wxClientDC                      vDc((wxWindow*)this);
-    wxBrush                         vBrush( GetBackgroundColour()
-                                           ,wxSOLID
-                                          );
-
-    vDc.SetBackground(vBrush);
-    vDc.Clear();
-} // end of wxWindowOS2::Clear
-
 void wxWindowOS2::Update()
 {
     ::WinUpdateWindow(GetHwnd());
@@ -1378,9 +1223,9 @@ void wxWindowOS2::Refresh(
             RECTL                   vOs2Rect;
 
             vOs2Rect.xLeft   = pRect->x;
-            vOs2Rect.yTop    = pRect->y;
+            vOs2Rect.yBottom = pRect->y;
             vOs2Rect.xRight  = pRect->x + pRect->width;
-            vOs2Rect.yBottom = pRect->y + pRect->height;
+            vOs2Rect.yTop    = pRect->y + pRect->height;
 
             ::WinInvalidateRect(hWnd, &vOs2Rect, bEraseBack);
         }
@@ -1402,14 +1247,7 @@ void wxWindowOS2::SetDropTarget(
   wxDropTarget*                     pDropTarget
 )
 {
-    if (m_dropTarget != 0)
-    {
-        m_dropTarget->Revoke(m_hWnd);
-        delete m_dropTarget;
-    }
     m_dropTarget = pDropTarget;
-    if (m_dropTarget != 0)
-        m_dropTarget->Register(m_hWnd);
 } // end of wxWindowOS2::SetDropTarget
 #endif
 
@@ -1633,7 +1471,6 @@ void wxWindowOS2::DoMoveWindow(
 )
 {
     RECTL                           vRect;
-    HWND                            hParent;
     wxWindow*                       pParent = GetParent();
 
     if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
@@ -1649,13 +1486,85 @@ void wxWindowOS2::DoMoveWindow(
         ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
         nY = vRect.yTop - (nY + nHeight);
     }
+
+    //
+    // In the case of a frame whose client is sized, the client cannot be
+    // large than its parent frame minus its borders! This usually happens
+    // when using an autosizer to size a frame to precisely hold client
+    // controls as in the notebook sample.
+    //
+    // In this case, we may need to resize both a frame and its client so we
+    // need a quick calc of the frame border size, then if the frame
+    // (less its borders) is smaller than the client, size the frame to
+    // encompass the client with the appropriate border size.
+    //
+    if (IsKindOf(CLASSINFO(wxFrame)))
+    {
+        RECTL                       vFRect;
+        HWND                        hWndFrame;
+        int                         nWidthFrameDelta = 0;
+        int                         nHeightFrameDelta = 0;
+        int                         nHeightFrame = 0;
+        int                         nWidthFrame = 0;
+        wxFrame*                    pFrame;
+
+        pFrame = wxDynamicCast(this, wxFrame);
+        hWndFrame = pFrame->GetFrame();
+        ::WinQueryWindowRect(hWndFrame, &vRect);
+        ::WinMapWindowPoints(hWndFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
+        vFRect = vRect;
+        ::WinCalcFrameRect(hWndFrame, &vRect, TRUE);
+        nWidthFrameDelta = ((vRect.xLeft - vFRect.xLeft) + (vFRect.xRight - vRect.xRight));
+        nHeightFrameDelta = ((vRect.yBottom - vFRect.yBottom) + (vFRect.yTop - vRect.yTop));
+        nWidthFrame = vFRect.xRight - vFRect.xLeft;
+        nHeightFrame = vFRect.yTop - vFRect.yBottom;
+
+        if (nWidth == vFRect.xRight - vFRect.xLeft &&
+            nHeight == vFRect.yTop - vFRect.yBottom)
+        {
+            //
+            // In this case the caller is not aware of OS/2's need to size both
+            // the frame and it's client and is really only moving the window,
+            // not resizeing it.  So move the frame, and back off the sizes
+            // for a proper client fit.
+            //
+            ::WinSetWindowPos( hWndFrame
+                              ,HWND_TOP
+                              ,(LONG)nX - (vRect.xLeft - vFRect.xLeft)
+                              ,(LONG)nY - (vRect.yBottom - vFRect.yBottom)
+                              ,(LONG)0
+                              ,(LONG)0
+                              ,SWP_MOVE
+                             );
+            nX += (vRect.xLeft - vFRect.xLeft);
+            nY += (vRect.yBottom - vFRect.yBottom);
+            nWidth -= nWidthFrameDelta;
+            nHeight -= nHeightFrameDelta;
+        }
+        else
+        {
+            if (nWidth > nWidthFrame - nHeightFrameDelta ||
+                nHeight > nHeightFrame - nHeightFrameDelta)
+            {
+                ::WinSetWindowPos( hWndFrame
+                                  ,HWND_TOP
+                                  ,(LONG)nX - (vRect.xLeft - vFRect.xLeft)
+                                  ,(LONG)nY - (vRect.yBottom - vFRect.yBottom)
+                                  ,(LONG)nWidth + nWidthFrameDelta
+                                  ,(LONG)nHeight + nHeightFrameDelta
+                                  ,SWP_MOVE | SWP_SIZE
+                                 );
+            }
+        }
+    }
+
     ::WinSetWindowPos( GetHwnd()
                       ,HWND_TOP
                       ,(LONG)nX
                       ,(LONG)nY
                       ,(LONG)nWidth
                       ,(LONG)nHeight
-                      ,SWP_ZORDER | SWP_SIZE | SWP_MOVE | SWP_SHOW
+                      ,SWP_SIZE | SWP_MOVE
                      );
     if (m_vWinSwp.cx == 0 && m_vWinSwp.cy == 0 && m_vWinSwp.fl == 0)
         //
@@ -1751,21 +1660,7 @@ void wxWindowOS2::DoSetSize(
     // Must convert Y coords to test for equality under OS/2
     //
     int                             nY2 = nY;
-    wxWindow*                       pParent = (wxWindow*)GetParent();
-
-    if (pParent && !IsKindOf(CLASSINFO(wxDialog)))
-    {
-        int                         nOS2Height = GetOS2ParentHeight(pParent);
 
-        nY2 = nOS2Height - (nY2 + nHeight);
-    }
-    else
-    {
-        RECTL                       vRect;
-
-        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
-        nY2 = vRect.yTop - (nY2 + nHeight);
-    }
     if (nX == nCurrentX && nY2 == nCurrentY &&
         nWidth == nCurrentWidth && nHeight == nCurrentHeight)
     {
@@ -1824,34 +1719,61 @@ void wxWindowOS2::DoSetClientSize(
 , int                               nHeight
 )
 {
-    wxWindow*                       pParent = GetParent();
-    HWND                            hWnd = GetHwnd();
-    HWND                            hParentWnd = (HWND)0;
     POINTL                          vPoint;
-    RECTL                           vRect;
-    RECTL                           vRect2;
-    RECTL                           vRect3;
-    HWND                            hClientWnd = (HWND)0;
+    int                             nActualWidth;
+    int                             nActualHeight;
+    wxWindow*                       pParent = (wxWindow*)GetParent();
+    HWND                            hParentWnd = (HWND)0;
 
-    hClientWnd = ::WinWindowFromID(hWnd, FID_CLIENT);
-    ::WinQueryWindowRect(hClientWnd, &vRect2);
-    ::WinQueryWindowRect(hWnd, &vRect);
-    ::WinQueryWindowRect(hParentWnd, &vRect3);
+    if (pParent)
+        hParentWnd = (HWND)pParent->GetHWND();
 
-    int                             nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
-    int                             nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight;
+    if (IsKindOf(CLASSINFO(wxFrame)))
+    {
+        wxFrame*                    pFrame = wxDynamicCast(this, wxFrame);
+        HWND                        hFrame = pFrame->GetFrame();
+        RECTL                       vRect;
+        RECTL                       vRect2;
+        RECTL                       vRect3;
 
-    vPoint.x = vRect2.xLeft;
-    vPoint.y = vRect2.yBottom;
-    if (pParent)
+        ::WinQueryWindowRect(GetHwnd(), &vRect2);
+        ::WinQueryWindowRect(hFrame, &vRect);
+        ::WinQueryWindowRect(hParentWnd, &vRect3);
+        nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
+        nActualHeight = vRect2.yTop - vRect2.yBottom - vRect.yTop + nHeight;
+
+        vPoint.x = vRect2.xLeft;
+        vPoint.y = vRect2.yBottom;
+        if (pParent)
+        {
+            vPoint.x -= vRect3.xLeft;
+            vPoint.y -= vRect3.yBottom;
+        }
+    }
+    else
     {
-        vPoint.x -= vRect3.xLeft;
-        vPoint.y -= vRect3.yBottom;
+        int                         nX;
+        int                         nY;
+
+        GetPosition(&nX, &nY);
+        nActualWidth  = nWidth;
+        nActualHeight = nHeight;
+
+        vPoint.x = nX;
+        vPoint.y = nY;
     }
+    DoMoveWindow( vPoint.x
+                 ,vPoint.y
+                 ,nActualWidth
+                 ,nActualHeight
+                );
 
-    DoMoveWindow(vPoint.x, vPoint.y, nActualWidth, nActualHeight);
+    wxSizeEvent                     vEvent( wxSize( nWidth
+                                                   ,nHeight
+                                                  )
+                                           ,m_windowId
+                                          );
 
-    wxSizeEvent                     vEvent(wxSize(nWidth, nHeight), m_windowId);
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::DoSetClientSize
@@ -1912,9 +1834,8 @@ void wxWindowOS2::GetTextExtent(
     int                             i;
     int                             l;
     FONTMETRICS                     vFM; // metrics structure
-    BOOL                            bRc;
+    BOOL                            bRc = FALSE;
     char*                           pStr;
-    ERRORID                         vErrorCode; // last error id code
     HPS                             hPS;
 
 
@@ -2015,89 +1936,11 @@ bool wxWindowOS2::IsMouseInWindow() const
     return hWnd != NULL;
 } // end of wxWindowOS2::IsMouseInWindow
 
-#if wxUSE_CARET && WXWIN_COMPATIBILITY
-// ---------------------------------------------------------------------------
-// Caret manipulation
-// ---------------------------------------------------------------------------
-
-void wxWindowOS2::CreateCaret(
-  int                               nWidth
-, int                               nHeight
-)
-{
-    SetCaret(new wxCaret( this
-                         ,nWidth
-                         ,nHeight
-                        ));
-} // end of wxWindowOS2::CreateCaret
-
-void wxWindowOS2::CreateCaret(
-  const wxBitmap*                   pBitmap
-)
-{
-    wxFAIL_MSG("not implemented");
-} // end of wxWindowOS2::CreateCaret
-
-void wxWindowOS2::ShowCaret(
-  bool                              bShow
-)
-{
-    wxCHECK_RET( m_caret, "no caret to show" );
-
-    m_caret->Show(bShow);
-} // end of wxWindowOS2::ShowCaret
-
-void wxWindowOS2::DestroyCaret()
-{
-    SetCaret(NULL);
-} // end of wxWindowOS2::DestroyCaret
-
-void wxWindowOS2::SetCaretPos(
-  int                               nX
-, int                               nY)
-{
-    wxCHECK_RET( m_caret, "no caret to move" );
-
-    m_caret->Move( nX
-                  ,nY
-                 );
-} // end of wxWindowOS2::SetCaretPos
-
-void wxWindowOS2::GetCaretPos(
-  int*                              pX
-, int*                              pY
-) const
-{
-    wxCHECK_RET( m_caret, "no caret to get position of" );
-
-    m_caret->GetPosition( pX
-                         ,pY
-                        );
-} // end of wxWindowOS2::GetCaretPos
-
-#endif //wxUSE_CARET
 
 // ---------------------------------------------------------------------------
 // popup menu
 // ---------------------------------------------------------------------------
 //
-#if wxUSE_MENUS_NATIVE
-static void wxYieldForCommandsOnly()
-{
-    //
-    // Peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
-    // want to process it here)
-    //
-    QMSG                            vMsg;
-
-    while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE)
-           && vMsg.msg != WM_QUIT)
-    {
-        wxTheApp->DoMessage((WXMSG*)&vMsg);
-    }
-}
-#endif // wxUSE_MENUS_NATIVE
-
 #if wxUSE_MENUS_NATIVE
 bool wxWindowOS2::DoPopupMenu(
   wxMenu*                           pMenu
@@ -2112,10 +1955,18 @@ bool wxWindowOS2::DoPopupMenu(
 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();
-
-    DoClientToScreen( &nX
-                     ,&nY
-                    );
+    
+    if ( x == -1 && y == -1 )
+    {
+        wxPoint mouse = wxGetMousePosition();
+        nX = mouse.x; nY = mouse.y;
+    }
+    else
+    {
+        DoClientToScreen( &nX
+                         ,&nY
+                        );
+    }
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent
@@ -2130,7 +1981,6 @@ bool wxWindowOS2::DoPopupMenu(
     while(bIsWaiting)
     {
         QMSG                            vMsg;
-        BOOL                            bRc = ::WinGetMsg(vHabmain, &vMsg, HWND(NULL), 0, 0);
 
         if (vMsg.msg == WM_MENUEND || vMsg.msg == WM_COMMAND)
         {
@@ -2288,6 +2138,14 @@ bool wxWindowOS2::OS2ProcessMessage(
                                 pBtn->OS2Command(BN_CLICKED, 0 /* unused */);
                                 return TRUE;
                             }
+                            else if (!IsTopLevel())
+                            {
+                                //
+                                // if not a top level window, let parent
+                                // handle it
+                                //
+                                return FALSE;
+                            }
                             // else: but if it does not it makes sense to make
                             //       it work like a TAB - and that's what we do.
                             //       Note that Ctrl-Enter always works this way.
@@ -2419,7 +2277,7 @@ void wxWindowOS2::UnpackMenuSelect(
 } // end of wxWindowOS2::UnpackMenuSelect
 
 // ---------------------------------------------------------------------------
-// Main wxWindows window proc and the window proc for wxWindow
+// Main wxWidgets window proc and the window proc for wxWindow
 // ---------------------------------------------------------------------------
 
 //
@@ -2438,14 +2296,6 @@ MRESULT EXPENTRY wxWndProc(
 , MPARAM                            lParam
 )
 {
-    //
-    // Trace all ulMsgs - useful for the debugging
-    //
-#ifdef __WXDEBUG__
-    wxLogTrace(wxTraceMessages, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
-               wxGetMessageName(ulMsg), wParam, lParam);
-#endif // __WXDEBUG__
-
     wxWindowOS2*                    pWnd = wxFindWinFromHandle((WXHWND)hWnd);
 
     //
@@ -2667,7 +2517,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
                     bProcessed = HandleMouseEvent( uMsg
                                                   ,nX
                                                   ,nY
-                                                  ,(WXUINT)SHORT1FROMMP(wParam)
+                                                  ,(WXUINT)SHORT2FROMMP(lParam)
                                                  );
                 }
                 else
@@ -2676,10 +2526,15 @@ MRESULT wxWindowOS2::OS2WindowProc(
                                                                    ,&nX
                                                                    ,&nY
                                                                   );
+                    if (!pWin->IsOfStandardClass())
+                    {
+                        if (uMsg == WM_BUTTON1DOWN && pWin->AcceptsFocus() )
+                            pWin->SetFocus();
+                    }
                     bProcessed = pWin->HandleMouseEvent( uMsg
                                                         ,nX
                                                         ,nY
-                                                        ,(WXUINT)SHORT1FROMMP(wParam)
+                                                        ,(WXUINT)SHORT2FROMMP(lParam)
                                                        );
                 }
             }
@@ -2714,8 +2569,9 @@ MRESULT wxWindowOS2::OS2WindowProc(
                 }
                 else
                 {
-                    bProcessed = OS2OnMeasureItem(nIdCtrl,
-                                                 (WXMEASUREITEMSTRUCT *)lParam);
+                    return MRFROMLONG(OS2OnMeasureItem( nIdCtrl
+                                                       ,(WXMEASUREITEMSTRUCT *)lParam
+                                                      ));
                 }
 
                 if ( bProcessed )
@@ -2781,7 +2637,6 @@ MRESULT wxWindowOS2::OS2WindowProc(
                             // Avoid duplicate messages to OnChar for these ASCII keys: they
                             // will be translated by TranslateMessage() and received in WM_CHAR
                             case VK_ESC:
-                            case VK_SPACE:
                             case VK_ENTER:
                             case VK_BACKSPACE:
                             case VK_TAB:
@@ -2842,6 +2697,157 @@ MRESULT wxWindowOS2::OS2WindowProc(
         case WM_CONTROL:
             switch(SHORT2FROMMP(wParam))
             {
+                case BN_PAINT:
+                    {
+                        HWND                hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam));
+                        wxWindowOS2*        pWin = wxFindWinFromHandle(hWnd);
+
+                        if (!pWin)
+                        {
+                            bProcessed = FALSE;
+                            break;
+                        }
+                        if (pWin->IsKindOf(CLASSINFO(wxBitmapButton)))
+                        {
+                            wxBitmapButton*     pBitmapButton = wxDynamicCast(pWin, wxBitmapButton);
+
+                            pBitmapButton->OS2OnDraw((WXDRAWITEMSTRUCT *)lParam);
+                        }
+                        return 0;
+                    }
+                    break;
+
+                case BKN_PAGESELECTEDPENDING:
+                    {
+                        PPAGESELECTNOTIFY  pPage = (PPAGESELECTNOTIFY)lParam;
+
+                        if ((pPage->ulPageIdNew != pPage->ulPageIdCur) &&
+                            (pPage->ulPageIdNew > 0L && pPage->ulPageIdCur > 0L))
+                        {
+                            wxWindowOS2*        pWin = wxFindWinFromHandle(pPage->hwndBook);
+                            wxNotebookEvent     vEvent( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
+                                                       ,(int)SHORT1FROMMP(wParam)
+                                                       ,(int)pPage->ulPageIdNew
+                                                       ,(int)pPage->ulPageIdCur
+                                                      );
+                            if (!pWin)
+                            {
+                                bProcessed = FALSE;
+                                break;
+                            }
+                            if (pWin->IsKindOf(CLASSINFO(wxNotebook)))
+                            {
+                                wxNotebook*         pNotebook = wxDynamicCast(pWin, wxNotebook);
+
+                                vEvent.SetEventObject(pWin);
+                                pNotebook->OnSelChange(vEvent);
+                                bProcessed = TRUE;
+                            }
+                            else
+                                bProcessed = FALSE;
+                        }
+                        else
+                            bProcessed = FALSE;
+                    }
+                    break;
+
+                case BN_CLICKED: // Dups as LN_SELECT and CBN_LBSELECT
+                    {
+                        HWND                hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam));
+                        wxWindowOS2*        pWin = wxFindWinFromHandle(hWnd);
+
+                        if (!pWin)
+                        {
+                            bProcessed = FALSE;
+                            break;
+                        }
+                        //
+                        // Simulate a WM_COMMAND here, as wxWidgets expects all control
+                        // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
+                        //
+                        if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
+                        {
+                            wxRadioBox*         pRadioBox = wxDynamicCast(pWin, wxRadioBox);
+
+                            pRadioBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
+                                                  ,(WXUINT)SHORT1FROMMP(wParam)
+                                                 );
+                        }
+                        if (pWin->IsKindOf(CLASSINFO(wxRadioButton)))
+                        {
+                            wxRadioButton*      pRadioButton = wxDynamicCast(pWin, wxRadioButton);
+
+                            pRadioButton->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
+                                                     ,(WXUINT)SHORT1FROMMP(wParam)
+                                                    );
+                        }
+                        if (pWin->IsKindOf(CLASSINFO(wxCheckBox)))
+                        {
+                            wxCheckBox*         pCheckBox = wxDynamicCast(pWin, wxCheckBox);
+
+                            pCheckBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
+                                                  ,(WXUINT)SHORT1FROMMP(wParam)
+                                                 );
+                        }
+                        if (pWin->IsKindOf(CLASSINFO(wxListBox)))
+                        {
+                            wxListBox*          pListBox = wxDynamicCast(pWin, wxListBox);
+
+                            pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
+                                                 ,(WXUINT)SHORT1FROMMP(wParam)
+                                                );
+                            if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW)
+                                Refresh();
+                        }
+                        if (pWin->IsKindOf(CLASSINFO(wxComboBox)))
+                        {
+                            wxComboBox*          pComboBox = wxDynamicCast(pWin, wxComboBox);
+
+                            pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
+                                                  ,(WXUINT)SHORT1FROMMP(wParam)
+                                                 );
+                        }
+                        return 0;
+                    }
+                    break;
+
+                case LN_ENTER:   /* dups as CBN_EFCHANGE */
+                    {
+                        HWND                hWnd = HWNDFROMMP(lParam);
+                        wxWindowOS2*        pWin = wxFindWinFromHandle(hWnd);
+
+                        if (!pWin)
+                        {
+                            bProcessed = FALSE;
+                            break;
+                        }
+                        //
+                        // Simulate a WM_COMMAND here, as wxWidgets expects all control
+                        // button clicks to generate WM_COMMAND msgs, not WM_CONTROL
+                        //
+                        if (pWin->IsKindOf(CLASSINFO(wxListBox)))
+                        {
+                            wxListBox*          pListBox = wxDynamicCast(pWin, wxListBox);
+
+                            pListBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
+                                                 ,(WXUINT)SHORT1FROMMP(wParam)
+                                                );
+                            if (pListBox->GetWindowStyle() & wxLB_OWNERDRAW)
+                                Refresh();
+
+                        }
+                        if (pWin->IsKindOf(CLASSINFO(wxComboBox)))
+                        {
+                            wxComboBox*          pComboBox = wxDynamicCast(pWin, wxComboBox);
+
+                            pComboBox->OS2Command( (WXUINT)SHORT2FROMMP(wParam)
+                                                  ,(WXUINT)SHORT1FROMMP(wParam)
+                                                 );
+                        }
+                        return 0;
+                    }
+                    break;
+
                 case SPBN_UPARROW:
                 case SPBN_DOWNARROW:
                 case SPBN_CHANGE:
@@ -2922,7 +2928,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
             if ( bProcessed )
             {
                 // we never set focus from here
-                mResult = FALSE;
+                mResult = (MRESULT)FALSE;
             }
             break;
 
@@ -2970,36 +2976,6 @@ MRESULT wxWindowOS2::OS2WindowProc(
     return mResult;
 } // end of wxWindowOS2::OS2WindowProc
 
-#ifndef __EMX__
-// clashes with wxDlgProc in toplevel.cpp?
-//
-// Dialog window proc
-//
-MRESULT wxDlgProc(
-  HWND                              WXUNUSED(hWnd)
-, UINT                              uMsg
-, MPARAM                            WXUNUSED(wParam)
-, MPARAM                            WXUNUSED(lParam))
-{
-    if (uMsg == WM_INITDLG)
-    {
-        //
-        // For this message, returning TRUE tells system to set focus to the
-        // first control in the dialog box
-        //
-        return (MRESULT)TRUE;
-    }
-    else
-    {
-        //
-        // For all the other ones, FALSE means that we didn't process the
-        // message
-        //
-        return (MRESULT)0;
-    }
-} // end of wxDlgProc
-#endif
-
 wxWindow* wxFindWinFromHandle(
   WXHWND                            hWnd
 )
@@ -3008,7 +2984,7 @@ wxWindow* wxFindWinFromHandle(
 
     if (!pNode)
         return NULL;
-    return (wxWindow *)pNode->Data();
+    return (wxWindow *)pNode->GetData();
 } // end of wxFindWinFromHandle
 
 void wxAssociateWinWithHandle(
@@ -3115,9 +3091,6 @@ bool wxWindowOS2::OS2Create(
     int                             nY      = 0L;
     int                             nWidth  = 0L;
     int                             nHeight = 0L;
-    wxWindow*                       pParent = GetParent();
-    HWND                            hWnd = NULLHANDLE;
-    HWND                            hParent;
     long                            lControlId = 0L;
     wxWindowCreationHook            vHook(this);
     wxString                        sClassName((wxChar*)zClass);
@@ -3143,7 +3116,7 @@ bool wxWindowOS2::OS2Create(
     // which is the same but without CS_[HV]REDRAW class styles so using it
     // ensures that the window is not fully repainted on each resize
     //
-    if (GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE)
+    if (!HasFlag(wxFULL_REPAINT_ON_RESIZE))
     {
         sClassName += wxT("NR");
     }
@@ -3182,7 +3155,7 @@ bool wxWindowOS2::OS2Create(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
-        wxLogError("Error creating frame. Error: %s\n", sError);
+        wxLogError("Error creating frame. Error: %s\n", sError.c_str());
         return FALSE;
     }
     SetSize( nX
@@ -3216,7 +3189,7 @@ bool wxWindowOS2::HandleCreate(
 bool wxWindowOS2::HandleDestroy()
 {
     wxWindowDestroyEvent            vEvent((wxWindow*)this);
-
+    vEvent.SetId(GetId());
     (void)GetEventHandler()->ProcessEvent(vEvent);
 
     //
@@ -3225,7 +3198,6 @@ bool wxWindowOS2::HandleDestroy()
 #if wxUSE_DRAG_AND_DROP
     if (m_dropTarget != NULL)
     {
-        m_dropTarget->Revoke(m_hWnd);
         delete m_dropTarget;
         m_dropTarget = NULL;
     }
@@ -3297,7 +3269,7 @@ bool wxWindowOS2::HandleSetFocus(
 } // end of wxWindowOS2::HandleSetFocus
 
 bool wxWindowOS2::HandleKillFocus(
-  WXHWND                            WXUNUSED(hWnd)
+  WXHWND                            hWnd
 )
 {
 #if wxUSE_CARET
@@ -3310,11 +3282,38 @@ bool wxWindowOS2::HandleKillFocus(
     }
 #endif // wxUSE_CARET
 
+#if wxUSE_TEXTCTRL
+    //
+    // If it's a wxTextCtrl don't send the event as it will be done
+    // after the control gets to process it.
+    //
+    wxTextCtrl*                     pCtrl = wxDynamicCastThis(wxTextCtrl);
+
+    if (pCtrl)
+    {
+        return FALSE;
+    }
+#endif
+
+    //
+    // Don't send the event when in the process of being deleted.  This can
+    // only cause problems if the event handler tries to access the object.
+    //
+    if ( m_isBeingDeleted )
+    {
+        return FALSE;
+    }
+
     wxFocusEvent                    vEvent( wxEVT_KILL_FOCUS
                                            ,m_windowId
                                           );
 
     vEvent.SetEventObject(this);
+
+    //
+    // wxFindWinFromHandle() may return NULL, it is ok
+    //
+    vEvent.SetWindow(wxFindWinFromHandle(hWnd));
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleKillFocus
 
@@ -3395,7 +3394,7 @@ bool wxWindowOS2::OS2OnDrawItem(
                   );
         vDc.SetHPS(pMeasureStruct->hps);
         //
-        // Load the wxWindows Pallete and set to RGB mode
+        // Load the wxWidgets Pallete and set to RGB mode
         //
         if (!::GpiCreateLogColorTable( pMeasureStruct->hps
                                       ,0L
@@ -3407,7 +3406,7 @@ bool wxWindowOS2::OS2OnDrawItem(
         {
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
-            wxLogError("Unable to set current color table. Error: %s\n", sError);
+            wxLogError("Unable to set current color table. Error: %s\n", sError.c_str());
         }
         //
         // Set the color table to RGB mode
@@ -3422,7 +3421,7 @@ bool wxWindowOS2::OS2OnDrawItem(
         {
             vError = ::WinGetLastError(vHabmain);
             sError = wxPMErrorToStr(vError);
-            wxLogError("Unable to set current color table. Error: %s\n", sError);
+            wxLogError("Unable to set current color table. Error: %s\n", sError.c_str());
         }
 
         wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
@@ -3523,7 +3522,7 @@ bool wxWindowOS2::OS2OnDrawItem(
     return FALSE;
 } // end of wxWindowOS2::OS2OnDrawItem
 
-bool wxWindowOS2::OS2OnMeasureItem(
+long wxWindowOS2::OS2OnMeasureItem(
   int                               lId
 , WXMEASUREITEMSTRUCT*              pItemStruct
 )
@@ -3549,20 +3548,26 @@ bool wxWindowOS2::OS2OnMeasureItem(
                                          ,&nHeight
                                         ))
             {
+                MRESULT             mRc;
+
                 pMeasureStruct->rclItem.xRight  = nWidth;
                 pMeasureStruct->rclItem.xLeft   = 0L;
                 pMeasureStruct->rclItem.yTop    = nHeight;
                 pMeasureStruct->rclItem.yBottom = 0L;
-                return TRUE;
+                mRc = MRFROM2SHORT(nHeight, nWidth);
+                return LONGFROMMR(mRc);
             }
-            return FALSE;
+            return 0L;
         }
     }
     wxWindow*                      pItem = FindItem(lId);
 
     if (pItem && pItem->IsKindOf(CLASSINFO(wxControl)))
     {
-        return ((wxControl *)pItem)->OS2OnMeasure(pItemStruct);
+        OWNERITEM                   vItem;
+
+        vItem.idItem = (LONG)pItemStruct;
+        return ((wxControl *)pItem)->OS2OnMeasure((WXMEASUREITEMSTRUCT*)&vItem);
     }
 #else
     lId = lId;
@@ -3625,14 +3630,14 @@ void wxWindowOS2::OnSysColourChanged(
   wxSysColourChangedEvent&          rEvent
 )
 {
-    wxNode*                         pNode = GetChildren().First();
+    wxWindowListNode*               pNode = GetChildren().GetFirst();
 
     while (pNode)
     {
         //
         // Only propagate to non-top-level windows
         //
-        wxWindow*                   pWin = (wxWindow *)pNode->Data();
+        wxWindow*                   pWin = (wxWindow *)pNode->GetData();
 
         if (pWin->GetParent())
         {
@@ -3641,7 +3646,7 @@ void wxWindowOS2::OnSysColourChanged(
             rEvent.m_eventObject = pWin;
             pWin->GetEventHandler()->ProcessEvent(vEvent);
         }
-        pNode = pNode->Next();
+        pNode = pNode->GetNext();
     }
 } // end of wxWindowOS2::OnSysColourChanged
 
@@ -3649,12 +3654,26 @@ void wxWindowOS2::OnSysColourChanged(
 // painting
 // ---------------------------------------------------------------------------
 
+void wxWindow::OnPaint (
+  wxPaintEvent&                     rEvent
+)
+{
+    HDC                             hDC = (HDC)wxPaintDC::FindDCInCache((wxWindow*) rEvent.GetEventObject());
+
+    if (hDC != 0)
+    {
+        OS2DefWindowProc( (WXUINT)WM_PAINT
+                         ,(WXWPARAM)hDC
+                         ,(WXLPARAM)0
+                        );
+    }
+} // end of wxWindow::OnPaint
+
 bool wxWindowOS2::HandlePaint()
 {
     HRGN                            hRgn;
     wxPaintEvent                    vEvent(m_windowId);
     HPS                             hPS;
-    RECTL                           vRect;
     bool                            bProcessed;
 
     // Create empty region
@@ -3680,12 +3699,12 @@ bool wxWindowOS2::HandlePaint()
     {
         //
         // OS/2 needs to process this right here, not by the default proc
-        // Window's default proc correctly paints everything, OS/2 does not!
+        // Window's default proc correctly paints everything, OS/2 does not.
+        // For decorative panels that typically have no children, we draw
+        // borders.
         //
         HPS                         hPS;
         RECTL                       vRect;
-        wxFrame*                    pFrame;
-        wxWindow*                   pParent;
 
         hPS = ::WinBeginPaint( GetHwnd()
                               ,NULLHANDLE
@@ -3707,11 +3726,11 @@ bool wxWindowOS2::HandlePaint()
                                      ,0L
                                      ,NULL
                                     );
-
-            ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
+            if (::WinIsWindowVisible(GetHWND()))
+                ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
             if (m_dwExStyle)
             {
-                LINEBUNDLE                      vLineBundle;
+                LINEBUNDLE      vLineBundle;
 
                 vLineBundle.lColor     = 0x00000000; // Black
                 vLineBundle.usMixMode  = FM_OVERPAINT;
@@ -3732,11 +3751,47 @@ bool wxWindowOS2::HandlePaint()
                              ,m_dwExStyle
                             );
             }
-            ::WinEndPaint(hPS);
         }
+        ::WinEndPaint(hPS);
         bProcessed = TRUE;
     }
+    else if (!bProcessed &&
+             IsKindOf(CLASSINFO(wxPanel))
+            )
+    {
+        //
+        // Panel with children, usually fills a frame client so no borders.
+        //
+        HPS                         hPS;
+        RECTL                       vRect;
 
+        hPS = ::WinBeginPaint( GetHwnd()
+                              ,NULLHANDLE
+                              ,&vRect
+                             );
+        if(hPS)
+        {
+            ::GpiCreateLogColorTable( hPS
+                                     ,0L
+                                     ,LCOLF_CONSECRGB
+                                     ,0L
+                                     ,(LONG)wxTheColourDatabase->m_nSize
+                                     ,(PLONG)wxTheColourDatabase->m_palTable
+                                    );
+            ::GpiCreateLogColorTable( hPS
+                                     ,0L
+                                     ,LCOLF_RGB
+                                     ,0L
+                                     ,0L
+                                     ,NULL
+                                    );
+
+            if (::WinIsWindowVisible(GetHWND()))
+                ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
+        }
+        ::WinEndPaint(hPS);
+        bProcessed = TRUE;
+    }
     return bProcessed;
 } // end of wxWindowOS2::HandlePaint
 
@@ -3828,7 +3883,6 @@ bool wxWindowOS2::HandleGetMinMaxInfo(
   PSWP                              pSwp
 )
 {
-    bool                            bRc = FALSE;
     POINTL                          vPoint;
 
     switch(pSwp->fl)
@@ -3913,13 +3967,20 @@ void wxWindowOS2::InitMouseEvent(
 , WXUINT                            uFlags
 )
 {
+    int                                 nHeight;
+    DoGetSize(0, &nHeight);
     rEvent.m_x           = nX;
-    rEvent.m_y           = nY;
-    rEvent.m_shiftDown   = ((uFlags & VK_SHIFT) != 0);
-    rEvent.m_controlDown = ((uFlags & VK_CTRL) != 0);
-    rEvent.m_leftDown    = ((uFlags & VK_BUTTON1) != 0);
-    rEvent.m_middleDown  = ((uFlags & VK_BUTTON3) != 0);
-    rEvent.m_rightDown   = ((uFlags & VK_BUTTON2) != 0);
+    // Convert to wxWidgets standard coordinate system!
+    rEvent.m_y           = nHeight - nY;
+    rEvent.m_shiftDown   = ((uFlags & KC_SHIFT) != 0);
+    rEvent.m_controlDown = ((uFlags & KC_CTRL) != 0);
+    rEvent.m_altDown     = ((uFlags & KC_ALT) != 0);
+    rEvent.m_leftDown    = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) &
+                           0x8000) != 0;
+    rEvent.m_middleDown  = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) &
+                           0x8000) != 0;
+    rEvent.m_rightDown   = (::WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) &
+                           0x8000) != 0;
     rEvent.SetTimestamp(s_currentMsg.time);
     rEvent.m_eventObject = this;
     rEvent.SetId(GetId());
@@ -3971,7 +4032,6 @@ bool wxWindowOS2::HandleMouseEvent(
     bProcessed = GetEventHandler()->ProcessEvent(vEvent);
     if (!bProcessed)
     {
-        HPOINTER                    hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE);
         HPOINTER                    hCursor = (HPOINTER)GetCursor().GetHCURSOR();
 
         if (hCursor != NULLHANDLE)
@@ -4087,9 +4147,11 @@ bool wxWindowOS2::HandleChar(
     if (isASCII)
     {
         //
-        // If 1 -> 26, translate to CTRL plus a letter.
+        // If 1 -> 26, translate to either special keycode or just set
+        // ctrlDown.  IOW, Ctrl-C should result in keycode == 3 and
+        // ControlDown() == TRUE.
         //
-        vId = (int)wParam;
+        vId = SHORT1FROMMP(lParam);
         if ((vId > 0) && (vId < 27))
         {
             switch (vId)
@@ -4108,13 +4170,13 @@ bool wxWindowOS2::HandleChar(
 
                 default:
                     bCtrlDown = TRUE;
-                    vId = vId + 'a' - 1;
+                    break;
             }
         }
     }
     else  // we're called from WM_KEYDOWN
     {
-        vId = wxCharCodeOS2ToWX((int)wParam);
+        vId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam));
         if (vId == 0)
             return FALSE;
     }
@@ -4136,14 +4198,14 @@ bool wxWindowOS2::HandleKeyDown(
 , WXLPARAM                          lParam
 )
 {
-    int                             nId = wxCharCodeOS2ToWX((int)wParam);
+    int                             nId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam));
 
     if (!nId)
     {
         //
         // Normal ASCII char
         //
-        nId = (int)wParam;
+        nId = SHORT1FROMMP(lParam);
     }
 
     if (nId != -1)
@@ -4167,7 +4229,7 @@ bool wxWindowOS2::HandleKeyUp(
 , WXLPARAM                          lParam
 )
 {
-    int                             nId = wxCharCodeOS2ToWX((int)wParam);
+    int                             nId = wxCharCodeOS2ToWX((int)SHORT2FROMMP(lParam));
 
     if (!nId)
     {
@@ -4260,62 +4322,72 @@ void wxWindowOS2::MoveChildren(
   int                               nDiff
 )
 {
-    SWP                                 vSwp;
-
-    for (wxWindowList::Node* pNode = GetChildren().GetFirst();
-         pNode;
-         pNode = pNode->GetNext())
+    //
+    // We want to handle top levels ourself, manually
+    //
+    if (!IsTopLevel() && GetAutoLayout())
     {
-        wxWindow*                   pWin = pNode->GetData();
+        Layout();
+    }
+    else
+    {
+        SWP                         vSwp;
 
-        ::WinQueryWindowPos( GetHwndOf(pWin)
-                            ,&vSwp
-                           );
-        if (pWin->IsKindOf(CLASSINFO(wxControl)))
+        for (wxWindowList::Node* pNode = GetChildren().GetFirst();
+             pNode;
+             pNode = pNode->GetNext())
         {
-            wxControl*          pCtrl;
+            wxWindow*               pWin = pNode->GetData();
 
-            //
-            // Must deal with controls that have margins like ENTRYFIELD.  The SWP
-            // struct of such a control will have and origin offset from its intended
-            // position by the width of the margins.
-            //
-            pCtrl = wxDynamicCast(pWin, wxControl);
-            vSwp.y -= pCtrl->GetYComp();
-            vSwp.x -= pCtrl->GetXComp();
-        }
-        ::WinSetWindowPos( GetHwndOf(pWin)
-                          ,HWND_TOP
-                          ,vSwp.x
-                          ,vSwp.y - nDiff
-                          ,vSwp.cx
-                          ,vSwp.cy
-                          ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
-                         );
-        ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp());
-        if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
-        {
-            wxRadioBox*     pRadioBox;
-
-            pRadioBox = wxDynamicCast(pWin, wxRadioBox);
-            pRadioBox->AdjustButtons( (int)vSwp.x
-                                     ,(int)vSwp.y - nDiff
-                                     ,(int)vSwp.cx
-                                     ,(int)vSwp.cy
-                                     ,pRadioBox->GetSizeFlags()
-                                    );
-        }
-        if (pWin->IsKindOf(CLASSINFO(wxSlider)))
-        {
-            wxSlider*           pSlider;
-
-            pSlider = wxDynamicCast(pWin, wxSlider);
-            pSlider->AdjustSubControls( (int)vSwp.x
-                                       ,(int)vSwp.y - nDiff
-                                       ,(int)vSwp.cx
-                                       ,(int)vSwp.cy
-                                       ,(int)pSlider->GetSizeFlags()
-                                      );
+            ::WinQueryWindowPos( GetHwndOf(pWin)
+                                ,&vSwp
+                               );
+            if (pWin->IsKindOf(CLASSINFO(wxControl)))
+            {
+                wxControl*          pCtrl;
+
+                //
+                // Must deal with controls that have margins like ENTRYFIELD.  The SWP
+                // struct of such a control will have and origin offset from its intended
+                // position by the width of the margins.
+                //
+                pCtrl = wxDynamicCast(pWin, wxControl);
+                vSwp.y -= pCtrl->GetYComp();
+                vSwp.x -= pCtrl->GetXComp();
+            }
+            ::WinSetWindowPos( GetHwndOf(pWin)
+                              ,HWND_TOP
+                              ,vSwp.x
+                              ,vSwp.y - nDiff
+                              ,vSwp.cx
+                              ,vSwp.cy
+                              ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
+                             );
+            ::WinQueryWindowPos(GetHwndOf(pWin), pWin->GetSwp());
+            if (pWin->IsKindOf(CLASSINFO(wxRadioBox)))
+            {
+                wxRadioBox*     pRadioBox;
+
+                pRadioBox = wxDynamicCast(pWin, wxRadioBox);
+                pRadioBox->AdjustButtons( (int)vSwp.x
+                                         ,(int)vSwp.y - nDiff
+                                         ,(int)vSwp.cx
+                                         ,(int)vSwp.cy
+                                         ,pRadioBox->GetSizeFlags()
+                                        );
+            }
+            if (pWin->IsKindOf(CLASSINFO(wxSlider)))
+            {
+                wxSlider*           pSlider;
+
+                pSlider = wxDynamicCast(pWin, wxSlider);
+                pSlider->AdjustSubControls( (int)vSwp.x
+                                           ,(int)vSwp.y - nDiff
+                                           ,(int)vSwp.cx
+                                           ,(int)vSwp.cy
+                                           ,(int)pSlider->GetSizeFlags()
+                                          );
+            }
         }
     }
     Refresh();
@@ -4324,7 +4396,7 @@ void wxWindowOS2::MoveChildren(
 //
 //  Getting the Y position for a window, like a control, is a real
 //  pain.  There are three sitatuions we must deal with in determining
-//  the OS2 to wxWindows Y coordinate.
+//  the OS2 to wxWidgets Y coordinate.
 //
 //  1)  The controls are created in a dialog.
 //      This is the easiest since a dialog is created with its original
@@ -4356,8 +4428,6 @@ int wxWindowOS2::GetOS2ParentHeight(
   wxWindowOS2*               pParent
 )
 {
-    wxWindowOS2*             pGrandParent = NULL;
-
     //
     // Case 1
     //
@@ -4838,7 +4908,7 @@ const char* wxGetMessageName(
         // Beginning of user defined messages
         case 0x1000: return "WM_USER";
 
-        // wxWindows user defined types
+        // wxWidgets user defined types
 
         // listview
         // case 0x1000 + 0: return "LVM_GETBKCOLOR";
@@ -5148,50 +5218,97 @@ wxWindowOS2* FindWindowForMouseEvent(
 , short*                            pnY
 )
 {
-    wxCHECK_MSG( pnX && pnY, pWin, _T("NULL pointer in FindWindowForMouseEvent") );
-    POINTL                          vPoint = { *pnX, *pnY };
     HWND                            hWnd = GetHwndOf(pWin);
     HWND                            hWndUnderMouse;
+    POINTL                          vPoint;
+    BOOL                            rcEnabled = FALSE;
+    BOOL                            rcVisible = FALSE;
 
-    //
-    // First try to find a non transparent child: this allows us to send events
-    // to a static text which is inside a static box, for example
-    //
-
-    hWndUnderMouse = ::WinWindowFromPoint( hWnd
-                                          ,&vPoint
-                                          ,TRUE
-                                         );
-    if (!hWndUnderMouse || hWndUnderMouse == hWnd)
+    ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
+    hWndUnderMouse = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
+    if (hWndUnderMouse != HWND_DESKTOP)
     {
-        //
-        // Now try any child window at all
-        //
-        hWndUnderMouse = ::WinWindowFromPoint( HWND_DESKTOP
-                                              ,&vPoint
-                                              ,TRUE
-                                             );
+        wxWindow*                   pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse);
+
+        if (pWinUnderMouse)
+        {
+            wxWindowList::Node*     pCurrent = pWinUnderMouse->GetChildren().GetFirst();
+            wxWindow*               pGrandChild = NULL;
+            RECTL                   vRect;
+            POINTL                  vPoint2;
 
+            ::WinMapWindowPoints(HWND_DESKTOP, hWndUnderMouse, &vPoint, 1);
+            //
+            // Find a child window mouse might be under
+            //
+            while (pCurrent)
+            {
+                wxWindow*                   pChild = pCurrent->GetData();
+
+                vPoint2.x = vPoint.x;
+                vPoint2.y = vPoint.y;
+                ::WinMapWindowPoints(hWndUnderMouse, pChild->GetHWND(), &vPoint2, 1);
+                ::WinQueryWindowRect(pChild->GetHWND(), &vRect);
+                if (::WinPtInRect(vHabmain, &vRect, &vPoint2))
+                {
+                    if (pChild->IsTopLevel())
+                    {
+                        POINTL                  vPoint3;
+                        wxWindowList::Node*     pCurrent2 =pChild->GetChildren().GetFirst();
+
+                        while (pCurrent2)
+                        {
+                            wxWindow*           pGrandChild = pCurrent2->GetData();
+
+                            vPoint3.x = vPoint2.x;
+                            vPoint3.y = vPoint2.y;
+                            ::WinMapWindowPoints( pChild->GetHWND()
+                                                 ,pGrandChild->GetHWND()
+                                                 ,&vPoint3
+                                                 ,1
+                                                );
+                            ::WinQueryWindowRect(pGrandChild->GetHWND(), &vRect);
+                            if (::WinPtInRect(vHabmain, &vRect, &vPoint3))
+                            {
+                                hWndUnderMouse = GetHwndOf(pGrandChild);
+                                pWinUnderMouse = pGrandChild;
+                                break;
+                            }
+                            pCurrent2 = pCurrent2->GetNext();
+                        }
+                        if (pGrandChild)
+                            break;
+                    }
+                    hWndUnderMouse = GetHwndOf(pChild);
+                    pWinUnderMouse = pChild;
+                    rcVisible = ::WinIsWindowVisible(hWndUnderMouse);
+                    rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse);
+                    if (rcVisible && rcEnabled)
+                        break;
+                }
+                pCurrent = pCurrent->GetNext();
+            }
+        }
     }
+    rcVisible = ::WinIsWindowVisible(hWndUnderMouse);
+    rcEnabled = ::WinIsWindowEnabled(hWndUnderMouse);
+
 
     //
     // Check that we have a child window which is susceptible to receive mouse
     // events: for this it must be shown and enabled
+    //
     if ( hWndUnderMouse &&
          hWndUnderMouse != hWnd &&
-         ::WinIsWindowVisible(hWndUnderMouse) &&
-         ::WinIsWindowEnabled(hWndUnderMouse))
+         rcVisible && rcEnabled)
     {
-        wxWindow*                   pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse);
+        wxWindow*                       pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse);
+
         if (pWinUnderMouse)
         {
-            // translate the mouse coords to the other window coords
-            pWin->ClientToScreen( (int*)pnX
-                                 ,(int*)pnY
-                                );
-            pWinUnderMouse->ScreenToClient( (int*)pnX
-                                           ,(int*)pnY
-                                          );
+            //
+            // Translate the mouse coords to the other window coords
+            //
             pWin = pWinUnderMouse;
         }
     }