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_COMMAND:
 544             {
 545                 WXWORD id, cmd;
 546                 WXHWND hwnd;
 547                 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
 548
 549                 (void)HandleCommand(id, cmd, hwnd);
 550
 551                 // even if the frame didn't process it, there is no need to try it
 552                 // once again (i.e. call wxFrame::HandleCommand()) - we just did it,
 553                 // so pretend we processed the message anyhow
 554                 processed = true;
 555             }
 556
 557             // always pass this message DefFrameProc(), otherwise MDI menu
 558             // commands (and sys commands - more surprisingly!) won't work
 559             MSWDefWindowProc(message, wParam, lParam);
 560             break;
 561
 562         case WM_CREATE:
 563             m_clientWindow = OnCreateClient();
 564             // Uses own style for client style
 565             if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
 566             {
 567                 wxLogMessage(_("Failed to create MDI parent frame."));
 568
 569                 rc = -1;
 570             }
 571
 572             processed = true;
 573             break;
 574
 575         case WM_ERASEBKGND:
 576             processed = true;
 577
 578             // we erase background ourselves
 579             rc = true;
 580             break;
 581
 582         case WM_SIZE:
 583             // though we don't (usually) resize the MDI client to exactly fit the
 584             // client area we need to pass this one to DefFrameProc to allow the children to show
 585             break;
 586     }
 587
 588     if ( !processed )
 589         rc = wxFrame::MSWWindowProc(message, wParam, lParam);
 590
 591     return rc;
 592 }
 593
 594 bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
 595 {
 596     bool processed = false;
 597
 598     if ( wxWindow::HandleActivate(state, minimized, activate) )
 599     {
 600         // already processed
 601         processed = true;
 602     }
 603
 604     // If this window is an MDI parent, we must also send an OnActivate message
 605     // to the current child.
 606     if ( GetActiveChild() &&
 607          ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
 608     {
 609         wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId());
 610         event.SetEventObject( GetActiveChild() );
 611         if ( GetActiveChild()->HandleWindowEvent(event) )
 612             processed = true;
 613     }
 614
 615     return processed;
 616 }
 617
 618 #if wxUSE_MENUS
 619
 620 void wxMDIParentFrame::OnMDIChild(wxCommandEvent& event)
 621 {
 622     wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
 623     while ( node )
 624     {
 625         wxWindow *child = node->GetData();
 626         if ( child->GetHWND() )
 627         {
 628             int childId = wxGetWindowId(child->GetHWND());
 629             if ( childId == event.GetId() )
 630             {
 631                 ::SendMessage( GetWinHwnd(GetClientWindow()),
 632                         WM_MDIACTIVATE,
 633                         (WPARAM)child->GetHWND(), 0);
 634                 return;
 635             }
 636         }
 637
 638         node = node->GetNext();
 639     }
 640
 641     wxFAIL_MSG( "unknown MDI child selected?" );
 642 }
 643
 644 void wxMDIParentFrame::OnMDICommand(wxCommandEvent& event)
 645 {
 646     WXWPARAM wParam = 0;
 647     WXLPARAM lParam = 0;
 648     int msg;
 649     switch ( event.GetId() )
 650     {
 651         case wxID_MDI_WINDOW_CASCADE:
 652             msg = WM_MDICASCADE;
 653             wParam = MDITILE_SKIPDISABLED;
 654             break;
 655
 656         case wxID_MDI_WINDOW_TILE_HORZ:
 657             wParam |= MDITILE_HORIZONTAL;
 658             // fall through
 659
 660         case wxID_MDI_WINDOW_TILE_VERT:
 661             if ( !wParam )
 662                 wParam = MDITILE_VERTICAL;
 663             msg = WM_MDITILE;
 664             wParam |= MDITILE_SKIPDISABLED;
 665             break;
 666
 667         case wxID_MDI_WINDOW_ARRANGE_ICONS:
 668             msg = WM_MDIICONARRANGE;
 669             break;
 670
 671         case wxID_MDI_WINDOW_NEXT:
 672             msg = WM_MDINEXT;
 673             lParam = 0;         // next child
 674             break;
 675
 676         case wxID_MDI_WINDOW_PREV:
 677             msg = WM_MDINEXT;
 678             lParam = 1;         // previous child
 679             break;
 680
 681         default:
 682             wxFAIL_MSG( "unknown MDI command" );
 683             return;
 684     }
 685
 686     ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam);
 687 }
 688
 689 #endif // wxUSE_MENUS
 690
 691 bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
 692 {
 693     wxMDIChildFrame * const child = GetActiveChild();
 694     if ( child && child->HandleCommand(id, cmd, hwnd) )
 695         return true;
 696
 697     return wxFrame::HandleCommand(id, cmd, hwnd);
 698 }
 699
 700 WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
 701                                         WXWPARAM wParam,
 702                                         WXLPARAM lParam)
 703 {
 704     WXHWND clientWnd;
 705     if ( GetClientWindow() )
 706         clientWnd = GetClientWindow()->GetHWND();
 707     else
 708         clientWnd = 0;
 709
 710     return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
 711 }
 712
 713 bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
 714 {
 715     MSG *pMsg = (MSG *)msg;
 716
 717     // first let the current child get it
 718     wxMDIChildFrame * const child = GetActiveChild();
 719     if ( child && child->MSWTranslateMessage(msg) )
 720     {
 721         return true;
 722     }
 723
 724     // then try out accelerator table (will also check the accelerators for the
 725     // normal menu items)
 726     if ( wxFrame::MSWTranslateMessage(msg) )
 727     {
 728         return true;
 729     }
 730
 731 #if wxUSE_MENUS && wxUSE_ACCEL
 732     // but it doesn't check for the (custom) accelerators of the window menu
 733     // items as it's not part of the menu bar as it's handled by Windows itself
 734     // so we need to do this explicitly
 735     if ( m_accelWindowMenu && m_accelWindowMenu->Translate(this, msg) )
 736         return true;
 737 #endif // wxUSE_MENUS && wxUSE_ACCEL
 738
 739     // finally, check for MDI specific built-in accelerators
 740     if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
 741     {
 742         if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
 743             return true;
 744     }
 745
 746     return false;
 747 }
 748
 749 // ===========================================================================
 750 // wxMDIChildFrame
 751 // ===========================================================================
 752
 753 void wxMDIChildFrame::Init()
 754 {
 755     m_needsResize = true;
 756     m_needsInitialShow = true;
 757 }
 758
 759 bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 760                              wxWindowID id,
 761                              const wxString& title,
 762                              const wxPoint& pos,
 763                              const wxSize& size,
 764                              long style,
 765                              const wxString& name)
 766 {
 767     m_mdiParent = parent;
 768
 769   SetName(name);
 770
 771   if ( id != wxID_ANY )
 772     m_windowId = id;
 773   else
 774     m_windowId = NewControlId();
 775
 776   if ( parent )
 777   {
 778       parent->AddChild(this);
 779   }
 780
 781   int x = pos.x;
 782   int y = pos.y;
 783   int width = size.x;
 784   int height = size.y;
 785
 786   MDICREATESTRUCT mcs;
 787
 788   wxString className =
 789       wxApp::GetRegisteredClassName(_T("wxMDIChildFrame"), COLOR_WINDOW);
 790   if ( !(style & wxFULL_REPAINT_ON_RESIZE) )
 791       className += wxApp::GetNoRedrawClassSuffix();
 792
 793   mcs.szClass = className.wx_str();
 794   mcs.szTitle = title.wx_str();
 795   mcs.hOwner = wxGetInstance();
 796   if (x != wxDefaultCoord)
 797       mcs.x = x;
 798   else
 799       mcs.x = CW_USEDEFAULT;
 800
 801   if (y != wxDefaultCoord)
 802       mcs.y = y;
 803   else
 804       mcs.y = CW_USEDEFAULT;
 805
 806   if (width != wxDefaultCoord)
 807       mcs.cx = width;
 808   else
 809       mcs.cx = CW_USEDEFAULT;
 810
 811   if (height != wxDefaultCoord)
 812       mcs.cy = height;
 813   else
 814       mcs.cy = CW_USEDEFAULT;
 815
 816   DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
 817   if (style & wxMINIMIZE_BOX)
 818     msflags |= WS_MINIMIZEBOX;
 819   if (style & wxMAXIMIZE_BOX)
 820     msflags |= WS_MAXIMIZEBOX;
 821   if (style & wxRESIZE_BORDER)
 822     msflags |= WS_THICKFRAME;
 823   if (style & wxSYSTEM_MENU)
 824     msflags |= WS_SYSMENU;
 825   if ((style & wxMINIMIZE) || (style & wxICONIZE))
 826     msflags |= WS_MINIMIZE;
 827   if (style & wxMAXIMIZE)
 828     msflags |= WS_MAXIMIZE;
 829   if (style & wxCAPTION)
 830     msflags |= WS_CAPTION;
 831
 832   mcs.style = msflags;
 833
 834   mcs.lParam = 0;
 835
 836   wxWindowCreationHook hook(this);
 837
 838   m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()),
 839                                  WM_MDICREATE, 0, (LPARAM)&mcs);
 840
 841   if ( !m_hWnd )
 842   {
 843       wxLogLastError(_T("WM_MDICREATE"));
 844       return false;
 845   }
 846
 847   SubclassWin(m_hWnd);
 848
 849   parent->AddMDIChild(this);
 850
 851   return true;
 852 }
 853
 854 wxMDIChildFrame::~wxMDIChildFrame()
 855 {
 856     // if we hadn't been created, there is nothing to destroy
 857     if ( !m_hWnd )
 858         return;
 859
 860     GetMDIParent()->RemoveMDIChild(this);
 861
 862     // will be destroyed by DestroyChildren() but reset them before calling it
 863     // to avoid using dangling pointers if a callback comes in the meanwhile
 864 #if wxUSE_TOOLBAR
 865     m_frameToolBar = NULL;
 866 #endif
 867 #if wxUSE_STATUSBAR
 868     m_frameStatusBar = NULL;
 869 #endif // wxUSE_STATUSBAR
 870
 871     DestroyChildren();
 872
 873     MDIRemoveWindowMenu(NULL, m_hMenu);
 874
 875     MSWDestroyWindow();
 876 }
 877
 878 bool wxMDIChildFrame::Show(bool show)
 879 {
 880     m_needsInitialShow = false;
 881
 882     if (!wxFrame::Show(show))
 883         return false;
 884
 885     // KH: Without this call, new MDI children do not become active.
 886     // This was added here after the same BringWindowToTop call was
 887     // removed from wxTopLevelWindow::Show (November 2005)
 888     if ( show )
 889         ::BringWindowToTop(GetHwnd());
 890
 891     // we need to refresh the MDI frame window menu to include (or exclude if
 892     // we've been hidden) this frame
 893     wxMDIParentFrame * const parent = GetMDIParent();
 894     MDISetMenu(parent->GetClientWindow(), NULL, NULL);
 895
 896     return true;
 897 }
 898
 899 // Set the client size (i.e. leave the calculation of borders etc.
 900 // to wxWidgets)
 901 void wxMDIChildFrame::DoSetClientSize(int width, int height)
 902 {
 903   HWND hWnd = GetHwnd();
 904
 905   RECT rect;
 906   ::GetClientRect(hWnd, &rect);
 907
 908   RECT rect2;
 909   GetWindowRect(hWnd, &rect2);
 910
 911   // Find the difference between the entire window (title bar and all)
 912   // and the client area; add this to the new client size to move the
 913   // window
 914   int actual_width = rect2.right - rect2.left - rect.right + width;
 915   int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
 916
 917 #if wxUSE_STATUSBAR
 918   if (GetStatusBar() && GetStatusBar()->IsShown())
 919   {
 920     int sx, sy;
 921     GetStatusBar()->GetSize(&sx, &sy);
 922     actual_height += sy;
 923   }
 924 #endif // wxUSE_STATUSBAR
 925
 926   POINT point;
 927   point.x = rect2.left;
 928   point.y = rect2.top;
 929
 930   // If there's an MDI parent, must subtract the parent's top left corner
 931   // since MoveWindow moves relative to the parent
 932   wxMDIParentFrame * const mdiParent = GetMDIParent();
 933   ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);
 934
 935   MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true);
 936
 937   wxSize size(width, height);
 938   wxSizeEvent event(size, m_windowId);
 939   event.SetEventObject( this );
 940   HandleWindowEvent(event);
 941 }
 942
 943 // Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the
 944 //  same as its GetScreenPosition
 945 void wxMDIChildFrame::DoGetScreenPosition(int *x, int *y) const
 946 {
 947   HWND hWnd = GetHwnd();
 948
 949   RECT rect;
 950   ::GetWindowRect(hWnd, &rect);
 951   if (x)
 952      *x = rect.left;
 953   if (y)
 954      *y = rect.top;
 955 }
 956
 957
 958 void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
 959 {
 960   RECT rect;
 961   GetWindowRect(GetHwnd(), &rect);
 962   POINT point;
 963   point.x = rect.left;
 964   point.y = rect.top;
 965
 966   // Since we now have the absolute screen coords,
 967   // if there's a parent we must subtract its top left corner
 968   wxMDIParentFrame * const mdiParent = GetMDIParent();
 969   ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point);
 970
 971   if (x)
 972       *x = point.x;
 973   if (y)
 974       *y = point.y;
 975 }
 976
 977 void wxMDIChildFrame::InternalSetMenuBar()
 978 {
 979     wxMDIParentFrame * const parent = GetMDIParent();
 980
 981     MDIInsertWindowMenu(parent->GetClientWindow(),
 982                      m_hMenu, GetMDIWindowMenu(parent));
 983 }
 984
 985 void wxMDIChildFrame::DetachMenuBar()
 986 {
 987     MDIRemoveWindowMenu(NULL, m_hMenu);
 988     wxFrame::DetachMenuBar();
 989 }
 990
 991 WXHICON wxMDIChildFrame::GetDefaultIcon() const
 992 {
 993     // we don't have any standard icons (any more)
 994     return (WXHICON)0;
 995 }
 996
 997 // ---------------------------------------------------------------------------
 998 // MDI operations
 999 // ---------------------------------------------------------------------------
1000
1001 void wxMDIChildFrame::Maximize(bool maximize)
1002 {
1003     wxMDIParentFrame * const parent = GetMDIParent();
1004     if ( parent && parent->GetClientWindow() )
1005     {
1006         ::SendMessage(GetWinHwnd(parent->GetClientWindow()),
1007                       maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
1008                       (WPARAM)GetHwnd(), 0);
1009     }
1010 }
1011
1012 void wxMDIChildFrame::Restore()
1013 {
1014     wxMDIParentFrame * const parent = GetMDIParent();
1015     if ( parent && parent->GetClientWindow() )
1016     {
1017         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
1018                       (WPARAM) GetHwnd(), 0);
1019     }
1020 }
1021
1022 void wxMDIChildFrame::Activate()
1023 {
1024     wxMDIParentFrame * const parent = GetMDIParent();
1025     if ( parent && parent->GetClientWindow() )
1026     {
1027         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
1028                       (WPARAM) GetHwnd(), 0);
1029     }
1030 }
1031
1032 // ---------------------------------------------------------------------------
1033 // MDI window proc and message handlers
1034 // ---------------------------------------------------------------------------
1035
1036 WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
1037                                     WXWPARAM wParam,
1038                                     WXLPARAM lParam)
1039 {
1040     WXLRESULT rc = 0;
1041     bool processed = false;
1042
1043     switch ( message )
1044     {
1045         case WM_GETMINMAXINFO:
1046             processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam);
1047             break;
1048
1049         case WM_MDIACTIVATE:
1050             {
1051                 WXWORD act;
1052                 WXHWND hwndAct, hwndDeact;
1053                 UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact);
1054
1055                 processed = HandleMDIActivate(act, hwndAct, hwndDeact);
1056             }
1057             // fall through
1058
1059         case WM_MOVE:
1060             // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
1061             // scrollbars if necessary
1062
1063             // fall through
1064
1065         case WM_SIZE:
1066             // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
1067             // things happen
1068             MSWDefWindowProc(message, wParam, lParam);
1069             break;
1070
1071         case WM_SYSCOMMAND:
1072             // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it
1073             // the message (the base class version does not)
1074             return MSWDefWindowProc(message, wParam, lParam);
1075
1076         case WM_WINDOWPOSCHANGING:
1077             processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);
1078             break;
1079     }
1080
1081     if ( !processed )
1082         rc = wxFrame::MSWWindowProc(message, wParam, lParam);
1083
1084     return rc;
1085 }
1086
1087 bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
1088                                         WXHWND hwndAct,
1089                                         WXHWND hwndDeact)
1090 {
1091     wxMDIParentFrame * const parent = GetMDIParent();
1092
1093     WXHMENU hMenuToSet = 0;
1094
1095     bool activated;
1096
1097     if ( m_hWnd == hwndAct )
1098     {
1099         activated = true;
1100         parent->SetActiveChild(this);
1101
1102         WXHMENU hMenuChild = m_hMenu;
1103         if ( hMenuChild )
1104             hMenuToSet = hMenuChild;
1105     }
1106     else if ( m_hWnd == hwndDeact )
1107     {
1108         wxASSERT_MSG( parent->GetActiveChild() == this,
1109                       wxT("can't deactivate MDI child which wasn't active!") );
1110
1111         activated = false;
1112         parent->SetActiveChild(NULL);
1113
1114         WXHMENU hMenuParent = parent->m_hMenu;
1115
1116         // activate the the parent menu only when there is no other child
1117         // that has been activated
1118         if ( hMenuParent && !hwndAct )
1119             hMenuToSet = hMenuParent;
1120     }
1121     else
1122     {
1123         // we have nothing to do with it
1124         return false;
1125     }
1126
1127     if ( hMenuToSet )
1128     {
1129         MDISetMenu(parent->GetClientWindow(),
1130                    (HMENU)hMenuToSet, GetMDIWindowMenu(parent));
1131     }
1132
1133     wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
1134     event.SetEventObject( this );
1135
1136     ResetWindowStyle(NULL);
1137
1138     return HandleWindowEvent(event);
1139 }
1140
1141 bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
1142 {
1143     WINDOWPOS *lpPos = (WINDOWPOS *)pos;
1144
1145     if (!(lpPos->flags & SWP_NOSIZE))
1146     {
1147         RECT rectClient;
1148         DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1149         DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1150         if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
1151         {
1152             ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle);
1153             lpPos->x = rectClient.left;
1154             lpPos->y = rectClient.top;
1155             lpPos->cx = rectClient.right - rectClient.left;
1156             lpPos->cy = rectClient.bottom - rectClient.top;
1157         }
1158     }
1159
1160     return false;
1161 }
1162
1163 bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo)
1164 {
1165     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
1166
1167     // let the default window proc calculate the size of MDI children
1168     // frames because it is based on the size of the MDI client window,
1169     // not on the values specified in wxWindow m_max variables
1170     bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0;
1171
1172     int minWidth = GetMinWidth(),
1173         minHeight = GetMinHeight();
1174
1175     // but allow GetSizeHints() to set the min size
1176     if ( minWidth != wxDefaultCoord )
1177     {
1178         info->ptMinTrackSize.x = minWidth;
1179
1180         processed = true;
1181     }
1182
1183     if ( minHeight != wxDefaultCoord )
1184     {
1185         info->ptMinTrackSize.y = minHeight;
1186
1187         processed = true;
1188     }
1189
1190     return processed;
1191 }
1192
1193 // ---------------------------------------------------------------------------
1194 // MDI specific message translation/preprocessing
1195 // ---------------------------------------------------------------------------
1196
1197 WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
1198 {
1199     return DefMDIChildProc(GetHwnd(),
1200                            (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
1201 }
1202
1203 bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
1204 {
1205     // we must pass the parent frame to ::TranslateAccelerator(), otherwise it
1206     // doesn't do its job correctly for MDI child menus
1207     return MSWDoTranslateMessage(GetMDIParent(), msg);
1208 }
1209
1210 // ---------------------------------------------------------------------------
1211 // misc
1212 // ---------------------------------------------------------------------------
1213
1214 void wxMDIChildFrame::MSWDestroyWindow()
1215 {
1216     wxMDIParentFrame * const parent = GetMDIParent();
1217
1218     // Must make sure this handle is invalidated (set to NULL) since all sorts
1219     // of things could happen after the child client is destroyed, but before
1220     // the wxFrame is destroyed.
1221
1222     HWND oldHandle = (HWND)GetHWND();
1223     SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
1224                 (WPARAM)oldHandle, 0);
1225
1226     if (parent->GetActiveChild() == NULL)
1227         ResetWindowStyle(NULL);
1228
1229     if (m_hMenu)
1230     {
1231         ::DestroyMenu((HMENU) m_hMenu);
1232         m_hMenu = 0;
1233     }
1234     wxRemoveHandleAssociation(this);
1235     m_hWnd = 0;
1236 }
1237
1238 // Change the client window's extended style so we don't get a client edge
1239 // style when a child is maximised (a double border looks silly.)
1240 bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
1241 {
1242     RECT *rect = (RECT *)vrect;
1243     wxMDIParentFrame * const pFrameWnd = GetMDIParent();
1244     wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
1245
1246     if (!pChild || (pChild == this))
1247     {
1248         HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow());
1249         DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE);
1250
1251         // we want to test whether there is a maximized child, so just set
1252         // dwThisStyle to 0 if there is no child at all
1253         DWORD dwThisStyle = pChild
1254             ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0;
1255         DWORD dwNewStyle = dwStyle;
1256         if ( dwThisStyle & WS_MAXIMIZE )
1257             dwNewStyle &= ~(WS_EX_CLIENTEDGE);
1258         else
1259             dwNewStyle |= WS_EX_CLIENTEDGE;
1260
1261         if (dwStyle != dwNewStyle)
1262         {
1263             // force update of everything
1264             ::RedrawWindow(hwndClient, NULL, NULL,
1265                            RDW_INVALIDATE | RDW_ALLCHILDREN);
1266             ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle);
1267             ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0,
1268                            SWP_FRAMECHANGED | SWP_NOACTIVATE |
1269                            SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1270                            SWP_NOCOPYBITS);
1271             if (rect)
1272                 ::GetClientRect(hwndClient, rect);
1273
1274             return true;
1275         }
1276     }
1277
1278     return false;
1279 }
1280
1281 // ===========================================================================
1282 // wxMDIClientWindow: the window of predefined (by Windows) class which
1283 // contains the child frames
1284 // ===========================================================================
1285
1286 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
1287 {
1288     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
1289
1290     CLIENTCREATESTRUCT ccs;
1291     m_windowStyle = style;
1292     m_parent = parent;
1293
1294     ccs.hWindowMenu = GetMDIWindowMenu(parent);
1295     ccs.idFirstChild = wxFIRST_MDI_CHILD;
1296
1297     DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD |
1298                     WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
1299
1300     if ( style & wxHSCROLL )
1301         msStyle |= WS_HSCROLL;
1302     if ( style & wxVSCROLL )
1303         msStyle |= WS_VSCROLL;
1304
1305     DWORD exStyle = WS_EX_CLIENTEDGE;
1306
1307     wxWindowCreationHook hook(this);
1308     m_hWnd = (WXHWND)::CreateWindowEx
1309                        (
1310                         exStyle,
1311                         wxT("MDICLIENT"),
1312                         NULL,
1313                         msStyle,
1314                         0, 0, 0, 0,
1315                         GetWinHwnd(parent),
1316                         NULL,
1317                         wxGetInstance(),
1318                         (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
1319     if ( !m_hWnd )
1320     {
1321         wxLogLastError(wxT("CreateWindowEx(MDI client)"));
1322
1323         return false;
1324     }
1325
1326     SubclassWin(m_hWnd);
1327
1328     return true;
1329 }
1330
1331 // Explicitly call default scroll behaviour
1332 void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
1333 {
1334     // Note: for client windows, the scroll position is not set in
1335     // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
1336     // scroll position we're at.
1337     // This makes it hard to paint patterns or bitmaps in the background,
1338     // and have the client area scrollable as well.
1339
1340     if ( event.GetOrientation() == wxHORIZONTAL )
1341         m_scrollX = event.GetPosition(); // Always returns zero!
1342     else
1343         m_scrollY = event.GetPosition(); // Always returns zero!
1344
1345     event.Skip();
1346 }
1347
1348 void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1349 {
1350     // Try to fix a problem whereby if you show an MDI child frame, then reposition the
1351     // client area, you can end up with a non-refreshed portion in the client window
1352     // (see OGL studio sample). So check if the position is changed and if so,
1353     // redraw the MDI child frames.
1354
1355     const wxPoint oldPos = GetPosition();
1356
1357     wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE);
1358
1359     const wxPoint newPos = GetPosition();
1360
1361     if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
1362     {
1363         if (GetParent())
1364         {
1365             wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst();
1366             while (node)
1367             {
1368                 wxWindow *child = node->GetData();
1369                 if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
1370                 {
1371                    ::RedrawWindow(GetHwndOf(child),
1372                                   NULL,
1373                                   NULL,
1374                                   RDW_FRAME |
1375                                   RDW_ALLCHILDREN |
1376                                   RDW_INVALIDATE);
1377                 }
1378                 node = node->GetNext();
1379             }
1380         }
1381     }
1382 }
1383
1384 void wxMDIChildFrame::OnIdle(wxIdleEvent& event)
1385 {
1386     // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted
1387     // in flicker e.g. when the frame contained controls with non-trivial
1388     // layout. Since 2.5.3, the frame is created hidden as all other top level
1389     // windows. In order to maintain backward compatibility, the frame is shown
1390     // in OnIdle, unless Show(false) was called by the programmer before.
1391     if ( m_needsInitialShow )
1392     {
1393         Show(true);
1394     }
1395
1396     // MDI child frames get their WM_SIZE when they're constructed but at this
1397     // moment they don't have any children yet so all child windows will be
1398     // positioned incorrectly when they are added later - to fix this, we
1399     // generate an artificial size event here
1400     if ( m_needsResize )
1401     {
1402         m_needsResize = false; // avoid any possibility of recursion
1403
1404         SendSizeEvent();
1405     }
1406
1407     event.Skip();
1408 }
1409
1410 // ---------------------------------------------------------------------------
1411 // private helper functions
1412 // ---------------------------------------------------------------------------
1413
1414 namespace
1415 {
1416
1417 void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
1418 {
1419     if ( hmenuFrame || hmenuWindow )
1420     {
1421         if ( !::SendMessage(GetWinHwnd(win),
1422                             WM_MDISETMENU,
1423                             (WPARAM)hmenuFrame,
1424                             (LPARAM)hmenuWindow) )
1425         {
1426 #ifdef __WXDEBUG__
1427             DWORD err = ::GetLastError();
1428             if ( err )
1429                 wxLogApiError(_T("SendMessage(WM_MDISETMENU)"), err);
1430 #endif // __WXDEBUG__
1431         }
1432     }
1433
1434     // update menu bar of the parent window
1435     wxWindow *parent = win->GetParent();
1436     wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
1437
1438     ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
1439
1440     ::DrawMenuBar(GetWinHwnd(parent));
1441 }
1442
1443 void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU menuWin)
1444 {
1445     HMENU hmenu = (HMENU)hMenu;
1446
1447     if ( menuWin )
1448     {
1449         // Try to insert Window menu in front of Help, otherwise append it.
1450         int N = GetMenuItemCount(hmenu);
1451         bool inserted = false;
1452         for ( int i = 0; i < N; i++ )
1453         {
1454             wxChar buf[256];
1455             if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
1456             {
1457                 wxLogLastError(wxT("GetMenuString"));
1458
1459                 continue;
1460             }
1461
1462             const wxString label = wxStripMenuCodes(buf);
1463             if ( label == wxGetStockLabel(wxID_HELP, wxSTOCK_NOFLAGS) )
1464             {
1465                 inserted = true;
1466                 ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
1467                              (UINT_PTR)menuWin,
1468                              wxGetTranslation(WINDOW_MENU_LABEL).wx_str());
1469                 break;
1470             }
1471         }
1472
1473         if ( !inserted )
1474         {
1475             ::AppendMenu(hmenu, MF_POPUP,
1476                          (UINT_PTR)menuWin,
1477                          wxGetTranslation(WINDOW_MENU_LABEL).wx_str());
1478         }
1479     }
1480
1481     MDISetMenu(win, hmenu, menuWin);
1482 }
1483
1484 void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu)
1485 {
1486     HMENU hmenu = (HMENU)hMenu;
1487
1488     if ( hmenu )
1489     {
1490         wxChar buf[1024];
1491
1492         int N = ::GetMenuItemCount(hmenu);
1493         for ( int i = 0; i < N; i++ )
1494         {
1495             if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
1496             {
1497                 // Ignore successful read of menu string with length 0 which
1498                 // occurs, for example, for a maximized MDI child system menu
1499                 if ( ::GetLastError() != 0 )
1500                 {
1501                     wxLogLastError(wxT("GetMenuString"));
1502                 }
1503
1504                 continue;
1505             }
1506
1507             if ( wxStrcmp(buf, wxGetTranslation(WINDOW_MENU_LABEL)) == 0 )
1508             {
1509                 if ( !::RemoveMenu(hmenu, i, MF_BYPOSITION) )
1510                 {
1511                     wxLogLastError(wxT("RemoveMenu"));
1512                 }
1513
1514                 break;
1515             }
1516         }
1517     }
1518
1519     if ( win )
1520     {
1521         // we don't change the windows menu, but we update the main one
1522         MDISetMenu(win, hmenu, NULL);
1523     }
1524 }
1525
1526 void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
1527                               WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
1528 {
1529     *activate = true;
1530     *hwndAct = (WXHWND)lParam;
1531     *hwndDeact = (WXHWND)wParam;
1532 }
1533
1534 } // anonymous namespace
1535
1536 #endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)