]> git.saurik.com Git - wxWidgets.git/blobdiff - src/os2/toplevel.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Refresh wxDisplay when a monitor is added to or removed from the system.
[wxWidgets.git] / src / os2 / toplevel.cpp
diff --git a/src/os2/toplevel.cpp b/src/os2/toplevel.cpp
index a77cb0a375a231ec79ffdd007bae7d0b7275f28d..b7df26740e151c5fe5f37fd5823d22c0a1811370 100644 (file)
--- a/src/os2/toplevel.cpp
+++ b/src/os2/toplevel.cpp
@@ -1,12 +1,12 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        msw/toplevel.cpp
-// Purpose:     implements wxTopLevelWindow for MSW
+// Name:        src/os2/toplevel.cpp
+// Purpose:     implements wxTopLevelWindow for OS/2
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     30.12.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     30.12.01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
-// License:     wxWindows license
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
-    #pragma implementation "toplevel.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
@@ -28,14 +24,19 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 
+#include "wx/toplevel.h"
+
 #ifndef WX_PRECOMP
     #include "wx/app.h"
 #ifndef WX_PRECOMP
     #include "wx/app.h"
-    #include "wx/toplevel.h"
+    #include "wx/dialog.h"
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"
     #include "wx/control.h"
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"
     #include "wx/control.h"
+    #include "wx/containr.h"        // wxSetFocusToChild()
+    #include "wx/settings.h"
+    #include "wx/module.h"        // wxSetFocusToChild()
 #endif //WX_PRECOMP
 
 #include "wx/os2/private.h"
 #endif //WX_PRECOMP
 
 #include "wx/os2/private.h"
@@ -49,14 +50,19 @@
 // globals
 // ----------------------------------------------------------------------------
 
 // globals
 // ----------------------------------------------------------------------------
 
-// list of all frames and modeless dialogs
-wxWindowList wxModelessWindows;
+// the name of the default wxWidgets class
+extern void wxAssociateWinWithHandle( HWND hWnd, wxWindowOS2* pWin );
+
+bool wxTopLevelWindowOS2::m_sbInitialized = false;
+wxWindow* wxTopLevelWindowOS2::m_spHiddenParent = NULL;
+
+// ============================================================================
+// wxTopLevelWindowOS2 implementation
+// ============================================================================
 
 
-// the name of the default wxWindows class
-extern void          wxAssociateWinWithHandle( HWND         hWnd
-                                              ,wxWindowOS2* pWin
-                                             );
-bool                 wxTopLevelWindowOS2::m_sbInitialized = FALSE;
+BEGIN_EVENT_TABLE(wxTopLevelWindowOS2, wxTopLevelWindowBase)
+    EVT_ACTIVATE(wxTopLevelWindowOS2::OnActivate)
+END_EVENT_TABLE()
 
 // ============================================================================
 // wxTopLevelWindowMSW implementation
 
 // ============================================================================
 // wxTopLevelWindowMSW implementation
@@ -65,53 +71,144 @@ bool                 wxTopLevelWindowOS2::m_sbInitialized = FALSE;
 // Dialog window proc
 MRESULT EXPENTRY wxDlgProc( HWND WXUNUSED(hWnd)
                            ,UINT uMessage
 // Dialog window proc
 MRESULT EXPENTRY wxDlgProc( HWND WXUNUSED(hWnd)
                            ,UINT uMessage
-                           ,MPARAM WXUNUSED(wParam)
-                           ,MPARAM WXUNUSED(lParam)
+                           ,void * WXUNUSED(wParam)
+                           ,void * WXUNUSED(lParam)
                           )
 {
                           )
 {
-    if (uMessage == WM_INITDLG)
-    {
-        //
-        // For this message, returning TRUE tells system to set focus to the
-        // first control in the dialog box.
-        //
-        return (MRESULT)TRUE;
-    }
-    else
+    switch(uMessage)
     {
     {
-        //
-        // For all the other ones, FALSE means that we didn't process the
-        // message
-        //
-        return (MRESULT)FALSE;
+        case WM_INITDLG:
+            //
+            // For this message, returning TRUE tells system to set focus to
+            // the first control in the dialog box, but we set the focus
+            // ourselves, however in OS/2 we must return true to enable the dialog
+            //
+            return (MRESULT)TRUE;
+        default:
+            //
+            // For all the other ones, FALSE means that we didn't process the
+            // message
+            //
+            return (MRESULT)FALSE;
     }
 } // end of wxDlgProc
 
     }
 } // end of wxDlgProc
 
+// ----------------------------------------------------------------------------
+// wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
+// module to ensure that the window is always deleted)
+// ----------------------------------------------------------------------------
+
+class wxTLWHiddenParentModule : public wxModule
+{
+public:
+    //
+    // Module init/finalize
+    //
+    virtual bool OnInit(void);
+    virtual void OnExit(void);
+
+    //
+    // Get the hidden window (creates on demand)
+    //
+    static HWND GetHWND(void);
+
+private:
+    //
+    // The HWND of the hidden parent
+    //
+    static HWND m_shWnd;
+
+    //
+    // The class used to create it
+    //
+    static const wxChar* m_szClassName;
+    DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule)
+}; // end of CLASS wxTLWHiddenParentModule
+
+IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule, wxModule)
+
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowOS2 creation
 // ----------------------------------------------------------------------------
 
 void wxTopLevelWindowOS2::Init()
 {
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowOS2 creation
 // ----------------------------------------------------------------------------
 
 void wxTopLevelWindowOS2::Init()
 {
-    m_bIconized = m_bMaximizeOnShow = FALSE;
+    m_bIconized = m_bMaximizeOnShow = false;
 
     //
     // Unlike (almost?) all other windows, frames are created hidden
     //
 
     //
     // Unlike (almost?) all other windows, frames are created hidden
     //
-    m_isShown = FALSE;
+    m_isShown = false;
 
     //
     // Data to save/restore when calling ShowFullScreen
     m_lFsStyle          = 0;
     m_lFsOldWindowStyle = 0;
 
     //
     // Data to save/restore when calling ShowFullScreen
     m_lFsStyle          = 0;
     m_lFsOldWindowStyle = 0;
-    m_bFsIsMaximized    = FALSE;
-    m_bFsIsShowing      = FALSE;
+    m_bFsIsMaximized    = false;
+    m_bFsIsShowing      = false;
 
     m_hFrame    = NULLHANDLE;
     memset(&m_vSwp, 0, sizeof(SWP));
     memset(&m_vSwpClient, 0, sizeof(SWP));
 
     m_hFrame    = NULLHANDLE;
     memset(&m_vSwp, 0, sizeof(SWP));
     memset(&m_vSwpClient, 0, sizeof(SWP));
+    m_pWinLastFocused = NULL;
 } // end of wxTopLevelWindowIOS2::Init
 
 } // end of wxTopLevelWindowIOS2::Init
 
+void wxTopLevelWindowOS2::OnActivate(
+  wxActivateEvent&                  rEvent
+)
+{
+    if (rEvent.GetActive())
+    {
+        //
+        // Restore focus to the child which was last focused
+        //
+        wxLogTrace(wxT("focus"), wxT("wxTLW %08lx activated."), m_hWnd);
+
+        wxWindow*                   pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
+                                                                : NULL;
+        if (!pParent)
+        {
+            pParent = this;
+        }
+
+        wxSetFocusToChild( pParent
+                          ,&m_pWinLastFocused
+                         );
+    }
+    else // deactivating
+    {
+        //
+        // Remember the last focused child if it is our child
+        //
+        m_pWinLastFocused = FindFocus();
+
+        //
+        // So we NULL it out if it's a child from some other frame
+        //
+        wxWindow*                   pWin = m_pWinLastFocused;
+
+        while (pWin)
+        {
+            if (pWin->IsTopLevel())
+            {
+                if (pWin != this)
+                {
+                    m_pWinLastFocused = NULL;
+                }
+                break;
+            }
+            pWin = pWin->GetParent();
+        }
+
+        wxLogTrace(wxT("focus"),
+                   wxT("wxTLW %08lx deactivated, last focused: %08lx."),
+                   m_hWnd,
+                   m_pWinLastFocused ? GetHwndOf(m_pWinLastFocused)
+                                     : NULL);
+        rEvent.Skip();
+    }
+} // end of wxTopLevelWindowOS2::OnActivate
+
 WXDWORD wxTopLevelWindowOS2::OS2GetStyle(
   long                              lStyle
 , WXDWORD*                          pdwExflags
 WXDWORD wxTopLevelWindowOS2::OS2GetStyle(
   long                              lStyle
 , WXDWORD*                          pdwExflags
@@ -121,57 +218,95 @@ WXDWORD wxTopLevelWindowOS2::OS2GetStyle(
                                                                      ,pdwExflags
                                                                     );
 
                                                                      ,pdwExflags
                                                                     );
 
-    if (lStyle == wxDEFAULT_FRAME_STYLE)
+    if ((lStyle & wxDEFAULT_FRAME_STYLE) == wxDEFAULT_FRAME_STYLE)
         lMsflags |= FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
                     FCF_MINMAX | FCF_TASKLIST;
         lMsflags |= FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
                     FCF_MINMAX | FCF_TASKLIST;
+
+    if ((lStyle & wxCAPTION) == wxCAPTION)
+        lMsflags |= FCF_TASKLIST;
     else
     else
+        lMsflags |= FCF_NOMOVEWITHOWNER;
+
+    if ((lStyle & wxVSCROLL) == wxVSCROLL)
+        lMsflags |= FCF_VERTSCROLL;
+    if ((lStyle & wxHSCROLL) == wxHSCROLL)
+        lMsflags |= FCF_HORZSCROLL;
+    if (lStyle & wxMINIMIZE_BOX)
+        lMsflags |= FCF_MINBUTTON;
+    if (lStyle & wxMAXIMIZE_BOX)
+        lMsflags |= FCF_MAXBUTTON;
+    if (lStyle & wxRESIZE_BORDER)
+        lMsflags |= FCF_DLGBORDER;
+    if (lStyle & wxSYSTEM_MENU)
+        lMsflags |= FCF_SYSMENU;
+    if (lStyle & wxCAPTION)
+        lMsflags |= FCF_TASKLIST;
+    if (lStyle & wxCLIP_CHILDREN)
     {
     {
-        if ((lStyle & wxCAPTION) == wxCAPTION)
-            lMsflags |= FCF_TASKLIST;
-        else
-            lMsflags |= FCF_NOMOVEWITHOWNER;
-
-        if ((lStyle & wxVSCROLL) == wxVSCROLL)
-            lMsflags |= FCF_VERTSCROLL;
-        if ((lStyle & wxHSCROLL) == wxHSCROLL)
-            lMsflags |= FCF_HORZSCROLL;
-        if (lStyle & wxMINIMIZE_BOX)
-            lMsflags |= FCF_MINBUTTON;
-        if (lStyle & wxMAXIMIZE_BOX)
-            lMsflags |= FCF_MAXBUTTON;
-        if (lStyle & wxTHICK_FRAME)
-            lMsflags |= FCF_DLGBORDER;
-        if (lStyle & wxSYSTEM_MENU)
-            lMsflags |= FCF_SYSMENU;
-        if (lStyle & wxCAPTION)
-            lMsflags |= FCF_TASKLIST;
-        if (lStyle & wxCLIP_CHILDREN)
-        {
-            // Invalid for frame windows under PM
-        }
+        // Invalid for frame windows under PM
+    }
 
 
-        if (lStyle & wxTINY_CAPTION_VERT)
-            lMsflags |= FCF_TASKLIST;
-        if (lStyle & wxTINY_CAPTION_HORIZ)
-            lMsflags |= FCF_TASKLIST;
+    if (lStyle & wxTINY_CAPTION)
+        lMsflags |= FCF_TASKLIST;
 
 
-        if ((lStyle & wxTHICK_FRAME) == 0)
-            lMsflags |= FCF_BORDER;
-        if (lStyle & wxFRAME_TOOL_WINDOW)
-            *pdwExflags = kFrameToolWindow;
+    if ((lStyle & wxRESIZE_BORDER) == 0)
+        lMsflags |= FCF_BORDER;
+    if (lStyle & wxFRAME_TOOL_WINDOW)
+        *pdwExflags = kFrameToolWindow;
+
+    if (lStyle & wxSTAY_ON_TOP)
+        lMsflags |= FCF_SYSMODAL;
 
 
-        if (lStyle & wxSTAY_ON_TOP)
-            lMsflags |= FCF_SYSMODAL;
-    }
     return lMsflags;
 } // end of wxTopLevelWindowOS2::OS2GetCreateWindowFlags
 
     return lMsflags;
 } // end of wxTopLevelWindowOS2::OS2GetCreateWindowFlags
 
-bool wxTopLevelWindowOS2::CreateDialog(
-  ULONG                             ulDlgTemplate
-, const wxString&                   rsTitle
-, const wxPoint&                    rPos
-, const wxSize&                     rSize
-)
+WXHWND wxTopLevelWindowOS2::OS2GetParent() const
+{
+    HWND                            hWndParent = NULL;
+
+    //
+    // For the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
+    // parent HWND 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
+    // wxFRAME_FLOAT_ON_PARENT flag)
+    //
+    if (HasFlag(wxFRAME_FLOAT_ON_PARENT) )
+    {
+        const wxWindow*             pParent = GetParent();
+
+        if (!pParent)
+        {
+            //
+            // This flag doesn't make sense then and will be ignored
+            //
+            wxFAIL_MSG( wxT("wxFRAME_FLOAT_ON_PARENT but no parent?") );
+        }
+        else
+        {
+            hWndParent = GetHwndOf(pParent);
+        }
+    }
+    //else: don't float on parent, must not be owned
+
+    //
+    // Now deal with the 2nd taskbar-related problem (see comments above in
+    // OS2GetStyle())
+    //
+    if (HasFlag(wxFRAME_NO_TASKBAR) && !hWndParent)
+    {
+        //
+        // Use hidden parent
+        //
+        hWndParent = wxTLWHiddenParentModule::GetHWND();
+    }
+    return (WXHWND)hWndParent;
+} // end of wxTopLevelWindowOS2::OS2GetParent
+
+
+bool wxTopLevelWindowOS2::CreateDialog( ULONG           ulDlgTemplate,
+                                        const wxString& WXUNUSED(rsTitle),
+                                        const wxPoint&  rPos,
+                                        const wxSize&   rSize )
 {
     wxWindow*                       pParent = GetParent();
 
 {
     wxWindow*                       pParent = GetParent();
 
@@ -220,11 +355,11 @@ bool wxTopLevelWindowOS2::CreateDialog(
 
     if ( !m_hWnd )
     {
 
     if ( !m_hWnd )
     {
-        wxFAIL_MSG(_("Did you forget to include wx/os2/wx.rc in your resources?"));
+        wxFAIL_MSG(wxT("Did you forget to include wx/os2/wx.rc in your resources?"));
 
 
-        wxLogSysError(_("Can't create dialog using template '%ul'"), ulDlgTemplate);
+        wxLogSysError(wxT("Can't create dialog using template '%ld'"), ulDlgTemplate);
 
 
-        return FALSE;
+        return false;
     }
 
     //
     }
 
     //
@@ -272,7 +407,7 @@ bool wxTopLevelWindowOS2::CreateDialog(
         nX = (vSizeDpy.x - nWidth) / 2;
         nY = (vSizeDpy.y - nHeight) / 2;
     }
         nX = (vSizeDpy.x - nWidth) / 2;
         nY = (vSizeDpy.y - nHeight) / 2;
     }
-    m_backgroundColour.Set(wxString("LIGHT GREY"));
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 
     LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 
 
     LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 
@@ -282,43 +417,44 @@ bool wxTopLevelWindowOS2::CreateDialog(
                            ,(PVOID)&lColor
                           ))
     {
                            ,(PVOID)&lColor
                           ))
     {
-        return FALSE;
+        return false;
     }
 
     }
 
+    // Convert to OS/2 coordinates
+    nY = GetOS2ParentHeight(pParent) - nY - nHeight;
+
     ::WinSetWindowPos( GetHwnd()
                       ,HWND_TOP
                       ,nX
                       ,nY
                       ,nWidth
                       ,nHeight
     ::WinSetWindowPos( GetHwnd()
                       ,HWND_TOP
                       ,nX
                       ,nY
                       ,nWidth
                       ,nHeight
-                      ,SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW
+                      ,SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW | SWP_ACTIVATE
                      );
     ::WinQueryWindowPos(GetHwnd(), GetSwp());
     m_hFrame = m_hWnd;
     SubclassWin(m_hWnd);
                      );
     ::WinQueryWindowPos(GetHwnd(), GetSwp());
     m_hFrame = m_hWnd;
     SubclassWin(m_hWnd);
-    return TRUE;
+    return true;
 } // end of wxTopLevelWindowOS2::CreateDialog
 
 } // end of wxTopLevelWindowOS2::CreateDialog
 
-bool wxTopLevelWindowOS2::CreateFrame(
-  const wxString&                   rsTitle
-, const wxPoint&                    rPos
-, const wxSize&                     rSize
-)
+bool wxTopLevelWindowOS2::CreateFrame( const wxString& rsTitle,
+                                       const wxPoint& rPos,
+                                       const wxSize& rSize )
 {
 {
-    WXDWORD                         lExflags;
-    WXDWORD                         lFlags = OS2GetCreateWindowFlags(&lExflags);
-    long                            lStyle = GetWindowStyleFlag();
-    int                             nX = rPos.x;
-    int                             nY = rPos.y;
-    int                             nWidth = rSize.x;
-    int                             nHeight = rSize.y;
-    ULONG                           ulStyleFlags = 0L;
-    ERRORID                         vError;
-    wxString                        sError;
-    wxWindow*                       pParent = GetParent();
-    HWND                            hParent;
-    HWND                            hFrame;
-    HWND                            hClient;
+    WXDWORD    lExflags;
+    WXDWORD    lFlags = OS2GetCreateWindowFlags(&lExflags);
+    long       lStyle = GetWindowStyleFlag();
+    int        nX = rPos.x;
+    int        nY = rPos.y;
+    int        nWidth = rSize.x;
+    int        nHeight = rSize.y;
+    ULONG      ulStyleFlags = 0L;
+    ERRORID    vError;
+    wxString   sError;
+    wxWindow*  pParent = GetParent();
+    HWND       hParent;
+    HWND       hFrame;
+    HWND       hClient;
 
     if (pParent)
         hParent = GetHwndOf(pParent);
 
     if (pParent)
         hParent = GetHwndOf(pParent);
@@ -334,7 +470,7 @@ bool wxTopLevelWindowOS2::CreateFrame(
     // Clear the visible flag, we always call show
     //
     ulStyleFlags &= (unsigned long)~WS_VISIBLE;
     // Clear the visible flag, we always call show
     //
     ulStyleFlags &= (unsigned long)~WS_VISIBLE;
-    m_bIconized = FALSE;
+    m_bIconized = false;
 
     //
     // Create the frame window:  We break ranks with other ports now
 
     //
     // Create the frame window:  We break ranks with other ports now
@@ -346,8 +482,8 @@ bool wxTopLevelWindowOS2::CreateFrame(
      hFrame = ::WinCreateStdWindow( hParent
                                    ,ulStyleFlags          // frame-window style
                                    ,(PULONG)&lFlags       // window style
      hFrame = ::WinCreateStdWindow( hParent
                                    ,ulStyleFlags          // frame-window style
                                    ,(PULONG)&lFlags       // window style
-                                   ,(PSZ)wxFrameClassName // class name
-                                   ,(PSZ)rsTitle.c_str()  // window title
+                                   ,wxString(wxFrameClassName).c_str() // class name
+                                   ,rsTitle.c_str()       // window title
                                    ,0L                    // default client style
                                    ,NULLHANDLE            // resource in executable file
                                    ,0                     // resource id
                                    ,0L                    // default client style
                                    ,NULLHANDLE            // resource in executable file
                                    ,0                     // resource id
@@ -357,8 +493,8 @@ bool wxTopLevelWindowOS2::CreateFrame(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
-        wxLogError("Error creating frame. Error: %s\n", sError);
-        return FALSE;
+        wxLogError(wxT("Error creating frame. Error: %s\n"), sError.c_str());
+        return false;
     }
 
     //
     }
 
     //
@@ -369,7 +505,7 @@ bool wxTopLevelWindowOS2::CreateFrame(
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 
-    m_backgroundColour.Set(wxString("MEDIUM GREY"));
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 
     LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 
 
     LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 
@@ -381,8 +517,8 @@ bool wxTopLevelWindowOS2::CreateFrame(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
-        wxLogError("Error creating frame. Error: %s\n", sError);
-        return FALSE;
+        wxLogError(wxT("Error creating frame. Error: %s\n"), sError.c_str());
+        return false;
     }
 
     //
     }
 
     //
@@ -396,17 +532,49 @@ bool wxTopLevelWindowOS2::CreateFrame(
     // Now size everything.  If adding a menu the client will need to be resized.
     //
 
     // Now size everything.  If adding a menu the client will need to be resized.
     //
 
-    if (pParent)
+    if (!OS2GetCreateWindowCoords( rPos
+                                  ,rSize
+                                  ,nX
+                                  ,nY
+                                  ,nWidth
+                                  ,nHeight
+                                 ))
     {
     {
-        nY = pParent->GetSize().y - (nY + nHeight);
+        nX = nWidth = (int)CW_USEDEFAULT;
     }
     }
-    else
+
+    //
+    // We can't use CW_USEDEFAULT here as we're not calling CreateWindow()
+    // and passing CW_USEDEFAULT to MoveWindow() results in resizing the
+    // window to (0, 0) size which breaks quite a lot of things, e.g. the
+    // sizer calculation in wxSizer::Fit()
+    //
+    if (nWidth == (int)CW_USEDEFAULT)
     {
     {
-        RECTL                   vRect;
+        //
+        // The exact number doesn't matter, the dialog will be resized
+        // again soon anyhow but it should be big enough to allow
+        // calculation relying on "totalSize - clientSize > 0" work, i.e.
+        // at least greater than the title bar height
+        //
+        nWidth = nHeight = 100;
+    }
+    if (nX == (int)CW_USEDEFAULT)
+    {
+        //
+        // Centre it on the screen for now - what else can we do?
+        // TODO: We could try FCF_SHELLPOSITION but it will require moving
+        //       things around a bit.
+        //
+        wxSize                      vSizeDpy = wxGetDisplaySize();
 
 
-        ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
-        nY = vRect.yTop - (nY + nHeight);
+        nX = (vSizeDpy.x - nWidth) / 2;
+        nY = (vSizeDpy.y - nHeight) / 2;
     }
     }
+
+    // Convert to OS/2 coordinates
+    nY = GetOS2ParentHeight(pParent) - nY - nHeight;
+
     if (!::WinSetWindowPos( m_hFrame
                            ,HWND_TOP
                            ,nX
     if (!::WinSetWindowPos( m_hFrame
                            ,HWND_TOP
                            ,nX
@@ -418,8 +586,8 @@ bool wxTopLevelWindowOS2::CreateFrame(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
-        wxLogError("Error sizing frame. Error: %s\n", sError);
-        return FALSE;
+        wxLogError(wxT("Error sizing frame. Error: %s\n"), sError.c_str());
+        return false;
     }
     lStyle =  ::WinQueryWindowULong( m_hWnd
                                     ,QWL_STYLE
     }
     lStyle =  ::WinQueryWindowULong( m_hWnd
                                     ,QWL_STYLE
@@ -429,7 +597,7 @@ bool wxTopLevelWindowOS2::CreateFrame(
                         ,QWL_STYLE
                         ,lStyle
                        );
                         ,QWL_STYLE
                         ,lStyle
                        );
-    return TRUE;
+    return true;
 } // end of wxTopLevelWindowOS2::CreateFrame
 
 bool wxTopLevelWindowOS2::Create(
 } // end of wxTopLevelWindowOS2::CreateFrame
 
 bool wxTopLevelWindowOS2::Create(
@@ -437,7 +605,7 @@ bool wxTopLevelWindowOS2::Create(
 , wxWindowID                        vId
 , const wxString&                   rsTitle
 , const wxPoint&                    rPos
 , wxWindowID                        vId
 , const wxString&                   rsTitle
 , const wxPoint&                    rPos
-, const wxSize&                     rSize
+, const wxSize&                     rSizeOrig
 , long                              lStyle
 , const wxString&                   rsName
 )
 , long                              lStyle
 , const wxString&                   rsName
 )
@@ -449,6 +617,19 @@ bool wxTopLevelWindowOS2::Create(
     m_windowStyle = lStyle;
     SetName(rsName);
     m_windowId = vId == -1 ? NewControlId() : vId;
     m_windowStyle = lStyle;
     SetName(rsName);
     m_windowId = vId == -1 ? NewControlId() : vId;
+
+    // always create a frame of some reasonable, even if arbitrary, size (at
+    // least for MSW compatibility)
+    wxSize rSize = rSizeOrig;
+    if ( rSize.x == -1 || rSize.y == -1 )
+    {
+        wxSize sizeDpy = wxGetDisplaySize();
+        if ( rSize.x == -1 )
+            rSize.x = sizeDpy.x / 3;
+        if ( rSize.y == -1 )
+            rSize.y = sizeDpy.y / 5;
+    }
+
     wxTopLevelWindows.Append(this);
     if (pParent)
         pParent->AddChild(this);
     wxTopLevelWindows.Append(this);
     if (pParent)
         pParent->AddChild(this);
@@ -456,9 +637,9 @@ bool wxTopLevelWindowOS2::Create(
     if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
     {
         //
     if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
     {
         //
-        // We have different dialog templates to allows creation of dialogs
-        // with & without captions under OS2indows, resizeable or not (but a
-        // resizeable dialog always has caption - otherwise it would look too
+        // We have different dialog templates to allow creation of dialogs
+        // with & without captions under OS2indows, resizable or not (but a
+        // resizable dialog always has caption - otherwise it would look too
         // strange)
         //
         ULONG                       ulDlgTemplate;
         // strange)
         //
         ULONG                       ulDlgTemplate;
@@ -486,20 +667,23 @@ bool wxTopLevelWindowOS2::Create(
 
 wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
 {
 
 wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
 {
-    wxTopLevelWindows.DeleteObject(this);
-
-    if (wxModelessWindows.Find(this))
-        wxModelessWindows.DeleteObject(this);
-
     //
     //
-    // If this is the last top-level window, exit.
+    // After destroying an owned window, Windows activates the next top level
+    // window in Z order but it may be different from our owner (to reproduce
+    // this simply Alt-TAB to another application and back before closing the
+    // owned frame) whereas we always want to yield activation to our parent
     //
     //
-    if (wxTheApp && (wxTopLevelWindows.Number() == 0))
+    if (HasFlag(wxFRAME_FLOAT_ON_PARENT))
     {
     {
-        wxTheApp->SetTopWindow(NULL);
-        if ( wxTheApp->GetExitOnFrameDelete() )
+        wxWindow*                   pParent = GetParent();
+
+        if (pParent)
         {
         {
-            ::WinPostMsg(NULL, WM_QUIT, 0, 0);
+            ::WinSetWindowPos( GetHwndOf(pParent)
+                              ,HWND_TOP
+                              ,0, 0, 0, 0
+                              ,SWP_ZORDER
+                             );
         }
     }
 } // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
         }
     }
 } // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
@@ -561,20 +745,25 @@ void wxTopLevelWindowOS2::DoShowWindow(
     m_bIconized = nShowCmd == SWP_MINIMIZE;
 } // end of wxTopLevelWindowOS2::DoShowWindow
 
     m_bIconized = nShowCmd == SWP_MINIMIZE;
 } // end of wxTopLevelWindowOS2::DoShowWindow
 
-bool wxTopLevelWindowOS2::Show(
-  bool                              bShow
-)
+bool wxTopLevelWindowOS2::Show( bool bShow )
 {
 {
-    int                             nShowCmd;
-    SWP                             vSwp;
-    RECTL                           vRect;
+    int nShowCmd;
+    SWP vSwp;
 
 
+    if (bShow != IsShown() )
+    {
+        m_isShown = bShow;
+    }
+    else
+    {
+        return false;
+    }
     if (bShow)
     {
         if (m_bMaximizeOnShow)
         {
             nShowCmd = SWP_MAXIMIZE;
     if (bShow)
     {
         if (m_bMaximizeOnShow)
         {
             nShowCmd = SWP_MAXIMIZE;
-            m_bMaximizeOnShow = FALSE;
+            m_bMaximizeOnShow = false;
         }
         else
         {
         }
         else
         {
@@ -589,21 +778,17 @@ bool wxTopLevelWindowOS2::Show(
 
     if (bShow)
     {
 
     if (bShow)
     {
-        wxActivateEvent             vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
+        wxActivateEvent vEvent(wxEVT_ACTIVATE, true, m_windowId);
 
         ::WinQueryWindowPos(m_hFrame, &vSwp);
 
         ::WinQueryWindowPos(m_hFrame, &vSwp);
-        m_bIconized = vSwp.fl & SWP_MINIMIZE;
+        m_bIconized = ( vSwp.fl & SWP_MINIMIZE ) == SWP_MINIMIZE ;
         ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
         ::WinQueryWindowPos(m_hWnd, &vSwp);
         ::WinEnableWindow(m_hFrame, TRUE);
 
         ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
         ::WinQueryWindowPos(m_hWnd, &vSwp);
         ::WinEnableWindow(m_hFrame, TRUE);
 
-        //
-        // Deal with children
-        //
-        MoveChildren(m_vSwpClient.cy - vSwp.cy);
         vEvent.SetEventObject(this);
         vEvent.SetEventObject(this);
-        GetEventHandler()->ProcessEvent(vEvent);
+        HandleWindowEvent(vEvent);
     }
     else
     {
     }
     else
     {
@@ -612,23 +797,14 @@ bool wxTopLevelWindowOS2::Show(
         //
         if (GetParent())
         {
         //
         if (GetParent())
         {
-            HWND                    hWndParent = GetHwndOf(GetParent());
+            HWND hWndParent = GetHwndOf(GetParent());
 
             ::WinQueryWindowPos(hWndParent, &vSwp);
 
             ::WinQueryWindowPos(hWndParent, &vSwp);
-            m_bIconized = vSwp.fl & SWP_MINIMIZE;
-            if (hWndParent)
-                ::WinSetWindowPos( hWndParent
-                                  ,HWND_TOP
-                                  ,vSwp.x
-                                  ,vSwp.y
-                                  ,vSwp.cx
-                                  ,vSwp.cy
-                                  ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
-                                 );
+            m_bIconized = (vSwp.fl & SWP_MINIMIZE)==SWP_MINIMIZE;
             ::WinEnableWindow(hWndParent, TRUE);
         }
     }
             ::WinEnableWindow(hWndParent, TRUE);
         }
     }
-    return TRUE;
+    return true;
 } // end of wxTopLevelWindowOS2::Show
 
 // ----------------------------------------------------------------------------
 } // end of wxTopLevelWindowOS2::Show
 
 // ----------------------------------------------------------------------------
@@ -652,21 +828,27 @@ void wxTopLevelWindowOS2::Maximize(
         // We can't maximize the hidden frame because it shows it as well, so
         // just remember that we should do it later in this case
         //
         // We can't maximize the hidden frame because it shows it as well, so
         // just remember that we should do it later in this case
         //
-        m_bMaximizeOnShow = TRUE;
+        m_bMaximizeOnShow = bMaximize;
     }
 } // end of wxTopLevelWindowOS2::Maximize
 
 bool wxTopLevelWindowOS2::IsMaximized() const
 {
     }
 } // end of wxTopLevelWindowOS2::Maximize
 
 bool wxTopLevelWindowOS2::IsMaximized() const
 {
-    bool                            bIconic;
-
     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
-    return (m_vSwp.fl & SWP_MAXIMIZE);
+    return (m_vSwp.fl & SWP_MAXIMIZE) == SWP_MAXIMIZE;
 } // end of wxTopLevelWindowOS2::IsMaximized
 
 } // end of wxTopLevelWindowOS2::IsMaximized
 
-void wxTopLevelWindowOS2::Iconize(
-  bool                              bIconize
-)
+void wxTopLevelWindowOS2::SetTitle( const wxString& title)
+{
+    SetLabel(title);
+}
+
+wxString wxTopLevelWindowOS2::GetTitle() const
+{
+    return GetLabel();
+}
+
+void wxTopLevelWindowOS2::Iconize( bool bIconize )
 {
     DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
 } // end of wxTopLevelWindowOS2::Iconize
 {
     DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
 } // end of wxTopLevelWindowOS2::Iconize
@@ -676,9 +858,9 @@ bool wxTopLevelWindowOS2::IsIconized() const
     // also update the current state
     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
     if (m_vSwp.fl & SWP_MINIMIZE)
     // also update the current state
     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
     if (m_vSwp.fl & SWP_MINIMIZE)
-        ((wxTopLevelWindow*)this)->m_bIconized = TRUE;
+        ((wxTopLevelWindow*)this)->m_bIconized = true;
     else
     else
-        ((wxTopLevelWindow*)this)->m_bIconized = FALSE;
+        ((wxTopLevelWindow*)this)->m_bIconized = false;
     return m_bIconized;
 } // end of wxTopLevelWindowOS2::IsIconized
 
     return m_bIconized;
 } // end of wxTopLevelWindowOS2::IsIconized
 
@@ -688,17 +870,28 @@ void wxTopLevelWindowOS2::Restore()
 } // end of wxTopLevelWindowOS2::Restore
 
 // generate an artificial resize event
 } // end of wxTopLevelWindowOS2::Restore
 
 // generate an artificial resize event
-void wxTopLevelWindowOS2::SendSizeEvent()
+void wxTopLevelWindowOS2::SendSizeEvent(int flags)
 {
     if (!m_bIconized)
     {
         RECTL                       vRect = wxGetWindowRect(GetHwnd());
 
 {
     if (!m_bIconized)
     {
         RECTL                       vRect = wxGetWindowRect(GetHwnd());
 
-        (void)::WinPostMsg( m_hFrame
-                           ,WM_SIZE
-                           ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
-                           ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
-                          );
+        if ( flags & wxSEND_EVENT_POST )
+        {
+            (void)::WinPostMsg( m_hFrame
+                               ,WM_SIZE
+                               ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+                               ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+                              );
+        }
+        else // send it
+        {
+            (void)::WinSendMsg( m_hFrame
+                               ,WM_SIZE
+                               ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+                               ,MPFROM2SHORT(vRect.xRight - vRect.xLeft, vRect.yTop - vRect.yBottom)
+                              );
+        }
     }
 } // end of wxTopLevelWindowOS2::SendSizeEvent
 
     }
 } // end of wxTopLevelWindowOS2::SendSizeEvent
 
@@ -706,17 +899,15 @@ void wxTopLevelWindowOS2::SendSizeEvent()
 // wxTopLevelWindowOS2 fullscreen
 // ----------------------------------------------------------------------------
 
 // wxTopLevelWindowOS2 fullscreen
 // ----------------------------------------------------------------------------
 
-bool wxTopLevelWindowOS2::ShowFullScreen(
-  bool                              bShow
-, long                              lStyle
-)
+bool wxTopLevelWindowOS2::ShowFullScreen( bool bShow,
+                                          long lStyle )
 {
     if (bShow)
     {
         if (IsFullScreen())
 {
     if (bShow)
     {
         if (IsFullScreen())
-            return FALSE;
+            return false;
 
 
-        m_bFsIsShowing = TRUE;
+        m_bFsIsShowing = true;
         m_lFsStyle = lStyle;
 
         //
         m_lFsStyle = lStyle;
 
         //
@@ -739,8 +930,8 @@ bool wxTopLevelWindowOS2::ShowFullScreen(
         //
         // Decide which window lStyle flags to turn off
         //
         //
         // Decide which window lStyle flags to turn off
         //
-        LONG                        lNewStyle = m_lFsOldWindowStyle;
-        LONG                        lOffFlags = 0;
+        LONG lNewStyle = m_lFsOldWindowStyle;
+        LONG lOffFlags = 0;
 
         if (lStyle & wxFULLSCREEN_NOBORDER)
             lOffFlags |= FCF_BORDER;
 
         if (lStyle & wxFULLSCREEN_NOBORDER)
             lOffFlags |= FCF_BORDER;
@@ -760,16 +951,14 @@ bool wxTopLevelWindowOS2::ShowFullScreen(
         //
         // Resize to the size of the desktop
         //
         //
         // Resize to the size of the desktop
         //
-        int                         nWidth;
-        int                         nHeight;
-        RECTL                       vRect = wxGetWindowRect(HWND_DESKTOP);
+        int   nWidth;
+        int   nHeight;
+        RECTL vRect = wxGetWindowRect(HWND_DESKTOP);
 
         nWidth = vRect.xRight - vRect.xLeft;
         nHeight = vRect.yTop - vRect.yBottom;
 
 
         nWidth = vRect.xRight - vRect.xLeft;
         nHeight = vRect.yTop - vRect.yBottom;
 
-        SetSize( nWidth
-                ,nHeight
-               );
+        SetSize( nWidth, nHeight );
 
         //
         // Now flush the window style cache and actually go full-screen
 
         //
         // Now flush the window style cache and actually go full-screen
@@ -783,21 +972,17 @@ bool wxTopLevelWindowOS2::ShowFullScreen(
                           ,SWP_SIZE | SWP_MOVE
                          );
 
                           ,SWP_SIZE | SWP_MOVE
                          );
 
-        wxSizeEvent                 vEvent( wxSize( nWidth
-                                                   ,nHeight
-                                                  )
-                                           ,GetId()
-                                          );
-
-        GetEventHandler()->ProcessEvent(vEvent);
-        return TRUE;
+        wxSize full( nWidth, nHeight );
+        wxSizeEvent vEvent( full, GetId() );
+        HandleWindowEvent(vEvent);
+        return true;
     }
     else
     {
         if (!IsFullScreen())
     }
     else
     {
         if (!IsFullScreen())
-            return FALSE;
+            return false;
 
 
-        m_bFsIsShowing = FALSE;
+        m_bFsIsShowing = false;
         Maximize(m_bFsIsMaximized);
         ::WinSetWindowULong( (HWND)GetHWND()
                             ,QWL_STYLE
         Maximize(m_bFsIsMaximized);
         ::WinSetWindowULong( (HWND)GetHWND()
                             ,QWL_STYLE
@@ -811,7 +996,7 @@ bool wxTopLevelWindowOS2::ShowFullScreen(
                           ,m_vFsOldSize.height
                           ,SWP_SIZE | SWP_MOVE
                          );
                           ,m_vFsOldSize.height
                           ,SWP_SIZE | SWP_MOVE
                          );
-        return TRUE;
+        return true;
     }
 } // end of wxTopLevelWindowOS2::ShowFullScreen
 
     }
 } // end of wxTopLevelWindowOS2::ShowFullScreen
 
@@ -819,20 +1004,22 @@ bool wxTopLevelWindowOS2::ShowFullScreen(
 // wxTopLevelWindowOS2 misc
 // ----------------------------------------------------------------------------
 
 // wxTopLevelWindowOS2 misc
 // ----------------------------------------------------------------------------
 
-void wxTopLevelWindowOS2::SetIcon(
-  const wxIcon&                     rIcon
+void wxTopLevelWindowOS2::SetIcons(
+  const wxIconBundle&               rIcons
 )
 {
     //
     // This sets m_icon
     //
 )
 {
     //
     // This sets m_icon
     //
-    wxTopLevelWindowBase::SetIcon(rIcon);
+    wxTopLevelWindowBase::SetIcons(rIcons);
 
 
-    if (m_icon.Ok())
+    const wxIcon& vIcon = rIcons.GetIconOfExactSize(32);
+
+    if (vIcon.IsOk())
     {
         ::WinSendMsg( m_hFrame
                      ,WM_SETICON
     {
         ::WinSendMsg( m_hFrame
                      ,WM_SETICON
-                     ,(MPARAM)((HPOINTER)m_icon.GetHICON())
+                     ,(MPARAM)((HPOINTER)vIcon.GetHICON())
                      ,NULL
                     );
         ::WinSendMsg( m_hFrame
                      ,NULL
                     );
         ::WinSendMsg( m_hFrame
@@ -843,19 +1030,17 @@ void wxTopLevelWindowOS2::SetIcon(
     }
 } // end of wxTopLevelWindowOS2::SetIcon
 
     }
 } // end of wxTopLevelWindowOS2::SetIcon
 
-bool wxTopLevelWindowOS2::EnableCloseButton(
-  bool                              bEnable
-)
+bool wxTopLevelWindowOS2::EnableCloseButton( bool bEnable )
 {
     //
     // Get system (a.k.a. window) menu
     //
 {
     //
     // Get system (a.k.a. window) menu
     //
-    HMENU                           hMenu = ::WinWindowFromID(m_hFrame, FID_SYSMENU);
+    HMENU hMenu = ::WinWindowFromID(m_hFrame, FID_SYSMENU);
 
     if (!hMenu)
     {
 
     if (!hMenu)
     {
-        wxLogLastError(_T("GetSystemMenu"));
-        return FALSE;
+        wxLogLastError(wxT("GetSystemMenu"));
+        return false;
     }
 
     //
     }
 
     //
@@ -883,6 +1068,77 @@ bool wxTopLevelWindowOS2::EnableCloseButton(
                  ,(MPARAM)FCF_MENU
                  ,(MPARAM)0
                 );
                  ,(MPARAM)FCF_MENU
                  ,(MPARAM)0
                 );
-    return TRUE;
+    return true;
 } // end of wxTopLevelWindowOS2::EnableCloseButton
 
 } // end of wxTopLevelWindowOS2::EnableCloseButton
 
+// ============================================================================
+// wxTLWHiddenParentModule implementation
+// ============================================================================
+
+HWND          wxTLWHiddenParentModule::m_shWnd = NULL;
+const wxChar* wxTLWHiddenParentModule::m_szClassName = NULL;
+
+bool wxTLWHiddenParentModule::OnInit()
+{
+    m_shWnd = NULL;
+    m_szClassName = NULL;
+    return true;
+} // end of wxTLWHiddenParentModule::OnInit
+
+void wxTLWHiddenParentModule::OnExit()
+{
+    if (m_shWnd)
+    {
+        if (!::WinDestroyWindow(m_shWnd))
+        {
+            wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
+        }
+        m_shWnd = NULL;
+    }
+
+    m_szClassName = NULL;
+} // end of wxTLWHiddenParentModule::OnExit
+
+/* static */
+HWND wxTLWHiddenParentModule::GetHWND()
+{
+    if (!m_shWnd)
+    {
+        if (!m_szClassName)
+        {
+            static const wxChar*    zHIDDEN_PARENT_CLASS = wxT("wxTLWHiddenParent");
+
+            if (!::WinRegisterClass( wxGetInstance()
+                                    ,(PSZ)zHIDDEN_PARENT_CLASS
+                                    ,NULL
+                                    ,0
+                                    ,sizeof(ULONG)
+                                   ))
+            {
+                wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
+            }
+            else
+            {
+                m_szClassName = zHIDDEN_PARENT_CLASS;
+            }
+        }
+        m_shWnd = ::WinCreateWindow( HWND_DESKTOP,
+                                     (PSZ)m_szClassName,
+                                     "",
+                                     0L,
+                                     (LONG)0L,
+                                     (LONG)0L,
+                                     (LONG)0L,
+                                     (LONG)0L,
+                                     NULLHANDLE,
+                                     HWND_TOP,
+                                     0L,
+                                     NULL,
+                                     NULL );
+        if (!m_shWnd)
+        {
+            wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));
+        }
+    }
+    return m_shWnd;
+} // end of wxTLWHiddenParentModule::GetHWND
wxWidgets (Impactor)