src/msw/mdi.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/mdi.cpp
   3 // Purpose:     MDI classes for wxMSW
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin on 2008-11-04 to use the base classes
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Julian Smart
   9 //              (c) 2008-2009 Vadim Zeitlin
  10 // Licence:     wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // ===========================================================================
  14 // declarations
  15 // ===========================================================================
  16
  17 // ---------------------------------------------------------------------------
  18 // headers
  19 // ---------------------------------------------------------------------------
  20
  21 // For compilers that support precompilation, includes "wx.h".
  22 #include "wx/wxprec.h"
  23
  24 #ifdef __BORLANDC__
  25     #pragma hdrstop
  26 #endif
  27
  28 #if wxUSE_MDI && !defined(__WXUNIVERSAL__)
  29
  30 #include "wx/mdi.h"
  31
  32 #ifndef WX_PRECOMP
  33     #include "wx/frame.h"
  34     #include "wx/menu.h"
  35     #include "wx/app.h"
  36     #include "wx/utils.h"
  37     #include "wx/dialog.h"
  38     #include "wx/statusbr.h"
  39     #include "wx/settings.h"
  40     #include "wx/intl.h"
  41     #include "wx/log.h"
  42     #include "wx/toolbar.h"
  43 #endif
  44
  45 #include "wx/stockitem.h"
  46 #include "wx/msw/private.h"
  47
  48 #include <string.h>
  49
  50 // ---------------------------------------------------------------------------
  51 // global variables
  52 // ---------------------------------------------------------------------------
  53
  54 extern wxMenu *wxCurrentPopupMenu;
  55
  56 extern void wxRemoveHandleAssociation(wxWindow *win);
  57
  58 namespace
  59 {
  60
  61 // ---------------------------------------------------------------------------
  62 // constants
  63 // ---------------------------------------------------------------------------
  64
  65 // This range gives a maximum of 500 MDI children. Should be enough :-)
  66 const int wxFIRST_MDI_CHILD = 4100;
  67 const int wxLAST_MDI_CHILD = 4600;
  68
  69 // The MDI "Window" menu label
  70 const char *WINDOW_MENU_LABEL = gettext_noop("&Window");
  71
  72 // ---------------------------------------------------------------------------
  73 // private functions
  74 // ---------------------------------------------------------------------------
  75
  76 // set the MDI menus (by sending the WM_MDISETMENU message) and update the menu
  77 // of the parent of win (which is supposed to be the MDI client window)
  78 void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow);
  79
  80 // insert the window menu (subMenu) into menu just before "Help" submenu or at
  81 // the very end if not found
  82 void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU subMenu);
  83
  84 // Remove the window menu
  85 void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu);
  86
  87 // unpack the parameters of WM_MDIACTIVATE message
  88 void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
  89                        WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact);
  90
  91 // return the HMENU of the MDI menu
  92 //
  93 // this function works correctly even when we don't have a window menu and just
  94 // returns 0 then
  95 inline HMENU GetMDIWindowMenu(wxMDIParentFrame *frame)
  96 {
  97     wxMenu *menu = frame->GetWindowMenu();
  98     return menu ? GetHmenuOf(menu) : 0;
  99 }
 100
 101 } // anonymous namespace
 102
 103 // ===========================================================================
 104 // implementation
 105 // ===========================================================================
 106
 107 // ---------------------------------------------------------------------------
 108 // wxWin macros
 109 // ---------------------------------------------------------------------------
 110
 111 IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
 112 IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
 113 IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
 114
 115 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
 116     EVT_SIZE(wxMDIParentFrame::OnSize)
 117     EVT_ICONIZE(wxMDIParentFrame::OnIconized)
 118     EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
 119
 120 #if wxUSE_MENUS
 121     EVT_MENU_RANGE(wxFIRST_MDI_CHILD, wxLAST_MDI_CHILD,
 122                    wxMDIParentFrame::OnMDIChild)
 123     EVT_MENU_RANGE(wxID_MDI_WINDOW_FIRST, wxID_MDI_WINDOW_LAST,
 124                    wxMDIParentFrame::OnMDICommand)
 125 #endif // wxUSE_MENUS
 126 END_EVENT_TABLE()
 127
 128 BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
 129     EVT_IDLE(wxMDIChildFrame::OnIdle)
 130 END_EVENT_TABLE()
 131
 132 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
 133     EVT_SCROLL(wxMDIClientWindow::OnScroll)
 134 END_EVENT_TABLE()
 135
 136 // ===========================================================================
 137 // wxMDIParentFrame: the frame which contains the client window which manages
 138 // the children
 139 // ===========================================================================
 140
 141 bool wxMDIParentFrame::Create(wxWindow *parent,
 142                               wxWindowID id,
 143                               const wxString& title,
 144                               const wxPoint& pos,
 145                               const wxSize& size,
 146                               long style,
 147                               const wxString& name)
 148 {
 149   // this style can be used to prevent a window from having the standard MDI
 150   // "Window" menu
 151   if ( !(style & wxFRAME_NO_WINDOW_MENU) )
 152   {
 153       // normal case: we have the window menu, so construct it
 154       m_windowMenu = new wxMenu;
 155
 156       m_windowMenu->Append(wxID_MDI_WINDOW_CASCADE, _("&Cascade"));
 157       m_windowMenu->Append(wxID_MDI_WINDOW_TILE_HORZ, _("Tile &Horizontally"));
 158       m_windowMenu->Append(wxID_MDI_WINDOW_TILE_VERT, _("Tile &Vertically"));
 159       m_windowMenu->AppendSeparator();
 160       m_windowMenu->Append(wxID_MDI_WINDOW_ARRANGE_ICONS, _("&Arrange Icons"));
 161       m_windowMenu->Append(wxID_MDI_WINDOW_NEXT, _("&Next"));
 162       m_windowMenu->Append(wxID_MDI_WINDOW_PREV, _("&Previous"));
 163   }
 164
 165 #if wxUSE_MENUS && wxUSE_ACCEL
 166   // the default menu doesn't have any accelerators (even if we have it)
 167   m_accelWindowMenu = NULL;
 168 #endif // wxUSE_MENUS && wxUSE_ACCEL
 169
 170   if (!parent)
 171     wxTopLevelWindows.Append(this);
 172
 173   SetName(name);
 174   m_windowStyle = style;
 175
 176   if ( parent )
 177       parent->AddChild(this);
 178
 179   if ( id != wxID_ANY )
 180     m_windowId = id;
 181   else
 182     m_windowId = NewControlId();
 183
 184   WXDWORD exflags;
 185   WXDWORD msflags = MSWGetCreateWindowFlags(&exflags);
 186   msflags &= ~WS_VSCROLL;
 187   msflags &= ~WS_HSCROLL;
 188
 189   if ( !wxWindow::MSWCreate(wxApp::GetRegisteredClassName(_T("wxMDIFrame")),
 190                             title.wx_str(),
 191                             pos, size,
 192                             msflags,
 193                             exflags) )
 194   {
 195       return false;
 196   }
 197
 198   SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 199
 200   // unlike (almost?) all other windows, frames are created hidden
 201   m_isShown = false;
 202
 203   return true;
 204 }
 205
 206 wxMDIParentFrame::~wxMDIParentFrame()
 207 {
 208     // see comment in ~wxMDIChildFrame
 209 #if wxUSE_TOOLBAR
 210     m_frameToolBar = NULL;
 211 #endif
 212 #if wxUSE_STATUSBAR
 213     m_frameStatusBar = NULL;
 214 #endif // wxUSE_STATUSBAR
 215
 216 #if wxUSE_MENUS && wxUSE_ACCEL
 217     delete m_accelWindowMenu;
 218 #endif // wxUSE_MENUS && wxUSE_ACCEL
 219
 220     DestroyChildren();
 221
 222     // the MDI frame menubar is not automatically deleted by Windows unlike for
 223     // the normal frames
 224     if ( m_hMenu )
 225         ::DestroyMenu((HMENU)m_hMenu);
 226
 227     if ( m_clientWindow )
 228     {
 229         if ( m_clientWindow->MSWGetOldWndProc() )
 230             m_clientWindow->UnsubclassWin();
 231
 232         m_clientWindow->SetHWND(0);
 233         delete m_clientWindow;
 234     }
 235 }
 236
 237 // ----------------------------------------------------------------------------
 238 // wxMDIParentFrame child management
 239 // ----------------------------------------------------------------------------
 240
 241 wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
 242 {
 243     HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
 244                                     WM_MDIGETACTIVE, 0, 0L);
 245     if ( !hWnd )
 246         return NULL;
 247
 248     return static_cast<wxMDIChildFrame *>(wxFindWinFromHandle(hWnd));
 249 }
 250
 251 int wxMDIParentFrame::GetChildFramesCount() const
 252 {
 253     int count = 0;
 254     for ( wxWindowList::const_iterator i = GetChildren().begin();
 255           i != GetChildren().end();
 256           ++i )
 257     {
 258         if ( wxDynamicCast(*i, wxMDIChildFrame) )
 259             count++;
 260     }
 261
 262     return count;
 263 }
 264
 265 #if wxUSE_MENUS
 266
 267 void wxMDIParentFrame::AddMDIChild(wxMDIChildFrame * WXUNUSED(child))
 268 {
 269     switch ( GetChildFramesCount() )
 270     {
 271         case 1:
 272             // first MDI child was just added, we need to insert the window
 273             // menu now if we have it
 274             AddWindowMenu();
 275
 276             // and disable the items which can't be used until we have more
 277             // than one child
 278             UpdateWindowMenu(false);
 279             break;
 280
 281         case 2:
 282             // second MDI child was added, enable the menu items which were
 283             // disabled because they didn't make sense for a single window
 284             UpdateWindowMenu(true);
 285             break;
 286     }
 287 }
 288
 289 void wxMDIParentFrame::RemoveMDIChild(wxMDIChildFrame * WXUNUSED(child))
 290 {
 291     switch ( GetChildFramesCount() )
 292     {
 293         case 1:
 294             // last MDI child is being removed, remove the now unnecessary
 295             // window menu too
 296             RemoveWindowMenu();
 297
 298             // there is no need to call UpdateWindowMenu(true) here so this is
 299             // not quite symmetric to AddMDIChild() above
 300             break;
 301
 302         case 2:
 303             // only one MDI child is going to remain, disable the menu commands
 304             // which don't make sense for a single child window
 305             UpdateWindowMenu(false);
 306             break;
 307     }
 308 }
 309
 310 // ----------------------------------------------------------------------------
 311 // wxMDIParentFrame window menu handling
 312 // ----------------------------------------------------------------------------
 313
 314 void wxMDIParentFrame::AddWindowMenu()
 315 {
 316     if ( m_windowMenu )
 317         MDIInsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this));
 318 }
 319
 320 void wxMDIParentFrame::RemoveWindowMenu()
 321 {
 322     if ( m_windowMenu )
 323         MDIRemoveWindowMenu(GetClientWindow(), m_hMenu);
 324 }
 325
 326 void wxMDIParentFrame::UpdateWindowMenu(bool enable)
 327 {
 328     if ( m_windowMenu )
 329     {
 330         m_windowMenu->Enable(wxID_MDI_WINDOW_NEXT, enable);
 331         m_windowMenu->Enable(wxID_MDI_WINDOW_PREV, enable);
 332     }
 333 }
 334
 335 #if wxUSE_MENUS_NATIVE
 336
 337 void wxMDIParentFrame::InternalSetMenuBar()
 338 {
 339     if ( GetActiveChild() )
 340     {
 341         AddWindowMenu();
 342     }
 343     else // we don't have any MDI children yet
 344     {
 345         // wait until we do to add the window menu but do set the main menu for
 346         // now (this is done by AddWindowMenu() as a side effect)
 347         MDISetMenu(GetClientWindow(), (HMENU)m_hMenu, NULL);
 348     }
 349 }
 350
 351 #endif // wxUSE_MENUS_NATIVE
 352
 353 void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
 354 {
 355     if ( menu != m_windowMenu )
 356     {
 357         // notice that Remove/AddWindowMenu() are safe to call even when
 358         // m_windowMenu is NULL
 359         RemoveWindowMenu();
 360
 361         delete m_windowMenu;
 362
 363         m_windowMenu = menu;
 364
 365         AddWindowMenu();
 366     }
 367
 368 #if wxUSE_ACCEL
 369     delete m_accelWindowMenu;
 370     m_accelWindowMenu = NULL;
 371
 372     if ( menu && menu->HasAccels() )
 373         m_accelWindowMenu = menu->CreateAccelTable();
 374 #endif // wxUSE_ACCEL
 375 }
 376
 377 // ----------------------------------------------------------------------------
 378 // wxMDIParentFrame other menu-related stuff
 379 // ----------------------------------------------------------------------------
 380
 381 void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu)
 382 {
 383     wxMDIChildFrame *child = GetActiveChild();
 384     if ( child )
 385     {
 386         wxEvtHandler* source = child->GetEventHandler();
 387         wxMenuBar* bar = child->GetMenuBar();
 388
 389         if (menu)
 390         {
 391             menu->UpdateUI(source);
 392         }
 393         else
 394         {
 395             if ( bar != NULL )
 396             {
 397                 int nCount = bar->GetMenuCount();
 398                 for (int n = 0; n < nCount; n++)
 399                     bar->GetMenu(n)->UpdateUI(source);
 400             }
 401         }
 402     }
 403     else
 404     {
 405         wxFrameBase::DoMenuUpdates(menu);
 406     }
 407 }
 408
 409 wxMenuItem *wxMDIParentFrame::FindItemInMenuBar(int menuId) const
 410 {
 411     wxMenuItem *item = wxFrame::FindItemInMenuBar(menuId);
 412     if ( !item && GetActiveChild() )
 413     {
 414         item = GetActiveChild()->FindItemInMenuBar(menuId);
 415     }
 416
 417     if ( !item && m_windowMenu )
 418         item = m_windowMenu->FindItem(menuId);
 419
 420     return item;
 421 }
 422
 423 WXHMENU wxMDIParentFrame::MSWGetActiveMenu() const
 424 {
 425     wxMDIChildFrame * const child  = GetActiveChild();
 426     if ( child )
 427     {
 428         const WXHMENU hmenu = child->MSWGetActiveMenu();
 429         if ( hmenu )
 430             return hmenu;
 431     }
 432
 433     return wxFrame::MSWGetActiveMenu();
 434 }
 435
 436 #endif // wxUSE_MENUS
 437
 438 // ----------------------------------------------------------------------------
 439 // wxMDIParentFrame event handling
 440 // ----------------------------------------------------------------------------
 441
 442 void wxMDIParentFrame::UpdateClientSize()
 443 {
 444     if ( GetClientWindow() )
 445     {
 446         int width, height;
 447         GetClientSize(&width, &height);
 448
 449         GetClientWindow()->SetSize(0, 0, width, height);
 450     }
 451 }
 452
 453 void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event))
 454 {
 455     UpdateClientSize();
 456
 457     // do not call event.Skip() here, it somehow messes up MDI client window
 458 }
 459
 460 void wxMDIParentFrame::OnIconized(wxIconizeEvent& event)
 461 {
 462     event.Skip();
 463
 464     if ( !event.IsIconized() )
 465         UpdateClientSize();
 466 }
 467
 468 // Responds to colour changes, and passes event on to children.
 469 void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
 470 {
 471     if ( m_clientWindow )
 472     {
 473         m_clientWindow->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 474         m_clientWindow->Refresh();
 475     }
 476
 477     event.Skip();
 478 }
 479
 480 WXHICON wxMDIParentFrame::GetDefaultIcon() const
 481 {
 482     // we don't have any standard icons (any more)
 483     return (WXHICON)0;
 484 }
 485
 486 // ---------------------------------------------------------------------------
 487 // MDI operations
 488 // ---------------------------------------------------------------------------
 489
 490 void wxMDIParentFrame::Cascade()
 491 {
 492     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
 493 }
 494
 495 void wxMDIParentFrame::Tile(wxOrientation orient)
 496 {
 497     wxASSERT_MSG( orient == wxHORIZONTAL || orient == wxVERTICAL,
 498                   _T("invalid orientation value") );
 499
 500     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE,
 501                   orient == wxHORIZONTAL ? MDITILE_HORIZONTAL
 502                                          : MDITILE_VERTICAL, 0);
 503 }
 504
 505 void wxMDIParentFrame::ArrangeIcons()
 506 {
 507     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0);
 508 }
 509
 510 void wxMDIParentFrame::ActivateNext()
 511 {
 512     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0);
 513 }
 514
 515 void wxMDIParentFrame::ActivatePrevious()
 516 {
 517     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);
 518 }
 519
 520 // ---------------------------------------------------------------------------
 521 // the MDI parent frame window proc
 522 // ---------------------------------------------------------------------------
 523
 524 WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message,
 525                                      WXWPARAM wParam,
 526                                      WXLPARAM lParam)
 527 {
 528     WXLRESULT rc = 0;
 529     bool processed = false;
 530
 531     switch ( message )
 532     {
 533         case WM_ACTIVATE:
 534             {
 535                 WXWORD state, minimized;
 536                 WXHWND hwnd;
 537                 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
 538
 539                 processed = HandleActivate(state, minimized != 0, hwnd);
 540             }
 541             break;
 542
 543         case WM_CREATE:
 544             m_clientWindow = OnCreateClient();
 545             // Uses own style for client style
 546             if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
 547             {
 548                 wxLogMessage(_("Failed to create MDI parent frame."));
 549
 550                 rc = -1;
 551             }
 552
 553             processed = true;
 554             break;
 555
 556         case WM_ERASEBKGND:
 557             processed = true;
 558
 559             // we erase background ourselves
 560             rc = true;
 561             break;
 562
 563         case WM_SIZE:
 564             // though we don't (usually) resize the MDI client to exactly fit the
 565             // client area we need to pass this one to DefFrameProc to allow the children to show
 566             break;
 567     }
 568
 569     if ( !processed )
 570         rc = wxFrame::MSWWindowProc(message, wParam, lParam);
 571
 572     return rc;
 573 }
 574
 575 bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
 576 {
 577     bool processed = false;
 578
 579     if ( wxWindow::HandleActivate(state, minimized, activate) )
 580     {
 581         // already processed
 582         processed = true;
 583     }
 584
 585     // If this window is an MDI parent, we must also send an OnActivate message
 586     // to the current child.
 587     if ( GetActiveChild() &&
 588          ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
 589     {
 590         wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId());
 591         event.SetEventObject( GetActiveChild() );
 592         if ( GetActiveChild()->HandleWindowEvent(event) )
 593             processed = true;
 594     }
 595
 596     return processed;
 597 }
 598
 599 #if wxUSE_MENUS
 600
 601 void wxMDIParentFrame::OnMDIChild(wxCommandEvent& event)
 602 {
 603     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 604     while ( node )
 605     {
 606         wxWindow *child = node->GetData();
 607         if ( child->GetHWND() )
 608         {
 609             int childId = wxGetWindowId(child->GetHWND());
 610             if ( childId == event.GetId() )
 611             {
 612                 ::SendMessage( GetWinHwnd(GetClientWindow()),
 613                         WM_MDIACTIVATE,
 614                         (WPARAM)child->GetHWND(), 0);
 615                 return;
 616             }
 617         }
 618
 619         node = node->GetNext();
 620     }
 621
 622     wxFAIL_MSG( "unknown MDI child selected?" );
 623 }
 624
 625 void wxMDIParentFrame::OnMDICommand(wxCommandEvent& event)
 626 {
 627     WXWPARAM wParam = 0;
 628     WXLPARAM lParam = 0;
 629     int msg;
 630     switch ( event.GetId() )
 631     {
 632         case wxID_MDI_WINDOW_CASCADE:
 633             msg = WM_MDICASCADE;
 634             wParam = MDITILE_SKIPDISABLED;
 635             break;
 636
 637         case wxID_MDI_WINDOW_TILE_HORZ:
 638             wParam |= MDITILE_HORIZONTAL;
 639             // fall through
 640
 641         case wxID_MDI_WINDOW_TILE_VERT:
 642             if ( !wParam )
 643                 wParam = MDITILE_VERTICAL;
 644             msg = WM_MDITILE;
 645             wParam |= MDITILE_SKIPDISABLED;
 646             break;
 647
 648         case wxID_MDI_WINDOW_ARRANGE_ICONS:
 649             msg = WM_MDIICONARRANGE;
 650             break;
 651
 652         case wxID_MDI_WINDOW_NEXT:
 653             msg = WM_MDINEXT;
 654             lParam = 0;         // next child
 655             break;
 656
 657         case wxID_MDI_WINDOW_PREV:
 658             msg = WM_MDINEXT;
 659             lParam = 1;         // previous child
 660             break;
 661
 662         default:
 663             wxFAIL_MSG( "unknown MDI command" );
 664             return;
 665     }
 666
 667     ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam);
 668 }
 669
 670 #endif // wxUSE_MENUS
 671
 672 bool wxMDIParentFrame::TryBefore(wxEvent& event)
 673 {
 674     // menu (and toolbar) events should be sent to the active child frame
 675     // first, if any
 676     if ( event.GetEventType() == wxEVT_COMMAND_MENU_SELECTED )
 677     {
 678         wxMDIChildFrame * const child = GetActiveChild();
 679         if ( child && child->ProcessEventHere(event) )
 680             return true;
 681     }
 682
 683     return wxMDIParentFrameBase::TryBefore(event);
 684 }
 685
 686 WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
 687                                         WXWPARAM wParam,
 688                                         WXLPARAM lParam)
 689 {
 690     WXHWND clientWnd;
 691     if ( GetClientWindow() )
 692         clientWnd = GetClientWindow()->GetHWND();
 693     else
 694         clientWnd = 0;
 695
 696     return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
 697 }
 698
 699 bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
 700 {
 701     MSG *pMsg = (MSG *)msg;
 702
 703     // first let the current child get it
 704     wxMDIChildFrame * const child = GetActiveChild();
 705     if ( child && child->MSWTranslateMessage(msg) )
 706     {
 707         return true;
 708     }
 709
 710     // then try out accelerator table (will also check the accelerators for the
 711     // normal menu items)
 712     if ( wxFrame::MSWTranslateMessage(msg) )
 713     {
 714         return true;
 715     }
 716
 717 #if wxUSE_MENUS && wxUSE_ACCEL
 718     // but it doesn't check for the (custom) accelerators of the window menu
 719     // items as it's not part of the menu bar as it's handled by Windows itself
 720     // so we need to do this explicitly
 721     if ( m_accelWindowMenu && m_accelWindowMenu->Translate(this, msg) )
 722         return true;
 723 #endif // wxUSE_MENUS && wxUSE_ACCEL
 724
 725     // finally, check for MDI specific built-in accelerators
 726     if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
 727     {
 728         if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
 729             return true;
 730     }
 731
 732     return false;
 733 }
 734
 735 // ===========================================================================
 736 // wxMDIChildFrame
 737 // ===========================================================================
 738
 739 void wxMDIChildFrame::Init()
 740 {
 741     m_needsResize = true;
 742     m_needsInitialShow = true;
 743 }
 744
 745 bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 746                              wxWindowID id,
 747                              const wxString& title,
 748                              const wxPoint& pos,
 749                              const wxSize& size,
 750                              long style,
 751                              const wxString& name)
 752 {
 753     m_mdiParent = parent;
 754
 755   SetName(name);
 756
 757   if ( id != wxID_ANY )
 758     m_windowId = id;
 759   else
 760     m_windowId = NewControlId();
 761
 762   if ( parent )
 763   {
 764       parent->AddChild(this);
 765   }
 766
 767   int x = pos.x;
 768   int y = pos.y;
 769   int width = size.x;
 770   int height = size.y;
 771
 772   MDICREATESTRUCT mcs;
 773
 774   wxString className =
 775       wxApp::GetRegisteredClassName(_T("wxMDIChildFrame"), COLOR_WINDOW);
 776   if ( !(style & wxFULL_REPAINT_ON_RESIZE) )
 777       className += wxApp::GetNoRedrawClassSuffix();
 778
 779   mcs.szClass = className.wx_str();
 780   mcs.szTitle = title.wx_str();
 781   mcs.hOwner = wxGetInstance();
 782   if (x != wxDefaultCoord)
 783       mcs.x = x;
 784   else
 785       mcs.x = CW_USEDEFAULT;
 786
 787   if (y != wxDefaultCoord)
 788       mcs.y = y;
 789   else
 790       mcs.y = CW_USEDEFAULT;
 791
 792   if (width != wxDefaultCoord)
 793       mcs.cx = width;
 794   else
 795       mcs.cx = CW_USEDEFAULT;
 796
 797   if (height != wxDefaultCoord)
 798       mcs.cy = height;
 799   else
 800       mcs.cy = CW_USEDEFAULT;
 801
 802   DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
 803   if (style & wxMINIMIZE_BOX)
 804     msflags |= WS_MINIMIZEBOX;
 805   if (style & wxMAXIMIZE_BOX)
 806     msflags |= WS_MAXIMIZEBOX;
 807   if (style & wxRESIZE_BORDER)
 808     msflags |= WS_THICKFRAME;
 809   if (style & wxSYSTEM_MENU)
 810     msflags |= WS_SYSMENU;
 811   if ((style & wxMINIMIZE) || (style & wxICONIZE))
 812     msflags |= WS_MINIMIZE;
 813   if (style & wxMAXIMIZE)
 814     msflags |= WS_MAXIMIZE;
 815   if (style & wxCAPTION)
 816     msflags |= WS_CAPTION;
 817
 818   mcs.style = msflags;
 819
 820   mcs.lParam = 0;
 821
 822   wxWindowCreationHook hook(this);
 823
 824   m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()),
 825                                  WM_MDICREATE, 0, (LPARAM)&mcs);
 826
 827   if ( !m_hWnd )
 828   {
 829       wxLogLastError(_T("WM_MDICREATE"));
 830       return false;
 831   }
 832
 833   SubclassWin(m_hWnd);
 834
 835   parent->AddMDIChild(this);
 836
 837   return true;
 838 }
 839
 840 wxMDIChildFrame::~wxMDIChildFrame()
 841 {
 842     // if we hadn't been created, there is nothing to destroy
 843     if ( !m_hWnd )
 844         return;
 845
 846     GetMDIParent()->RemoveMDIChild(this);
 847
 848     // will be destroyed by DestroyChildren() but reset them before calling it
 849     // to avoid using dangling pointers if a callback comes in the meanwhile
 850 #if wxUSE_TOOLBAR
 851     m_frameToolBar = NULL;
 852 #endif
 853 #if wxUSE_STATUSBAR
 854     m_frameStatusBar = NULL;
 855 #endif // wxUSE_STATUSBAR
 856
 857     DestroyChildren();
 858
 859     MDIRemoveWindowMenu(NULL, m_hMenu);
 860
 861     MSWDestroyWindow();
 862 }
 863
 864 bool wxMDIChildFrame::Show(bool show)
 865 {
 866     m_needsInitialShow = false;
 867
 868     if (!wxFrame::Show(show))
 869         return false;
 870
 871     // KH: Without this call, new MDI children do not become active.
 872     // This was added here after the same BringWindowToTop call was
 873     // removed from wxTopLevelWindow::Show (November 2005)
 874     if ( show )
 875         ::BringWindowToTop(GetHwnd());
 876
 877     // we need to refresh the MDI frame window menu to include (or exclude if
 878     // we've been hidden) this frame
 879     wxMDIParentFrame * const parent = GetMDIParent();
 880     MDISetMenu(parent->GetClientWindow(), NULL, NULL);
 881
 882     return true;
 883 }
 884
 885 // Set the client size (i.e. leave the calculation of borders etc.
 886 // to wxWidgets)
 887 void wxMDIChildFrame::DoSetClientSize(int width, int height)
 888 {
 889   HWND hWnd = GetHwnd();
 890
 891   RECT rect;
 892   ::GetClientRect(hWnd, &rect);
 893
 894   RECT rect2;
 895   GetWindowRect(hWnd, &rect2);
 896
 897   // Find the difference between the entire window (title bar and all)
 898   // and the client area; add this to the new client size to move the
 899   // window
 900   int actual_width = rect2.right - rect2.left - rect.right + width;
 901   int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
 902
 903 #if wxUSE_STATUSBAR
 904   if (GetStatusBar() && GetStatusBar()->IsShown())
 905   {
 906     int sx, sy;
 907     GetStatusBar()->GetSize(&sx, &sy);
 908     actual_height += sy;
 909   }
 910 #endif // wxUSE_STATUSBAR
 911
 912   POINT point;
 913   point.x = rect2.left;
 914   point.y = rect2.top;
 915
 916   // If there's an MDI parent, must subtract the parent's top left corner
 917   // since MoveWindow moves relative to the parent
 918   wxMDIParentFrame * const mdiParent = GetMDIParent();
 919   ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);
 920
 921   MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true);
 922
 923   wxSize size(width, height);
 924   wxSizeEvent event(size, m_windowId);
 925   event.SetEventObject( this );
 926   HandleWindowEvent(event);
 927 }
 928
 929 // Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the
 930 //  same as its GetScreenPosition
 931 void wxMDIChildFrame::DoGetScreenPosition(int *x, int *y) const
 932 {
 933   HWND hWnd = GetHwnd();
 934
 935   RECT rect;
 936   ::GetWindowRect(hWnd, &rect);
 937   if (x)
 938      *x = rect.left;
 939   if (y)
 940      *y = rect.top;
 941 }
 942
 943
 944 void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
 945 {
 946   RECT rect;
 947   GetWindowRect(GetHwnd(), &rect);
 948   POINT point;
 949   point.x = rect.left;
 950   point.y = rect.top;
 951
 952   // Since we now have the absolute screen coords,
 953   // if there's a parent we must subtract its top left corner
 954   wxMDIParentFrame * const mdiParent = GetMDIParent();
 955   ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);
 956
 957   if (x)
 958       *x = point.x;
 959   if (y)
 960       *y = point.y;
 961 }
 962
 963 void wxMDIChildFrame::InternalSetMenuBar()
 964 {
 965     wxMDIParentFrame * const parent = GetMDIParent();
 966
 967     MDIInsertWindowMenu(parent->GetClientWindow(),
 968                      m_hMenu, GetMDIWindowMenu(parent));
 969 }
 970
 971 void wxMDIChildFrame::DetachMenuBar()
 972 {
 973     MDIRemoveWindowMenu(NULL, m_hMenu);
 974     wxFrame::DetachMenuBar();
 975 }
 976
 977 WXHICON wxMDIChildFrame::GetDefaultIcon() const
 978 {
 979     // we don't have any standard icons (any more)
 980     return (WXHICON)0;
 981 }
 982
 983 // ---------------------------------------------------------------------------
 984 // MDI operations
 985 // ---------------------------------------------------------------------------
 986
 987 void wxMDIChildFrame::Maximize(bool maximize)
 988 {
 989     wxMDIParentFrame * const parent = GetMDIParent();
 990     if ( parent && parent->GetClientWindow() )
 991     {
 992         ::SendMessage(GetWinHwnd(parent->GetClientWindow()),
 993                       maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
 994                       (WPARAM)GetHwnd(), 0);
 995     }
 996 }
 997
 998 void wxMDIChildFrame::Restore()
 999 {
1000     wxMDIParentFrame * const parent = GetMDIParent();
1001     if ( parent && parent->GetClientWindow() )
1002     {
1003         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
1004                       (WPARAM) GetHwnd(), 0);
1005     }
1006 }
1007
1008 void wxMDIChildFrame::Activate()
1009 {
1010     wxMDIParentFrame * const parent = GetMDIParent();
1011     if ( parent && parent->GetClientWindow() )
1012     {
1013         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
1014                       (WPARAM) GetHwnd(), 0);
1015     }
1016 }
1017
1018 // ---------------------------------------------------------------------------
1019 // MDI window proc and message handlers
1020 // ---------------------------------------------------------------------------
1021
1022 WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
1023                                     WXWPARAM wParam,
1024                                     WXLPARAM lParam)
1025 {
1026     WXLRESULT rc = 0;
1027     bool processed = false;
1028
1029     switch ( message )
1030     {
1031         case WM_GETMINMAXINFO:
1032             processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam);
1033             break;
1034
1035         case WM_MDIACTIVATE:
1036             {
1037                 WXWORD act;
1038                 WXHWND hwndAct, hwndDeact;
1039                 UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact);
1040
1041                 processed = HandleMDIActivate(act, hwndAct, hwndDeact);
1042             }
1043             // fall through
1044
1045         case WM_MOVE:
1046             // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
1047             // scrollbars if necessary
1048
1049             // fall through
1050
1051         case WM_SIZE:
1052             // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
1053             // things happen
1054             MSWDefWindowProc(message, wParam, lParam);
1055             break;
1056
1057         case WM_SYSCOMMAND:
1058             // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it
1059             // the message (the base class version does not)
1060             return MSWDefWindowProc(message, wParam, lParam);
1061
1062         case WM_WINDOWPOSCHANGING:
1063             processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);
1064             break;
1065     }
1066
1067     if ( !processed )
1068         rc = wxFrame::MSWWindowProc(message, wParam, lParam);
1069
1070     return rc;
1071 }
1072
1073 bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
1074                                         WXHWND hwndAct,
1075                                         WXHWND hwndDeact)
1076 {
1077     wxMDIParentFrame * const parent = GetMDIParent();
1078
1079     WXHMENU hMenuToSet = 0;
1080
1081     bool activated;
1082
1083     if ( m_hWnd == hwndAct )
1084     {
1085         activated = true;
1086         parent->SetActiveChild(this);
1087
1088         WXHMENU hMenuChild = m_hMenu;
1089         if ( hMenuChild )
1090             hMenuToSet = hMenuChild;
1091     }
1092     else if ( m_hWnd == hwndDeact )
1093     {
1094         wxASSERT_MSG( parent->GetActiveChild() == this,
1095                       wxT("can't deactivate MDI child which wasn't active!") );
1096
1097         activated = false;
1098         parent->SetActiveChild(NULL);
1099
1100         WXHMENU hMenuParent = parent->m_hMenu;
1101
1102         // activate the the parent menu only when there is no other child
1103         // that has been activated
1104         if ( hMenuParent && !hwndAct )
1105             hMenuToSet = hMenuParent;
1106     }
1107     else
1108     {
1109         // we have nothing to do with it
1110         return false;
1111     }
1112
1113     if ( hMenuToSet )
1114     {
1115         MDISetMenu(parent->GetClientWindow(),
1116                    (HMENU)hMenuToSet, GetMDIWindowMenu(parent));
1117     }
1118
1119     wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
1120     event.SetEventObject( this );
1121
1122     ResetWindowStyle(NULL);
1123
1124     return HandleWindowEvent(event);
1125 }
1126
1127 bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
1128 {
1129     WINDOWPOS *lpPos = (WINDOWPOS *)pos;
1130
1131     if (!(lpPos->flags & SWP_NOSIZE))
1132     {
1133         RECT rectClient;
1134         DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1135         DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1136         if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
1137         {
1138             ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle);
1139             lpPos->x = rectClient.left;
1140             lpPos->y = rectClient.top;
1141             lpPos->cx = rectClient.right - rectClient.left;
1142             lpPos->cy = rectClient.bottom - rectClient.top;
1143         }
1144     }
1145
1146     return false;
1147 }
1148
1149 bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo)
1150 {
1151     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
1152
1153     // let the default window proc calculate the size of MDI children
1154     // frames because it is based on the size of the MDI client window,
1155     // not on the values specified in wxWindow m_max variables
1156     bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0;
1157
1158     int minWidth = GetMinWidth(),
1159         minHeight = GetMinHeight();
1160
1161     // but allow GetSizeHints() to set the min size
1162     if ( minWidth != wxDefaultCoord )
1163     {
1164         info->ptMinTrackSize.x = minWidth;
1165
1166         processed = true;
1167     }
1168
1169     if ( minHeight != wxDefaultCoord )
1170     {
1171         info->ptMinTrackSize.y = minHeight;
1172
1173         processed = true;
1174     }
1175
1176     return processed;
1177 }
1178
1179 // ---------------------------------------------------------------------------
1180 // MDI specific message translation/preprocessing
1181 // ---------------------------------------------------------------------------
1182
1183 WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
1184 {
1185     return DefMDIChildProc(GetHwnd(),
1186                            (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
1187 }
1188
1189 bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
1190 {
1191     // we must pass the parent frame to ::TranslateAccelerator(), otherwise it
1192     // doesn't do its job correctly for MDI child menus
1193     return MSWDoTranslateMessage(GetMDIParent(), msg);
1194 }
1195
1196 // ---------------------------------------------------------------------------
1197 // misc
1198 // ---------------------------------------------------------------------------
1199
1200 void wxMDIChildFrame::MSWDestroyWindow()
1201 {
1202     wxMDIParentFrame * const parent = GetMDIParent();
1203
1204     // Must make sure this handle is invalidated (set to NULL) since all sorts
1205     // of things could happen after the child client is destroyed, but before
1206     // the wxFrame is destroyed.
1207
1208     HWND oldHandle = (HWND)GetHWND();
1209     SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
1210                 (WPARAM)oldHandle, 0);
1211
1212     if (parent->GetActiveChild() == NULL)
1213         ResetWindowStyle(NULL);
1214
1215     if (m_hMenu)
1216     {
1217         ::DestroyMenu((HMENU) m_hMenu);
1218         m_hMenu = 0;
1219     }
1220     wxRemoveHandleAssociation(this);
1221     m_hWnd = 0;
1222 }
1223
1224 // Change the client window's extended style so we don't get a client edge
1225 // style when a child is maximised (a double border looks silly.)
1226 bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
1227 {
1228     RECT *rect = (RECT *)vrect;
1229     wxMDIParentFrame * const pFrameWnd = GetMDIParent();
1230     wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
1231
1232     if (!pChild || (pChild == this))
1233     {
1234         HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow());
1235         DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE);
1236
1237         // we want to test whether there is a maximized child, so just set
1238         // dwThisStyle to 0 if there is no child at all
1239         DWORD dwThisStyle = pChild
1240             ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0;
1241         DWORD dwNewStyle = dwStyle;
1242         if ( dwThisStyle & WS_MAXIMIZE )
1243             dwNewStyle &= ~(WS_EX_CLIENTEDGE);
1244         else
1245             dwNewStyle |= WS_EX_CLIENTEDGE;
1246
1247         if (dwStyle != dwNewStyle)
1248         {
1249             // force update of everything
1250             ::RedrawWindow(hwndClient, NULL, NULL,
1251                            RDW_INVALIDATE | RDW_ALLCHILDREN);
1252             ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle);
1253             ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0,
1254                            SWP_FRAMECHANGED | SWP_NOACTIVATE |
1255                            SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1256                            SWP_NOCOPYBITS);
1257             if (rect)
1258                 ::GetClientRect(hwndClient, rect);
1259
1260             return true;
1261         }
1262     }
1263
1264     return false;
1265 }
1266
1267 // ===========================================================================
1268 // wxMDIClientWindow: the window of predefined (by Windows) class which
1269 // contains the child frames
1270 // ===========================================================================
1271
1272 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
1273 {
1274     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
1275
1276     CLIENTCREATESTRUCT ccs;
1277     m_windowStyle = style;
1278     m_parent = parent;
1279
1280     ccs.hWindowMenu = GetMDIWindowMenu(parent);
1281     ccs.idFirstChild = wxFIRST_MDI_CHILD;
1282
1283     DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD |
1284                     WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
1285
1286     if ( style & wxHSCROLL )
1287         msStyle |= WS_HSCROLL;
1288     if ( style & wxVSCROLL )
1289         msStyle |= WS_VSCROLL;
1290
1291     DWORD exStyle = WS_EX_CLIENTEDGE;
1292
1293     wxWindowCreationHook hook(this);
1294     m_hWnd = (WXHWND)::CreateWindowEx
1295                        (
1296                         exStyle,
1297                         wxT("MDICLIENT"),
1298                         NULL,
1299                         msStyle,
1300                         0, 0, 0, 0,
1301                         GetWinHwnd(parent),
1302                         NULL,
1303                         wxGetInstance(),
1304                         (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
1305     if ( !m_hWnd )
1306     {
1307         wxLogLastError(wxT("CreateWindowEx(MDI client)"));
1308
1309         return false;
1310     }
1311
1312     SubclassWin(m_hWnd);
1313
1314     return true;
1315 }
1316
1317 // Explicitly call default scroll behaviour
1318 void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
1319 {
1320     // Note: for client windows, the scroll position is not set in
1321     // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
1322     // scroll position we're at.
1323     // This makes it hard to paint patterns or bitmaps in the background,
1324     // and have the client area scrollable as well.
1325
1326     if ( event.GetOrientation() == wxHORIZONTAL )
1327         m_scrollX = event.GetPosition(); // Always returns zero!
1328     else
1329         m_scrollY = event.GetPosition(); // Always returns zero!
1330
1331     event.Skip();
1332 }
1333
1334 void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1335 {
1336     // Try to fix a problem whereby if you show an MDI child frame, then reposition the
1337     // client area, you can end up with a non-refreshed portion in the client window
1338     // (see OGL studio sample). So check if the position is changed and if so,
1339     // redraw the MDI child frames.
1340
1341     const wxPoint oldPos = GetPosition();
1342
1343     wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE);
1344
1345     const wxPoint newPos = GetPosition();
1346
1347     if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
1348     {
1349         if (GetParent())
1350         {
1351             wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst();
1352             while (node)
1353             {
1354                 wxWindow *child = node->GetData();
1355                 if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
1356                 {
1357                    ::RedrawWindow(GetHwndOf(child),
1358                                   NULL,
1359                                   NULL,
1360                                   RDW_FRAME |
1361                                   RDW_ALLCHILDREN |
1362                                   RDW_INVALIDATE);
1363                 }
1364                 node = node->GetNext();
1365             }
1366         }
1367     }
1368 }
1369
1370 void wxMDIChildFrame::OnIdle(wxIdleEvent& event)
1371 {
1372     // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted
1373     // in flicker e.g. when the frame contained controls with non-trivial
1374     // layout. Since 2.5.3, the frame is created hidden as all other top level
1375     // windows. In order to maintain backward compatibility, the frame is shown
1376     // in OnIdle, unless Show(false) was called by the programmer before.
1377     if ( m_needsInitialShow )
1378     {
1379         Show(true);
1380     }
1381
1382     // MDI child frames get their WM_SIZE when they're constructed but at this
1383     // moment they don't have any children yet so all child windows will be
1384     // positioned incorrectly when they are added later - to fix this, we
1385     // generate an artificial size event here
1386     if ( m_needsResize )
1387     {
1388         m_needsResize = false; // avoid any possibility of recursion
1389
1390         SendSizeEvent();
1391     }
1392
1393     event.Skip();
1394 }
1395
1396 // ---------------------------------------------------------------------------
1397 // private helper functions
1398 // ---------------------------------------------------------------------------
1399
1400 namespace
1401 {
1402
1403 void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
1404 {
1405     if ( hmenuFrame || hmenuWindow )
1406     {
1407         if ( !::SendMessage(GetWinHwnd(win),
1408                             WM_MDISETMENU,
1409                             (WPARAM)hmenuFrame,
1410                             (LPARAM)hmenuWindow) )
1411         {
1412 #ifdef __WXDEBUG__
1413             DWORD err = ::GetLastError();
1414             if ( err )
1415                 wxLogApiError(_T("SendMessage(WM_MDISETMENU)"), err);
1416 #endif // __WXDEBUG__
1417         }
1418     }
1419
1420     // update menu bar of the parent window
1421     wxWindow *parent = win->GetParent();
1422     wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
1423
1424     ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
1425
1426     ::DrawMenuBar(GetWinHwnd(parent));
1427 }
1428
1429 void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU menuWin)
1430 {
1431     HMENU hmenu = (HMENU)hMenu;
1432
1433     if ( menuWin )
1434     {
1435         // Try to insert Window menu in front of Help, otherwise append it.
1436         int N = GetMenuItemCount(hmenu);
1437         bool inserted = false;
1438         for ( int i = 0; i < N; i++ )
1439         {
1440             wxChar buf[256];
1441             if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
1442             {
1443                 wxLogLastError(wxT("GetMenuString"));
1444
1445                 continue;
1446             }
1447
1448             const wxString label = wxStripMenuCodes(buf);
1449             if ( label == wxGetStockLabel(wxID_HELP, wxSTOCK_NOFLAGS) )
1450             {
1451                 inserted = true;
1452                 ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
1453                              (UINT_PTR)menuWin,
1454                              wxGetTranslation(WINDOW_MENU_LABEL).wx_str());
1455                 break;
1456             }
1457         }
1458
1459         if ( !inserted )
1460         {
1461             ::AppendMenu(hmenu, MF_POPUP,
1462                          (UINT_PTR)menuWin,
1463                          wxGetTranslation(WINDOW_MENU_LABEL).wx_str());
1464         }
1465     }
1466
1467     MDISetMenu(win, hmenu, menuWin);
1468 }
1469
1470 void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu)
1471 {
1472     HMENU hmenu = (HMENU)hMenu;
1473
1474     if ( hmenu )
1475     {
1476         wxChar buf[1024];
1477
1478         int N = ::GetMenuItemCount(hmenu);
1479         for ( int i = 0; i < N; i++ )
1480         {
1481             if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
1482             {
1483                 // Ignore successful read of menu string with length 0 which
1484                 // occurs, for example, for a maximized MDI child system menu
1485                 if ( ::GetLastError() != 0 )
1486                 {
1487                     wxLogLastError(wxT("GetMenuString"));
1488                 }
1489
1490                 continue;
1491             }
1492
1493             if ( wxStrcmp(buf, wxGetTranslation(WINDOW_MENU_LABEL)) == 0 )
1494             {
1495                 if ( !::RemoveMenu(hmenu, i, MF_BYPOSITION) )
1496                 {
1497                     wxLogLastError(wxT("RemoveMenu"));
1498                 }
1499
1500                 break;
1501             }
1502         }
1503     }
1504
1505     if ( win )
1506     {
1507         // we don't change the windows menu, but we update the main one
1508         MDISetMenu(win, hmenu, NULL);
1509     }
1510 }
1511
1512 void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
1513                               WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
1514 {
1515     *activate = true;
1516     *hwndAct = (WXHWND)lParam;
1517     *hwndDeact = (WXHWND)wParam;
1518 }
1519
1520 } // anonymous namespace
1521
1522 #endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)