Weekly updates

[wxWidgets.git] / src / os2 / window.cpp

diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index 30ac8d5c44d2c53d01cb50af67730f0eb454386d..6fc21ee0c34257daf4d0dba498ed893d47b1d00e 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -1,4 +1,3 @@
-/////////////////////////////////////////////////////////////////////////////

 // Name:        windows.cpp
 // Purpose:     wxWindow
 // Author:      David Webster
 // Name:        windows.cpp
 // Purpose:     wxWindow
 // Author:      David Webster


@@ -36,6 +35,7 @@
     #include "wx/scrolwin.h"
     #include "wx/radiobox.h"
     #include "wx/slider.h"
     #include "wx/scrolwin.h"
     #include "wx/radiobox.h"
     #include "wx/slider.h"

+    #include "wx/statbox.h"

     #include "wx/statusbr.h"
     #include "wx/toolbar.h"
     #include "wx/settings.h"
     #include "wx/statusbr.h"
     #include "wx/toolbar.h"
     #include "wx/settings.h"


@@ -93,6 +93,20 @@
 #  define CW_USEDEFAULT    ((int)0x80000000)
 #endif
 
 #  define CW_USEDEFAULT    ((int)0x80000000)
 #endif
 

+#ifndef VK_OEM_1
+    #define VK_OEM_1        0xBA
+    #define VK_OEM_PLUS     0xBB
+    #define VK_OEM_COMMA    0xBC
+    #define VK_OEM_MINUS    0xBD
+    #define VK_OEM_PERIOD   0xBE
+    #define VK_OEM_2        0xBF
+    #define VK_OEM_3        0xC0
+    #define VK_OEM_4        0xDB
+    #define VK_OEM_5        0xDC
+    #define VK_OEM_6        0xDD
+    #define VK_OEM_7        0xDE
+#endif
+

 // ---------------------------------------------------------------------------
 // global variables
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // global variables
 // ---------------------------------------------------------------------------


@@ -125,24 +139,16 @@ MRESULT EXPENTRY wxWndProc( HWND hWnd
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 
     const char *wxGetMessageName(int message);
 #endif  //__WXDEBUG__
 

-void      wxRemoveHandleAssociation(wxWindowOS2* pWin);
-void      wxAssociateWinWithHandle( HWND         hWnd
-                                   ,wxWindowOS2* pWin
-                                  );
+wxWindowOS2* FindWindowForMouseEvent( wxWindow* pWin
+                                     ,short*    pnX
+                                     ,short*    pnY
+                                    );
+void         wxRemoveHandleAssociation(wxWindowOS2* pWin);
+void         wxAssociateWinWithHandle( HWND         hWnd
+                                      ,wxWindowOS2* pWin
+                                     );

 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 
 wxWindow* wxFindWinFromHandle(WXHWND hWnd);
 

-//
-// This magical function is used to translate VK_APPS key presses to right
-// mouse clicks
-//
-// Unused?
-#if 0
-static void TranslateKbdEventToMouse( wxWindow* pWin
-                                     ,int*      pX
-                                     ,int*      pY
-                                     ,MPARAM*   pFlags
-                                    );
-#endif

 //
 // get the current state of SHIFT/CTRL keys
 //
 //
 // get the current state of SHIFT/CTRL keys
 //


@@ -288,13 +294,15 @@ void wxWindowOS2::Init()
     //
     // PM specific
     //
     //
     // PM specific
     //

-    m_bDoubleClickAllowed = 0;

     m_bWinCaptured = FALSE;
 
     m_bWinCaptured = FALSE;
 

-    m_isBeingDeleted = FALSE;
-    m_fnOldWndProc = 0;
-    m_bUseCtl3D = FALSE;
-    m_bMouseInWindow = FALSE;
+    m_isBeingDeleted        = FALSE;
+    m_fnOldWndProc          = NULL;
+    m_bUseCtl3D             = FALSE;
+    m_bMouseInWindow        = FALSE;
+    m_bLastKeydownProcessed = FALSE;
+    m_bIsActivePage         = TRUE;
+    m_pChildrenDisabled     = NULL;

 
     //
     // wxWnd
 
     //
     // wxWnd


@@ -304,8 +312,11 @@ void wxWindowOS2::Init()
     m_hWndScrollBarHorz = 0L;
     m_hWndScrollBarVert = 0L;
 
     m_hWndScrollBarHorz = 0L;
     m_hWndScrollBarVert = 0L;
 

+    memset(&m_vWinSwp, '\0', sizeof (SWP));
+

     //
     // Pass WM_GETDLGCODE to DefWindowProc()
     //
     // Pass WM_GETDLGCODE to DefWindowProc()

+    //

     m_lDlgCode = 0;
 
     m_nXThumbSize = 0;
     m_lDlgCode = 0;
 
     m_nXThumbSize = 0;


@@ -333,12 +344,12 @@ wxWindowOS2::~wxWindowOS2()
 
     for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
     {
 
     for (wxWindow* pWin = GetParent(); pWin; pWin = pWin->GetParent())
     {

-        wxFrame*                    pFrame = wxDynamicCast(pWin, wxFrame);
+        wxTopLevelWindow*           pFrame = wxDynamicCast(pWin, wxTopLevelWindow);

 
         if (pFrame)
         {
             if (pFrame->GetLastFocus() == this)
 
         if (pFrame)
         {
             if (pFrame->GetLastFocus() == this)

-                pFrame->SetLastFocus((wxWindow*)NULL);
+                pFrame->SetLastFocus(NULL);

         }
     }
 
         }
     }
 


@@ -356,6 +367,7 @@ wxWindowOS2::~wxWindowOS2()
         //
         wxRemoveHandleAssociation(this);
     }
         //
         wxRemoveHandleAssociation(this);
     }

+    delete m_pChildrenDisabled;

 } // end of wxWindowOS2::~wxWindowOS2
 
 // real construction (Init() must have been called before!)
 } // end of wxWindowOS2::~wxWindowOS2
 
 // real construction (Init() must have been called before!)


@@ -374,6 +386,19 @@ bool wxWindowOS2::Create(
 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 
 
     wxCHECK_MSG(pParent, FALSE, wxT("can't create wxWindow without parent"));
 

+#if wxUSE_STATBOX
+    //
+    // wxGTK doesn't allow to create controls with static box as the parent so
+    // this will result in a crash when the program is ported to wxGTK - warn
+    // about it
+    //
+    // the correct solution is to create the controls as siblings of the
+    // static box
+    //
+    wxASSERT_MSG( !wxDynamicCast(pParent, wxStaticBox),
+                  _T("wxStaticBox can't be used as a window parent!") );
+#endif // wxUSE_STATBOX
+

     if ( !CreateBase( pParent
                      ,vId
                      ,rPos
     if ( !CreateBase( pParent
                      ,vId
                      ,rPos


@@ -402,59 +427,36 @@ bool wxWindowOS2::Create(
     // set in those class create procs.  PM's basic windows styles are
     // very limited.
     //
     // set in those class create procs.  PM's basic windows styles are
     // very limited.
     //

-    ulCreateFlags |=  WS_VISIBLE;
+    ulCreateFlags |=  OS2GetCreateWindowFlags(&dwExStyle);

 
 
 #ifdef __WXUNIVERSAL__
     // no 3d effects, we draw them ourselves
     WXDWORD exStyle = 0;
 
 
 #ifdef __WXUNIVERSAL__
     // no 3d effects, we draw them ourselves
     WXDWORD exStyle = 0;

-#else // !wxUniversal
-    if (lStyle & wxCLIP_SIBLINGS)
-        ulCreateFlags |= WS_CLIPSIBLINGS;
-
-    if (lStyle & wxCLIP_CHILDREN )
-        ulCreateFlags |= WS_CLIPCHILDREN;
-
-    //
-    //
-    //
-    bool                            bWant3D;
-    dwExStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &bWant3D);
-
-#endif
-
-    //
-    // Add the simple border style as we'll use this to draw borders
-    //
-    if (lStyle & wxSIMPLE_BORDER)
-        dwExStyle |= wxSIMPLE_BORDER;
-
+#endif // !wxUniversal

     if (lStyle & wxPOPUP_WINDOW)
     {
     if (lStyle & wxPOPUP_WINDOW)
     {

-        // a popup window floats on top of everything
-//TODO: fix this...
-//        exStyle |= WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
-
-        // it is also created hidden as other top level windows

         ulCreateFlags &= ~WS_VISIBLE;
         m_isShown = FALSE;
     }
         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.
     //
 
     //
     // Generic OS/2 Windows have no Control Data but other classes
     // that call OS2Create may have some.
     //

-    OS2Create( (PSZ)wxCanvasClassName
-              ,rName.c_str()
-              ,ulCreateFlags
-              ,rPos
-              ,rSize
-              ,NULL         // Control Data
-              ,dwExStyle
-              ,TRUE         // Child
-             );
-
-    return(TRUE);
+    return(OS2Create( (PSZ)wxCanvasClassName
+                     ,rName.c_str()
+                     ,ulCreateFlags
+                     ,rPos
+                     ,rSize
+                     ,NULL         // Control Data
+                     ,dwExStyle
+                     ,TRUE         // Child
+                    ));

 } // end of wxWindowOS2::Create
 
 // ---------------------------------------------------------------------------
 } // end of wxWindowOS2::Create
 
 // ---------------------------------------------------------------------------


@@ -470,6 +472,14 @@ void wxWindowOS2::SetFocus()
         ::WinSetFocus(HWND_DESKTOP, hWnd);
 } // end of wxWindowOS2::SetFocus
 
         ::WinSetFocus(HWND_DESKTOP, hWnd);
 } // end of wxWindowOS2::SetFocus
 

+void wxWindowOS2::SetFocusFromKbd()
+{
+    //
+    // Nothing else to do under OS/2
+    //
+    wxWindowBase::SetFocusFromKbd();
+} // end of wxWindowOS2::SetFocus
+

 wxWindow* wxWindowBase::FindFocus()
 {
     HWND                            hWnd = ::WinQueryFocus(HWND_DESKTOP);
 wxWindow* wxWindowBase::FindFocus()
 {
     HWND                            hWnd = ::WinQueryFocus(HWND_DESKTOP);


@@ -499,9 +509,44 @@ bool wxWindowOS2::Enable(
     {
         wxWindow*                   pChild = pNode->GetData();
 
     {
         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();
     }
         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
 
     return TRUE;
 } // end of wxWindowOS2::Enable
 


@@ -583,77 +628,11 @@ bool wxWindowOS2::SetFont(
 
     HWND                            hWnd = GetHwnd();
 
 
     HWND                            hWnd = GetHwnd();
 

-    if (hWnd != 0)
-    {
-        char                        zFont[128];
-        char                        zFacename[30];
-        char                        zWeight[30];
-        char                        zStyle[30];
-
-        //
-        // The fonts available for Presentation Params are just three
-        // outline fonts, the rest are available to the GPI, so we must
-        // map the families to one of these three
-        //
-        switch(rFont.GetFamily())
-        {
-            case wxSCRIPT:
-            case wxDECORATIVE:
-            case wxROMAN:
-                strcpy(zFacename,"Times New Roman");
-                break;
-
-            case wxTELETYPE:
-            case wxMODERN:
-                strcpy(zFacename, "Courier");
-                break;
-
-            case wxSWISS:
-            case wxDEFAULT:
-            default:
-                strcpy(zFacename, "Helvetica");
-                break;
-        }
-
-        switch(rFont.GetWeight())
-        {
-            default:
-            case wxNORMAL:
-            case wxLIGHT:
-                zWeight[0] = '\0';
-                break;
-
-            case wxBOLD:
-            case wxFONTWEIGHT_MAX:
-                strcpy(zWeight, "Bold");
-                break;
-        }
-        switch(rFont.GetStyle())
-        {
-            case wxITALIC:
-            case wxSLANT:
-                strcpy(zStyle, "Italic");
-                break;
-
-            default:
-                zStyle[0] = '\0';
-                break;
-        }
-        sprintf(zFont, "%d.%s", rFont.GetPointSize(), zFacename);
-        if (zWeight[0] != '\0')
-        {
-            strcat(zFont, " ");
-            strcat(zFont, zWeight);
-        }
-        if (zStyle[0] != '\0')
-        {
-            strcat(zFont, " ");
-            strcat(zFont, zStyle);
-        }
-        ::WinSetPresParam(hWnd, PP_FONTNAMESIZE, strlen(zFont) + 1, (PVOID)zFont);
-    }
+    wxOS2SetFont( hWnd
+                 ,rFont
+                );

     return(TRUE);
     return(TRUE);

-}
+} // end of wxWindowOS2::SetFont

 
 bool wxWindowOS2::SetCursor(
   const wxCursor&                   rCursor
 
 bool wxWindowOS2::SetCursor(
   const wxCursor&                   rCursor


@@ -825,15 +804,39 @@ void wxWindowOS2::SetScrollbar(
 , bool                              WXUNUSED(bRefresh)
 )
 {
 , bool                              WXUNUSED(bRefresh)
 )
 {

+    HWND                            hWnd = GetHwnd();

     int                             nOldRange = nRange - nThumbVisible;
     int                             nRange1 = nOldRange;
     int                             nPageSize = nThumbVisible;
     int                             nOldRange = nRange - nThumbVisible;
     int                             nRange1 = nOldRange;
     int                             nPageSize = nThumbVisible;

+

     SBCDATA                         vInfo;
     SBCDATA                         vInfo;

-    HWND                            hWnd = GetHwnd();

     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;
     ULONG                           ulStyle = WS_VISIBLE | WS_SYNCPAINT;

+    SWP                             vSwp;
+    SWP                             vSwpOwner;

     RECTL                           vRect;
     RECTL                           vRect;

+    HWND                            hWndParent;
+    HWND                            hWndClient;
+    wxWindow*                       pParent = GetParent();
+
+    if (pParent && pParent->IsKindOf(CLASSINFO(wxFrame)))
+    {
+        wxFrame*                    pFrame;
+
+        pFrame = wxDynamicCast(pParent, wxFrame);
+        hWndParent = pFrame->GetFrame();
+        hWndClient = GetHwndOf(pParent);
+    }
+    else
+    {
+        if (pParent)
+            hWndParent = GetHwndOf(pParent);
+        else
+            hWndParent = GetHwnd();
+        hWndClient = hWndParent;
+    }
+    ::WinQueryWindowPos(hWndClient, &vSwp);
+    ::WinQueryWindowPos(hWnd, &vSwpOwner);

 
 

-    ::WinQueryWindowRect(hWnd, &vRect);

     if (nPageSize > 1 && nRange > 0)
     {
         nRange1 += (nPageSize - 1);
     if (nPageSize > 1 && nRange > 0)
     {
         nRange1 += (nPageSize - 1);


@@ -850,53 +853,70 @@ void wxWindowOS2::SetScrollbar(
         if (m_hWndScrollBarHorz == 0L)
         {
             //
         if (m_hWndScrollBarHorz == 0L)
         {
             //

-            // We create the scrollbars with the desktop so that they are not
-            // registered as child windows of the window in order that child
-            // windows may be scrolled without scrolling the scrollbars themselves!
+            // Since the scrollbars are usually created before the owner is
+            // sized either via an OnSize event directly or via sizers or
+            // layout constraints, we will initially just use the coords of
+            // the parent window (this is usually a frame client window). But
+            // the bars themselves, are children of the parent frame (i.e
+            // siblings of the frame client.  The owner, however is the actual
+            // window being scrolled (or at least the one responsible for
+            // handling the scroll events). The owner will be resized later,
+            // as it is usually a child of a top level window, and when that
+            // is done its scrollbars will be resized and repositioned as well.

             //
             //

-            m_hWndScrollBarHorz = ::WinCreateWindow( hWnd
+            m_hWndScrollBarHorz = ::WinCreateWindow( hWndParent

                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle

-                                                    ,vRect.xLeft
-                                                    ,vRect.yBottom
-                                                    ,vRect.xRight - vRect.xLeft
+                                                    ,vSwp.x
+                                                    ,vSwp.y
+                                                    ,vSwp.cx - 20

                                                     ,20
                                                     ,hWnd
                                                     ,HWND_TOP
                                                     ,20
                                                     ,hWnd
                                                     ,HWND_TOP

-                                                    ,FID_HORZSCROLL
+                                                    ,60000

                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {
                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {

-            RECTL                   vRect2;
-

             //
             //

-            // Only want to resize the scrollbar if it changes, otherwise
-            // we'd probably end up in a recursive loop until we crash the call stack
-            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
-            // generates those events.
+            // The owner (the scrolled window) is a child of the Frame's
+            // client window, usually.  The scrollbars are children of the
+            // frame, itself, and thus are positioned relative to the frame's
+            // origin, not the frame's client window origin.
+            // The starting x position is the same as the starting x position
+            // of the owner, but in terms of the parent frame.
+            // The starting y position is 20 pels below the origin of the
+            // owner in terms of the parent frame.
+            // The horz bar is the same width as the owner and 20 pels high.

             //
             //

-            ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect2);
-            if (!(vRect2.xLeft == vRect.xLeft     &&
-                  vRect2.xRight == vRect.xRight   &&
-                  vRect2.yBottom == vRect.yBottom &&
-                  vRect2.yTop == vRect.yTop
-                ) )
+            if (nRange1 >= nThumbVisible)

             {
                 ::WinSetWindowPos( m_hWndScrollBarHorz
                                   ,HWND_TOP
             {
                 ::WinSetWindowPos( m_hWndScrollBarHorz
                                   ,HWND_TOP

-                                  ,vRect.xLeft
-                                  ,vRect.yBottom
-                                  ,vRect.xRight - vRect.xLeft
+                                  ,vSwp.x + vSwpOwner.x
+                                  ,(vSwp.y + vSwpOwner.y) - 20
+                                  ,vSwpOwner.cx

                                   ,20
                                   ,20

-                                  ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
+                                  ,SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER

                                  );
                                  );

+                ::WinSendMsg( m_hWndScrollBarHorz
+                             ,SBM_SETSCROLLBAR
+                             ,(MPARAM)nPos
+                             ,MPFROM2SHORT(0, (SHORT)nRange1)
+                            );
+                ::WinSendMsg( m_hWndScrollBarHorz
+                             ,SBM_SETTHUMBSIZE
+                             ,MPFROM2SHORT( (SHORT)nThumbVisible
+                                           ,(SHORT)nRange1
+                                          )
+                             ,(MPARAM)0
+                            );

             }
             }

-            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
-            ::WinSendMsg(m_hWndScrollBarHorz, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+            else
+                ::WinShowWindow(m_hWndScrollBarHorz, FALSE);

         }
     }
     else
         }
     }
     else


@@ -904,49 +924,75 @@ void wxWindowOS2::SetScrollbar(
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {
         ulStyle |= SBS_VERT;
         if (m_hWndScrollBarVert == 0L)
         {

-            m_hWndScrollBarVert = ::WinCreateWindow( hWnd
+            //
+            // Since the scrollbars are usually created before the owner is
+            // sized either via an OnSize event directly or via sizers or
+            // layout constraints, we will initially just use the coords of
+            // the parent window (this is usually a frame client window). But
+            // the bars themselves, are children of the parent frame (i.e
+            // siblings of the frame client.  The owner, however is the actual
+            // window being scrolled (or at least the one responsible for
+            // handling the scroll events). The owner will be resized later,
+            // as it is usually a child of a top level window, and when that
+            // is done its scrollbars will be resized and repositioned as well.
+            //
+            m_hWndScrollBarVert = ::WinCreateWindow( hWndParent

                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle
                                                     ,WC_SCROLLBAR
                                                     ,(PSZ)NULL
                                                     ,ulStyle

-                                                    ,vRect.xRight - 20
-                                                    ,vRect.yBottom + 20
+                                                    ,vSwp.x + vSwp.cx - 20
+                                                    ,vSwp.y + 20

                                                     ,20
                                                     ,20

-                                                    ,vRect.yTop - (vRect.yBottom + 20)
+                                                    ,vSwp.cy - 20

                                                     ,hWnd
                                                     ,HWND_TOP
                                                     ,hWnd
                                                     ,HWND_TOP

-                                                    ,FID_VERTSCROLL
+                                                    ,60001

                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {
                                                     ,&vInfo
                                                     ,NULL
                                                    );
         }
         else
         {

-            RECTL                   vRect2;
-

             //
             //

-            // Only want to resize the scrollbar if it changes, otherwise
-            // we'd probably end up in a recursive loop until we crash the call stack
-            // because this method is called in a ScrolledWindow OnSize event and SWP_MOVE | SWP_SIZE
-            // generates those events.
+            // The owner (the scrolled window) is a child of the Frame's
+            // client window, usually.  The scrollbars are children of the
+            // frame, itself and thus are positioned relative to the frame's
+            // origin, not the frame's client window's origin.
+            // Thus, the x position will be frame client's x (usually a few
+            // pels inside the parent frame, plus the width of the owner.
+            // Since we may be using sizers or layout constraints for multiple
+            // child scrolled windows, the y position will be the frame client's
+            // y pos plus the scrolled windows y position, yielding the y
+            // position of the scrollbar relative to the parent frame (the vert
+            // scrollbar is on the right and starts at the bottom of the
+            // owner window).
+            // It is 20 pels wide and the same height as the owner.

             //
             //

-            ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect2);
-            if (!(vRect2.xLeft == vRect.xLeft     &&
-                  vRect2.xRight == vRect.xRight   &&
-                  vRect2.yBottom == vRect.yBottom &&
-                  vRect2.yTop == vRect.yTop
-                ) )
+            if (nRange1 >= nThumbVisible)

             {
                 ::WinSetWindowPos( m_hWndScrollBarVert
                                   ,HWND_TOP
             {
                 ::WinSetWindowPos( m_hWndScrollBarVert
                                   ,HWND_TOP

-                                  ,vRect.xRight - 20
-                                  ,vRect.yBottom + 20
+                                  ,vSwp.x + vSwpOwner.x + vSwpOwner.cx
+                                  ,vSwp.y + vSwpOwner.y

                                   ,20
                                   ,20

-                                  ,vRect.yTop - (vRect.yBottom + 20)
+                                  ,vSwpOwner.cy

                                   ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
                                  );
                                   ,SWP_ACTIVATE | SWP_MOVE | SWP_SIZE | SWP_SHOW
                                  );

+                ::WinSendMsg( m_hWndScrollBarVert
+                             ,SBM_SETSCROLLBAR
+                             ,(MPARAM)nPos
+                             ,MPFROM2SHORT(0, (SHORT)nRange1)
+                            );
+                ::WinSendMsg( m_hWndScrollBarVert
+                             ,SBM_SETTHUMBSIZE
+                             ,MPFROM2SHORT( (SHORT)nThumbVisible
+                                           ,(SHORT)nRange1
+                                          )
+                             ,(MPARAM)0
+                            );

             }
             }

-            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETSCROLLBAR, (MPARAM)nPos, MPFROM2SHORT(0, (SHORT)nRange1));
-            ::WinSendMsg(m_hWndScrollBarVert, SBM_SETTHUMBSIZE, MPFROM2SHORT((SHORT)nThumbVisible, (SHORT)nRange1), (MPARAM)0);
+            else
+                ::WinShowWindow(m_hWndScrollBarVert, FALSE);

         }
         m_nYThumbSize = nThumbVisible;
     }
         }
         m_nYThumbSize = nThumbVisible;
     }


@@ -959,86 +1005,32 @@ void wxWindowOS2::ScrollWindow(
 )
 {
     RECTL                           vRect;
 )
 {
     RECTL                           vRect;

-    RECTL                           vRect2;
+    RECTL                           vRectHorz;
+    RECTL                           vRectVert;
+    RECTL                           vRectChild;

 
 

-    nDy *= -1; // flip the sign of Dy as OS/2 is opposite wxWin.

     if (pRect)
     {
     if (pRect)
     {

-        vRect2.xLeft   = pRect->x;
-        vRect2.yTop    = pRect->y + pRect->height;
-        vRect2.xRight  = pRect->x + pRect->width;
-        vRect2.yBottom = pRect->y;
+        vRect.xLeft   = pRect->x;
+        vRect.yTop    = pRect->y + pRect->height;
+        vRect.xRight  = pRect->x + pRect->width;
+        vRect.yBottom = pRect->y;

     }
     else
     {
     }
     else
     {

-        ::WinQueryWindowRect(GetHwnd(), &vRect2);
-        ::WinQueryWindowRect(m_hWndScrollBarHorz, &vRect);
-        vRect2.yBottom += vRect.yTop - vRect.yBottom;
-        ::WinQueryWindowRect(m_hWndScrollBarVert, &vRect);
-        vRect2.xRight -= vRect.xRight - vRect.xLeft;
-
-    }
-    if (pRect)
-        ::WinScrollWindow( GetHwnd()
-                          ,(LONG)nDx
-                          ,(LONG)nDy
-                          ,&vRect2
-                          ,NULL
-                          ,NULLHANDLE
-                          ,NULL
-                          ,SW_INVALIDATERGN
-                         );
-    else
-        ::WinScrollWindow( GetHwnd()
-                          ,nDx
-                          ,nDy
-                          ,NULL
-                          ,NULL
-                          ,NULLHANDLE
-                          ,NULL
-                          ,SW_INVALIDATERGN
-                         );
-
-    //
-    // Move the children
-    wxWindowList::Node*             pCurrent = GetChildren().GetFirst();
-    SWP                             vSwp;
-
-    while (pCurrent)
-    {
-        wxWindow*                   pChildWin = pCurrent->GetData();
-
-        if (pChildWin->GetHWND() != NULLHANDLE)
-        {
-            ::WinQueryWindowPos(pChildWin->GetHWND(), &vSwp);
-            ::WinQueryWindowRect(pChildWin->GetHWND(), &vRect);
-            if (pChildWin->GetHWND() == m_hWndScrollBarVert ||
-                pChildWin->GetHWND() == m_hWndScrollBarHorz)
-            {
-                ::WinSetWindowPos( pChildWin->GetHWND()
-                                  ,HWND_TOP
-                                  ,vSwp.x + nDx
-                                  ,vSwp.y + nDy
-                                  ,0
-                                  ,0
-                                  ,SWP_MOVE | SWP_SHOW | SWP_ZORDER
-                                 );
-            }
-            else
-            {
-                ::WinSetWindowPos( pChildWin->GetHWND()
-                                  ,HWND_BOTTOM
-                                  ,vSwp.x + nDx
-                                  ,vSwp.y + nDy
-                                  ,0
-                                  ,0
-                                  ,SWP_MOVE | SWP_ZORDER
-                                 );
-                ::WinInvalidateRect(pChildWin->GetHWND(), &vRect, FALSE);
-            }
-        }
-        pCurrent = pCurrent->GetNext();
+        ::WinQueryWindowRect(GetHwnd(), &vRect);

     }
     }

+    nDy *= -1; // flip the sign of Dy as OS/2 is opposite Windows.
+    ::WinScrollWindow( GetHwnd()
+                      ,(LONG)nDx
+                      ,(LONG)nDy
+                      ,&vRect
+                      ,&vRect
+                      ,NULLHANDLE
+                      ,NULL
+                      ,SW_SCROLLCHILDREN | SW_INVALIDATERGN
+                     );
+    Refresh();

 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------
 } // end of wxWindowOS2::ScrollWindow
 
 // ---------------------------------------------------------------------------


@@ -1051,9 +1043,20 @@ void wxWindowOS2::SubclassWin(
 {
     HWND                            hwnd = (HWND)hWnd;
 
 {
     HWND                            hwnd = (HWND)hWnd;
 

-    wxASSERT_MSG( !m_fnOldWndProc, wxT("subclassing window twice?") );

     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );
     wxCHECK_RET(::WinIsWindow(vHabmain, hwnd), wxT("invalid HWND in SubclassWin") );

-    m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
+    wxAssociateWinWithHandle( hWnd
+                             ,(wxWindow*)this
+                            );
+    if (!wxCheckWindowWndProc( hWnd
+                              ,(WXFARPROC)wxWndProc
+                             ))
+    {
+        m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(hwnd, (PFNWP)wxWndProc);
+    }
+    else
+    {
+        m_fnOldWndProc = (WXFARPROC)NULL;
+    }

 } // end of wxWindowOS2::SubclassWin
 
 void wxWindowOS2::UnsubclassWin()
 } // end of wxWindowOS2::SubclassWin
 
 void wxWindowOS2::UnsubclassWin()


@@ -1090,6 +1093,69 @@ bool wxCheckWindowWndProc(
     return(fnWndProc == (WXFARPROC)vCls.pfnWindowProc);
 } // end of WinGuiBase_CheckWindowWndProc
 
     return(fnWndProc == (WXFARPROC)vCls.pfnWindowProc);
 } // end of WinGuiBase_CheckWindowWndProc
 

+void wxWindowOS2::SetWindowStyleFlag(
+  long                              lFlags
+)
+{
+    long                            lFlagsOld = GetWindowStyleFlag();
+
+    if (lFlags == lFlagsOld)
+        return;
+
+    //
+    // Update the internal variable
+    //
+    wxWindowBase::SetWindowStyleFlag(lFlags);
+
+    //
+    // Now update the Windows style as well if needed - and if the window had
+    // been already created
+    //
+    if (!GetHwnd())
+        return;
+
+    WXDWORD                         dwExstyle;
+    WXDWORD                         dwExstyleOld;
+    long                            lStyle = OS2GetStyle( lFlags
+                                                         ,&dwExstyle
+                                                        );
+    long                            lStyleOld = OS2GetStyle( lFlagsOld
+                                                            ,&dwExstyleOld
+                                                           );
+
+    if (lStyle != lStyleOld)
+    {
+        //
+        // Some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
+        // this function so instead of simply setting the style to the new
+        // value we clear the bits which were set in styleOld but are set in
+        // the new one and set the ones which were not set before
+        //
+        long                        lStyleReal = ::WinQueryWindowULong(GetHwnd(), QWL_STYLE);
+
+        lStyleReal &= ~lStyleOld;
+        lStyleReal |= lStyle;
+
+        ::WinSetWindowULong(GetHwnd(), QWL_STYLE, lStyleReal);
+    }
+} // end of wxWindowOS2::SetWindowStyleFlag
+
+WXDWORD wxWindowOS2::OS2GetStyle(
+  long                              lFlags
+, WXDWORD*                          pdwExstyle
+) const
+{
+    WXDWORD                         dwStyle = 0L;
+
+    if (lFlags & wxCLIP_CHILDREN )
+        dwStyle |= WS_CLIPCHILDREN;
+
+    if (lFlags & wxCLIP_SIBLINGS )
+        dwStyle |= WS_CLIPSIBLINGS;
+
+    return dwStyle;
+} // end of wxWindowMSW::MSWGetStyle
+

 //
 // Make a Windows extended style from the given wxWindows window style
 //
 //
 // Make a Windows extended style from the given wxWindows window style
 //


@@ -1357,6 +1423,10 @@ void wxWindowOS2::Refresh(
         }
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);
         }
         else
             ::WinInvalidateRect(hWnd, NULL, bEraseBack);

+        if (m_hWndScrollBarHorz != NULLHANDLE)
+            ::WinInvalidateRect(m_hWndScrollBarHorz, NULL, TRUE);
+        if (m_hWndScrollBarVert != NULLHANDLE)
+            ::WinInvalidateRect(m_hWndScrollBarVert, NULL, TRUE);

     }
 } // end of wxWindowOS2::Refresh
 
     }
 } // end of wxWindowOS2::Refresh
 


@@ -1616,14 +1686,142 @@ void wxWindowOS2::DoMoveWindow(
         ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
         nY = vRect.yTop - (nY + nHeight);
     }
         ::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;
+        ULONG                       ulFLag = SWP_MOVE;
+        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
     ::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)
+        //
+        // Uninitialized
+        //
+        ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
+    else
+    {
+        int                         nYDiff = m_vWinSwp.cy - nHeight;
+
+        //
+        // Handle resizing of scrolled windows.  The target or window to
+        // be scrolled is the owner (gets the scroll notificaitons).  The
+        // parent is usually the parent frame of the scrolled panel window.
+        // In order to show the scrollbars the target window will be shrunk
+        // by the size of the scroll bar widths (20) and moved in the X and Y
+        // directon.  That value will be computed as part of the diff for
+        // moving the children.  Everytime the window is sized the
+        // toplevel OnSize is going to resize the panel to fit the client
+        // or the whole sizer and will need to me resized. This will send
+        // a WM_SIZE out which will be intercepted by the ScrollHelper
+        // which will cause the scrollbars to be displayed via the SetScrollbar
+        // call in CWindow.
+        //
+        if ( IsKindOf(CLASSINFO(wxGenericScrolledWindow)) ||
+             IsKindOf(CLASSINFO(wxScrolledWindow))
+           )
+        {
+            int                     nAdjustWidth  = 0;
+            int                     nAdjustHeight = 0;
+            SWP                     vSwpScroll;
+
+            if (GetScrollBarHorz() == NULLHANDLE ||
+                !WinIsWindowShowing(GetScrollBarHorz()))
+                nAdjustHeight = 0L;
+            else
+                nAdjustHeight = 20L;
+            if (GetScrollBarVert() == NULLHANDLE ||
+                !WinIsWindowShowing(GetScrollBarVert()))
+                nAdjustWidth = 0L;
+            else
+                nAdjustWidth = 20L;
+            ::WinQueryWindowPos(GetHWND(), &vSwpScroll);
+            ::WinSetWindowPos( GetHWND()
+                              ,HWND_TOP
+                              ,vSwpScroll.x
+                              ,vSwpScroll.y + nAdjustHeight
+                              ,vSwpScroll.cx - nAdjustWidth
+                              ,vSwpScroll.cy - nAdjustHeight
+                              ,SWP_MOVE | SWP_SIZE
+                             );
+            nYDiff += nAdjustHeight;
+        }
+        MoveChildren(nYDiff);
+        ::WinQueryWindowPos(GetHwnd(), &m_vWinSwp);
+    }

 } // end of wxWindowOS2::DoMoveWindow
 
 //
 } // end of wxWindowOS2::DoMoveWindow
 
 //


@@ -1665,19 +1863,6 @@ void wxWindowOS2::DoSetSize(
     int                             nY2 = nY;
     wxWindow*                       pParent = (wxWindow*)GetParent();
 
     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)
     {
     if (nX == nCurrentX && nY2 == nCurrentY &&
         nWidth == nCurrentWidth && nHeight == nCurrentHeight)
     {


@@ -1736,34 +1921,61 @@ void wxWindowOS2::DoSetClientSize(
 , int                               nHeight
 )
 {
 , int                               nHeight
 )
 {

-    wxWindow*                       pParent = GetParent();
-    HWND                            hWnd = GetHwnd();
-    HWND                            hParentWnd = (HWND)0;

     POINTL                          vPoint;
     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
     vEvent.SetEventObject(this);
     GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::DoSetClientSize


@@ -2002,8 +2214,8 @@ static void wxYieldForCommandsOnly()
     //
     QMSG                            vMsg;
 
     //
     QMSG                            vMsg;
 

-    while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND,
-           WM_COMMAND,PM_REMOVE) && vMsg.msg != WM_QUIT)
+    while (::WinPeekMsg(vHabmain, &vMsg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE)
+           && vMsg.msg != WM_QUIT)

     {
         wxTheApp->DoMessage((WXMSG*)&vMsg);
     }
     {
         wxTheApp->DoMessage((WXMSG*)&vMsg);
     }


@@ -2017,9 +2229,10 @@ bool wxWindowOS2::DoPopupMenu(
 , int                               nY
 )
 {
 , int                               nY
 )
 {

-    HWND                            hWnd = GetHwnd();
-    HWND                            hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
+    HWND                            hWndOwner = GetHwnd();
+    HWND                            hWndParent = GetHwnd();

     HWND                            hMenu = GetHmenuOf(pMenu);
     HWND                            hMenu = GetHmenuOf(pMenu);

+    bool                            bIsWaiting = TRUE;

 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();
 
     pMenu->SetInvokingWindow(this);
     pMenu->UpdateUI();


@@ -2030,23 +2243,27 @@ bool wxWindowOS2::DoPopupMenu(
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent
     wxCurrentPopupMenu = pMenu;
 
     ::WinPopupMenu( hWndParent

-                   ,hWnd
+                   ,hWndOwner

                    ,hMenu
                    ,nX
                    ,nY
                    ,0L
                    ,hMenu
                    ,nX
                    ,nY
                    ,0L

-                   ,PU_MOUSEBUTTON2DOWN | PU_MOUSEBUTTON2 | PU_KEYBOARD
+                   ,PU_HCONSTRAIN | PU_VCONSTRAIN | PU_MOUSEBUTTON1 | PU_KEYBOARD

                   );
                   );

-    // we need to do it righ now as otherwise the events are never going to be
-    // sent to wxCurrentPopupMenu from ;()
-    //
-    // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
-    // help and we'd still need wxYieldForCommandsOnly() as the menu may be
-    // destroyed as soon as we return (it can be a local variable in the caller
-    // for example) and so we do need to process the event immediately
-    wxYieldForCommandsOnly();
-    wxCurrentPopupMenu = NULL;

 
 

+    while(bIsWaiting)
+    {
+        QMSG                            vMsg;
+        BOOL                            bRc = ::WinGetMsg(vHabmain, &vMsg, HWND(NULL), 0, 0);
+
+        if (vMsg.msg == WM_MENUEND || vMsg.msg == WM_COMMAND)
+        {
+            bIsWaiting = FALSE;
+        }
+        ::WinDispatchMsg(vHabmain, (PQMSG)&vMsg);
+
+    }
+    wxCurrentPopupMenu = NULL;

     pMenu->SetInvokingWindow(NULL);
     return TRUE;
 } // end of wxWindowOS2::DoPopupMenu
     pMenu->SetInvokingWindow(NULL);
     return TRUE;
 } // end of wxWindowOS2::DoPopupMenu


@@ -2239,17 +2456,6 @@ bool wxWindowOS2::OS2ProcessMessage(
     pMsg = pMsg; // just shut up the compiler
 #endif // __WXUNIVERSAL__
 
     pMsg = pMsg; // just shut up the compiler
 #endif // __WXUNIVERSAL__
 

-#if wxUSE_TOOLTIPS
-    if ( m_tooltip )
-    {
-        // relay mouse move events to the tooltip control
-        QMSG*                       pQMsg = (QMSG*)pMsg;
-
-        if (pQMsg->msg == WM_MOUSEMOVE )
-            m_tooltip->RelayEvent(pMsg);
-    }
-#endif // wxUSE_TOOLTIPS
-

     return FALSE;
 } // end of wxWindowOS2::OS2ProcessMessage
 
     return FALSE;
 } // end of wxWindowOS2::OS2ProcessMessage
 


@@ -2393,7 +2599,18 @@ MRESULT EXPENTRY wxWndProc(
     else
     {
         if (pWnd)
     else
     {
         if (pWnd)

+        {

             rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
             rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);

+            if ( (pWnd->GetScrollBarHorz() != NULLHANDLE ||
+                  pWnd->GetScrollBarVert() != NULLHANDLE) &&
+                  ulMsg == WM_PAINT)
+            {
+                if (pWnd->GetScrollBarHorz() != NULLHANDLE)
+                    ::WinInvalidateRect(pWnd->GetScrollBarHorz(), NULL, TRUE);
+                if (pWnd->GetScrollBarVert() != NULLHANDLE)
+                    ::WinInvalidateRect(pWnd->GetScrollBarVert(), NULL, TRUE);
+            }
+        }

         else
             rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
     }
         else
             rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
     }


@@ -2471,7 +2688,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
             // child controls, so we need to already be sized
             // in order to get the child controls positoned properly.
             //
             // child controls, so we need to already be sized
             // in order to get the child controls positoned properly.
             //

-            if (IsKindOf(CLASSINFO(wxDialog)))
+            if (IsKindOf(CLASSINFO(wxDialog)) || IsKindOf(CLASSINFO(wxFrame)))

             {
                 PSWP                pSwp = (PSWP)PVOIDFROMMP(wParam);
                 PSWP                pSwp2 = pSwp++;
             {
                 PSWP                pSwp = (PSWP)PVOIDFROMMP(wParam);
                 PSWP                pSwp2 = pSwp++;


@@ -2482,6 +2699,18 @@ MRESULT wxWindowOS2::OS2WindowProc(
                                             ,pSwp->cy
                                             ,(WXUINT)lParam
                                            );
                                             ,pSwp->cy
                                             ,(WXUINT)lParam
                                            );

+                if (IsKindOf(CLASSINFO(wxFrame)))
+                {
+                    wxFrame*            pFrame = wxDynamicCast(this, wxFrame);
+
+                    if (pFrame)
+                    {
+                        if (pFrame->GetStatusBar())
+                            pFrame->PositionStatusBar();
+                        if (pFrame->GetToolBar())
+                            pFrame->PositionToolBar();
+                    }
+                }

             }
             break;
 
             }
             break;
 


@@ -2548,12 +2777,38 @@ MRESULT wxWindowOS2::OS2WindowProc(
         case WM_BUTTON3MOTIONEND:
         case WM_BUTTON3MOTIONSTART:
             {
         case WM_BUTTON3MOTIONEND:
         case WM_BUTTON3MOTIONSTART:
             {

-                short x = LOWORD(lParam);
-                short y = HIWORD(lParam);
+                if (uMsg == WM_BUTTON1DOWN && AcceptsFocus())
+                    SetFocus();
+
+                short               nX = LOWORD(wParam);
+                short               nY = HIWORD(wParam);

 
 

-                bProcessed = HandleMouseEvent(uMsg, x, y, (WXUINT)wParam);
+                //
+                // Redirect the event to a static control if necessary
+                //
+                if (this == GetCapture())
+                {
+                    bProcessed = HandleMouseEvent( uMsg
+                                                  ,nX
+                                                  ,nY
+                                                  ,(WXUINT)SHORT1FROMMP(wParam)
+                                                 );
+                }
+                else
+                {
+                    wxWindow*       pWin = FindWindowForMouseEvent( this
+                                                                   ,&nX
+                                                                   ,&nY
+                                                                  );
+                    bProcessed = pWin->HandleMouseEvent( uMsg
+                                                        ,nX
+                                                        ,nY
+                                                        ,(WXUINT)SHORT1FROMMP(wParam)
+                                                       );
+                }

             }
             break;
             }
             break;

+

         case WM_SYSCOMMAND:
             bProcessed = HandleSysCommand(wParam, lParam);
             break;
         case WM_SYSCOMMAND:
             bProcessed = HandleSysCommand(wParam, lParam);
             break;


@@ -2593,10 +2848,13 @@ MRESULT wxWindowOS2::OS2WindowProc(
             break;
 
         case WM_QUERYDLGCODE:
             break;
 
         case WM_QUERYDLGCODE:

-            if ( m_lDlgCode )
+            if (!IsOfStandardClass())

             {
             {

-                mResult = (MRESULT)m_lDlgCode;
-                bProcessed = TRUE;
+                if ( m_lDlgCode )
+                {
+                    mResult = (MRESULT)m_lDlgCode;
+                    bProcessed = TRUE;
+                }

             }
             //
             //else: get the dlg code from the DefWindowProc()
             }
             //
             //else: get the dlg code from the DefWindowProc()


@@ -2614,17 +2872,18 @@ MRESULT wxWindowOS2::OS2WindowProc(
                 if (uKeyFlags & KC_KEYUP)
                 {
                     //TODO: check if the cast to WXWORD isn't causing trouble
                 if (uKeyFlags & KC_KEYUP)
                 {
                     //TODO: check if the cast to WXWORD isn't causing trouble

-                    bProcessed = HandleKeyUp((WXDWORD)wParam, lParam);
+                    bProcessed = HandleKeyUp(wParam, lParam);

                     break;
                 }
                 else // keydown event
                 {
                     break;
                 }
                 else // keydown event
                 {

+                    m_bLastKeydownProcessed = FALSE;

                     //
                     // If this has been processed by an event handler,
                     // return 0 now (we've handled it). DON't RETURN
                     // we still need to process further
                     //
                     //
                     // If this has been processed by an event handler,
                     // return 0 now (we've handled it). DON't RETURN
                     // we still need to process further
                     //

-                    HandleKeyDown((WXDWORD)wParam, lParam);
+                    m_bLastKeydownProcessed = HandleKeyDown(wParam, lParam);

                     if (uKeyFlags & KC_VIRTUALKEY)
                     {
                         USHORT          uVk = SHORT2FROMMP((MPARAM)lParam);
                     if (uKeyFlags & KC_VIRTUALKEY)
                     {
                         USHORT          uVk = SHORT2FROMMP((MPARAM)lParam);


@@ -2632,14 +2891,17 @@ MRESULT wxWindowOS2::OS2WindowProc(
                         //
                         // We consider these message "not interesting" to OnChar
                         //
                         //
                         // We consider these message "not interesting" to OnChar
                         //

-                        if (uVk == VK_SHIFT || uVk == VK_CTRL )
-                        {
-                            bProcessed = TRUE;
-                            break;
-                        }

                         switch(uVk)
                         {
                         switch(uVk)
                         {

-                            //
+                            case VK_SHIFT:
+                            case VK_CTRL:
+                            case VK_MENU:
+                            case VK_CAPSLOCK:
+                            case VK_NUMLOCK:
+                            case VK_SCRLLOCK:
+                                bProcessed = TRUE;
+                                break;
+

                             // Avoid duplicate messages to OnChar for these ASCII keys: they
                             // will be translated by TranslateMessage() and received in WM_CHAR
                             case VK_ESC:
                             // Avoid duplicate messages to OnChar for these ASCII keys: they
                             // will be translated by TranslateMessage() and received in WM_CHAR
                             case VK_ESC:


@@ -2653,19 +2915,28 @@ MRESULT wxWindowOS2::OS2WindowProc(
                                 bProcessed = FALSE;
                                 break;
 
                                 bProcessed = FALSE;
                                 break;
 

-                            case VK_LEFT:
-                            case VK_RIGHT:
-                            case VK_DOWN:
-                            case VK_UP:

                             default:
                             default:

-                                bProcessed = HandleChar((WXDWORD)wParam, lParam);
+                                bProcessed = HandleChar(wParam, lParam);

                          }
                          break;
                     }
                     else // WM_CHAR -- Always an ASCII character
                     {
                          }
                          break;
                     }
                     else // WM_CHAR -- Always an ASCII character
                     {

-                        bProcessed = HandleChar((WXDWORD)wParam, lParam, TRUE);
-                        break;
+                        if (m_bLastKeydownProcessed)
+                        {
+                            //
+                            // The key was handled in the EVT_KEY_DOWN and handling
+                            // a key in an EVT_KEY_DOWN handler is meant, by
+                            // design, to prevent EVT_CHARs from happening
+                            //
+                            m_bLastKeydownProcessed = FALSE;
+                            bProcessed = TRUE;
+                        }
+                        else // do generate a CHAR event
+                        {
+                            bProcessed = HandleChar(wParam, lParam, TRUE);
+                            break;
+                        }

                     }
                 }
             }
                     }
                 }
             }


@@ -2695,6 +2966,48 @@ MRESULT wxWindowOS2::OS2WindowProc(
         case WM_CONTROL:
             switch(SHORT2FROMMP(wParam))
             {
         case WM_CONTROL:
             switch(SHORT2FROMMP(wParam))
             {

+                case BN_CLICKED:
+                    {
+                        HWND                hWnd = ::WinWindowFromID((HWND)GetHwnd(), SHORT1FROMMP(wParam));
+                        wxWindowOS2*        pWin = wxFindWinFromHandle(hWnd);
+
+                        if (!pWin)
+                        {
+                            bProcessed = FALSE;
+                            break;
+                        }
+                        //
+                        // Simulate a WM_COMMAND here, as wxWindows 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)
+                                                 );
+                        }
+                        return 0;
+                    }
+                    break;
+

                 case SPBN_UPARROW:
                 case SPBN_DOWNARROW:
                 case SPBN_CHANGE:
                 case SPBN_UPARROW:
                 case SPBN_DOWNARROW:
                 case SPBN_CHANGE:


@@ -2723,6 +3036,11 @@ MRESULT wxWindowOS2::OS2WindowProc(
                         HWND                hWnd = ::WinWindowFromID(GetHWND(), SHORT1FROMMP(wParam));
                         wxWindowOS2*        pChild = wxFindWinFromHandle(hWnd);
 
                         HWND                hWnd = ::WinWindowFromID(GetHWND(), SHORT1FROMMP(wParam));
                         wxWindowOS2*        pChild = wxFindWinFromHandle(hWnd);
 

+                        if (!pChild)
+                        {
+                            bProcessed = FALSE;
+                            break;
+                        }

                         if (pChild->IsKindOf(CLASSINFO(wxSlider)))
                             bProcessed = OS2OnScroll( wxVERTICAL
                                                      ,(int)SHORT2FROMMP(wParam)
                         if (pChild->IsKindOf(CLASSINFO(wxSlider)))
                             bProcessed = OS2OnScroll( wxVERTICAL
                                                      ,(int)SHORT2FROMMP(wParam)


@@ -2770,7 +3088,7 @@ MRESULT wxWindowOS2::OS2WindowProc(
             if ( bProcessed )
             {
                 // we never set focus from here
             if ( bProcessed )
             {
                 // we never set focus from here

-                mResult = FALSE;
+                mResult = (MRESULT)FALSE;

             }
             break;
 
             }
             break;
 


@@ -2915,36 +3233,37 @@ bool wxWindowOS2::OS2GetCreateWindowCoords(
 ) const
 {
     bool                            bNonDefault = FALSE;
 ) const
 {
     bool                            bNonDefault = FALSE;

+    static const int                DEFAULT_Y = 200;
+    static const int                DEFAULT_H = 250;

 
     if (rPos.x == -1)
     {
 
     if (rPos.x == -1)
     {

-        //
-        // If set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
-        // just as well set it to CW_USEDEFAULT as well

         rnX = rnY = CW_USEDEFAULT;
     }
     else
     {
         rnX = rPos.x;
         rnX = rnY = CW_USEDEFAULT;
     }
     else
     {
         rnX = rPos.x;

-        rnY = rPos.y == -1 ? CW_USEDEFAULT : rPos.y;
+        rnY = rPos.y == -1 ? DEFAULT_Y : rPos.y;

         bNonDefault = TRUE;
     }
     if (rSize.x == -1)
     {
         bNonDefault = TRUE;
     }
     if (rSize.x == -1)
     {

-        //
-        // As abobe, h is not used at all in this case anyhow
-        //

         rnWidth = rnHeight = CW_USEDEFAULT;
     }
     else
     {
         rnWidth  = rSize.x;
         rnWidth = rnHeight = CW_USEDEFAULT;
     }
     else
     {
         rnWidth  = rSize.x;

-        rnHeight = rSize.y == -1 ? CW_USEDEFAULT : rSize.y;
+        rnHeight = rSize.y == -1 ? DEFAULT_H : rSize.y;

         bNonDefault = TRUE;
     }
     return bNonDefault;
 } // end of wxWindowOS2::OS2GetCreateWindowCoords
 
         bNonDefault = TRUE;
     }
     return bNonDefault;
 } // end of wxWindowOS2::OS2GetCreateWindowCoords
 

+WXHWND wxWindowOS2::OS2GetParent() const
+{
+    return m_parent ? m_parent->GetHWND() : NULL;
+}
+

 bool wxWindowOS2::OS2Create(
   PSZ                               zClass
 , const char*                       zTitle
 bool wxWindowOS2::OS2Create(
   PSZ                               zClass
 , const char*                       zTitle


@@ -2977,31 +3296,6 @@ bool wxWindowOS2::OS2Create(
                              ,nHeight
                             );
 
                              ,nHeight
                             );
 

-    if (GetWindowStyleFlag() & wxPOPUP_WINDOW)
-        hParent = HWND_DESKTOP;
-    else
-    {
-        if ((bIsChild || HasFlag(wxFRAME_TOOL_WINDOW)) && pParent )
-        {
-            //
-            // This is either a normal child window or a top level window with
-            // wxFRAME_TOOL_WINDOW style (see below)
-            //
-            hParent = GetHwndOf(pParent);
-        }
-        else
-        {
-            //
-            // This is either a window for which no parent was specified (not
-            // much we can do then) or a frame without wxFRAME_TOOL_WINDOW
-            // style: we should use NULL parent HWND for it or it would be
-            // always on top of its parent which is not what we usually want
-            // (in fact, we only want it for frames with the special
-            // wxFRAME_TOOL_WINDOW as above)
-            //
-            hParent = NULL;
-        }
-    }

     if (bIsChild)
     {
         lControlId = GetId();
     if (bIsChild)
     {
         lControlId = GetId();


@@ -3019,46 +3313,20 @@ bool wxWindowOS2::OS2Create(
     {
         sClassName += wxT("NR");
     }
     {
         sClassName += wxT("NR");
     }

-
-    //
-    // If the window being created is a Frame's Statusbar we need to use
-    // the actual Frame's size, not its client
-    //
-    if (pParent)
-    {
-        if (IsKindOf(CLASSINFO(wxStatusBar)) &&
-            pParent->IsKindOf(CLASSINFO(wxFrame)))
-        {
-            RECTL                   vRect;
-            wxFrame*                pFrame = wxDynamicCast(pParent, wxFrame);
-
-            ::WinQueryWindowRect((HWND)pFrame->GetFrame(), &vRect);
-            nY = vRect.yTop - (nY + nHeight);
-        }
-        else
-            nY = pParent->GetSize().y - (nY + nHeight);
-    }
-    else
-    {
-        RECTL                   vRect;
-
-        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
-        nY = vRect.yTop - (nY + nHeight);
-    }
-    m_hWnd = (WXHWND)::WinCreateWindow( (HWND)hParent
-                                      ,(PSZ)sClassName.c_str()
-                                      ,(PSZ)zTitle ? zTitle : ""
-                                      ,(ULONG)dwStyle
-                                      ,(LONG)0L
-                                      ,(LONG)0L
-                                      ,(LONG)0L
-                                      ,(LONG)0L
-                                      ,NULLHANDLE
-                                      ,HWND_TOP
-                                      ,(ULONG)lControlId
-                                      ,pCtlData
-                                      ,NULL
-                                     );
+    m_hWnd = (WXHWND)::WinCreateWindow( (HWND)OS2GetParent()
+                                       ,(PSZ)sClassName.c_str()
+                                       ,(PSZ)zTitle ? zTitle : ""
+                                       ,(ULONG)dwStyle
+                                       ,(LONG)0L
+                                       ,(LONG)0L
+                                       ,(LONG)0L
+                                       ,(LONG)0L
+                                       ,NULLHANDLE
+                                       ,HWND_TOP
+                                       ,(ULONG)lControlId
+                                       ,pCtlData
+                                       ,NULL
+                                      );

     if (!m_hWnd)
     {
         vError = ::WinGetLastError(wxGetInstance());
     if (!m_hWnd)
     {
         vError = ::WinGetLastError(wxGetInstance());


@@ -3067,6 +3335,22 @@ bool wxWindowOS2::OS2Create(
     }
     SubclassWin(m_hWnd);
     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
     }
     SubclassWin(m_hWnd);
     SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));

+
+    m_backgroundColour.Set(wxString("GREY"));
+
+    LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
+
+    if (!::WinSetPresParam( m_hWnd
+                           ,PP_BACKGROUNDCOLOR
+                           ,sizeof(LONG)
+                           ,(PVOID)&lColor
+                          ))
+    {
+        vError = ::WinGetLastError(vHabmain);
+        sError = wxPMErrorToStr(vError);
+        wxLogError("Error creating frame. Error: %s\n", sError);
+        return FALSE;
+    }

     SetSize( nX
             ,nY
             ,nWidth
     SetSize( nX
             ,nY
             ,nWidth


@@ -3179,7 +3463,7 @@ bool wxWindowOS2::HandleSetFocus(
 } // end of wxWindowOS2::HandleSetFocus
 
 bool wxWindowOS2::HandleKillFocus(
 } // end of wxWindowOS2::HandleSetFocus
 
 bool wxWindowOS2::HandleKillFocus(

-  WXHWND                            WXUNUSED(hWnd)
+  WXHWND                            hWnd

 )
 {
 #if wxUSE_CARET
 )
 {
 #if wxUSE_CARET


@@ -3192,11 +3476,38 @@ bool wxWindowOS2::HandleKillFocus(
     }
 #endif // wxUSE_CARET
 
     }
 #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);
     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
 
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleKillFocus
 


@@ -3555,7 +3866,114 @@ bool wxWindowOS2::HandlePaint()
     vEvent.SetEventObject(this);
     bProcessed = GetEventHandler()->ProcessEvent(vEvent);
 
     vEvent.SetEventObject(this);
     bProcessed = GetEventHandler()->ProcessEvent(vEvent);
 

-    return GetEventHandler()->ProcessEvent(vEvent); //bProcessed;
+    if (!bProcessed &&
+         IsKindOf(CLASSINFO(wxPanel)) &&
+         GetChildren().GetCount() == 0
+       )
+    {
+        //
+        // OS/2 needs to process this right here, not by the default proc
+        // 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
+                              ,&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()) && m_bIsActivePage)
+            {
+                ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
+                if (m_dwExStyle)
+                {
+                    LINEBUNDLE      vLineBundle;
+
+                    vLineBundle.lColor     = 0x00000000; // Black
+                    vLineBundle.usMixMode  = FM_OVERPAINT;
+                    vLineBundle.fxWidth    = 1;
+                    vLineBundle.lGeomWidth = 1;
+                    vLineBundle.usType     = LINETYPE_SOLID;
+                    vLineBundle.usEnd      = 0;
+                    vLineBundle.usJoin     = 0;
+                    ::GpiSetAttrs( hPS
+                                  ,PRIM_LINE
+                                  ,LBB_COLOR | LBB_MIX_MODE | LBB_WIDTH | LBB_GEOM_WIDTH | LBB_TYPE
+                                  ,0L
+                                  ,&vLineBundle
+                                 );
+                    ::WinQueryWindowRect(GetHwnd(), &vRect);
+                    wxDrawBorder( hPS
+                                 ,vRect
+                                 ,m_dwExStyle
+                                );
+                }
+            }
+        }
+        ::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;
+        wxFrame*                    pFrame;
+        wxWindow*                   pParent;
+
+        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()) && m_bIsActivePage)
+                ::WinFillRect(hPS, &vRect,  GetBackgroundColour().GetPixel());
+        }
+        ::WinEndPaint(hPS);
+        bProcessed = TRUE;
+    }
+    return bProcessed;

 } // end of wxWindowOS2::HandlePaint
 
 bool wxWindowOS2::HandleEraseBkgnd(
 } // end of wxWindowOS2::HandlePaint
 
 bool wxWindowOS2::HandleEraseBkgnd(


@@ -3740,6 +4158,7 @@ void wxWindowOS2::InitMouseEvent(
     rEvent.m_rightDown   = ((uFlags & VK_BUTTON2) != 0);
     rEvent.SetTimestamp(s_currentMsg.time);
     rEvent.m_eventObject = this;
     rEvent.m_rightDown   = ((uFlags & VK_BUTTON2) != 0);
     rEvent.SetTimestamp(s_currentMsg.time);
     rEvent.m_eventObject = this;

+    rEvent.SetId(GetId());

 
 #if wxUSE_MOUSEEVENT_HACK
     m_lastMouseX = nX;
 
 #if wxUSE_MOUSEEVENT_HACK
     m_lastMouseX = nX;


@@ -3755,6 +4174,8 @@ bool wxWindowOS2::HandleMouseEvent(
 , WXUINT                            uFlags
 )
 {
 , WXUINT                            uFlags
 )
 {

+    bool                            bProcessed = FALSE;
+

     //
     // The mouse events take consecutive IDs from WM_MOUSEFIRST to
     // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
     //
     // The mouse events take consecutive IDs from WM_MOUSEFIRST to
     // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST


@@ -3783,6 +4204,18 @@ bool wxWindowOS2::HandleMouseEvent(
                    ,uFlags
                   );
 
                    ,uFlags
                   );
 

+    bProcessed = GetEventHandler()->ProcessEvent(vEvent);
+    if (!bProcessed)
+    {
+        HPOINTER                    hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_WAIT, FALSE);
+        HPOINTER                    hCursor = (HPOINTER)GetCursor().GetHCURSOR();
+
+        if (hCursor != NULLHANDLE)
+        {
+            ::WinSetPointer(HWND_DESKTOP, hCursor);
+            bProcessed = TRUE;
+        }
+    }

     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleMouseEvent
 
     return GetEventHandler()->ProcessEvent(vEvent);
 } // end of wxWindowOS2::HandleMouseEvent
 


@@ -3828,6 +4261,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent(
   wxEventType                       eType
 , int                               nId
 , WXLPARAM                          lParam
   wxEventType                       eType
 , int                               nId
 , WXLPARAM                          lParam

+, WXWPARAM                          wParam

 ) const
 {
     wxKeyEvent                      vEvent(eType);
 ) const
 {
     wxKeyEvent                      vEvent(eType);


@@ -3839,6 +4273,8 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent(
 
     vEvent.m_eventObject = (wxWindow *)this; // const_cast
     vEvent.m_keyCode     = nId;
 
     vEvent.m_eventObject = (wxWindow *)this; // const_cast
     vEvent.m_keyCode     = nId;

+    vEvent.m_rawCode = (wxUint32)wParam;
+    vEvent.m_rawFlags = (wxUint32)lParam;

     vEvent.SetTimestamp(s_currentMsg.time);
 
     //
     vEvent.SetTimestamp(s_currentMsg.time);
 
     //


@@ -3866,7 +4302,7 @@ wxKeyEvent wxWindowOS2::CreateKeyEvent(
 // WM_KEYDOWN one
 //
 bool wxWindowOS2::HandleChar(
 // WM_KEYDOWN one
 //
 bool wxWindowOS2::HandleChar(

-  WXDWORD                           wParam
+  WXWPARAM                          wParam

 , WXLPARAM                          lParam
 , bool                              isASCII
 )
 , WXLPARAM                          lParam
 , bool                              isASCII
 )


@@ -3874,12 +4310,24 @@ bool wxWindowOS2::HandleChar(
     bool                            bCtrlDown = FALSE;
     int                             vId;
 
     bool                            bCtrlDown = FALSE;
     int                             vId;
 

+    if (m_bLastKeydownProcessed)
+    {
+        //
+        // The key was handled in the EVT_KEY_DOWN.  Handling a key in an
+        // EVT_KEY_DOWN handler is meant, by design, to prevent EVT_CHARs
+        // from happening, so just bail out at this point.
+        //
+        m_bLastKeydownProcessed = FALSE;
+        return TRUE;
+    }

     if (isASCII)
     {
         //
     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 = wParam;
+        vId = (int)wParam;

         if ((vId > 0) && (vId < 27))
         {
             switch (vId)
         if ((vId > 0) && (vId < 27))
         {
             switch (vId)


@@ -3898,57 +4346,50 @@ bool wxWindowOS2::HandleChar(
 
                 default:
                     bCtrlDown = TRUE;
 
                 default:
                     bCtrlDown = TRUE;

-                    vId = vId + 96;
+                    break;

             }
         }
     }
             }
         }
     }

-    else if ( (vId = wxCharCodeOS2ToWX(wParam)) == 0)
+    else  // we're called from WM_KEYDOWN

     {
     {

-        //
-        // It's ASCII and will be processed here only when called from
-        // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
-        //
-        vId = -1;
+        vId = wxCharCodeOS2ToWX((int)wParam);
+        if (vId == 0)
+            return FALSE;

     }
 
     }
 

-    if (vId != -1)
-    {
-        wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_CHAR
+    wxKeyEvent                      vEvent(CreateKeyEvent( wxEVT_CHAR

                                                           ,vId
                                                           ,lParam
                                                          ));
 
                                                           ,vId
                                                           ,lParam
                                                          ));
 

-        if (bCtrlDown)
-        {
-            vEvent.m_controlDown = TRUE;
-        }
-
-        if (GetEventHandler()->ProcessEvent(vEvent))
-            return TRUE;
+    if (bCtrlDown)
+    {
+        vEvent.m_controlDown = TRUE;

     }
     }

-    return FALSE;
+    return (GetEventHandler()->ProcessEvent(vEvent));

 }
 
 bool wxWindowOS2::HandleKeyDown(
 }
 
 bool wxWindowOS2::HandleKeyDown(

-  WXWORD                            wParam
+  WXWPARAM                          wParam

 , WXLPARAM                          lParam
 )
 {
 , WXLPARAM                          lParam
 )
 {

-    int                             nId = wxCharCodeOS2ToWX(wParam);
+    int                             nId = wxCharCodeOS2ToWX((int)wParam);

 
     if (!nId)
     {
         //
         // Normal ASCII char
         //
 
     if (!nId)
     {
         //
         // Normal ASCII char
         //

-        nId = wParam;
+        nId = (int)wParam;

     }
 
     if (nId != -1)
     {
         wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_KEY_DOWN
                                                           ,nId
     }
 
     if (nId != -1)
     {
         wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_KEY_DOWN
                                                           ,nId

-                                                          ,lParam
+                                                          ,(MPARAM)lParam
+                                                          ,(MPARAM)wParam

                                                          ));
 
         if (GetEventHandler()->ProcessEvent(vEvent))
                                                          ));
 
         if (GetEventHandler()->ProcessEvent(vEvent))


@@ -3960,18 +4401,18 @@ bool wxWindowOS2::HandleKeyDown(
 } // end of wxWindowOS2::HandleKeyDown
 
 bool wxWindowOS2::HandleKeyUp(
 } // end of wxWindowOS2::HandleKeyDown
 
 bool wxWindowOS2::HandleKeyUp(

-  WXDWORD                           wParam
+  WXWPARAM                          wParam

 , WXLPARAM                          lParam
 )
 {
 , WXLPARAM                          lParam
 )
 {

-    int                             nId = wxCharCodeOS2ToWX(wParam);
+    int                             nId = wxCharCodeOS2ToWX((int)wParam);

 
     if (!nId)
     {
         //
         // Normal ASCII char
         //
 
     if (!nId)
     {
         //
         // Normal ASCII char
         //

-        nId = wParam;
+        nId = (int)wParam;

     }
 
     if (nId != -1)
     }
 
     if (nId != -1)


@@ -3979,6 +4420,7 @@ bool wxWindowOS2::HandleKeyUp(
         wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_KEY_UP
                                                           ,nId
                                                           ,lParam
         wxKeyEvent                  vEvent(CreateKeyEvent( wxEVT_KEY_UP
                                                           ,nId
                                                           ,lParam

+                                                          ,wParam

                                                          ));
 
         if (GetEventHandler()->ProcessEvent(vEvent))
                                                          ));
 
         if (GetEventHandler()->ProcessEvent(vEvent))


@@ -4056,63 +4498,72 @@ void wxWindowOS2::MoveChildren(
   int                               nDiff
 )
 {
   int                               nDiff
 )
 {

-    SWP                                 vSwp;
-
-    for (wxWindowList::Node* pNode = GetChildren().GetFirst();
-         pNode;
-         pNode = pNode->GetNext())
+    if (GetAutoLayout())
+    {
+        Layout();
+    }
+    else

     {
     {

-        wxWindow*                   pWin = pNode->GetData();
+        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
-                         );
-        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();

 } // end of wxWindowOS2::MoveChildren
 
 //
 } // end of wxWindowOS2::MoveChildren
 
 //


@@ -4132,6 +4583,8 @@ void wxWindowOS2::MoveChildren(
 //
 //  3)  The controls are children of a panel, which in turn is a child of
 //      a frame.
 //
 //  3)  The controls are children of a panel, which in turn is a child of
 //      a frame.

+//      The panel may be one of many, in which case the same treatment
+//      as 1 applies. It may be the only child, though.

 //      This is the nastiest case.  A panel is created as the only child of
 //      the frame and as such, when a frame has only one child, the child is
 //      expanded to fit the entire client area of the frame.  Because the
 //      This is the nastiest case.  A panel is created as the only child of
 //      the frame and as such, when a frame has only one child, the child is
 //      expanded to fit the entire client area of the frame.  Because the


@@ -4168,46 +4621,39 @@ int wxWindowOS2::GetOS2ParentHeight(
             IsKindOf(CLASSINFO(wxMenuBar))   ||
             IsKindOf(CLASSINFO(wxToolBar))
            )
             IsKindOf(CLASSINFO(wxMenuBar))   ||
             IsKindOf(CLASSINFO(wxToolBar))
            )

-            return(pParent->GetSize().y);
+        {
+            if (IsKindOf(CLASSINFO(wxToolBar)))
+            {
+                wxFrame*            pFrame = wxDynamicCast(GetParent(), wxFrame);
+
+                if (pFrame->GetToolBar() == this)
+                    return(pParent->GetSize().y);
+                else
+                    return(pParent->GetClientSize().y);
+            }
+            else
+                return(pParent->GetSize().y);
+        }

         else
             return(pParent->GetClientSize().y);
     }
         else
             return(pParent->GetClientSize().y);
     }

-

     //
     //

-    // Case 3 -- this is for any window that is the sole child of a Frame.
-    //           The grandparent must exist and it must be of type CFrame
-    //           and it's height must be different. Otherwise the standard
-    //           applies.
+    // Case -- this is for any window that is the sole child of a Frame.
+    //         The grandparent must exist and it must be of type CFrame
+    //         and it's height must be different. Otherwise the standard
+    //         applies.

     //
     else
     {
     //
     else
     {

-        pGrandParent = pParent->GetParent();
-        if (pGrandParent &&
-            pGrandParent->IsKindOf(CLASSINFO(wxFrame)) &&
-            pGrandParent->GetClientSize().y != pParent->GetSize().y
-           )
-        {
-            int                     nParentHeight = 0L;
-            int                     nStatusBarHeight = 0L;
-            wxFrame*                pFrame = wxDynamicCast(pGrandParent, wxFrame);
-            wxStatusBar*            pStatbar = pFrame->GetStatusBar();
-
-            nParentHeight = pGrandParent->GetClientSize().y;
-            if (pStatbar)
-                nStatusBarHeight = pStatbar->GetSize().y;
-            nParentHeight -= nStatusBarHeight;
-            return(nParentHeight);
-        }
-        else
-            //
-            // Panel is a child of some other kind of window so we'll
-            // just use it's original size
-            //
-            return(pParent->GetClientSize().y);
+        return(pParent->GetClientSize().y);

     }
     return(0L);
 } // end of wxWindowOS2::GetOS2ParentHeight
 
     }
     return(0L);
 } // end of wxWindowOS2::GetOS2ParentHeight
 

+//
+// OS/2 needs a lot extra manipulation to deal with layouts
+// for canvas windows, particularly scrolled ones.
+//

 wxWindowCreationHook::wxWindowCreationHook(
   wxWindow*                         pWinBeingCreated
 )
 wxWindowCreationHook::wxWindowCreationHook(
   wxWindow*                         pWinBeingCreated
 )


@@ -4285,6 +4731,7 @@ int wxCharCodeOS2ToWX(
         case VK_PRINTSCRN:  nId = WXK_PRINT; break;
         case VK_INSERT:     nId = WXK_INSERT; break;
         case VK_DELETE:     nId = WXK_DELETE; break;
         case VK_PRINTSCRN:  nId = WXK_PRINT; break;
         case VK_INSERT:     nId = WXK_INSERT; break;
         case VK_DELETE:     nId = WXK_DELETE; break;

+        case VK_CAPSLOCK:   nId = WXK_CAPITAL; break;

         case VK_F1:         nId = WXK_F1; break;
         case VK_F2:         nId = WXK_F2; break;
         case VK_F3:         nId = WXK_F3; break;
         case VK_F1:         nId = WXK_F1; break;
         case VK_F2:         nId = WXK_F2; break;
         case VK_F3:         nId = WXK_F3; break;


@@ -4309,6 +4756,17 @@ int wxCharCodeOS2ToWX(
         case VK_F22:        nId = WXK_F22; break;
         case VK_F23:        nId = WXK_F23; break;
         case VK_F24:        nId = WXK_F24; break;
         case VK_F22:        nId = WXK_F22; break;
         case VK_F23:        nId = WXK_F23; break;
         case VK_F24:        nId = WXK_F24; break;

+        case VK_OEM_1:      nId = ';'; break;
+        case VK_OEM_PLUS:   nId = '+'; break;
+        case VK_OEM_COMMA:  nId = ','; break;
+        case VK_OEM_MINUS:  nId = '-'; break;
+        case VK_OEM_PERIOD: nId = '.'; break;
+        case VK_OEM_2:      nId = '/'; break;
+        case VK_OEM_3:      nId = '~'; break;
+        case VK_OEM_4:      nId = '['; break;
+        case VK_OEM_5:      nId = '\\'; break;
+        case VK_OEM_6:      nId = ']'; break;
+        case VK_OEM_7:      nId = '\''; break;

         case VK_NUMLOCK:    nId = WXK_NUMLOCK; break;
         case VK_SCRLLOCK:   nId = WXK_SCROLL; break;
         default:
         case VK_NUMLOCK:    nId = WXK_NUMLOCK; break;
         case VK_SCRLLOCK:   nId = WXK_SCROLL; break;
         default:


@@ -4929,3 +5387,108 @@ wxPoint wxGetMousePosition()
     return wxPoint(vPt.x, vPt.y);
 }
 
     return wxPoint(vPt.x, vPt.y);
 }
 

+wxWindowOS2* FindWindowForMouseEvent(
+  wxWindow*                         pWin
+, short*                            pnX
+, short*                            pnY
+)
+{
+    HWND                            hWnd = GetHwndOf(pWin);
+    HWND                            hWndUnderMouse;
+    POINTL                          vPoint;
+    BOOL                            rcEnabled = FALSE;
+    BOOL                            rcVisible = FALSE;
+    HWND                            hWndDesktop = HWND_DESKTOP;
+
+    ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
+    hWndUnderMouse = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
+    if (hWndUnderMouse != HWND_DESKTOP)
+    {
+        wxWindow*                   pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse);
+
+        if (pWinUnderMouse)
+        {
+            wxWindowList::Node*     pCurrent = pWinUnderMouse->GetChildren().GetFirst();
+            wxWindow*               pChild = NULL;
+            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 &&
+         rcVisible && rcEnabled)
+    {
+        wxWindow*                       pWinUnderMouse = wxFindWinFromHandle((WXHWND)hWndUnderMouse);
+
+        if (pWinUnderMouse)
+        {
+            //
+            // Translate the mouse coords to the other window coords
+            //
+            pWin = pWinUnderMouse;
+        }
+    }
+    return pWin;
+} // end of FindWindowForMouseEvent
+