Change friendship so that the base implementation class is the friend.

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

diff --git a/src/os2/toplevel.cpp b/src/os2/toplevel.cpp
index b135598646582694ac66c5fe2e53b4f33fa997cf..d98d7992b44e7a8e41ae82514f3b54497ebd31d8 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:        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
+// License:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 ///////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -31,12 +31,16 @@
 #ifndef WX_PRECOMP
     #include "wx/app.h"
     #include "wx/toplevel.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/string.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"

+    #include "wx/control.h"
+    #include "wx/containr.h"        // wxSetFocusToChild()

 #endif //WX_PRECOMP
 
 #endif //WX_PRECOMP
 

+#include "wx/module.h"        // wxSetFocusToChild()

 #include "wx/os2/private.h"
 
 // ----------------------------------------------------------------------------
 #include "wx/os2/private.h"
 
 // ----------------------------------------------------------------------------


@@ -51,10 +55,20 @@
 // list of all frames and modeless dialogs
 wxWindowList wxModelessWindows;
 
 // list of all frames and modeless dialogs
 wxWindowList wxModelessWindows;
 

-// the name of the default wxWindows class
+// the name of the default wxWidgets class

 extern void          wxAssociateWinWithHandle( HWND         hWnd
                                               ,wxWindowOS2* pWin
                                              );
 extern void          wxAssociateWinWithHandle( HWND         hWnd
                                               ,wxWindowOS2* pWin
                                              );

+bool                 wxTopLevelWindowOS2::m_sbInitialized = FALSE;
+wxWindow*            wxTopLevelWindowOS2::m_spHiddenParent = NULL;
+
+// ============================================================================
+// wxTopLevelWindowOS2 implementation
+// ============================================================================
+
+BEGIN_EVENT_TABLE(wxTopLevelWindowOS2, wxTopLevelWindowBase)
+    EVT_ACTIVATE(wxTopLevelWindowOS2::OnActivate)
+END_EVENT_TABLE()

 
 // ============================================================================
 // wxTopLevelWindowMSW implementation
 
 // ============================================================================
 // wxTopLevelWindowMSW implementation


@@ -63,28 +77,62 @@ extern void          wxAssociateWinWithHandle( HWND         hWnd
 // 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)
+    switch(uMessage)

     {
     {

-        //
-        // For this message, returning TRUE tells system to set focus to the
-        // first control in the dialog box.
-        //
-        return (MRESULT)TRUE;
-    }
-    else
-    {
-        //
-        // For all the other ones, FALSE means that we didn't process the
-        // message
-        //
-        return (MRESULT)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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowOS2 creation
 // ----------------------------------------------------------------------------


@@ -108,60 +156,160 @@ void wxTopLevelWindowOS2::Init()
     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 = (wxWindow *)NULL;

 } // end of wxTopLevelWindowIOS2::Init
 
 } // end of wxTopLevelWindowIOS2::Init
 

-long wxTopLevelWindowOS2::OS2GetCreateWindowFlags(
-  long*                             plExflags
-) const
+void wxTopLevelWindowOS2::OnActivate(
+  wxActivateEvent&                  rEvent
+)

 {
 {

-    long                            lStyle = GetWindowStyle();
-    long                            lMsflags = 0;
+    if (rEvent.GetActive())
+    {
+        //
+        // Restore focus to the child which was last focused
+        //
+        wxLogTrace(_T("focus"), _T("wxTLW %08lx activated."), m_hWnd);

 
 

-    if (lStyle == wxDEFAULT_FRAME_STYLE)
-        lMsflags = FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
-                        FCF_MINMAX | FCF_TASKLIST;
-    else
+        wxWindow*                   pParent = m_pWinLastFocused ? m_pWinLastFocused->GetParent()
+                                                                : NULL;
+        if (!pParent)
+        {
+            pParent = this;
+        }
+
+        wxSetFocusToChild( pParent
+                          ,&m_pWinLastFocused
+                         );
+    }
+    else // deactivating

     {
     {

-        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)
+        //
+        // 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)

         {
         {

-            // Invalid for frame windows under PM
+            if (pWin->IsTopLevel())
+            {
+                if (pWin != this)
+                {
+                    m_pWinLastFocused = NULL;
+                }
+                break;
+            }
+            pWin = pWin->GetParent();

         }
 
         }
 

-        if (lStyle & wxTINY_CAPTION_VERT)
-            lMsflags |= FCF_TASKLIST;
-        if (lStyle & wxTINY_CAPTION_HORIZ)
-            lMsflags |= FCF_TASKLIST;
+        wxLogTrace(_T("focus"),
+                   _T("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
+) const
+{
+    long                            lMsflags = wxWindow::OS2GetStyle( (lStyle & ~wxBORDER_MASK) | wxBORDER_NONE
+                                                                     ,pdwExflags
+                                                                    );

 
 

-        if ((lStyle & wxTHICK_FRAME) == 0)
-            lMsflags |= FCF_BORDER;
-        if (lStyle & wxFRAME_TOOL_WINDOW)
-            *plExflags = kFrameToolWindow;
+    if ((lStyle & wxDEFAULT_FRAME_STYLE) == wxDEFAULT_FRAME_STYLE)
+        lMsflags |= FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
+                    FCF_MINMAX | FCF_TASKLIST;

 
 

-        if (lStyle & wxSTAY_ON_TOP)
-            lMsflags |= FCF_SYSMODAL;
+    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

     }
     }

+
+    if (lStyle & wxTINY_CAPTION_VERT)
+        lMsflags |= FCF_TASKLIST;
+    if (lStyle & wxTINY_CAPTION_HORIZ)
+        lMsflags |= FCF_TASKLIST;
+
+    if ((lStyle & wxTHICK_FRAME) == 0)
+        lMsflags |= FCF_BORDER;
+    if (lStyle & wxFRAME_TOOL_WINDOW)
+        *pdwExflags = kFrameToolWindow;
+
+    if (lStyle & wxSTAY_ON_TOP)
+        lMsflags |= FCF_SYSMODAL;
+

     return lMsflags;
 } // end of wxTopLevelWindowOS2::OS2GetCreateWindowFlags
 
     return lMsflags;
 } // end of wxTopLevelWindowOS2::OS2GetCreateWindowFlags
 

+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( _T("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&                   rsTitle
 bool wxTopLevelWindowOS2::CreateDialog(
   ULONG                             ulDlgTemplate
 , const wxString&                   rsTitle


@@ -197,15 +345,15 @@ bool wxTopLevelWindowOS2::CreateDialog(
     }
 
     HWND                            hWndDlg;
     }
 
     HWND                            hWndDlg;

-    HWND                            hWndParent;
+    HWND                            hWndOwner;

 
     if (pParent)
 
     if (pParent)

-        hWndParent = GetHwndOf(pParent);
+        hWndOwner = GetHwndOf(pParent);

     else
     else

-        hWndParent = HWND_DESKTOP;
+        hWndOwner = HWND_DESKTOP;

 
 

-    hWndDlg = ::WinLoadDlg( hWndParent
-                           ,hWndParent
+    hWndDlg = ::WinLoadDlg( HWND_DESKTOP
+                           ,hWndOwner

                            ,(PFNWP)wxDlgProc
                            ,NULL
                            ,(ULONG)ulDlgTemplate
                            ,(PFNWP)wxDlgProc
                            ,NULL
                            ,(ULONG)ulDlgTemplate


@@ -216,9 +364,9 @@ 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;
     }


@@ -268,18 +416,29 @@ 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"));
+
+    LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
+
+    if (!::WinSetPresParam( m_hWnd
+                           ,PP_BACKGROUNDCOLOR
+                           ,sizeof(LONG)
+                           ,(PVOID)&lColor
+                          ))
+    {
+        return FALSE;
+    }
+

     ::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

                      );
                      );

-    if (!rsTitle.IsNull())
-    {
-        ::WinSetWindowText(GetHwnd(), rsTitle.c_str());
-    }
+    ::WinQueryWindowPos(GetHwnd(), GetSwp());
+    m_hFrame = m_hWnd;

     SubclassWin(m_hWnd);
     return TRUE;
 } // end of wxTopLevelWindowOS2::CreateDialog
     SubclassWin(m_hWnd);
     return TRUE;
 } // end of wxTopLevelWindowOS2::CreateDialog


@@ -290,8 +449,8 @@ bool wxTopLevelWindowOS2::CreateFrame(
 , const wxSize&                     rSize
 )
 {
 , const wxSize&                     rSize
 )
 {

-    long                            lExflags;
-    long                            lFlags = OS2GetCreateWindowFlags(&lExflags);
+    WXDWORD                         lExflags;
+    WXDWORD                         lFlags = OS2GetCreateWindowFlags(&lExflags);

     long                            lStyle = GetWindowStyleFlag();
     int                             nX = rPos.x;
     int                             nY = rPos.y;
     long                            lStyle = GetWindowStyleFlag();
     int                             nX = rPos.x;
     int                             nY = rPos.y;


@@ -342,7 +501,7 @@ bool wxTopLevelWindowOS2::CreateFrame(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);

-        wxLogError("Error creating frame. Error: %s\n", sError);
+        wxLogError("Error creating frame. Error: %s\n", sError.c_str());

         return FALSE;
     }
 
         return FALSE;
     }
 


@@ -354,7 +513,7 @@ bool wxTopLevelWindowOS2::CreateFrame(
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 
     wxAssociateWinWithHandle(m_hWnd, this);
     wxAssociateWinWithHandle(m_hFrame, this);
 

-    m_backgroundColour.Set(wxString("GREY"));
+    m_backgroundColour.Set(wxString("MEDIUM GREY"));

 
     LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 
 
     LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 


@@ -366,7 +525,7 @@ bool wxTopLevelWindowOS2::CreateFrame(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);

-        wxLogError("Error creating frame. Error: %s\n", sError);
+        wxLogError("Error creating frame. Error: %s\n", sError.c_str());

         return FALSE;
     }
 
         return FALSE;
     }
 


@@ -403,9 +562,17 @@ bool wxTopLevelWindowOS2::CreateFrame(
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);
     {
         vError = ::WinGetLastError(vHabmain);
         sError = wxPMErrorToStr(vError);

-        wxLogError("Error sizing frame. Error: %s\n", sError);
+        wxLogError("Error sizing frame. Error: %s\n", sError.c_str());

         return FALSE;
     }
         return FALSE;
     }

+    lStyle =  ::WinQueryWindowULong( m_hWnd
+                                    ,QWL_STYLE
+                                   );
+    lStyle |= WS_CLIPCHILDREN;
+    ::WinSetWindowULong( m_hWnd
+                        ,QWL_STYLE
+                        ,lStyle
+                       );

     return TRUE;
 } // end of wxTopLevelWindowOS2::CreateFrame
 
     return TRUE;
 } // end of wxTopLevelWindowOS2::CreateFrame
 


@@ -414,7 +581,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
 )


@@ -426,6 +593,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);


@@ -463,81 +643,29 @@ bool wxTopLevelWindowOS2::Create(
 
 wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
 {
 
 wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
 {

-    wxTopLevelWindows.DeleteObject(this);
-

     if (wxModelessWindows.Find(this))
         wxModelessWindows.DeleteObject(this);
 
     //
     if (wxModelessWindows.Find(this))
         wxModelessWindows.DeleteObject(this);
 
     //

-    // If this is the last top-level window, exit.
-    //
-    if (wxTheApp && (wxTopLevelWindows.Number() == 0))
-    {
-        wxTheApp->SetTopWindow(NULL);
-        if ( wxTheApp->GetExitOnFrameDelete() )
-        {
-            ::WinPostMsg(NULL, WM_QUIT, 0, 0);
-        }
-    }
-} // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
-
-//
-//  IF we have child controls in the Frame's client we need to alter
-//  the y position, because, OS/2 controls are positioned relative to
-//  wxWindows orgin (top left) not the OS/2 origin (bottom left)
-//
-void wxTopLevelWindowOS2::AlterChildPos()
-{
-    //
-    // OS/2 is the only OS concerned about this
+    // 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

     //
     //

-    wxWindow*                               pChild = NULL;
-    wxControl*                              pCtrl = NULL;
-    RECTL                                   vRect;
-    SWP                                     vSwp;
-
-    ::WinQueryWindowRect(GetHwnd(), &vRect);
-    for (wxWindowList::Node* pNode = GetChildren().GetFirst();
-         pNode;
-         pNode = pNode->GetNext())
+    if (HasFlag(wxFRAME_FLOAT_ON_PARENT))

     {
     {

-        wxWindow*                   pChild = pNode->GetData();
+        wxWindow*                   pParent = GetParent();

 
 

-        ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
-        vSwp.y += (vRect.yTop - m_vSwpClient.cy);
-        if (pChild->IsKindOf(CLASSINFO(wxControl)))
+        if (pParent)

         {
         {

-            pCtrl = wxDynamicCast(pChild, wxControl);
-            //
-            // 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.
-            //
-            vSwp.y -= pCtrl->GetYComp();
-            vSwp.x -= pCtrl->GetXComp();
+            ::WinSetWindowPos( GetHwndOf(pParent)
+                              ,HWND_TOP
+                              ,0, 0, 0, 0
+                              ,SWP_ZORDER
+                             );

         }
         }

-        ::WinSetWindowPos( pChild->GetHWND()
-                          ,HWND_TOP
-                          ,vSwp.x
-                          ,vSwp.y
-                          ,vSwp.cx
-                          ,vSwp.cy
-                          ,SWP_MOVE
-                         );
-        ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
-        pChild = NULL;

     }
     }

-    ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
-} // end of wxTopLevelWindowOS2::AlterChildPos
-
-void wxTopLevelWindowOS2::UpdateInternalSize(
-  wxWindow*                         pChild
-, int                               nHeight
-)
-{
-    pChild->MoveChildren(m_vSwpClient.cy - nHeight);
-    ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
-} // end of wxTopLevelWindowOS2::UpdateInternalSize
+} // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2

 
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowOS2 client size
 
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowOS2 client size


@@ -587,7 +715,12 @@ void wxTopLevelWindowOS2::DoShowWindow(
   int                               nShowCmd
 )
 {
   int                               nShowCmd
 )
 {

-    ::WinShowWindow(m_hFrame, (BOOL)nShowCmd);
+    ::WinShowWindow(m_hFrame, (BOOL)(nShowCmd & SWP_SHOW));
+
+    //
+    // Need to artificially send a size event as wxApps often expect to do some
+    // final child control sizing
+    SendSizeEvent();

     m_bIconized = nShowCmd == SWP_MINIMIZE;
 } // end of wxTopLevelWindowOS2::DoShowWindow
 
     m_bIconized = nShowCmd == SWP_MINIMIZE;
 } // end of wxTopLevelWindowOS2::DoShowWindow
 


@@ -597,18 +730,25 @@ bool wxTopLevelWindowOS2::Show(
 {
     int                             nShowCmd;
     SWP                             vSwp;
 {
     int                             nShowCmd;
     SWP                             vSwp;

-    RECTL                           vRect;

 
 

+    if (bShow != IsShown() )
+    {
+        m_isShown = bShow;
+    }
+    else
+    {
+        return FALSE;
+    }

     if (bShow)
     {
         if (m_bMaximizeOnShow)
         {
     if (bShow)
     {
         if (m_bMaximizeOnShow)
         {

-            nShowCmd = SWP_SHOW;
+            nShowCmd = SWP_MAXIMIZE;

             m_bMaximizeOnShow = FALSE;
         }
         else
         {
             m_bMaximizeOnShow = FALSE;
         }
         else
         {

-            nShowCmd = SWP_HIDE;
+            nShowCmd = SWP_SHOW;

         }
     }
     else // hide
         }
     }
     else // hide


@@ -625,7 +765,13 @@ bool wxTopLevelWindowOS2::Show(
         m_bIconized = vSwp.fl & SWP_MINIMIZE;
         ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
         m_bIconized = vSwp.fl & SWP_MINIMIZE;
         ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);

+        ::WinQueryWindowPos(m_hWnd, &vSwp);

         ::WinEnableWindow(m_hFrame, TRUE);
         ::WinEnableWindow(m_hFrame, TRUE);

+
+        //
+        // Deal with children
+        //
+        MoveChildren(m_vSwpClient.cy - vSwp.cy);

         vEvent.SetEventObject(this);
         GetEventHandler()->ProcessEvent(vEvent);
     }
         vEvent.SetEventObject(this);
         GetEventHandler()->ProcessEvent(vEvent);
     }


@@ -640,15 +786,6 @@ bool wxTopLevelWindowOS2::Show(
 
             ::WinQueryWindowPos(hWndParent, &vSwp);
             m_bIconized = vSwp.fl & SWP_MINIMIZE;
 
             ::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
-                                 );

             ::WinEnableWindow(hWndParent, TRUE);
         }
     }
             ::WinEnableWindow(hWndParent, TRUE);
         }
     }


@@ -676,13 +813,12 @@ 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);
     return (m_vSwp.fl & SWP_MAXIMIZE);
 
     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
     return (m_vSwp.fl & SWP_MAXIMIZE);


@@ -711,6 +847,21 @@ void wxTopLevelWindowOS2::Restore()
     DoShowWindow(SWP_RESTORE);
 } // end of wxTopLevelWindowOS2::Restore
 
     DoShowWindow(SWP_RESTORE);
 } // end of wxTopLevelWindowOS2::Restore
 

+// generate an artificial resize event
+void wxTopLevelWindowOS2::SendSizeEvent()
+{
+    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)
+                          );
+    }
+} // end of wxTopLevelWindowOS2::SendSizeEvent
+

 // ----------------------------------------------------------------------------
 // wxTopLevelWindowOS2 fullscreen
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxTopLevelWindowOS2 fullscreen
 // ----------------------------------------------------------------------------


@@ -831,17 +982,26 @@ bool wxTopLevelWindowOS2::ShowFullScreen(
 void wxTopLevelWindowOS2::SetIcon(
   const wxIcon&                     rIcon
 )
 void wxTopLevelWindowOS2::SetIcon(
   const wxIcon&                     rIcon
 )

+{
+    SetIcons(wxIconBundle(rIcon));
+} // end of wxTopLevelWindowOS2::SetIcon
+
+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.GetIcon(wxSize(32, 32));
+
+    if (vIcon.Ok() && vIcon.GetWidth() == 32 && vIcon.GetHeight() == 32)

     {
         ::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


@@ -895,3 +1055,75 @@ bool wxTopLevelWindowOS2::EnableCloseButton(
     return TRUE;
 } // end of wxTopLevelWindowOS2::EnableCloseButton
 
     return TRUE;
 } // 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(_T("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 = _T("wxTLWHiddenParent");
+
+            if (!::WinRegisterClass( wxGetInstance()
+                                    ,zHIDDEN_PARENT_CLASS
+                                    ,NULL
+                                    ,0
+                                    ,sizeof(ULONG)
+                                   ))
+            {
+                wxLogLastError(_T("RegisterClass(\"wxTLWHiddenParent\")"));
+            }
+            else
+            {
+                m_szClassName = zHIDDEN_PARENT_CLASS;
+            }
+        }
+        m_shWnd = ::WinCreateWindow( HWND_DESKTOP
+                                    ,m_szClassName
+                                    ,""
+                                    ,0L
+                                    ,(LONG)0L
+                                    ,(LONG)0L
+                                    ,(LONG)0L
+                                    ,(LONG)0L
+                                    ,NULLHANDLE
+                                    ,HWND_TOP
+                                    ,0L
+                                    ,NULL
+                                    ,NULL
+                                   );
+        if (!m_shWnd)
+        {
+            wxLogLastError(_T("CreateWindow(hidden TLW parent)"));
+        }
+    }
+    return m_shWnd;
+} // end of wxTLWHiddenParentModule::GetHWND