No real changes, just use wxString::clear() instead of assignment.

[wxWidgets.git] / src / msw / mdi.cpp

diff --git a/src/msw/mdi.cpp b/src/msw/mdi.cpp
index 7f933c7c84bf96b05cd08b11842d62cb38937eb6..e6ea206faccd5f524ec7db4125a2015bc632e55d 100644 (file)
--- a/src/msw/mdi.cpp
+++ b/src/msw/mdi.cpp
@@ -1,12 +1,13 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        mdi.cpp
-// Purpose:     MDI classes
+// Name:        src/msw/mdi.cpp
+// Purpose:     MDI classes for wxMSW

 // Author:      Julian Smart
 // Author:      Julian Smart

-// Modified by:
+// Modified by: Vadim Zeitlin on 2008-11-04 to use the base classes

 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Created:     04/01/98
 // RCS-ID:      $Id$

-// Copyright:   (c) Julian Smart and Markus Holzem
-// Licence:     wxWindows license
+// Copyright:   (c) 1998 Julian Smart
+//              (c) 2008-2009 Vadim Zeitlin
+// Licence:     wxWindows licence

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


@@ -17,10 +18,6 @@
 // headers
 // ---------------------------------------------------------------------------
 
 // headers
 // ---------------------------------------------------------------------------
 

-#ifdef __GNUG__
-    #pragma implementation "mdi.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,8 +25,11 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_MDI && !defined(__WXUNIVERSAL__)
+
+#include "wx/mdi.h"
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

-    #include "wx/setup.h"

     #include "wx/frame.h"
     #include "wx/menu.h"
     #include "wx/app.h"
     #include "wx/frame.h"
     #include "wx/menu.h"
     #include "wx/app.h"


@@ -37,46 +37,76 @@
     #include "wx/dialog.h"
     #include "wx/statusbr.h"
     #include "wx/settings.h"
     #include "wx/dialog.h"
     #include "wx/statusbr.h"
     #include "wx/settings.h"

+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/toolbar.h"

 #endif
 
 #endif
 

-#include "wx/mdi.h"
+#include "wx/stockitem.h"

 #include "wx/msw/private.h"
 
 #include "wx/msw/private.h"
 

-#if wxUSE_NATIVE_STATUSBAR
-    #include <wx/msw/statbr95.h>
-#endif
-

 #include <string.h>
 
 // ---------------------------------------------------------------------------
 // global variables
 // ---------------------------------------------------------------------------
 
 #include <string.h>
 
 // ---------------------------------------------------------------------------
 // global variables
 // ---------------------------------------------------------------------------
 

-extern wxWindowList wxModelessWindows;      // from dialog.cpp

 extern wxMenu *wxCurrentPopupMenu;
 
 extern wxMenu *wxCurrentPopupMenu;
 

-extern char wxMDIFrameClassName[];
-extern char wxMDIChildFrameClassName[];
-extern wxWindow *wxWndHook;                 // from window.cpp
+extern void wxRemoveHandleAssociation(wxWindow *win);

 
 

-extern wxList *wxWinHandleList;
+namespace
+{

 
 // ---------------------------------------------------------------------------
 // constants
 // ---------------------------------------------------------------------------
 
 
 // ---------------------------------------------------------------------------
 // constants
 // ---------------------------------------------------------------------------
 

-static const int IDM_WINDOWTILE  = 4001;
-static const int IDM_WINDOWCASCADE = 4002;
-static const int IDM_WINDOWICONS = 4003;
-static const int IDM_WINDOWNEXT = 4004;
+// First ID for the MDI child menu item in the "Window" menu.
+const int wxFIRST_MDI_CHILD = 4100;
+
+// There can be no more than 9 children in the "Window" menu as beginning with
+// the tenth one they're not shown and "More windows..." menu item is used
+// instead.
+const int wxLAST_MDI_CHILD = wxFIRST_MDI_CHILD + 8;
+
+// The ID of the "More windows..." menu item is the next one after the last
+// child.
+const int wxID_MDI_MORE_WINDOWS = wxLAST_MDI_CHILD + 1;
+
+// The MDI "Window" menu label
+const char *WINDOW_MENU_LABEL = gettext_noop("&Window");
+
+// ---------------------------------------------------------------------------
+// private functions
+// ---------------------------------------------------------------------------
+
+// set the MDI menus (by sending the WM_MDISETMENU message) and update the menu
+// of the parent of win (which is supposed to be the MDI client window)
+void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow);

 
 

-// This range gives a maximum of 500 MDI children. Should be enough :-)
-static const int wxFIRST_MDI_CHILD = 4100;
-static const int wxLAST_MDI_CHILD = 4600;
+// insert the window menu (subMenu) into menu just before "Help" submenu or at
+// the very end if not found
+void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU subMenu);

 
 

-// Status border dimensions
-static const int wxTHICK_LINE_BORDER = 3;
-static const int wxTHICK_LINE_WIDTH  = 1;
+// Remove the window menu
+void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu);
+
+// unpack the parameters of WM_MDIACTIVATE message
+void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
+                       WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact);
+
+// return the HMENU of the MDI menu
+//
+// this function works correctly even when we don't have a window menu and just
+// returns 0 then
+inline HMENU GetMDIWindowMenu(wxMDIParentFrame *frame)
+{
+    wxMenu *menu = frame->GetWindowMenu();
+    return menu ? GetHmenuOf(menu) : 0;
+}
+
+} // anonymous namespace

 
 // ===========================================================================
 // implementation
 
 // ===========================================================================
 // implementation


@@ -86,32 +116,42 @@ static const int wxTHICK_LINE_WIDTH  = 1;
 // wxWin macros
 // ---------------------------------------------------------------------------
 
 // wxWin macros
 // ---------------------------------------------------------------------------
 

-#if !USE_SHARED_LIBRARY
-    IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
-    IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
-    IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
-#endif // USE_SHARED_LIBRARY
+IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
+IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
+IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)

 
 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
     EVT_SIZE(wxMDIParentFrame::OnSize)
 
 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
     EVT_SIZE(wxMDIParentFrame::OnSize)

-    EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
+    EVT_ICONIZE(wxMDIParentFrame::OnIconized)

     EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
     EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)

+
+#if wxUSE_MENUS
+    EVT_MENU_RANGE(wxFIRST_MDI_CHILD, wxLAST_MDI_CHILD,
+                   wxMDIParentFrame::OnMDIChild)
+    EVT_MENU_RANGE(wxID_MDI_WINDOW_FIRST, wxID_MDI_WINDOW_LAST,
+                   wxMDIParentFrame::OnMDICommand)
+#endif // wxUSE_MENUS
+END_EVENT_TABLE()
+
+BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
+    EVT_IDLE(wxMDIChildFrame::OnIdle)

 END_EVENT_TABLE()
 
 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
     EVT_SCROLL(wxMDIClientWindow::OnScroll)
 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 
 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
     EVT_SCROLL(wxMDIClientWindow::OnScroll)
 END_EVENT_TABLE()
 

-// ---------------------------------------------------------------------------
-// wxMDIParentFrame
-// ---------------------------------------------------------------------------
+// ===========================================================================
+// wxMDIParentFrame: the frame which contains the client window which manages
+// the children
+// ===========================================================================

 
 

-wxMDIParentFrame::wxMDIParentFrame()
+void wxMDIParentFrame::Init()

 {
 {

-    m_clientWindow = NULL;
-    m_currentChild = NULL;
-    m_windowMenu = 0;
-    m_parentFrameActive = TRUE;
+#if wxUSE_MENUS && wxUSE_ACCEL
+  // the default menu doesn't have any accelerators (even if we have it)
+  m_accelWindowMenu = NULL;
+#endif // wxUSE_MENUS && wxUSE_ACCEL

 }
 
 bool wxMDIParentFrame::Create(wxWindow *parent,
 }
 
 bool wxMDIParentFrame::Create(wxWindow *parent,


@@ -122,12 +162,21 @@ bool wxMDIParentFrame::Create(wxWindow *parent,
                               long style,
                               const wxString& name)
 {
                               long style,
                               const wxString& name)
 {

-  m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON);
-
-  m_clientWindow = NULL;
-  m_currentChild = NULL;
-  m_windowMenu = 0;
-  m_parentFrameActive = TRUE;
+  // this style can be used to prevent a window from having the standard MDI
+  // "Window" menu
+  if ( !(style & wxFRAME_NO_WINDOW_MENU) )
+  {
+      // normal case: we have the window menu, so construct it
+      m_windowMenu = new wxMenu;
+
+      m_windowMenu->Append(wxID_MDI_WINDOW_CASCADE, _("&Cascade"));
+      m_windowMenu->Append(wxID_MDI_WINDOW_TILE_HORZ, _("Tile &Horizontally"));
+      m_windowMenu->Append(wxID_MDI_WINDOW_TILE_VERT, _("Tile &Vertically"));
+      m_windowMenu->AppendSeparator();
+      m_windowMenu->Append(wxID_MDI_WINDOW_ARRANGE_ICONS, _("&Arrange Icons"));
+      m_windowMenu->Append(wxID_MDI_WINDOW_NEXT, _("&Next"));
+      m_windowMenu->Append(wxID_MDI_WINDOW_PREV, _("&Previous"));
+  }

 
   if (!parent)
     wxTopLevelWindows.Append(this);
 
   if (!parent)
     wxTopLevelWindows.Append(this);


@@ -135,159 +184,305 @@ bool wxMDIParentFrame::Create(wxWindow *parent,
   SetName(name);
   m_windowStyle = style;
 
   SetName(name);
   m_windowStyle = style;
 

-  if (parent) parent->AddChild(this);
+  if ( parent )
+      parent->AddChild(this);

 
 

-  if ( id > -1 )
+  if ( id != wxID_ANY )

     m_windowId = id;
   else
     m_windowId = id;
   else

-    m_windowId = (int)NewControlId();
+    m_windowId = NewControlId();
+
+  WXDWORD exflags;
+  WXDWORD msflags = MSWGetCreateWindowFlags(&exflags);
+  msflags &= ~WS_VSCROLL;
+  msflags &= ~WS_HSCROLL;
+
+  if ( !wxWindow::MSWCreate(wxApp::GetRegisteredClassName(wxT("wxMDIFrame")),
+                            title.t_str(),
+                            pos, size,
+                            msflags,
+                            exflags) )
+  {
+      return false;
+  }

 
 

-  int x = pos.x;
-  int y = pos.y;
-  int width = size.x;
-  int height = size.y;
+  SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));

 
 

-  m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), "wxWindowMenu");
+  // unlike (almost?) all other windows, frames are created hidden
+  m_isShown = false;

 
 

-  DWORD msflags = WS_OVERLAPPED ;
-  if (style & wxMINIMIZE_BOX)
-    msflags |= WS_MINIMIZEBOX;
-  if (style & wxMAXIMIZE_BOX)
-    msflags |= WS_MAXIMIZEBOX;
-  if (style & wxTHICK_FRAME)
-    msflags |= WS_THICKFRAME;
-  if (style & wxSYSTEM_MENU)
-    msflags |= WS_SYSMENU;
-  if ((style & wxMINIMIZE) || (style & wxICONIZE))
-    msflags |= WS_MINIMIZE;
-  if (style & wxMAXIMIZE)
-    msflags |= WS_MAXIMIZE;
-  if (style & wxCAPTION)
-    msflags |= WS_CAPTION;
+  return true;
+}
+
+wxMDIParentFrame::~wxMDIParentFrame()
+{
+    // see comment in ~wxMDIChildFrame
+#if wxUSE_TOOLBAR
+    m_frameToolBar = NULL;
+#endif
+#if wxUSE_STATUSBAR
+    m_frameStatusBar = NULL;
+#endif // wxUSE_STATUSBAR
+
+#if wxUSE_MENUS && wxUSE_ACCEL
+    delete m_accelWindowMenu;
+#endif // wxUSE_MENUS && wxUSE_ACCEL

 
 

-  // Adding WS_CLIPCHILDREN causes children not to be properly
-  // drawn when first displaying them.
-//  if (style & wxCLIP_CHILDREN)
-//    msflags |= WS_CLIPCHILDREN;
+    DestroyChildren();

 
 

-  wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
-         msflags);
+    // the MDI frame menubar is not automatically deleted by Windows unlike for
+    // the normal frames
+    if ( m_hMenu )
+        ::DestroyMenu((HMENU)m_hMenu);

 
 

-  wxModelessWindows.Append(this);
+    if ( m_clientWindow )
+    {
+        if ( m_clientWindow->MSWGetOldWndProc() )
+            m_clientWindow->UnsubclassWin();

 
 

-  return TRUE;
+        m_clientWindow->SetHWND(0);
+        delete m_clientWindow;
+    }

 }
 
 }
 

-wxMDIParentFrame::~wxMDIParentFrame()
+// ----------------------------------------------------------------------------
+// wxMDIParentFrame child management
+// ----------------------------------------------------------------------------
+
+wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
+{
+    HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
+                                    WM_MDIGETACTIVE, 0, 0L);
+    if ( !hWnd )
+        return NULL;
+
+    return static_cast<wxMDIChildFrame *>(wxFindWinFromHandle(hWnd));
+}
+
+int wxMDIParentFrame::GetChildFramesCount() const

 {
 {

-  DestroyChildren();
+    int count = 0;
+    for ( wxWindowList::const_iterator i = GetChildren().begin();
+          i != GetChildren().end();
+          ++i )
+    {
+        if ( wxDynamicCast(*i, wxMDIChildFrame) )
+            count++;
+    }
+
+    return count;
+}

 
 

-  DestroyMenu((HMENU) m_windowMenu); // Destroy dummy "Window" menu
-  m_windowMenu = 0;
+#if wxUSE_MENUS

 
 

-  if (m_clientWindow->MSWGetOldWndProc())
-      m_clientWindow->UnsubclassWin();
+void wxMDIParentFrame::AddMDIChild(wxMDIChildFrame * WXUNUSED(child))
+{
+    switch ( GetChildFramesCount() )
+    {
+        case 1:
+            // first MDI child was just added, we need to insert the window
+            // menu now if we have it
+            AddWindowMenu();
+
+            // and disable the items which can't be used until we have more
+            // than one child
+            UpdateWindowMenu(false);
+            break;

 
 

-  m_clientWindow->SetHWND(0);
-  delete m_clientWindow;
+        case 2:
+            // second MDI child was added, enable the menu items which were
+            // disabled because they didn't make sense for a single window
+            UpdateWindowMenu(true);
+            break;
+    }

 }
 
 }
 

-void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar)
+void wxMDIParentFrame::RemoveMDIChild(wxMDIChildFrame * WXUNUSED(child))

 {
 {

-  if (!menu_bar)
-  {
-    m_frameMenuBar = NULL;
-    return;
-  }
+    switch ( GetChildFramesCount() )
+    {
+        case 1:
+            // last MDI child is being removed, remove the now unnecessary
+            // window menu too
+            RemoveWindowMenu();

 
 

-  if ( menu_bar->IsAttached() )
-     return;
+            // there is no need to call UpdateWindowMenu(true) here so this is
+            // not quite symmetric to AddMDIChild() above
+            break;

 
 

-  m_hMenu = menu_bar->Create();
+        case 2:
+            // only one MDI child is going to remain, disable the menu commands
+            // which don't make sense for a single child window
+            UpdateWindowMenu(false);
+            break;
+    }
+}

 
 

-  if (m_frameMenuBar)
-    delete m_frameMenuBar;
+// ----------------------------------------------------------------------------
+// wxMDIParentFrame window menu handling
+// ----------------------------------------------------------------------------

 
 

-  // MDI parent-specific code follows
+void wxMDIParentFrame::AddWindowMenu()
+{
+    if ( m_windowMenu )
+    {
+        // For correct handling of the events from this menu we also must
+        // attach it to the menu bar.
+        m_windowMenu->Attach(GetMenuBar());

 
 

-  HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);
+        MDIInsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this));
+    }
+}

 
 

-  // Try to insert Window menu in front of Help, otherwise append it.
-  HMENU menu = (HMENU)m_hMenu;
-  int N = GetMenuItemCount(menu);
-  bool success = FALSE;
-  for (int i = 0; i < N; i++)
-  {
-        char buf[100];
-        int chars = GetMenuString(menu, i, buf, 100, MF_BYPOSITION);
-        if ((chars > 0) && (strcmp(buf, "&Help") == 0 ||
-                            strcmp(buf, "Help") == 0))
-        {
-           success = TRUE;
-           InsertMenu(menu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
-                      (UINT)subMenu, "&Window");
-           break;
-        }
-  }
-  if (!success)
-    AppendMenu(menu, MF_POPUP,
-                         (UINT)subMenu,
-                         "&Window");
-  m_parentFrameActive = TRUE;
-#ifdef __WIN32__
-  SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDISETMENU,
-                (WPARAM)menu,
-                  (LPARAM)subMenu);
-#else
-  SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDISETMENU, 0,
-              MAKELPARAM(menu, subMenu));
-#endif
-  DrawMenuBar((HWND) GetHWND());
+void wxMDIParentFrame::RemoveWindowMenu()
+{
+    if ( m_windowMenu )
+    {
+        MDIRemoveWindowMenu(GetClientWindow(), m_hMenu);

 
 

-  m_frameMenuBar = menu_bar;
-  menu_bar->Attach(this);
+        m_windowMenu->Detach();
+    }

 }
 
 }
 

-void wxMDIParentFrame::OnSize(wxSizeEvent& event)
+void wxMDIParentFrame::UpdateWindowMenu(bool enable)

 {
 {

-#if wxUSE_CONSTRAINTS
-    if ( GetAutoLayout() )
+    if ( m_windowMenu )

     {
     {

-        Layout();
-        return;
+        m_windowMenu->Enable(wxID_MDI_WINDOW_NEXT, enable);
+        m_windowMenu->Enable(wxID_MDI_WINDOW_PREV, enable);

     }
     }

-#endif // wxUSE_CONSTRAINTS
+}

 
 

-    int x = 0;
-    int y = 0;
-    int width, height;
-    GetClientSize(&width, &height);
+#if wxUSE_MENUS_NATIVE

 
 

-    if ( GetClientWindow() )
-        GetClientWindow()->SetSize(x, y, width, height);
+void wxMDIParentFrame::InternalSetMenuBar()
+{
+    if ( GetActiveChild() )
+    {
+        AddWindowMenu();
+    }
+    else // we don't have any MDI children yet
+    {
+        // wait until we do to add the window menu but do set the main menu for
+        // now (this is done by AddWindowMenu() as a side effect)
+        MDISetMenu(GetClientWindow(), (HMENU)m_hMenu, NULL);
+    }

 }
 
 }
 

-void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
+#endif // wxUSE_MENUS_NATIVE
+
+void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)

 {
 {

-    // Do nothing
+    if ( menu != m_windowMenu )
+    {
+        // notice that Remove/AddWindowMenu() are safe to call even when
+        // m_windowMenu is NULL
+        RemoveWindowMenu();
+
+        delete m_windowMenu;
+
+        m_windowMenu = menu;
+
+        AddWindowMenu();
+    }
+
+#if wxUSE_ACCEL
+    wxDELETE(m_accelWindowMenu);
+
+    if ( menu && menu->HasAccels() )
+        m_accelWindowMenu = menu->CreateAccelTable();
+#endif // wxUSE_ACCEL

 }
 
 }
 

-// Returns the active MDI child window
-wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
+// ----------------------------------------------------------------------------
+// wxMDIParentFrame other menu-related stuff
+// ----------------------------------------------------------------------------
+
+void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu)

 {
 {

-    HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
-                                    WM_MDIGETACTIVE, 0, 0L);
-    if ( hWnd == 0 )
-        return NULL;
+    wxMDIChildFrame *child = GetActiveChild();
+    if ( child )
+    {
+        wxEvtHandler* source = child->GetEventHandler();
+        wxMenuBar* bar = child->GetMenuBar();
+
+        if (menu)
+        {
+            menu->UpdateUI(source);
+        }
+        else
+        {
+            if ( bar != NULL )
+            {
+                int nCount = bar->GetMenuCount();
+                for (int n = 0; n < nCount; n++)
+                    bar->GetMenu(n)->UpdateUI(source);
+            }
+        }
+    }

     else
     else

-        return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd);
+    {
+        wxFrameBase::DoMenuUpdates(menu);
+    }
+}
+
+wxMenuItem *wxMDIParentFrame::FindItemInMenuBar(int menuId) const
+{
+    wxMenuItem *item = wxFrame::FindItemInMenuBar(menuId);
+    if ( !item && GetActiveChild() )
+    {
+        item = GetActiveChild()->FindItemInMenuBar(menuId);
+    }
+
+    if ( !item && m_windowMenu )
+        item = m_windowMenu->FindItem(menuId);
+
+    return item;
+}
+
+WXHMENU wxMDIParentFrame::MSWGetActiveMenu() const
+{
+    wxMDIChildFrame * const child  = GetActiveChild();
+    if ( child )
+    {
+        const WXHMENU hmenu = child->MSWGetActiveMenu();
+        if ( hmenu )
+            return hmenu;
+    }
+
+    return wxFrame::MSWGetActiveMenu();
+}
+
+#endif // wxUSE_MENUS
+
+// ----------------------------------------------------------------------------
+// wxMDIParentFrame event handling
+// ----------------------------------------------------------------------------
+
+void wxMDIParentFrame::UpdateClientSize()
+{
+    if ( GetClientWindow() )
+    {
+        int width, height;
+        GetClientSize(&width, &height);
+
+        GetClientWindow()->SetSize(0, 0, width, height);
+    }

 }
 
 }
 

-// Create the client window class (don't Create the window, just return a new
-// class)
-wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
+void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event))

 {
 {

-    return new wxMDIClientWindow;
+    UpdateClientSize();
+
+    // do not call event.Skip() here, it somehow messes up MDI client window
+}
+
+void wxMDIParentFrame::OnIconized(wxIconizeEvent& event)
+{
+    event.Skip();
+
+    if ( !event.IsIconized() )
+        UpdateClientSize();

 }
 
 // Responds to colour changes, and passes event on to children.
 }
 
 // Responds to colour changes, and passes event on to children.


@@ -295,31 +490,36 @@ void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
 {
     if ( m_clientWindow )
     {
 {
     if ( m_clientWindow )
     {

-        m_clientWindow->SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
+        m_clientWindow->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));

         m_clientWindow->Refresh();
     }
         m_clientWindow->Refresh();
     }

-/*
-    if ( m_frameToolBar )
-    {
-        wxSysColourChangedEvent event2;
-        event2.eventObject = m_frameToolBar;
-        m_frameToolBar->GetEventHandler()->ProcessEvent(event2);
-    }
-*/

 
 

-    // Propagate the event to the non-top-level children
-    wxFrame::OnSysColourChanged(event);
+    event.Skip();
+}
+
+WXHICON wxMDIParentFrame::GetDefaultIcon() const
+{
+    // we don't have any standard icons (any more)
+    return (WXHICON)0;

 }
 
 }
 

+// ---------------------------------------------------------------------------

 // MDI operations
 // MDI operations

+// ---------------------------------------------------------------------------
+

 void wxMDIParentFrame::Cascade()
 {
     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
 }
 
 void wxMDIParentFrame::Cascade()
 {
     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
 }
 

-void wxMDIParentFrame::Tile()
+void wxMDIParentFrame::Tile(wxOrientation orient)

 {
 {

-    ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0);
+    wxASSERT_MSG( orient == wxHORIZONTAL || orient == wxVERTICAL,
+                  wxT("invalid orientation value") );
+
+    ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE,
+                  orient == wxHORIZONTAL ? MDITILE_HORIZONTAL
+                                         : MDITILE_VERTICAL, 0);

 }
 
 void wxMDIParentFrame::ArrangeIcons()
 }
 
 void wxMDIParentFrame::ArrangeIcons()


@@ -337,56 +537,60 @@ void wxMDIParentFrame::ActivatePrevious()
     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);
 }
 
     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);
 }
 

+// ---------------------------------------------------------------------------

 // the MDI parent frame window proc
 // the MDI parent frame window proc

-long wxMDIParentFrame::MSWWindowProc(WXUINT message,
-                                     WXWPARAM wParam,
-                                     WXLPARAM lParam)
+// ---------------------------------------------------------------------------
+
+WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message,
+                                          WXWPARAM wParam,
+                                          WXLPARAM lParam)

 {
 {

-    long rc = 0;
-    bool processed = FALSE;
+    WXLRESULT rc = 0;
+    bool processed = false;

 
     switch ( message )
     {
 
     switch ( message )
     {

-        case WM_CREATE:
-            m_clientWindow = OnCreateClient();
-            // Uses own style for client style
-            if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
+        case WM_ACTIVATE:

             {
             {

-                wxLogMessage(_("Failed to create MDI parent frame."));
+                WXWORD state, minimized;
+                WXHWND hwnd;
+                UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);

 
 

-                rc = -1;
+                processed = HandleActivate(state, minimized != 0, hwnd);

             }
             }

-
-            processed = TRUE;

             break;
 
             break;
 

-        case WM_ERASEBKGND:
-            processed = TRUE;
+        case WM_COMMAND:
+            // system messages such as SC_CLOSE are sent as WM_COMMANDs to the
+            // parent MDI frame and we must let the DefFrameProc() have them
+            // for these commands to work (without it, closing the maximized
+            // MDI children doesn't work, for example)
+            {
+                WXWORD id, cmd;
+                WXHWND hwnd;
+                UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);

 
 

-            // we erase background ourselves
-            rc = TRUE;
+                if ( id == wxID_MDI_MORE_WINDOWS ||
+                     (cmd == 0 /* menu */ &&
+                        id >= SC_SIZE /* first system menu command */) )
+                {
+                    MSWDefWindowProc(message, wParam, lParam);
+                    processed = true;
+                }
+            }

             break;
 
             break;
 

-        case WM_MENUSELECT:
+        case WM_CREATE:
+            m_clientWindow = OnCreateClient();
+            // Uses own style for client style
+            if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )

             {
             {

-                WORD item = (WORD)wParam;
-#ifdef __WIN32__
-                WORD flags = HIWORD(wParam);
-                HMENU menu = (HMENU)lParam;
-#else
-                WORD flags = LOWORD(lParam);
-                HMENU menu = (HMENU)HIWORD(lParam);
-#endif
-                if ( m_parentFrameActive )
-                {
-                    processed = HandleMenuSelect(item, flags, (WXHMENU)menu);
-                }
-                else if (m_currentChild)
-                {
-                    processed = m_currentChild->
-                        HandleMenuSelect(item, flags, (WXHMENU)menu);
-                }
+                wxLogMessage(_("Failed to create MDI parent frame."));
+
+                rc = -1;

             }
             }

+
+            processed = true;

             break;
     }
 
             break;
     }
 


@@ -396,116 +600,118 @@ long wxMDIParentFrame::MSWWindowProc(WXUINT message,
     return rc;
 }
 
     return rc;
 }
 

-bool wxMDIParentFrame::MSWOnActivate(int state, bool minimized, WXHWND activate)
+bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)

 {
 {

-    bool processed = FALSE;
+    bool processed = false;

 
 

-    if ( wxWindow::MSWOnActivate(state, minimized, activate) )
+    if ( wxWindow::HandleActivate(state, minimized, activate) )

     {
         // already processed
     {
         // already processed

-        processed = TRUE;
+        processed = true;

     }
 
     // If this window is an MDI parent, we must also send an OnActivate message
     // to the current child.
     }
 
     // If this window is an MDI parent, we must also send an OnActivate message
     // to the current child.

-    if ( (m_currentChild != NULL) && 
+    if ( GetActiveChild() &&

          ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
     {
          ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
     {

-        wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId());
-        event.SetEventObject( m_currentChild );
-        if ( m_currentChild->GetEventHandler()->ProcessEvent(event) )
-            processed = TRUE;
+        wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId());
+        event.SetEventObject( GetActiveChild() );
+        if ( GetActiveChild()->HandleWindowEvent(event) )
+            processed = true;

     }
 
     return processed;
 }
 
     }
 
     return processed;
 }
 

-bool wxMDIParentFrame::MSWOnCommand(WXWORD id, WXWORD cmd, WXHWND control)
-{
-//  if (cmd == 0) // Why did I do this test?
-  {
-    // In case it's e.g. a toolbar.
-    wxWindow *win = wxFindWinFromHandle(control);
-    if (win)
-      return win->MSWCommand(cmd, id);
-
-/*
-    if (wxCurrentPopupMenu)
-    {
-        wxMenu *popupMenu = wxCurrentPopupMenu;
-        wxCurrentPopupMenu = NULL;
-        if (!popupMenu->MSWCommand(cmd, id))
-            return TRUE;
-    }
-*/
-
-    switch (id)
-    {
-      case IDM_WINDOWCASCADE:
-        SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDICASCADE, MDITILE_SKIPDISABLED, 0);
-        return TRUE;
-      case IDM_WINDOWTILE:
-        SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDITILE, MDITILE_HORIZONTAL, 0);
-        return TRUE;
-      case IDM_WINDOWICONS:
-        SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDIICONARRANGE, 0, 0);
-        return TRUE;
-      case IDM_WINDOWNEXT:
-        SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDINEXT, 0, 0);
-        return TRUE;
-      default:
-        break;
-     }
-    if (id >= 0xF000)
-    {
-      return FALSE; // Get WndProc to call default proc
-    }
+#if wxUSE_MENUS

 
 

-    if (m_parentFrameActive && (id < wxFIRST_MDI_CHILD || id > wxLAST_MDI_CHILD))
-    {
-      ProcessCommand(id);
-      return TRUE;
-    }
-    else if (m_currentChild && (id < wxFIRST_MDI_CHILD || id > wxLAST_MDI_CHILD))
-    {
-      return m_currentChild->MSWOnCommand(id, cmd, control);
-    }
-  }
-  if (id >= wxFIRST_MDI_CHILD && id <= wxLAST_MDI_CHILD)
-  {
-    wxNode* node = GetChildren().First();
-    while (node)
+void wxMDIParentFrame::OnMDIChild(wxCommandEvent& event)
+{
+    wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
+    while ( node )

     {
     {

-        wxWindow* child = (wxWindow*) node->Data();
-        if (child->GetHWND())
+        wxWindow *child = node->GetData();
+        if ( child->GetHWND() )

         {
         {

-#ifdef __WIN32__
-            long childId = GetWindowLong((HWND) child->GetHWND(), GWL_ID);
-#else
-            long childId = GetWindowWord((HWND) child->GetHWND(), GWW_ID);
-#endif
-            if (childId == id)
+            int childId = wxGetWindowId(child->GetHWND());
+            if ( childId == event.GetId() )

             {
             {

-                ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) child->GetHWND(), 0);
-                return TRUE;
+                wxStaticCast(child, wxMDIChildFrame)->Activate();
+                return;

             }
         }
             }
         }

-        node = node->Next();
+
+        node = node->GetNext();
+    }
+
+    wxFAIL_MSG( "unknown MDI child selected?" );
+}
+
+void wxMDIParentFrame::OnMDICommand(wxCommandEvent& event)
+{
+    WXWPARAM wParam = 0;
+    WXLPARAM lParam = 0;
+    int msg;
+    switch ( event.GetId() )
+    {
+        case wxID_MDI_WINDOW_CASCADE:
+            msg = WM_MDICASCADE;
+            wParam = MDITILE_SKIPDISABLED;
+            break;
+
+        case wxID_MDI_WINDOW_TILE_HORZ:
+            wParam |= MDITILE_HORIZONTAL;
+            // fall through
+
+        case wxID_MDI_WINDOW_TILE_VERT:
+            if ( !wParam )
+                wParam = MDITILE_VERTICAL;
+            msg = WM_MDITILE;
+            wParam |= MDITILE_SKIPDISABLED;
+            break;
+
+        case wxID_MDI_WINDOW_ARRANGE_ICONS:
+            msg = WM_MDIICONARRANGE;
+            break;
+
+        case wxID_MDI_WINDOW_NEXT:
+            msg = WM_MDINEXT;
+            lParam = 0;         // next child
+            break;
+
+        case wxID_MDI_WINDOW_PREV:
+            msg = WM_MDINEXT;
+            lParam = 1;         // previous child
+            break;
+
+        default:
+            wxFAIL_MSG( "unknown MDI command" );
+            return;

     }
     }

-/*
-    wxWindow* child = FindItem(id);
-    if (child)
+
+    ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam);
+}
+
+#endif // wxUSE_MENUS
+
+bool wxMDIParentFrame::TryBefore(wxEvent& event)
+{
+    // menu (and toolbar) events should be sent to the active child frame
+    // first, if any
+    if ( event.GetEventType() == wxEVT_COMMAND_MENU_SELECTED )

     {
     {

-        ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) child->GetHWND(), 0);
-        return TRUE;
+        wxMDIChildFrame * const child = GetActiveChild();
+        if ( child && child->ProcessWindowEventLocally(event) )
+            return true;

     }
     }

-*/
-  }

 
 

-  return wxWindow::MSWOnCommand(id, cmd, control);
+    return wxMDIParentFrameBase::TryBefore(event);

 }
 
 }
 

-long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
+                                        WXWPARAM wParam,
+                                        WXLPARAM lParam)

 {
     WXHWND clientWnd;
     if ( GetClientWindow() )
 {
     WXHWND clientWnd;
     if ( GetClientWindow() )


@@ -516,46 +722,50 @@ long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARA
     return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
 }
 
     return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
 }
 

-bool wxMDIParentFrame::MSWProcessMessage(WXMSG* msg)
-{
-    return m_currentChild && m_currentChild->GetHWND() &&
-           m_currentChild->MSWProcessMessage(msg);
-}
-

 bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
 {
     MSG *pMsg = (MSG *)msg;
 
 bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
 {
     MSG *pMsg = (MSG *)msg;
 

-    if ( m_currentChild && m_currentChild->GetHWND() &&
-         m_currentChild->MSWTranslateMessage(msg) )
+    // first let the current child get it
+    wxMDIChildFrame * const child = GetActiveChild();
+    if ( child && child->MSWTranslateMessage(msg) )

     {
     {

-        return TRUE;
+        return true;

     }
 
     }
 

-    if ( m_acceleratorTable.Ok() &&
-         ::TranslateAccelerator(GetHwnd(),
-                                GetTableHaccel(&m_acceleratorTable),
-                                pMsg) )
+    // then try out accelerator table (will also check the accelerators for the
+    // normal menu items)
+    if ( wxFrame::MSWTranslateMessage(msg) )

     {
     {

-        return TRUE;
+        return true;

     }
 
     }
 

+#if wxUSE_MENUS && wxUSE_ACCEL
+    // but it doesn't check for the (custom) accelerators of the window menu
+    // items as it's not part of the menu bar as it's handled by Windows itself
+    // so we need to do this explicitly
+    if ( m_accelWindowMenu && m_accelWindowMenu->Translate(this, msg) )
+        return true;
+#endif // wxUSE_MENUS && wxUSE_ACCEL
+
+    // finally, check for MDI specific built-in accelerators

     if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
     {
         if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
     if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
     {
         if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))

-            return TRUE;
+            return true;

     }
 
     }
 

-    return FALSE;
+    return false;

 }
 
 }
 

-// ---------------------------------------------------------------------------
+// ===========================================================================

 // wxMDIChildFrame
 // wxMDIChildFrame

-// ---------------------------------------------------------------------------
+// ===========================================================================

 
 

-wxMDIChildFrame::wxMDIChildFrame()
+void wxMDIChildFrame::Init()

 {
 {

-//    m_active = FALSE;
+    m_needsResize = true;
+    m_needsInitialShow = true;

 }
 
 bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 }
 
 bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,


@@ -566,18 +776,19 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
                              long style,
                              const wxString& name)
 {
                              long style,
                              const wxString& name)
 {

-  m_defaultIcon = (WXHICON) (wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON : wxDEFAULT_MDICHILDFRAME_ICON);
+    m_mdiParent = parent;

 
   SetName(name);
 
 
   SetName(name);
 

-  if ( id > -1 )
+  if ( id != wxID_ANY )

     m_windowId = id;
   else
     m_windowId = id;
   else

-    m_windowId = (int)NewControlId();
+    m_windowId = NewControlId();

 
 

-  if (parent) parent->AddChild(this);
-
-  wxWndHook = this;
+  if ( parent )
+  {
+      parent->AddChild(this);
+  }

 
   int x = pos.x;
   int y = pos.y;
 
   int x = pos.x;
   int y = pos.y;


@@ -586,27 +797,40 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 
   MDICREATESTRUCT mcs;
 
 
   MDICREATESTRUCT mcs;
 

-  mcs.szClass = wxMDIChildFrameClassName;
-  mcs.szTitle = title;
+  wxString className =
+      wxApp::GetRegisteredClassName(wxT("wxMDIChildFrame"), COLOR_WINDOW);
+  if ( !(style & wxFULL_REPAINT_ON_RESIZE) )
+      className += wxApp::GetNoRedrawClassSuffix();
+
+  mcs.szClass = className.t_str();
+  mcs.szTitle = title.t_str();

   mcs.hOwner = wxGetInstance();
   mcs.hOwner = wxGetInstance();

-  if (x > -1) mcs.x = x;
-  else mcs.x = CW_USEDEFAULT;
+  if (x != wxDefaultCoord)
+      mcs.x = x;
+  else
+      mcs.x = CW_USEDEFAULT;

 
 

-  if (y > -1) mcs.y = y;
-  else mcs.y = CW_USEDEFAULT;
+  if (y != wxDefaultCoord)
+      mcs.y = y;
+  else
+      mcs.y = CW_USEDEFAULT;

 
 

-  if (width > -1) mcs.cx = width;
-  else mcs.cx = CW_USEDEFAULT;
+  if (width != wxDefaultCoord)
+      mcs.cx = width;
+  else
+      mcs.cx = CW_USEDEFAULT;

 
 

-  if (height > -1) mcs.cy = height;
-  else mcs.cy = CW_USEDEFAULT;
+  if (height != wxDefaultCoord)
+      mcs.cy = height;
+  else
+      mcs.cy = CW_USEDEFAULT;

 
 

-  DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN ;
+  DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;

   if (style & wxMINIMIZE_BOX)
     msflags |= WS_MINIMIZEBOX;
   if (style & wxMAXIMIZE_BOX)
     msflags |= WS_MAXIMIZEBOX;
   if (style & wxMINIMIZE_BOX)
     msflags |= WS_MINIMIZEBOX;
   if (style & wxMAXIMIZE_BOX)
     msflags |= WS_MAXIMIZEBOX;

-  if (style & wxTHICK_FRAME)
+  if (style & wxRESIZE_BORDER)

     msflags |= WS_THICKFRAME;
   if (style & wxSYSTEM_MENU)
     msflags |= WS_SYSMENU;
     msflags |= WS_THICKFRAME;
   if (style & wxSYSTEM_MENU)
     msflags |= WS_SYSMENU;


@@ -621,37 +845,82 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 
   mcs.lParam = 0;
 
 
   mcs.lParam = 0;
 

-  DWORD Return = SendMessage((HWND) parent->GetClientWindow()->GetHWND(),
-        WM_MDICREATE, 0, (LONG)(LPSTR)&mcs);
+  wxWindowCreationHook hook(this);

 
 

-  //handle = (HWND)LOWORD(Return);
-  // Must be the DWORRD for WIN32. And in 16 bits, HIWORD=0 (says Microsoft)
-  m_hWnd = (WXHWND)Return;
+  m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()),
+                                 WM_MDICREATE, 0, (LPARAM)&mcs);

 
 

-  // This gets reassigned so can't be stored
-//  m_windowId = GetWindowLong((HWND) m_hWnd, GWL_ID);
+  if ( !m_hWnd )
+  {
+      wxLogLastError(wxT("WM_MDICREATE"));
+      return false;
+  }

 
 

-  wxWndHook = NULL;
-  wxWinHandleList->Append((long)GetHWND(), this);
+  SubclassWin(m_hWnd);

 
 

-  SetWindowLong((HWND) GetHWND(), 0, (long)this);
+  parent->AddMDIChild(this);

 
 

-  wxModelessWindows.Append(this);
-  return TRUE;
+  return true;

 }
 
 wxMDIChildFrame::~wxMDIChildFrame()
 {
 }
 
 wxMDIChildFrame::~wxMDIChildFrame()
 {

-    MSWDestroyWindow();
+    // if we hadn't been created, there is nothing to destroy
+    if ( !m_hWnd )
+        return;

 
 

-    ResetWindowStyle(NULL);
+    GetMDIParent()->RemoveMDIChild(this);
+
+    // will be destroyed by DestroyChildren() but reset them before calling it
+    // to avoid using dangling pointers if a callback comes in the meanwhile
+#if wxUSE_TOOLBAR
+    m_frameToolBar = NULL;
+#endif
+#if wxUSE_STATUSBAR
+    m_frameStatusBar = NULL;
+#endif // wxUSE_STATUSBAR
+
+    DestroyChildren();
+
+    MDIRemoveWindowMenu(NULL, m_hMenu);
+
+    MSWDestroyWindow();
+}
+
+bool wxMDIChildFrame::Show(bool show)
+{
+    m_needsInitialShow = false;
+
+    if (!wxFrame::Show(show))
+        return false;
+
+    // KH: Without this call, new MDI children do not become active.
+    // This was added here after the same BringWindowToTop call was
+    // removed from wxTopLevelWindow::Show (November 2005)
+    if ( show )
+        ::BringWindowToTop(GetHwnd());
+
+    // we need to refresh the MDI frame window menu to include (or exclude if
+    // we've been hidden) this frame
+    wxMDIParentFrame * const parent = GetMDIParent();
+    MDISetMenu(parent->GetClientWindow(), NULL, NULL);
+
+    return true;
+}
+
+void
+wxMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
+{
+    // we need to disable client area origin adjustments used for the child
+    // windows for the frame itself
+    wxMDIChildFrameBase::DoSetSize(x, y, width, height, sizeFlags);

 }
 
 // Set the client size (i.e. leave the calculation of borders etc.
 }
 
 // Set the client size (i.e. leave the calculation of borders etc.

-// to wxWindows)
+// to wxWidgets)

 void wxMDIChildFrame::DoSetClientSize(int width, int height)
 {
 void wxMDIChildFrame::DoSetClientSize(int width, int height)
 {

-  HWND hWnd = (HWND) GetHWND();
+  HWND hWnd = GetHwnd();

 
   RECT rect;
   ::GetClientRect(hWnd, &rect);
 
   RECT rect;
   ::GetClientRect(hWnd, &rect);


@@ -665,12 +934,14 @@ void wxMDIChildFrame::DoSetClientSize(int width, int height)
   int actual_width = rect2.right - rect2.left - rect.right + width;
   int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
 
   int actual_width = rect2.right - rect2.left - rect.right + width;
   int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
 

-  if (GetStatusBar())
+#if wxUSE_STATUSBAR
+  if (GetStatusBar() && GetStatusBar()->IsShown())

   {
     int sx, sy;
     GetStatusBar()->GetSize(&sx, &sy);
     actual_height += sy;
   }
   {
     int sx, sy;
     GetStatusBar()->GetSize(&sx, &sy);
     actual_height += sy;
   }

+#endif // wxUSE_STATUSBAR

 
   POINT point;
   point.x = rect2.left;
 
   POINT point;
   point.x = rect2.left;


@@ -678,439 +949,608 @@ void wxMDIChildFrame::DoSetClientSize(int width, int height)
 
   // If there's an MDI parent, must subtract the parent's top left corner
   // since MoveWindow moves relative to the parent
 
   // If there's an MDI parent, must subtract the parent's top left corner
   // since MoveWindow moves relative to the parent

-  wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
-  ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
+  wxMDIParentFrame * const mdiParent = GetMDIParent();
+  ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);

 
 

-  MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)TRUE);
+  MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true);

 
 

-  wxSizeEvent event(wxSize(width, height), m_windowId);
+  wxSize size(width, height);
+  wxSizeEvent event(size, m_windowId);

   event.SetEventObject( this );
   event.SetEventObject( this );

-  GetEventHandler()->ProcessEvent(event);
+  HandleWindowEvent(event);

 }
 
 }
 

+// Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the
+//  same as its GetScreenPosition
+void wxMDIChildFrame::DoGetScreenPosition(int *x, int *y) const
+{
+  HWND hWnd = GetHwnd();
+
+  RECT rect;
+  ::GetWindowRect(hWnd, &rect);
+  if (x)
+     *x = rect.left;
+  if (y)
+     *y = rect.top;
+}
+
+

 void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
 {
   RECT rect;
 void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
 {
   RECT rect;

-  GetWindowRect((HWND) GetHWND(), &rect);
+  GetWindowRect(GetHwnd(), &rect);

   POINT point;
   point.x = rect.left;
   point.y = rect.top;
 
   // Since we now have the absolute screen coords,
   // if there's a parent we must subtract its top left corner
   POINT point;
   point.x = rect.left;
   point.y = rect.top;
 
   // Since we now have the absolute screen coords,
   // if there's a parent we must subtract its top left corner

-  wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
-  ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
+  wxMDIParentFrame * const mdiParent = GetMDIParent();
+  ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);

 
 

-  *x = point.x;
-  *y = point.y;
+  if (x)
+      *x = point.x;
+  if (y)
+      *y = point.y;

 }
 
 }
 

-void wxMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
+void wxMDIChildFrame::InternalSetMenuBar()

 {
 {

-  if (!menu_bar)
-  {
-    m_frameMenuBar = NULL;
-    return;
-  }
-
-  if ( menu_bar->IsAttached() )
-     return;
+    wxMDIParentFrame * const parent = GetMDIParent();

 
 

-  m_hMenu = menu_bar->Create();
-
-  if (m_frameMenuBar)
-    delete m_frameMenuBar;
-
-   wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
-
-   parent->m_parentFrameActive = FALSE;
-   HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);
+    MDIInsertWindowMenu(parent->GetClientWindow(),
+                     m_hMenu, GetMDIWindowMenu(parent));
+}

 
 

-   // Try to insert Window menu in front of Help, otherwise append it.
-   HMENU menu = (HMENU)m_hMenu;
-   int N = GetMenuItemCount(menu);
-   bool success = FALSE;
-   for (int i = 0; i < N; i++)
-   {
-        char buf[100];
-        int chars = GetMenuString(menu, i, buf, 100, MF_BYPOSITION);
-        if ((chars > 0) && (strcmp(buf, "&Help") == 0 ||
-                            strcmp(buf, "Help") == 0))
-        {
-           success = TRUE;
-           InsertMenu(menu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
-                      (UINT)subMenu, "&Window");
-           break;
-        }
-      }
-  if (!success)
-    AppendMenu(menu, MF_POPUP,
-                         (UINT)subMenu,
-                         "&Window");
-#ifdef __WIN32__
-  SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU,
-                  (WPARAM)menu,
-                  (LPARAM)subMenu);
-#else
-  SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, 0,
-                  MAKELPARAM(menu, subMenu));
-#endif
+void wxMDIChildFrame::DetachMenuBar()
+{
+    MDIRemoveWindowMenu(NULL, m_hMenu);
+    wxFrame::DetachMenuBar();
+}

 
 

-  DrawMenuBar((HWND) parent->GetHWND());
-  m_frameMenuBar = menu_bar;
-  menu_bar->Attach(this);
+WXHICON wxMDIChildFrame::GetDefaultIcon() const
+{
+    // we don't have any standard icons (any more)
+    return (WXHICON)0;

 }
 
 }
 

+// ---------------------------------------------------------------------------

 // MDI operations
 // MDI operations

-void wxMDIChildFrame::Maximize()
+// ---------------------------------------------------------------------------
+
+void wxMDIChildFrame::Maximize(bool maximize)

 {
 {

-    wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+    wxMDIParentFrame * const parent = GetMDIParent();

     if ( parent && parent->GetClientWindow() )
     if ( parent && parent->GetClientWindow() )

-        ::SendMessage( (HWND) parent->GetClientWindow()->GetHWND(), WM_MDIMAXIMIZE, (WPARAM) (HWND) GetHWND(), 0);
+    {
+        ::SendMessage(GetWinHwnd(parent->GetClientWindow()),
+                      maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
+                      (WPARAM)GetHwnd(), 0);
+    }

 }
 
 void wxMDIChildFrame::Restore()
 {
 }
 
 void wxMDIChildFrame::Restore()
 {

-    wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+    wxMDIParentFrame * const parent = GetMDIParent();

     if ( parent && parent->GetClientWindow() )
     if ( parent && parent->GetClientWindow() )

-        ::SendMessage( (HWND) parent->GetClientWindow()->GetHWND(), WM_MDIRESTORE, (WPARAM) (HWND) GetHWND(), 0);
+    {
+        ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
+                      (WPARAM) GetHwnd(), 0);
+    }

 }
 
 void wxMDIChildFrame::Activate()
 {
 }
 
 void wxMDIChildFrame::Activate()
 {

-    wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+    wxMDIParentFrame * const parent = GetMDIParent();

     if ( parent && parent->GetClientWindow() )
     if ( parent && parent->GetClientWindow() )

-        ::SendMessage( (HWND) parent->GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) GetHWND(), 0);
+    {
+        // Activating an iconized MDI frame doesn't do anything, so restore it
+        // first to really present it to the user.
+        if ( IsIconized() )
+            Restore();
+
+        ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
+                      (WPARAM) GetHwnd(), 0);
+    }

 }
 
 }
 

-static HWND invalidHandle = 0;
-bool wxMDIChildFrame::MSWOnSize(int x, int y, WXUINT id)
+// ---------------------------------------------------------------------------
+// MDI window proc and message handlers
+// ---------------------------------------------------------------------------
+
+WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
+                                         WXWPARAM wParam,
+                                         WXLPARAM lParam)

 {
 {

-    HWND hwnd = GetHwnd();
-    
-    if ( !hwnd || hwnd == invalidHandle )
-    {
-        return FALSE;
-    }
-    
-    switch (id)
+    WXLRESULT rc = 0;
+    bool processed = false;
+
+    switch ( message )

     {
     {

-        case SIZEFULLSCREEN:
-        case SIZENORMAL:
-            m_iconized = FALSE;
+        case WM_GETMINMAXINFO:
+            processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam);
+            break;
+
+        case WM_MDIACTIVATE:
+            {
+                WXWORD act;
+                WXHWND hwndAct, hwndDeact;
+                UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact);
+
+                processed = HandleMDIActivate(act, hwndAct, hwndDeact);
+            }
+            // fall through
+
+        case WM_MOVE:
+            // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
+            // scrollbars if necessary
+
+            // fall through
+
+        case WM_SIZE:
+            // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
+            // things happen
+            MSWDefWindowProc(message, wParam, lParam);

             break;
 
             break;
 

-        case SIZEICONIC:
-            m_iconized = TRUE;
+        case WM_WINDOWPOSCHANGING:
+            processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);

             break;
     }
             break;
     }

-    
-    if (!m_iconized)
+
+    if ( !processed )
+        rc = wxFrame::MSWWindowProc(message, wParam, lParam);
+
+    return rc;
+}
+
+bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
+                                        WXHWND hwndAct,
+                                        WXHWND hwndDeact)
+{
+    wxMDIParentFrame * const parent = GetMDIParent();
+
+    WXHMENU hMenuToSet = 0;
+
+    bool activated;
+
+    if ( m_hWnd == hwndAct )

     {
     {

-        // forward WM_SIZE to status bar control
-#if wxUSE_NATIVE_STATUSBAR
-        if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
-        {
-            wxSizeEvent event(wxSize(x, y), m_frameStatusBar->GetId());
-            event.SetEventObject( m_frameStatusBar );
-            
-            ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event);
-        }
-#endif
-        
-        PositionStatusBar();
-        PositionToolBar();
-        
-        return wxWindow::MSWOnSize(x, y, id);
+        activated = true;
+        parent->SetActiveChild(this);
+
+        WXHMENU hMenuChild = m_hMenu;
+        if ( hMenuChild )
+            hMenuToSet = hMenuChild;

     }
     }

-    else
+    else if ( m_hWnd == hwndDeact )

     {
     {

-        return FALSE;
-    }
-}
+        wxASSERT_MSG( parent->GetActiveChild() == this,
+                      wxT("can't deactivate MDI child which wasn't active!") );

 
 

-bool wxMDIChildFrame::MSWOnCommand(WXWORD id, WXWORD cmd, WXHWND control)
-{
-//  if ((cmd == 0) && GetHWND())
-  if (GetHWND())
-  {
-    // In case it's e.g. a toolbar.
-    wxWindow *win = wxFindWinFromHandle(control);
-    if (win)
-      return win->MSWCommand(cmd, id);
+        activated = false;
+        parent->SetActiveChild(NULL);
+
+        WXHMENU hMenuParent = parent->m_hMenu;

 
 

-    if (wxCurrentPopupMenu)
+        // activate the parent menu only when there is no other child
+        // that has been activated
+        if ( hMenuParent && !hwndAct )
+            hMenuToSet = hMenuParent;
+    }
+    else

     {
     {

-        wxMenu *popupMenu = wxCurrentPopupMenu;
-        wxCurrentPopupMenu = NULL;
-        if (popupMenu->MSWCommand(cmd, id))
-            return TRUE;
+        // we have nothing to do with it
+        return false;

     }
 
     }
 

-    if (GetMenuBar() && GetMenuBar()->FindItemForId(id))
+    if ( hMenuToSet )

     {
     {

-      ProcessCommand(id);
-      return TRUE;
+        MDISetMenu(parent->GetClientWindow(),
+                   (HMENU)hMenuToSet, GetMDIWindowMenu(parent));

     }
     }

-    else
-      return FALSE;
-    return TRUE;
-  }
-  else
-    return wxWindow::MSWOnCommand(id, cmd, control);
-}

 
 

-long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam)
-{
-  if (GetHWND())
-    return DefMDIChildProc((HWND) GetHWND(), (UINT) message, (WPARAM) wParam, (LPARAM) lParam);
-  else return 0;
-}
+    wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
+    event.SetEventObject( this );

 
 

-bool wxMDIChildFrame::MSWProcessMessage(WXMSG *msg)
-{
-  return FALSE;
+    ResetWindowStyle(NULL);
+
+    return HandleWindowEvent(event);

 }
 
 }
 

-bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
+bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)

 {
 {

-  MSG *pMsg = (MSG *)msg;
-  if (m_acceleratorTable.Ok())
-  {
-    wxFrame *parent = (wxFrame *)GetParent();
-    HWND parent_hwnd = (HWND) parent->GetHWND();
-    return (::TranslateAccelerator(parent_hwnd, (HACCEL) m_acceleratorTable.GetHACCEL(), pMsg) != 0);
-  }
+    WINDOWPOS *lpPos = (WINDOWPOS *)pos;

 
 

-  return FALSE;
+    if (!(lpPos->flags & SWP_NOSIZE))
+    {
+        RECT rectClient;
+        DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
+        DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
+        if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
+        {
+            ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle);
+            lpPos->x = rectClient.left;
+            lpPos->y = rectClient.top;
+            lpPos->cx = rectClient.right - rectClient.left;
+            lpPos->cy = rectClient.bottom - rectClient.top;
+        }
+    }
+
+    return false;

 }
 
 }
 

-bool wxMDIChildFrame::MSWOnMDIActivate(long activate, WXHWND WXUNUSED(one), WXHWND WXUNUSED(two))
+bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo)

 {
 {

-  wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
-  HMENU parent_menu = (HMENU) parent->GetWinMenu();
-  HMENU child_menu = (HMENU) GetWinMenu();
+    MINMAXINFO *info = (MINMAXINFO *)mmInfo;

 
 

-  if (activate)
-  {
-//    m_active = TRUE;
-    parent->m_currentChild = this;
-    if (child_menu)
+    // let the default window proc calculate the size of MDI children
+    // frames because it is based on the size of the MDI client window,
+    // not on the values specified in wxWindow m_max variables
+    bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0;
+
+    int minWidth = GetMinWidth(),
+        minHeight = GetMinHeight();
+
+    // but allow GetSizeHints() to set the min size
+    if ( minWidth != wxDefaultCoord )

     {
     {

-      parent->m_parentFrameActive = FALSE;
-      HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);
-#ifdef __WIN32__
-      ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU,
-                    (WPARAM)child_menu,
-                    (LPARAM)subMenu);
-#else
-      ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, 0,
-                  MAKELONG(child_menu, subMenu));
-#endif
+        info->ptMinTrackSize.x = minWidth;

 
 

-      ::DrawMenuBar((HWND) parent->GetHWND());
+        processed = true;

     }
     }

-    wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_windowId);
-    event.SetEventObject( this );
-    return GetEventHandler()->ProcessEvent(event);
-  }
-  else
-  {
-    if (parent->m_currentChild == this)
-      parent->m_currentChild = NULL;
-
-    wxActivateEvent event(wxEVT_ACTIVATE, FALSE, m_windowId);
-    event.SetEventObject( this );
-    if ( GetEventHandler()->ProcessEvent(event) )
-        return TRUE;

 
 

-//    m_active = FALSE;
-    if (parent_menu)
+    if ( minHeight != wxDefaultCoord )

     {
     {

-      parent->m_parentFrameActive = TRUE;
-      HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);
-#ifdef __WIN32__
-      ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU,
-                    (WPARAM)parent_menu,
-                    (LPARAM)subMenu);
-#else
-      ::SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDISETMENU, 0,
-                  MAKELONG(parent_menu, subMenu));
-#endif
+        info->ptMinTrackSize.y = minHeight;

 
 

-      ::DrawMenuBar((HWND) parent->GetHWND());
+        processed = true;

     }
     }

-  }
-  bool flag = (activate != 0);
-  wxActivateEvent event(wxEVT_ACTIVATE, flag, m_windowId);
-  event.SetEventObject( this );
-  return GetEventHandler()->ProcessEvent(event);
+
+    return processed;
+}
+
+// ---------------------------------------------------------------------------
+// MDI specific message translation/preprocessing
+// ---------------------------------------------------------------------------
+
+WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
+{
+    return DefMDIChildProc(GetHwnd(),
+                           (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
+}
+
+bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
+{
+    // we must pass the parent frame to ::TranslateAccelerator(), otherwise it
+    // doesn't do its job correctly for MDI child menus
+    return MSWDoTranslateMessage(GetMDIParent(), msg);

 }
 
 }
 

+// ---------------------------------------------------------------------------
+// misc
+// ---------------------------------------------------------------------------
+

 void wxMDIChildFrame::MSWDestroyWindow()
 {
 void wxMDIChildFrame::MSWDestroyWindow()
 {

-  MSWDetachWindowMenu();
-  invalidHandle = (HWND) GetHWND();
+    wxMDIParentFrame * const parent = GetMDIParent();

 
 

-  wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+    // Must make sure this handle is invalidated (set to NULL) since all sorts
+    // of things could happen after the child client is destroyed, but before
+    // the wxFrame is destroyed.

 
 

-  // Must make sure this handle is invalidated (set to NULL)
-  // since all sorts of things could happen after the
-  // child client is destroyed, but before the wxFrame is
-  // destroyed.
+    HWND oldHandle = (HWND)GetHWND();
+    SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
+                (WPARAM)oldHandle, 0);

 
 

-  HWND oldHandle = (HWND)GetHWND();
-#ifdef __WIN32__
-  SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDIDESTROY, (WPARAM)oldHandle, (LPARAM)0);
-#else
-  SendMessage((HWND) parent->GetClientWindow()->GetHWND(), WM_MDIDESTROY, (HWND)oldHandle, 0);
-#endif
-  invalidHandle = 0;
+    if (parent->GetActiveChild() == NULL)
+        ResetWindowStyle(NULL);

 
 

-  if (m_hMenu)
-  {
-    ::DestroyMenu((HMENU) m_hMenu);
-    m_hMenu = 0;
-  }
-  m_hWnd = 0;
+    if (m_hMenu)
+    {
+        ::DestroyMenu((HMENU) m_hMenu);
+        m_hMenu = 0;
+    }
+    wxRemoveHandleAssociation(this);
+    m_hWnd = 0;

 }
 
 }
 

-// Change the client window's extended style so we don't
-// get a client edge style when a child is maximised (a double
-// border looks silly.)
+// Change the client window's extended style so we don't get a client edge
+// style when a child is maximised (a double border looks silly.)

 bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
 {
 bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
 {

-#if defined(__WIN95__)

     RECT *rect = (RECT *)vrect;
     RECT *rect = (RECT *)vrect;

-    wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
+    wxMDIParentFrame * const pFrameWnd = GetMDIParent();

     wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
     wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();

+

     if (!pChild || (pChild == this))
     {
     if (!pChild || (pChild == this))
     {

-        DWORD dwStyle = ::GetWindowLong((HWND) pFrameWnd->GetClientWindow()->GetHWND(), GWL_EXSTYLE);
-        DWORD dwThisStyle = ::GetWindowLong((HWND) GetHWND(), GWL_STYLE);
+        HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow());
+        DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE);
+
+        // we want to test whether there is a maximized child, so just set
+        // dwThisStyle to 0 if there is no child at all
+        DWORD dwThisStyle = pChild
+            ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0;

         DWORD dwNewStyle = dwStyle;
         DWORD dwNewStyle = dwStyle;

-        if (pChild != NULL && (dwThisStyle & WS_MAXIMIZE))
+        if ( dwThisStyle & WS_MAXIMIZE )

             dwNewStyle &= ~(WS_EX_CLIENTEDGE);
         else
             dwNewStyle |= WS_EX_CLIENTEDGE;
 
         if (dwStyle != dwNewStyle)
         {
             dwNewStyle &= ~(WS_EX_CLIENTEDGE);
         else
             dwNewStyle |= WS_EX_CLIENTEDGE;
 
         if (dwStyle != dwNewStyle)
         {

-            ::RedrawWindow((HWND) pFrameWnd->GetClientWindow()->GetHWND(), NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
-            ::SetWindowLong((HWND) pFrameWnd->GetClientWindow()->GetHWND(), GWL_EXSTYLE, dwNewStyle);
-            ::SetWindowPos((HWND) pFrameWnd->GetClientWindow()->GetHWND(), NULL, 0, 0, 0, 0,
-                SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOCOPYBITS);
+            // force update of everything
+            ::RedrawWindow(hwndClient, NULL, NULL,
+                           RDW_INVALIDATE | RDW_ALLCHILDREN);
+            ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle);
+            ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0,
+                           SWP_FRAMECHANGED | SWP_NOACTIVATE |
+                           SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
+                           SWP_NOCOPYBITS);

             if (rect)
             if (rect)

-                ::GetClientRect((HWND) pFrameWnd->GetClientWindow()->GetHWND(), rect);
-            return TRUE;
+                ::GetClientRect(hwndClient, rect);
+
+            return true;

         }
     }
         }
     }

-    return FALSE;
-#else
-    return FALSE;
-#endif
+
+    return false;

 }
 
 }
 

-bool wxMDIChildFrame::MSWOnWindowPosChanging(void *pos)
+// ===========================================================================
+// wxMDIClientWindow: the window of predefined (by Windows) class which
+// contains the child frames
+// ===========================================================================
+
+bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)

 {
 {

-    WINDOWPOS *lpPos = (WINDOWPOS *)pos;
-#if defined(__WIN95__)
-    if (!(lpPos->flags & SWP_NOSIZE))
+    m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
+
+    CLIENTCREATESTRUCT ccs;
+    m_windowStyle = style;
+    m_parent = parent;
+
+    ccs.hWindowMenu = GetMDIWindowMenu(parent);
+    ccs.idFirstChild = wxFIRST_MDI_CHILD;
+
+    DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD |
+                    WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
+
+    if ( style & wxHSCROLL )
+        msStyle |= WS_HSCROLL;
+    if ( style & wxVSCROLL )
+        msStyle |= WS_VSCROLL;
+
+    DWORD exStyle = WS_EX_CLIENTEDGE;
+
+    wxWindowCreationHook hook(this);
+    m_hWnd = (WXHWND)::CreateWindowEx
+                       (
+                        exStyle,
+                        wxT("MDICLIENT"),
+                        NULL,
+                        msStyle,
+                        0, 0, 0, 0,
+                        GetWinHwnd(parent),
+                        NULL,
+                        wxGetInstance(),
+                        (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
+    if ( !m_hWnd )

     {
     {

-        RECT rectClient;
-        DWORD dwExStyle = ::GetWindowLong((HWND) GetHWND(), GWL_EXSTYLE);
-        DWORD dwStyle = ::GetWindowLong((HWND) GetHWND(), GWL_STYLE);
-        if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
-        {
-            ::AdjustWindowRectEx(&rectClient, dwStyle, FALSE, dwExStyle);
-            lpPos->x = rectClient.left;
-            lpPos->y = rectClient.top;
-            lpPos->cx = rectClient.right - rectClient.left;
-            lpPos->cy = rectClient.bottom - rectClient.top;
-        }
-        wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
-        if (pFrameWnd && pFrameWnd->GetToolBar())
-        {
-            pFrameWnd->GetToolBar()->Refresh();
-        }
+        wxLogLastError(wxT("CreateWindowEx(MDI client)"));
+
+        return false;

     }
     }

-#endif

 
 

-    return FALSE;
+    SubclassWin(m_hWnd);
+
+    return true;

 }
 
 }
 

-// Client window
-wxMDIClientWindow::wxMDIClientWindow()
+// Explicitly call default scroll behaviour
+void wxMDIClientWindow::OnScroll(wxScrollEvent& event)

 {
 {

-    m_scrollX = 0;
-    m_scrollY = 0;
+    // Note: for client windows, the scroll position is not set in
+    // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
+    // scroll position we're at.
+    // This makes it hard to paint patterns or bitmaps in the background,
+    // and have the client area scrollable as well.
+
+    if ( event.GetOrientation() == wxHORIZONTAL )
+        m_scrollX = event.GetPosition(); // Always returns zero!
+    else
+        m_scrollY = event.GetPosition(); // Always returns zero!
+
+    event.Skip();

 }
 
 }
 

-wxMDIClientWindow::~wxMDIClientWindow()
+void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)

 {
 {

+    // Try to fix a problem whereby if you show an MDI child frame, then reposition the
+    // client area, you can end up with a non-refreshed portion in the client window
+    // (see OGL studio sample). So check if the position is changed and if so,
+    // redraw the MDI child frames.
+
+    const wxPoint oldPos = GetPosition();
+
+    wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE);
+
+    const wxPoint newPos = GetPosition();
+
+    if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
+    {
+        if (GetParent())
+        {
+            wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst();
+            while (node)
+            {
+                wxWindow *child = node->GetData();
+                if (wxDynamicCast(child, wxMDIChildFrame))
+                {
+                   ::RedrawWindow(GetHwndOf(child),
+                                  NULL,
+                                  NULL,
+                                  RDW_FRAME |
+                                  RDW_ALLCHILDREN |
+                                  RDW_INVALIDATE);
+                }
+                node = node->GetNext();
+            }
+        }
+    }

 }
 
 }
 

-bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
+void wxMDIChildFrame::OnIdle(wxIdleEvent& event)

 {
 {

-  m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
+    // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted
+    // in flicker e.g. when the frame contained controls with non-trivial
+    // layout. Since 2.5.3, the frame is created hidden as all other top level
+    // windows. In order to maintain backward compatibility, the frame is shown
+    // in OnIdle, unless Show(false) was called by the programmer before.
+    if ( m_needsInitialShow )
+    {
+        Show(true);
+    }

 
 

-  CLIENTCREATESTRUCT ccs;
-  m_windowStyle = style;
-  m_parent = parent;
+    // MDI child frames get their WM_SIZE when they're constructed but at this
+    // moment they don't have any children yet so all child windows will be
+    // positioned incorrectly when they are added later - to fix this, we
+    // generate an artificial size event here
+    if ( m_needsResize )
+    {
+        m_needsResize = false; // avoid any possibility of recursion

 
 

-  ccs.hWindowMenu = (HMENU) parent->GetWindowMenu();
-  ccs.idFirstChild = wxFIRST_MDI_CHILD;
+        SendSizeEvent();
+    }

 
 

-  DWORD msStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN ;
-  if ( parent->GetWindowStyleFlag() & wxHSCROLL )
-    msStyle |= WS_HSCROLL;
-  if ( parent->GetWindowStyleFlag() & wxVSCROLL )
-    msStyle |= WS_VSCROLL ;
+    event.Skip();
+}

 
 

-#if defined(__WIN95__)
-  DWORD exStyle = WS_EX_CLIENTEDGE;
-#else
-  DWORD exStyle = 0;
-#endif
+// ---------------------------------------------------------------------------
+// private helper functions
+// ---------------------------------------------------------------------------

 
 

-  wxWndHook = this;
-  m_hWnd = (WXHWND) ::CreateWindowEx(exStyle, "mdiclient", NULL,
-                msStyle, 0, 0, 0, 0, (HWND) parent->GetHWND(), NULL,
-                wxGetInstance(), (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
-  SubclassWin(m_hWnd);
-  wxWndHook = NULL;
+namespace
+{

 
 

-  return (m_hWnd != 0) ;
+void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
+{
+    if ( hmenuFrame || hmenuWindow )
+    {
+        if ( !::SendMessage(GetWinHwnd(win),
+                            WM_MDISETMENU,
+                            (WPARAM)hmenuFrame,
+                            (LPARAM)hmenuWindow) )
+        {
+            DWORD err = ::GetLastError();
+            if ( err )
+            {
+                wxLogApiError(wxT("SendMessage(WM_MDISETMENU)"), err);
+            }
+        }
+    }
+
+    // update menu bar of the parent window
+    wxWindow *parent = win->GetParent();
+    wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
+
+    ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
+
+    ::DrawMenuBar(GetWinHwnd(parent));

 }
 
 }
 

-// Window procedure: here for debugging purposes
-long wxMDIClientWindow::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU menuWin)

 {
 {

-    return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
-//    return MSWDefWindowProc(nMsg, wParam, lParam);
+    HMENU hmenu = (HMENU)hMenu;
+
+    if ( menuWin )
+    {
+        // Try to insert Window menu in front of Help, otherwise append it.
+        int N = GetMenuItemCount(hmenu);
+        bool inserted = false;
+        for ( int i = 0; i < N; i++ )
+        {
+            wxChar buf[256];
+            if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
+            {
+                wxLogLastError(wxT("GetMenuString"));
+
+                continue;
+            }
+
+            const wxString label = wxStripMenuCodes(buf);
+            if ( label == wxGetStockLabel(wxID_HELP, wxSTOCK_NOFLAGS) )
+            {
+                inserted = true;
+                ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
+                             (UINT_PTR)menuWin,
+                             wxString(wxGetTranslation(WINDOW_MENU_LABEL)).t_str());
+                break;
+            }
+        }
+
+        if ( !inserted )
+        {
+            ::AppendMenu(hmenu, MF_POPUP,
+                         (UINT_PTR)menuWin,
+                         wxString(wxGetTranslation(WINDOW_MENU_LABEL)).t_str());
+        }
+    }
+
+    MDISetMenu(win, hmenu, menuWin);

 }
 
 }
 

-long wxMDIClientWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu)

 {
 {

-    if ( MSWGetOldWndProc() != 0)
-          return ::CallWindowProc(CASTWNDPROC MSWGetOldWndProc(), (HWND) GetHWND(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
-    else
-        return ::DefWindowProc((HWND) m_hWnd, (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
+    HMENU hmenu = (HMENU)hMenu;
+
+    if ( hmenu )
+    {
+        wxChar buf[1024];
+
+        int N = ::GetMenuItemCount(hmenu);
+        for ( int i = 0; i < N; i++ )
+        {
+            if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
+            {
+                // Ignore successful read of menu string with length 0 which
+                // occurs, for example, for a maximized MDI child system menu
+                if ( ::GetLastError() != 0 )
+                {
+                    wxLogLastError(wxT("GetMenuString"));
+                }
+
+                continue;
+            }
+
+            if ( wxStrcmp(buf, wxGetTranslation(WINDOW_MENU_LABEL)) == 0 )
+            {
+                if ( !::RemoveMenu(hmenu, i, MF_BYPOSITION) )
+                {
+                    wxLogLastError(wxT("RemoveMenu"));
+                }
+
+                break;
+            }
+        }
+    }
+
+    if ( win )
+    {
+        // we don't change the windows menu, but we update the main one
+        MDISetMenu(win, hmenu, NULL);
+    }

 }
 
 }
 

-// Explicitly call default scroll behaviour
-void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
+void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
+                              WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)

 {
 {

-    // Note: for client windows, the scroll position is not set in
-    // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
-    // scroll position we're at.
-    // This makes it hard to paint patterns or bitmaps in the background,
-    // and have the client area scrollable as well.
+    *activate = true;
+    *hwndAct = (WXHWND)lParam;
+    *hwndDeact = (WXHWND)wParam;
+}

 
 

-    if ( event.GetOrientation() == wxHORIZONTAL )
-        m_scrollX = event.GetPosition(); // Always returns zero!
-    else
-        m_scrollY = event.GetPosition(); // Always returns zero!
+} // anonymous namespace

 
 

-    Default();
-}
+#endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)