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