fixed setfocus() flicker in listctrl

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

diff --git a/src/msw/mdi.cpp b/src/msw/mdi.cpp
index dfb324db7fd71e386fbbf4e34399be4deccc6c1e..fe708c0538acae5731ee83ecbc7fb583a52b249f 100644 (file)
--- a/src/msw/mdi.cpp
+++ b/src/msw/mdi.cpp
@@ -6,96 +6,157 @@
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart and Markus Holzem

-// Licence:    wxWindows license
+// Licence:     wxWindows license

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

+// ===========================================================================
+// declarations
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
+

 #ifdef __GNUG__
 #ifdef __GNUG__

-#pragma implementation "mdi.h"
+    #pragma implementation "mdi.h"

 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 #endif
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP

-#include "wx/setup.h"
-#include "wx/frame.h"
-#include "wx/menu.h"
-#include "wx/app.h"
-#include "wx/utils.h"
-#include "wx/dialog.h"
-#include "wx/statusbr.h"
-#include "wx/settings.h"
+    #include "wx/setup.h"
+    #include "wx/frame.h"
+    #include "wx/menu.h"
+    #include "wx/app.h"
+    #include "wx/utils.h"
+    #include "wx/dialog.h"
+    #if wxUSE_STATUSBAR
+        #include "wx/statusbr.h"
+    #endif
+    #include "wx/settings.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"

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

-#if USE_NATIVE_STATUSBAR
-#include <wx/msw/statbr95.h>
+#if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR
+    #include "wx/msw/statbr95.h"

 #endif
 
 #endif
 

+#if wxUSE_TOOLBAR
+    #include "wx/toolbar.h"
+#endif // wxUSE_TOOLBAR
+

 #include <string.h>
 
 #include <string.h>
 

-extern wxList wxModelessWindows;
+// ---------------------------------------------------------------------------
+// global variables
+// ---------------------------------------------------------------------------
+
+extern wxWindowList wxModelessWindows;      // from dialog.cpp
+extern wxMenu *wxCurrentPopupMenu;

 
 

-#define IDM_WINDOWTILE  4001
-#define IDM_WINDOWCASCADE 4002
-#define IDM_WINDOWICONS 4003
-#define IDM_WINDOWNEXT 4004
-// This range gives a maximum of 500
-// MDI children. Should be enough :-)
-#define wxFIRST_MDI_CHILD 4100
-#define wxLAST_MDI_CHILD 4600
+extern wxChar wxMDIFrameClassName[];
+extern wxChar wxMDIChildFrameClassName[];
+extern wxWindow *wxWndHook;                 // from window.cpp
+
+extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
+
+static HWND invalidHandle = 0;
+
+// ---------------------------------------------------------------------------
+// constants
+// ---------------------------------------------------------------------------
+
+static const int IDM_WINDOWTILE  = 4001;
+static const int IDM_WINDOWTILEHOR  = 4001;
+static const int IDM_WINDOWCASCADE = 4002;
+static const int IDM_WINDOWICONS = 4003;
+static const int IDM_WINDOWNEXT = 4004;
+static const int IDM_WINDOWTILEVERT = 4005;
+
+// 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;

 
 // Status border dimensions
 
 // Status border dimensions

-#define         wxTHICK_LINE_BORDER 3
-#define         wxTHICK_LINE_WIDTH  1
+static const int wxTHICK_LINE_BORDER = 3;
+static const int wxTHICK_LINE_WIDTH  = 1;

 
 

-extern char wxMDIFrameClassName[];
-extern char wxMDIChildFrameClassName[];
-extern wxWindow *wxWndHook;
+// ---------------------------------------------------------------------------
+// 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)
+static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow);
+
+// insert the window menu (subMenu) into menu just before "Help" submenu or at
+// the very end if not found
+static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu);
+
+// is this an id of an MDI child?
+inline bool IsMdiCommandId(int id)
+{
+    return (id >= wxFIRST_MDI_CHILD) && (id <= wxLAST_MDI_CHILD);
+}
+
+static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
+                              WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact);
+
+// ===========================================================================
+// implementation
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// wxWin macros
+// ---------------------------------------------------------------------------

 
 #if !USE_SHARED_LIBRARY
 
 #if !USE_SHARED_LIBRARY

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

 
 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
 
 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)

-  EVT_SIZE(wxMDIParentFrame::OnSize)
-  EVT_ACTIVATE(wxMDIParentFrame::OnActivate)
-  EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
+    EVT_SIZE(wxMDIParentFrame::OnSize)
+    EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)

 END_EVENT_TABLE()
 
 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
 END_EVENT_TABLE()
 
 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)

-  EVT_SCROLL(wxMDIClientWindow::OnScroll)
+    EVT_SCROLL(wxMDIClientWindow::OnScroll)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

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

 
 

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

 {
     m_clientWindow = NULL;
     m_currentChild = NULL;
     m_windowMenu = 0;
     m_parentFrameActive = TRUE;
 {
     m_clientWindow = NULL;
     m_currentChild = NULL;
     m_windowMenu = 0;
     m_parentFrameActive = TRUE;

-       m_frameToolBar = NULL ;

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

-           wxWindowID id,
-           const wxString& title,
-           const wxPoint& pos,
-           const wxSize& size,
-           long style,
-           const wxString& name)
+                              wxWindowID id,
+                              const wxString& title,
+                              const wxPoint& pos,
+                              const wxSize& size,
+                              long style,
+                              const wxString& name)

 {
   m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON);
 
 {
   m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON);
 

-  m_frameToolBar = NULL ;

   m_clientWindow = NULL;
   m_currentChild = NULL;
   m_windowMenu = 0;
   m_clientWindow = NULL;
   m_currentChild = NULL;
   m_windowMenu = 0;


@@ -119,13 +180,9 @@ bool wxMDIParentFrame::Create(wxWindow *parent,
   int width = size.x;
   int height = size.y;
 
   int width = size.x;
   int height = size.y;
 

-  m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), "wxWindowMenu");
+  m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), wxT("wxWindowMenu"));

 
 

-#if WXDEBUG > 1
-  wxDebugMsg("Loaded m_windowMenu %d\n", m_windowMenu);
-#endif
-
-  DWORD msflags = WS_OVERLAPPED ;
+  DWORD msflags = WS_OVERLAPPED;

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


@@ -141,10 +198,8 @@ bool wxMDIParentFrame::Create(wxWindow *parent,
   if (style & wxCAPTION)
     msflags |= WS_CAPTION;
 
   if (style & wxCAPTION)
     msflags |= WS_CAPTION;
 

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

 
   wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
          msflags);
 
   wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
          msflags);


@@ -154,217 +209,59 @@ bool wxMDIParentFrame::Create(wxWindow *parent,
   return TRUE;
 }
 
   return TRUE;
 }
 

-wxMDIParentFrame::~wxMDIParentFrame(void)
+wxMDIParentFrame::~wxMDIParentFrame()

 {
 {

-  DestroyChildren();
-
-  DestroyMenu((HMENU) m_windowMenu); // Destroy dummy "Window" menu
-  m_windowMenu = 0;
-
-  if (m_clientWindow->MSWGetOldWndProc())
-       m_clientWindow->UnsubclassWin();
-
-  m_clientWindow->m_hWnd = 0;
-  delete m_clientWindow;
-}
+    DestroyChildren();

 
 

-// Get size *available for subwindows* i.e. excluding menu bar.
-void wxMDIParentFrame::GetClientSize(int *x, int *y) const
-{
-  RECT rect;
-  GetClientRect((HWND) GetHWND(), &rect);
+    ::DestroyMenu((HMENU)m_windowMenu);
+    m_windowMenu = 0;

 
 

-  int cwidth = rect.right;
-  int cheight = rect.bottom;
-/*
-  if (m_frameToolBar)
-  {
-    int tw, th;
-    m_frameToolBar->GetSize(&tw, &th);
-    cheight -= th;
-  }
-*/
-  if ( GetStatusBar() )
-  {
-       int sw, sh;
-       GetStatusBar()->GetSize(&sw, &sh);
-       cheight -= sh;
-  }
+    if ( m_clientWindow )
+    {
+        if ( m_clientWindow->MSWGetOldWndProc() )
+            m_clientWindow->UnsubclassWin();

 
 

-  *x = cwidth;
-  *y = cheight;
+        m_clientWindow->SetHWND(0);
+        delete m_clientWindow;
+    }

 }
 
 }
 

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

 {
 {

-  if (!menu_bar)
-  {
-    m_frameMenuBar = NULL;
-    return;
-  }
-  
-  if (menu_bar->m_menuBarFrame)
-        return;
+    HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);

 
 

-  int i;
-  HMENU menu = CreateMenu();
-
-  for (i = 0; i < menu_bar->m_menuCount; i ++)
-  {
-    HMENU popup = (HMENU)menu_bar->m_menus[i]->m_hMenu;
-    //
-    // After looking Bounds Checker result, it seems that all
-    // menus must be individually destroyed. So, don't reset m_hMenu,
-    // to  allow ~wxMenu to do the job.
-    //
-    menu_bar->m_menus[i]->m_savehMenu = (WXHMENU) popup;
-    // Uncommenting for the moment... JACS
-    menu_bar->m_menus[i]->m_hMenu = (WXHMENU) NULL;
-    AppendMenu(menu, MF_POPUP | MF_STRING, (UINT)popup, menu_bar->m_titles[i]);
-  }
-
-  menu_bar->m_hMenu = (WXHMENU)menu;
-  if (m_frameMenuBar)
-    delete m_frameMenuBar;
-
-  this->m_hMenu = (WXHMENU) menu;
-
-  // MDI parent-specific code follows
-
-  HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);
-
-  // Try to insert Window menu in front of Help, otherwise append it.
-  int N = GetMenuItemCount(menu);
-  bool success = FALSE;
-  for (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());
+    m_parentFrameActive = TRUE;

 
 

-  m_frameMenuBar = menu_bar;
-  menu_bar->m_menuBarFrame = this;
+    InsertWindowMenu(GetClientWindow(), m_hMenu, subMenu);

 }
 
 void wxMDIParentFrame::OnSize(wxSizeEvent& event)
 {
 }
 
 void wxMDIParentFrame::OnSize(wxSizeEvent& event)
 {

-#if USE_CONSTRAINTS
-    if (GetAutoLayout())
-      Layout();
-#endif
-    int x = 0;
-    int y = 0;
-    int width, height;
-    GetClientSize(&width, &height);
-    if ( GetToolBar() )
-    {
-        int wt, ht;
-        GetToolBar()->GetSize(&wt, &ht);
-        height -= ht;
-        y += ht;
-        GetToolBar()->SetSize(0, 0, width, ht);
-    }
-

     if ( GetClientWindow() )
     if ( GetClientWindow() )

-        GetClientWindow()->SetSize(x, y, width, height);
-
-  // forward WM_SIZE to status bar control
-#if USE_NATIVE_STATUSBAR
-  if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
-    ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event);
-#endif
-}
-
-void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
-{
-       // Do nothing
-}
-
-#if WXWIN_COMPATIBILITY
-/*
-void wxMDIParentFrame::OldOnSize(int x, int y)
-{
-#if WXWIN_COMPATIBILITY == 1
-  wxSizeEvent event(wxSize(x, y), m_windowId);
-  event.SetEventObject( this );
-  GetEventHandler()->ProcessEvent(event);
-#else
-
-#if USE_CONSTRAINTS
-  if (GetAutoLayout())
-    Layout();
-#endif
-  int x = 0;
-  int y = 0;
-  int width, height;
-  GetClientSize(&width, &height);
-  if ( GetToolBar() )
-  {
-      int wt, ht;
-      GetToolBar()->GetSize(&wt, &ht);
-      height -= ht;
-      y += ht;
-  }
-
-  if ( GetClientWindow() )
-      GetClientWindow()->SetSize(x, y, width, height);
-
-#endif
-}
+    {
+        int width, height;
+        GetClientSize(&width, &height);

 
 

-// Default activation behaviour - nothing.
-// Default activation behaviour - override dedault wxFrame behaviour
-void wxMDIParentFrame::OldOnActivate(bool flag)
-{
-#if WXWIN_COMPATIBILITY == 1
-  wxActivateEvent event(wxEVT_ACTIVATE, flag, m_windowId);
-  event.SetEventObject( this );
-  GetEventHandler()->ProcessEvent(event);
-#else
-#endif
+        GetClientWindow()->SetSize(0, 0, width, height);
+    }

 }
 }

-*/
-
-#endif

 
 // Returns the active MDI child window
 
 // Returns the active MDI child window

-wxMDIChildFrame *wxMDIParentFrame::GetActiveChild(void) const
+wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const

 {
 {

-//  HWND hWnd = (HWND)LOWORD(SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDIGETACTIVE, 0, 0L));
-  HWND hWnd = (HWND)SendMessage((HWND) GetClientWindow()->GetHWND(), WM_MDIGETACTIVE, 0, 0L);
-  if (hWnd == 0)
-    return NULL;
-  else
-    return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd);
+    HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
+                                    WM_MDIGETACTIVE, 0, 0L);
+    if ( hWnd == 0 )
+        return NULL;
+    else
+        return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd);

 }
 
 }
 

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

 {
 {

-       return new wxMDIClientWindow ;
+    return new wxMDIClientWindow;

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


@@ -375,274 +272,307 @@ void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
         m_clientWindow->SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
         m_clientWindow->Refresh();
     }
         m_clientWindow->SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
         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();

 }
 
 }
 

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

 // MDI operations
 // MDI operations

-void wxMDIParentFrame::Cascade(void)
+// ---------------------------------------------------------------------------
+
+void wxMDIParentFrame::Cascade()

 {
 {

-    ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDICASCADE, 0, 0);
+    ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);

 }
 
 }
 

-void wxMDIParentFrame::Tile(void)
+// TODO: add a direction argument (hor/vert)
+void wxMDIParentFrame::Tile()

 {
 {

-    ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDITILE, MDITILE_HORIZONTAL, 0);
+    ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0);

 }
 
 }
 

-void wxMDIParentFrame::ArrangeIcons(void)
+void wxMDIParentFrame::ArrangeIcons()

 {
 {

-    ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIICONARRANGE, 0, 0);
+    ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0);

 }
 
 }
 

-void wxMDIParentFrame::ActivateNext(void)
+void wxMDIParentFrame::ActivateNext()

 {
 {

-    ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDINEXT, 0, 0);
+    ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0);

 }
 
 }
 

-void wxMDIParentFrame::ActivatePrevious(void)
+void wxMDIParentFrame::ActivatePrevious()

 {
 {

-    ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDINEXT, 0, 1);
+    ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);

 }
 
 }
 

+// ---------------------------------------------------------------------------
+// the MDI parent frame window proc
+// ---------------------------------------------------------------------------

 
 

-/*
-// Returns a style for the client window - usually 0
-// or, for example, wxHSCROLL | wxVSCROLL
-long wxMDIParentFrame::GetClientStyle(void) const
+long wxMDIParentFrame::MSWWindowProc(WXUINT message,
+                                     WXWPARAM wParam,
+                                     WXLPARAM lParam)

 {
 {

-       return wxHSCROLL | wxVSCROLL ;
-}
-*/
+    long rc = 0;
+    bool processed = FALSE;

 
 

-bool wxMDIParentFrame::MSWOnDestroy(void)
-{
-  return FALSE;
-}
+    switch ( message )
+    {
+        case WM_ACTIVATE:
+            {
+                WXWORD state, minimized;
+                WXHWND hwnd;
+                UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);

 
 

-void wxMDIParentFrame::MSWOnCreate(WXLPCREATESTRUCT WXUNUSED(cs))
-{
-       m_clientWindow = new wxMDIClientWindow;
-       // Uses own style for client style
-       m_clientWindow->CreateClient(this, GetWindowStyleFlag());
-}
+                processed = HandleActivate(state, minimized != 0, hwnd);
+            }
+            break;

 
 

-void wxMDIParentFrame::MSWOnSize(int x, int y, WXUINT id)
-{
-  switch (id)
-  {
-    case SIZEFULLSCREEN:
-    case SIZENORMAL:
-      m_iconized = FALSE;
-    break;
-    case SIZEICONIC:
-      m_iconized = TRUE;
-    break;
-  }
+        case WM_COMMAND:
+            {
+                WXWORD id, cmd;
+                WXHWND hwnd;
+                UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);

 
 

- if (!m_iconized)
- {
-  // forward WM_SIZE to status bar control
-#if USE_NATIVE_STATUSBAR
-  if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
-  {
-    wxSizeEvent event(wxSize(x, y), m_frameStatusBar->GetId());
-    event.SetEventObject( m_frameStatusBar );
+                (void)HandleCommand(id, cmd, hwnd);

 
 

-    ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event);
-  }
-#endif
+                // even if the frame didn't process it, there is no need to try it
+                // once again (i.e. call wxFrame::HandleCommand()) - we just dud it,
+                // so pretend we processed the message anyhow
+                processed = TRUE;
+            }

 
 

-       PositionStatusBar();
+            // always pass this message DefFrameProc(), otherwise MDI menu
+            // commands (and sys commands - more surprizingly!) won't work
+            MSWDefWindowProc(message, wParam, lParam);
+            break;

 
 

-    wxSizeEvent event(wxSize(x, y), m_windowId);
-    event.SetEventObject( this );
-    if (!GetEventHandler()->ProcessEvent(event))
-        Default();
-  }
+        case WM_CREATE:
+            m_clientWindow = OnCreateClient();
+            // Uses own style for client style
+            if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
+            {
+                wxLogMessage(_("Failed to create MDI parent frame."));
+
+                rc = -1;
+            }
+
+            processed = TRUE;
+            break;
+
+        case WM_ERASEBKGND:
+            processed = TRUE;
+
+            // we erase background ourselves
+            rc = TRUE;
+            break;
+
+        case WM_MENUSELECT:
+            {
+                WXWORD item, flags;
+                WXHMENU hmenu;
+                UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
+
+                if ( m_parentFrameActive )
+                {
+                    processed = HandleMenuSelect(item, flags, hmenu);
+                }
+                else if (m_currentChild)
+                {
+                    processed = m_currentChild->
+                        HandleMenuSelect(item, flags, hmenu);
+                }
+            }
+            break;
+
+        case WM_SIZE:
+            // as we don't (usually) resize the MDI client to exactly fit the
+            // client area (we put it below the toolbar, above statusbar &c),
+            // we should not pass this one to DefFrameProc
+            break;
+    }
+
+    if ( !processed )
+        rc = wxFrame::MSWWindowProc(message, wParam, lParam);
+
+    return rc;

 }
 
 }
 

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

 {
 {

-       wxWindow::MSWOnActivate(state, minimized, activate);
+    bool processed = FALSE;
+
+    if ( wxWindow::HandleActivate(state, minimized, activate) )
+    {
+        // already processed
+        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) && ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)))
-       {
+    if ( (m_currentChild != NULL) &&
+         ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
+    {

         wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId());
         event.SetEventObject( m_currentChild );
         wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId());
         event.SetEventObject( m_currentChild );

-        m_currentChild->GetEventHandler()->ProcessEvent(event);
+        if ( m_currentChild->GetEventHandler()->ProcessEvent(event) )
+            processed = TRUE;

     }
     }

-    return 0;
+
+    return processed;

 }
 
 }
 

-bool wxMDIParentFrame::MSWOnCommand(WXWORD id, WXWORD cmd, WXHWND control)
+bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)

 {
 {

-  if (cmd == 0)
-  {

     // In case it's e.g. a toolbar.
     // In case it's e.g. a toolbar.

-    wxWindow *win = wxFindWinFromHandle(control);
-    if (win)
-      return win->MSWCommand(cmd, id);
-
-    switch (id)
+    if ( hwnd )

     {
     {

-      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)
+        wxWindow *win = wxFindWinFromHandle(hwnd);
+        if ( win )
+            return win->MSWCommand(cmd, id);
+    }
+
+    // is it one of standard MDI commands?
+    WXWPARAM wParam = 0;
+    int msg;
+    switch ( id )

     {
     {

-#if WXDEBUG > 1
-      wxDebugMsg("wxMDIFrame::OnCommand %d: system command: calling default window proc\n", GetHWND());
-#endif
-      return FALSE; // Get WndProc to call default proc
+        case IDM_WINDOWCASCADE:
+            msg = WM_MDICASCADE;
+            wParam = MDITILE_SKIPDISABLED;
+            break;
+
+        case IDM_WINDOWTILEHOR:
+            wParam |= MDITILE_HORIZONTAL;
+            // fall through
+
+        case IDM_WINDOWTILEVERT:
+            if ( !wParam )
+                wParam = MDITILE_VERTICAL;
+            msg = WM_MDITILE;
+            wParam |= MDITILE_SKIPDISABLED;
+            break;
+
+        case IDM_WINDOWICONS:
+            msg = WM_MDIICONARRANGE;
+            break;
+
+        case IDM_WINDOWNEXT:
+            msg = WM_MDINEXT;
+            break;
+
+        default:
+            msg = 0;

     }
     }

-    
-    if (m_parentFrameActive && (id < wxFIRST_MDI_CHILD || id > wxLAST_MDI_CHILD))
+
+    if ( msg )

     {
     {

-      ProcessCommand(id);
-      return TRUE;
+        ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, 0);
+
+        return TRUE;

     }
     }

-    else if (m_currentChild && (id < wxFIRST_MDI_CHILD || id > wxLAST_MDI_CHILD))
+
+    // FIXME VZ: what does this test do??
+    if (id >= 0xF000)

     {
     {

-#if WXDEBUG > 1
-      wxDebugMsg("wxMDIFrame::MSWOnCommand %d: calling child OnCommand\n", GetHWND());
-#endif
-      return m_currentChild->MSWOnCommand(id, cmd, control);
+        return FALSE; // Get WndProc to call default proc

     }
     }

-  }
-  if (id >= wxFIRST_MDI_CHILD && id <= wxLAST_MDI_CHILD)
-  {
-    wxNode* node = GetChildren()->First();
-    while (node)
+
+    if ( IsMdiCommandId(id) )

     {
     {

-        wxWindow* child = (wxWindow*) node->Data();
-        if (child->GetHWND())
+        wxWindowList::Node* node = GetChildren().GetFirst();
+        while ( node )

         {
         {

-#ifdef __WIN32__
-            long childId = GetWindowLong((HWND) child->GetHWND(), GWL_ID);
-#else
-            long childId = GetWindowWord((HWND) child->GetHWND(), GWW_ID);
-#endif
-            if (childId == id)
+            wxWindow* child = node->GetData();
+            if ( child->GetHWND() )

             {
             {

-                ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) child->GetHWND(), 0);
-                return TRUE;
+                long childId = wxGetWindowId(child->GetHWND());
+                if (childId == (long)id)
+                {
+                    ::SendMessage( GetWinHwnd(GetClientWindow()),
+                                   WM_MDIACTIVATE,
+                                   (WPARAM)child->GetHWND(), 0);
+                    return TRUE;
+                }

             }
             }

+            node = node->GetNext();

         }
         }

-        node = node->Next();

     }
     }

-/*
-    wxWindow* child = FindItem(id);
-    if (child)
+    else if ( m_parentFrameActive )

     {
     {

-        ::SendMessage( (HWND) GetClientWindow()->GetHWND(), WM_MDIACTIVATE, (WPARAM) (HWND) child->GetHWND(), 0);
-        return TRUE;
+        return ProcessCommand(id);

     }
     }

-*/
-  }
-
-  return FALSE;
-}
-
-void wxMDIParentFrame::MSWOnMenuHighlight(WXWORD nItem, WXWORD nFlags, WXHMENU hSysMenu)
-{
-  if (m_parentFrameActive)
-  {
-    if (nFlags == 0xFFFF && hSysMenu == (WXHMENU) NULL)
+    else if ( m_currentChild )

     {
     {

-        wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, -1);
-        event.SetEventObject( this );
-        GetEventHandler()->ProcessEvent(event);
+        return m_currentChild->HandleCommand(id, cmd, hwnd);

     }
     }

-    else if (nFlags != MF_SEPARATOR)
+    else

     {
     {

-        wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, nItem);
-        event.SetEventObject( this );
-        GetEventHandler()->ProcessEvent(event);
+        // this shouldn't happen because it means that our messages are being
+        // lost (they're not sent to the parent frame nor to the children)
+        wxFAIL_MSG(wxT("MDI parent frame is not active, "
+                      "yet there is no active MDI child?"));

     }
     }

-  }
-  else if (m_currentChild)
-  {
-    m_currentChild->MSWOnMenuHighlight(nItem, nFlags, hSysMenu);
-  }
+
+    return FALSE;

 }
 
 }
 

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

 {
 {

-       WXHWND clientWnd;
-       if ( GetClientWindow() )
-           clientWnd = GetClientWindow()->GetHWND();
-       else
-               clientWnd = 0;
+    WXHWND clientWnd;
+    if ( GetClientWindow() )
+        clientWnd = GetClientWindow()->GetHWND();
+    else
+        clientWnd = 0;

 
 

-  return DefFrameProc((HWND) GetHWND(), (HWND) clientWnd, message, wParam, lParam);
+    return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);

 }
 
 }
 

-bool wxMDIParentFrame::MSWProcessMessage(WXMSG* msg)
+bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)

 {
 {

-  MSG *pMsg = (MSG *)msg;
+    MSG *pMsg = (MSG *)msg;

 
 

-  if ((m_currentChild != (wxWindow *)NULL) && (m_currentChild->GetHWND() != (WXHWND) NULL) && m_currentChild->MSWProcessMessage(msg))
-     return TRUE;
-       
-  if (m_acceleratorTable != (WXHANDLE) NULL &&
-          ::TranslateAccelerator((HWND) GetHWND(), (HANDLE) m_acceleratorTable, pMsg))
-    return TRUE;
+    if ( m_currentChild && m_currentChild->GetHWND() &&
+         m_currentChild->MSWTranslateMessage(msg) )
+    {
+        return TRUE;
+    }

 
 

-  if (pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN)
-  {
-    if (::TranslateMDISysAccel((HWND) GetClientWindow()->GetHWND(), pMsg))
-      return TRUE;
-  }
+    if ( m_acceleratorTable.Translate(this, msg) )
+    {
+        return TRUE;
+    }

 
 

-  return FALSE;
-}
+    if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
+    {
+        if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
+            return TRUE;
+    }

 
 

-bool wxMDIParentFrame::MSWOnEraseBkgnd(WXHDC WXUNUSED(pDC))
-{
-  return TRUE;
+    return FALSE;

 }
 
 }
 

-extern wxWindow *wxWndHook;
-extern wxList *wxWinHandleList;
+// ===========================================================================
+// wxMDIChildFrame
+// ===========================================================================

 
 

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

 {
 {

-//     m_active = FALSE;

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

-           wxWindowID id,
-           const wxString& title,
-           const wxPoint& pos,
-           const wxSize& size,
-           long style,
-           const wxString& name)
+                             wxWindowID id,
+                             const wxString& title,
+                             const wxPoint& pos,
+                             const wxSize& size,
+                             long style,
+                             const wxString& name)

 {
 {

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

 
   SetName(name);
 
 
   SetName(name);
 


@@ -651,7 +581,10 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
   else
     m_windowId = (int)NewControlId();
 
   else
     m_windowId = (int)NewControlId();
 

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

 
   wxWndHook = this;
 
 
   wxWndHook = this;
 


@@ -661,23 +594,31 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
   int height = size.y;
 
   MDICREATESTRUCT mcs;
   int height = size.y;
 
   MDICREATESTRUCT mcs;

-       
+

   mcs.szClass = wxMDIChildFrameClassName;
   mcs.szTitle = title;
   mcs.hOwner = wxGetInstance();
   mcs.szClass = wxMDIChildFrameClassName;
   mcs.szTitle = title;
   mcs.hOwner = wxGetInstance();

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

 
 

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

 
 

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

 
 

-  if (height > -1) mcs.cy = height;
-  else mcs.cy = CW_USEDEFAULT;
+  if (height > -1)
+      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)
   if (style & wxMINIMIZE_BOX)
     msflags |= WS_MINIMIZEBOX;
   if (style & wxMAXIMIZE_BOX)


@@ -697,40 +638,36 @@ bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 
   mcs.lParam = 0;
 
 
   mcs.lParam = 0;
 

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

 
   //handle = (HWND)LOWORD(Return);
   // Must be the DWORRD for WIN32. And in 16 bits, HIWORD=0 (says Microsoft)
   m_hWnd = (WXHWND)Return;
 
 
   //handle = (HWND)LOWORD(Return);
   // Must be the DWORRD for WIN32. And in 16 bits, HIWORD=0 (says Microsoft)
   m_hWnd = (WXHWND)Return;
 

-  // This gets reassigned so can't be stored
-//  m_windowId = GetWindowLong((HWND) m_hWnd, GWL_ID);
-

   wxWndHook = NULL;
   wxWndHook = NULL;

-  wxWinHandleList->Append((long)GetHWND(), this);
+  wxAssociateWinWithHandle((HWND) GetHWND(), this);

 
 

-  SetWindowLong((HWND) GetHWND(), 0, (long)this);
+  // VZ: what's this? an act of piracy?
+  //SetWindowLong(GetHwnd(), 0, (long)this);

 
   wxModelessWindows.Append(this);
   return TRUE;
 }
 
 
   wxModelessWindows.Append(this);
   return TRUE;
 }
 

-wxMDIChildFrame::~wxMDIChildFrame(void)
+wxMDIChildFrame::~wxMDIChildFrame()

 {
 {

-       MSWDestroyWindow();
-
-    ResetWindowStyle(NULL);
+    MSWDestroyWindow();

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

-void wxMDIChildFrame::SetClientSize(int width, int height)
+void wxMDIChildFrame::DoSetClientSize(int width, int height)

 {
 {

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

 
   RECT rect;
 
   RECT rect;

-  GetClientRect(hWnd, &rect);
+  ::GetClientRect(hWnd, &rect);

 
   RECT rect2;
   GetWindowRect(hWnd, &rect2);
 
   RECT rect2;
   GetWindowRect(hWnd, &rect2);


@@ -743,8 +680,8 @@ void wxMDIChildFrame::SetClientSize(int width, int height)
 
   if (GetStatusBar())
   {
 
   if (GetStatusBar())
   {

-       int sx, sy;
-       GetStatusBar()->GetSize(&sx, &sy);
+    int sx, sy;
+    GetStatusBar()->GetSize(&sx, &sy);

     actual_height += sy;
   }
 
     actual_height += sy;
   }
 


@@ -764,10 +701,10 @@ void wxMDIChildFrame::SetClientSize(int width, int height)
   GetEventHandler()->ProcessEvent(event);
 }
 
   GetEventHandler()->ProcessEvent(event);
 }
 

-void wxMDIChildFrame::GetPosition(int *x, int *y) const
+void wxMDIChildFrame::DoGetPosition(int *x, int *y) const

 {
   RECT rect;
 {
   RECT rect;

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

   POINT point;
   point.x = rect.left;
   point.y = rect.top;
   POINT point;
   point.x = rect.left;
   point.y = rect.top;


@@ -781,424 +718,412 @@ void wxMDIChildFrame::GetPosition(int *x, int *y) const
   *y = point.y;
 }
 
   *y = point.y;
 }
 

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

 {
 {

-  if (!menu_bar)
-  {
-    m_frameMenuBar = NULL;
-    return;
-  }
-  
-  if (menu_bar->m_menuBarFrame)
-        return;
-
-  int i;
-  HMENU menu = CreateMenu();
-
-  for (i = 0; i < menu_bar->m_menuCount; i ++)
-  {
-    HMENU popup = (HMENU)menu_bar->m_menus[i]->m_hMenu;
-    //
-    // After looking Bounds Checker result, it seems that all
-    // menus must be individually destroyed. So, don't reset m_hMenu,
-    // to  allow ~wxMenu to do the job.
-    //
-    menu_bar->m_menus[i]->m_savehMenu = (WXHMENU) popup;
-    // Uncommenting for the moment... JACS
-    menu_bar->m_menus[i]->m_hMenu = 0;
-    ::AppendMenu((HMENU) menu, MF_POPUP | MF_STRING, (UINT)popup, menu_bar->m_titles[i]);
-  }
-
-  menu_bar->m_hMenu = (WXHMENU)menu;
-  if (m_frameMenuBar)
-    delete m_frameMenuBar;
-
-  this->m_hMenu = (WXHMENU) menu;
+    wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();

 
 

-   wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+    HMENU subMenu = GetSubMenu((HMENU)parent->GetWindowMenu(), 0);

 
 

-   parent->m_parentFrameActive = FALSE;
-   HMENU subMenu = GetSubMenu((HWND) parent->GetWindowMenu(), 0);
+    InsertWindowMenu(parent->GetClientWindow(), m_hMenu, subMenu);

 
 

-   // Try to insert Window menu in front of Help, otherwise append it.
-   int N = GetMenuItemCount(menu);
-   bool success = FALSE;
-   for (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
-
-  DrawMenuBar((HWND) parent->GetHWND());
-  m_frameMenuBar = menu_bar;
-  menu_bar->m_menuBarFrame = this;
+    parent->m_parentFrameActive = FALSE;

 }
 
 }
 

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

 // MDI operations
 // MDI operations

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

 {
     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
     if ( parent && parent->GetClientWindow() )
 {
     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
     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)
+void wxMDIChildFrame::Restore()

 {
     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
     if ( parent && parent->GetClientWindow() )
 {
     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
     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)
+void wxMDIChildFrame::Activate()

 {
     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
     if ( parent && parent->GetClientWindow() )
 {
     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
     if ( parent && parent->GetClientWindow() )

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

 }
 
 }
 

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

 {
 {

-  if (!GetHWND()) return;
+    long rc = 0;
+    bool processed = FALSE;

 
 

-  if (invalidHandle == (HWND) GetHWND())
-  {
-#if WXDEBUG > 1
-  wxDebugMsg("wxMDIChildFrame::OnSize %d: invalid, so returning.\n", GetHWND());
-#endif
-    return;
-  }
-  
-  (void)MSWDefWindowProc(m_lastMsg, m_lastWParam, m_lastLParam);
+    switch ( message )
+    {
+        case WM_COMMAND:
+            {
+                WORD id, cmd;
+                WXHWND hwnd;
+                UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
+                              &id, &hwnd, &cmd);

 
 

-  switch (id)
-  {
-    case SIZEFULLSCREEN:
-    case SIZENORMAL:
-      m_iconized = FALSE;
-    break;
-    case SIZEICONIC:
-      m_iconized = TRUE;
-    break;
-  }
+                processed = HandleCommand(id, cmd, (WXHWND)hwnd);
+            }
+            break;

 
 

-  if (!m_iconized)
-  {
-    // forward WM_SIZE to status bar control
-#if USE_NATIVE_STATUSBAR
-    if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
-    {
-      wxSizeEvent event(wxSize(x, y), m_frameStatusBar->GetId());
-      event.SetEventObject( m_frameStatusBar );
+        case WM_GETMINMAXINFO:
+            // 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_min/max variables
+            return MSWDefWindowProc(message, wParam, lParam);
+
+        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

 
 

-      ((wxStatusBar95 *)m_frameStatusBar)->OnSize(event);
+            // fall through
+
+        case WM_SIZE:
+            // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
+            // things happen
+            MSWDefWindowProc(message, wParam, lParam);
+            break;
+
+        case WM_SYSCOMMAND:
+            // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it
+            // the message (the base class version does not)
+            return MSWDefWindowProc(message, wParam, lParam);
+
+        case WM_WINDOWPOSCHANGING:
+            processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);
+            break;

     }
     }

-#endif

 
 

-    PositionStatusBar();
+    if ( !processed )
+        rc = wxFrame::MSWWindowProc(message, wParam, lParam);

 
 

-    wxWindow::MSWOnSize(x, y, id);
-  }
+    return rc;

 }
 
 }
 

-bool wxMDIChildFrame::MSWOnCommand(WXWORD id, WXWORD cmd, WXHWND control)
+bool wxMDIChildFrame::HandleSize(int x, int y, WXUINT id)

 {
 {

-#if WXDEBUG > 1
-  wxDebugMsg("wxMDIChildFrame::MSWOnCommand %d\n", GetHWND());
-#endif
-  if ((cmd == 0) && GetHWND())
-  {
-    // In case it's e.g. a toolbar.
-    wxWindow *win = wxFindWinFromHandle(control);
-    if (win)
-      return win->MSWCommand(cmd, id);
+    HWND hwnd = GetHwnd();

 
 

-    if (GetMenuBar() && GetMenuBar()->FindItemForId(id))
+    if ( !hwnd || hwnd == invalidHandle )

     {
     {

-      ProcessCommand(id);
-      return TRUE;
+        return FALSE;

     }
     }

-    else
-      return FALSE;
-    return TRUE;
-  }
-  else
-    return FALSE;
-}

 
 

-long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam)
-{
-  if (GetHWND())
-    return DefMDIChildProc((HWND) GetHWND(), (UINT) message, (WPARAM) wParam, (LPARAM) lParam);
-  else return 0;
-}
+    switch (id)
+    {
+        case SIZEFULLSCREEN:
+        case SIZENORMAL:
+            m_iconized = FALSE;
+            break;
+
+        case SIZEICONIC:
+            m_iconized = TRUE;
+            break;
+    }

 
 

-bool wxMDIChildFrame::MSWProcessMessage(WXMSG *msg)
-{
-  MSG *pMsg = (MSG *)msg;
-  if (m_acceleratorTable && GetHWND())
-  {
-    wxFrame *parent = (wxFrame *)GetParent();
-    HWND parent_hwnd = (HWND) parent->GetHWND();
-    return (::TranslateAccelerator(parent_hwnd, (HANDLE) m_acceleratorTable, pMsg) != 0);
-  }
-  return FALSE;
+    if ( !m_iconized )
+    {
+        // 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 // wxUSE_NATIVE_STATUSBAR
+
+        PositionStatusBar();
+        PositionToolBar();
+
+        return wxWindow::HandleSize(x, y, id);
+    }
+    else
+    {
+        return FALSE;
+    }

 }
 
 }
 

-long wxMDIChildFrame::MSWOnMDIActivate(long activate, WXHWND WXUNUSED(one), WXHWND WXUNUSED(two))
+bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)

 {
 {

-  wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
-  HMENU parent_menu = (HMENU) parent->GetWinMenu();
-#if WXDEBUG > 1
-  wxDebugMsg("Parent menu is %d\n", parent_menu);
-#endif
-  HMENU child_menu = (HMENU) GetWinMenu();
-#if WXDEBUG > 1
-  wxDebugMsg("Child menu is %d\n", child_menu);
-#endif
+    // In case it's e.g. a toolbar.
+    if ( hwnd )
+    {
+        wxWindow *win = wxFindWinFromHandle(hwnd);
+        if (win)
+            return win->MSWCommand(cmd, id);
+    }

 
 

-  if (activate)
-  {
-//    m_active = TRUE;
-    parent->m_currentChild = this;
-    if (child_menu)
+    if (wxCurrentPopupMenu)

     {
     {

-      parent->m_parentFrameActive = FALSE;
-      HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);
-#if WXDEBUG > 1
-      wxDebugMsg("Window submenu is %d\n", subMenu);
-#endif
-//      HMENU subMenu = 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
+        wxMenu *popupMenu = wxCurrentPopupMenu;
+        wxCurrentPopupMenu = NULL;
+        if (popupMenu->MSWCommand(cmd, id))
+            return TRUE;
+    }

 
 

-      ::DrawMenuBar((HWND) parent->GetHWND());
+    if (GetMenuBar() && GetMenuBar()->FindItem(id))
+    {
+        ProcessCommand(id);
+        return TRUE;

     }
     }

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

 
 

-    wxActivateEvent event(wxEVT_ACTIVATE, FALSE, m_windowId);
-    event.SetEventObject( this );
-    GetEventHandler()->ProcessEvent(event);
+    return TRUE;
+}
+
+bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
+                                        WXHWND hwndAct,
+                                        WXHWND hwndDeact)
+{
+    wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+
+    HMENU menuToSet = 0;

 
 

-//    m_active = FALSE;
-    if (parent_menu)
+    bool activated;
+
+    if ( m_hWnd == hwndAct )

     {
     {

-      parent->m_parentFrameActive = TRUE;
-      HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);
-#if WXDEBUG > 1
-      wxDebugMsg("Window submenu is %d\n", subMenu);
-#endif
-//      HMENU subMenu = 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
+        activated = TRUE;
+        parent->m_currentChild = this;
+
+        HMENU child_menu = (HMENU)GetWinMenu();
+        if ( child_menu )
+        {
+            parent->m_parentFrameActive = FALSE;

 
 

-      ::DrawMenuBar((HWND) parent->GetHWND());
+            menuToSet = child_menu;
+        }

     }
     }

-  }
-  bool flag = (activate != 0);
-  wxActivateEvent event(wxEVT_ACTIVATE, flag, m_windowId);
-  event.SetEventObject( this );
-  GetEventHandler()->ProcessEvent(event);
+    else if ( m_hWnd == hwndDeact )
+    {
+        wxASSERT_MSG( parent->m_currentChild == this,
+                      wxT("can't deactivate MDI child which wasn't active!") );

 
 

-#if WXDEBUG > 1
-  wxDebugMsg("Finished (de)activating\n");
-#endif
-  return 0;
-}
+        activated = FALSE;
+        parent->m_currentChild = NULL;

 
 

-void wxMDIChildFrame::MSWDestroyWindow(void)
-{
-  MSWDetachWindowMenu();
-  invalidHandle = (HWND) GetHWND();
+        HMENU parent_menu = (HMENU)parent->GetWinMenu();
+        if ( parent_menu )
+        {
+            parent->m_parentFrameActive = TRUE;

 
 

-  wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
+            menuToSet = parent_menu;
+        }
+    }
+    else
+    {
+        // we have nothing to with it
+        return FALSE;
+    }

 
 

-  // 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.
+    if ( menuToSet )
+    {
+        HMENU subMenu = GetSubMenu((HMENU) parent->GetWindowMenu(), 0);

 
 

-  HWND oldHandle = (HWND)GetHWND();
-#if WXDEBUG > 1
-  wxDebugMsg("*** About to DestroyWindow MDI child %d\n", oldHandle);
-#endif
-#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
-#if WXDEBUG > 1
-  wxDebugMsg("*** Finished DestroyWindow MDI child %d\n", oldHandle);
-#endif
-  invalidHandle = 0;
+        MDISetMenu(parent->GetClientWindow(), menuToSet, subMenu);
+    }

 
 

-  if (m_hMenu)
-  {
-    ::DestroyMenu((HMENU) m_hMenu);
-    m_hMenu = 0;
-  }
-  m_hWnd = 0;
-}
+    wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
+    event.SetEventObject( this );

 
 

-// 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)
-{
-#if defined(__WIN95__)
-    RECT *rect = (RECT *)vrect;
-       wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
-       wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
-       if (!pChild || (pChild == this))
-       {
-               DWORD dwStyle = ::GetWindowLong((HWND) pFrameWnd->GetClientWindow()->GetHWND(), GWL_EXSTYLE);
-        DWORD dwThisStyle = ::GetWindowLong((HWND) GetHWND(), GWL_STYLE);
-               DWORD dwNewStyle = dwStyle;
-               if (pChild != NULL && (dwThisStyle & WS_MAXIMIZE))
-                       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);
-                       if (rect)
-                               ::GetClientRect((HWND) pFrameWnd->GetClientWindow()->GetHWND(), rect);
-                       return TRUE;
-               }
-       }
-       return FALSE;
-#else
-    return FALSE;
-#endif
+    return GetEventHandler()->ProcessEvent(event);

 }
 
 }
 

-void wxMDIChildFrame::MSWOnWindowPosChanging(void *pos)
+bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)

 {
     WINDOWPOS *lpPos = (WINDOWPOS *)pos;
 #if defined(__WIN95__)
     if (!(lpPos->flags & SWP_NOSIZE))
 {
     WINDOWPOS *lpPos = (WINDOWPOS *)pos;
 #if defined(__WIN95__)
     if (!(lpPos->flags & SWP_NOSIZE))

-       {
-               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;
+    {
+        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->y = rectClient.top;

-                       lpPos->cx = rectClient.right - rectClient.left;
+            lpPos->cx = rectClient.right - rectClient.left;

             lpPos->cy = rectClient.bottom - rectClient.top;
             lpPos->cy = rectClient.bottom - rectClient.top;

-               }
-           wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
+        }
+        wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();

         if (pFrameWnd && pFrameWnd->GetToolBar())
         {
             pFrameWnd->GetToolBar()->Refresh();
         }
         if (pFrameWnd && pFrameWnd->GetToolBar())
         {
             pFrameWnd->GetToolBar()->Refresh();
         }

-       }
-#endif
-    Default();
+    }
+#endif // Win95
+
+    return FALSE;

 }
 
 }
 

-// Client window
-wxMDIClientWindow::wxMDIClientWindow(void)
+// ---------------------------------------------------------------------------
+// MDI specific message translation/preprocessing
+// ---------------------------------------------------------------------------
+
+long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam)
+{
+    return DefMDIChildProc(GetHwnd(),
+                           (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
+}
+
+bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
+{
+    return m_acceleratorTable.Translate(GetParent(), msg);
+}
+
+// ---------------------------------------------------------------------------
+// misc
+// ---------------------------------------------------------------------------
+
+void wxMDIChildFrame::MSWDestroyWindow()

 {
 {

-    m_scrollX = 0;
-    m_scrollY = 0;
+    MSWDetachWindowMenu();
+    invalidHandle = GetHwnd();
+
+    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.
+
+    HWND oldHandle = (HWND)GetHWND();
+    SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
+                (WPARAM)oldHandle, 0);
+    invalidHandle = 0;
+
+    if (m_hMenu)
+    {
+        ::DestroyMenu((HMENU) m_hMenu);
+        m_hMenu = 0;
+    }
+    m_hWnd = 0;

 }
 
 }
 

-wxMDIClientWindow::~wxMDIClientWindow(void)
+// 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)

 {
 {

+#if defined(__WIN95__)
+    RECT *rect = (RECT *)vrect;
+    wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
+    wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
+    if (!pChild || (pChild == this))
+    {
+        DWORD dwStyle = ::GetWindowLong(GetWinHwnd(pFrameWnd->GetClientWindow()), GWL_EXSTYLE);
+        DWORD dwThisStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
+        DWORD dwNewStyle = dwStyle;
+        if (pChild != NULL && (dwThisStyle & WS_MAXIMIZE))
+            dwNewStyle &= ~(WS_EX_CLIENTEDGE);
+        else
+            dwNewStyle |= WS_EX_CLIENTEDGE;
+
+        if (dwStyle != dwNewStyle)
+        {
+            HWND hwnd = GetWinHwnd(pFrameWnd->GetClientWindow());
+            ::RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
+            ::SetWindowLong(hwnd, GWL_EXSTYLE, dwNewStyle);
+            ::SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
+                           SWP_FRAMECHANGED | SWP_NOACTIVATE |
+                           SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
+                           SWP_NOCOPYBITS);
+            if (rect)
+                ::GetClientRect(hwnd, rect);
+
+            return TRUE;
+        }
+    }
+#endif // Win95
+
+    return FALSE;

 }
 
 }
 

+// ===========================================================================
+// wxMDIClientWindow: the window of predefined (by Windows) class which
+// contains the child frames
+// ===========================================================================
+

 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
 {
 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
 {

-  m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
+    m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);

 
 

-  CLIENTCREATESTRUCT ccs;
-  m_windowStyle = style;
-  m_windowParent = parent;
-       
-  ccs.hWindowMenu = (HMENU) parent->GetWindowMenu();
-  ccs.idFirstChild = wxFIRST_MDI_CHILD;
+    CLIENTCREATESTRUCT ccs;
+    m_windowStyle = style;
+    m_parent = parent;
+
+    ccs.hWindowMenu = (HMENU)parent->GetWindowMenu();
+    ccs.idFirstChild = wxFIRST_MDI_CHILD;

 
 

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

 
 #if defined(__WIN95__)
 
 #if defined(__WIN95__)

-  DWORD exStyle = WS_EX_CLIENTEDGE;
+    DWORD exStyle = WS_EX_CLIENTEDGE;

 #else
 #else

-  DWORD exStyle = 0;
+    DWORD exStyle = 0;

 #endif
 
 #endif
 

-  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;
+    wxWndHook = this;
+    m_hWnd = (WXHWND)::CreateWindowEx
+                       (
+                        exStyle,
+                        wxT("MDICLIENT"),
+                        NULL,
+                        msStyle,
+                        0, 0, 0, 0,
+                        GetWinHwnd(parent),
+                        NULL,
+                        wxGetInstance(),
+                        (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
+    if ( !m_hWnd )
+    {
+        wxLogLastError("CreateWindowEx(MDI client)");

 
 

-  return (m_hWnd != 0) ;
-}
+        return FALSE;
+    }

 
 

-// Window procedure: here for debugging purposes
-long wxMDIClientWindow::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
-{
-    return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
-//    return MSWDefWindowProc(nMsg, wParam, lParam);
-}
+    SubclassWin(m_hWnd);
+    wxWndHook = NULL;

 
 

-long wxMDIClientWindow::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
-{
-       if ( MSWGetOldWndProc() != 0)
-               return ::CallWindowProc(CASTWNDPROC (FARPROC) MSWGetOldWndProc(), (HWND) GetHWND(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
-       else
-               return ::DefWindowProc((HWND) m_hWnd, (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
+    return TRUE;

 }
 
 // Explicitly call default scroll behaviour
 }
 
 // Explicitly call default scroll behaviour


@@ -1215,12 +1140,73 @@ void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
     else
         m_scrollY = event.GetPosition(); // Always returns zero!
 
     else
         m_scrollY = event.GetPosition(); // Always returns zero!
 

-       Default();
+    event.Skip();

 }
 
 }
 

-// Should hand the message to the default proc
-long wxMDIClientWindow::MSWOnMDIActivate(long bActivate, WXHWND, WXHWND)
+// ---------------------------------------------------------------------------
+// non member functions
+// ---------------------------------------------------------------------------
+
+static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
+{
+    ::SendMessage(GetWinHwnd(win), WM_MDISETMENU,
+#ifdef __WIN32__
+                  (WPARAM)hmenuFrame, (LPARAM)hmenuWindow);
+#else
+                  0, MAKELPARAM(hmenuFrame, hmenuWindow));
+#endif
+
+    // update menu bar of the parent window
+    wxWindow *parent = win->GetParent();
+    wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
+
+    ::DrawMenuBar(GetWinHwnd(parent));
+}
+
+static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu)

 {
 {

-    return Default();
+    // Try to insert Window menu in front of Help, otherwise append it.
+    HMENU hmenu = (HMENU)menu;
+    int N = GetMenuItemCount(hmenu);
+    bool success = FALSE;
+    for ( int i = 0; i < N; i++ )
+    {
+        wxChar buf[256];
+        int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
+        if ( chars == 0 )
+        {
+            wxLogLastError(wxT("GetMenuString"));
+
+            continue;
+        }
+
+        if ( wxStripMenuCodes(wxString(buf)).IsSameAs(wxT("Help")) )
+        {
+            success = TRUE;
+            ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
+                         (UINT)subMenu, wxT("&Window"));
+            break;
+        }
+    }
+
+    if ( !success )
+    {
+        ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, wxT("&Window"));
+    }
+
+    MDISetMenu(win, hmenu, subMenu);

 }
 
 }
 

+static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
+                              WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
+{
+#ifdef __WIN32__
+    *activate = TRUE;
+    *hwndAct = (WXHWND)lParam;
+    *hwndDeact = (WXHWND)wParam;
+#else // Win16
+    *activate = (WXWORD)wParam;
+    *hwndAct = (WXHWND)LOWORD(lParam);
+    *hwndDeact = (WXHWND)HIWORD(lParam);
+#endif // Win32/Win16
+}