src/msw/mdi.cpp

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