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 void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
 863 {
 864   RECT rect;
 865   GetWindowRect(GetHwnd(), &rect);
 866   POINT point;
 867   point.x = rect.left;
 868   point.y = rect.top;
 869
 870   // Since we now have the absolute screen coords,
 871   // if there's a parent we must subtract its top left corner
 872   wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
 873   ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
 874
 875   if (x)
 876       *x = point.x;
 877   if (y)
 878       *y = point.y;
 879 }
 880
 881 void wxMDIChildFrame::InternalSetMenuBar()
 882 {
 883     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 884
 885     InsertWindowMenu(parent->GetClientWindow(),
 886                      m_hMenu, GetMDIWindowMenu(parent));
 887
 888     parent->m_parentFrameActive = false;
 889 }
 890
 891 void wxMDIChildFrame::DetachMenuBar()
 892 {
 893     RemoveWindowMenu(NULL, m_hMenu);
 894     wxFrame::DetachMenuBar();
 895 }
 896
 897 WXHICON wxMDIChildFrame::GetDefaultIcon() const
 898 {
 899     // we don't have any standard icons (any more)
 900     return (WXHICON)0;
 901 }
 902
 903 // ---------------------------------------------------------------------------
 904 // MDI operations
 905 // ---------------------------------------------------------------------------
 906
 907 void wxMDIChildFrame::Maximize(bool maximize)
 908 {
 909     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 910     if ( parent && parent->GetClientWindow() )
 911     {
 912         ::SendMessage(GetWinHwnd(parent->GetClientWindow()),
 913                       maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
 914                       (WPARAM)GetHwnd(), 0);
 915     }
 916 }
 917
 918 void wxMDIChildFrame::Restore()
 919 {
 920     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 921     if ( parent && parent->GetClientWindow() )
 922     {
 923         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
 924                       (WPARAM) GetHwnd(), 0);
 925     }
 926 }
 927
 928 void wxMDIChildFrame::Activate()
 929 {
 930     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 931     if ( parent && parent->GetClientWindow() )
 932     {
 933         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
 934                       (WPARAM) GetHwnd(), 0);
 935     }
 936 }
 937
 938 // ---------------------------------------------------------------------------
 939 // MDI window proc and message handlers
 940 // ---------------------------------------------------------------------------
 941
 942 WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message,
 943                                     WXWPARAM wParam,
 944                                     WXLPARAM lParam)
 945 {
 946     WXLRESULT rc = 0;
 947     bool processed = false;
 948
 949     switch ( message )
 950     {
 951         case WM_COMMAND:
 952             {
 953                 WORD id, cmd;
 954                 WXHWND hwnd;
 955                 UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
 956                               &id, &hwnd, &cmd);
 957
 958                 processed = HandleCommand(id, cmd, (WXHWND)hwnd);
 959             }
 960             break;
 961
 962         case WM_GETMINMAXINFO:
 963             processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam);
 964             break;
 965
 966         case WM_MDIACTIVATE:
 967             {
 968                 WXWORD act;
 969                 WXHWND hwndAct, hwndDeact;
 970                 UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact);
 971
 972                 processed = HandleMDIActivate(act, hwndAct, hwndDeact);
 973             }
 974             // fall through
 975
 976         case WM_MOVE:
 977             // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
 978             // scrollbars if necessary
 979
 980             // fall through
 981
 982         case WM_SIZE:
 983             // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
 984             // things happen
 985             MSWDefWindowProc(message, wParam, lParam);
 986             break;
 987
 988         case WM_SYSCOMMAND:
 989             // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it
 990             // the message (the base class version does not)
 991             return MSWDefWindowProc(message, wParam, lParam);
 992
 993         case WM_WINDOWPOSCHANGING:
 994             processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);
 995             break;
 996     }
 997
 998     if ( !processed )
 999         rc = wxFrame::MSWWindowProc(message, wParam, lParam);
1000
1001     return rc;
1002 }
1003
1004 bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
1005 {
1006     // In case it's e.g. a toolbar.
1007     if ( hwnd )
1008     {
1009         wxWindow *win = wxFindWinFromHandle(hwnd);
1010         if (win)
1011             return win->MSWCommand(cmd, id);
1012     }
1013
1014     if (wxCurrentPopupMenu)
1015     {
1016         wxMenu *popupMenu = wxCurrentPopupMenu;
1017         wxCurrentPopupMenu = NULL;
1018         if (popupMenu->MSWCommand(cmd, id))
1019             return true;
1020     }
1021
1022     bool processed;
1023     if (GetMenuBar() && GetMenuBar()->FindItem(id))
1024     {
1025         processed = ProcessCommand(id);
1026     }
1027     else
1028     {
1029         processed = false;
1030     }
1031
1032     return processed;
1033 }
1034
1035 bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
1036                                         WXHWND hwndAct,
1037                                         WXHWND hwndDeact)
1038 {
1039     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
1040
1041     HMENU menuToSet = 0;
1042
1043     bool activated;
1044
1045     if ( m_hWnd == hwndAct )
1046     {
1047         activated = true;
1048         parent->m_currentChild = this;
1049
1050         HMENU child_menu = (HMENU)GetWinMenu();
1051         if ( child_menu )
1052         {
1053             parent->m_parentFrameActive = false;
1054
1055             menuToSet = child_menu;
1056         }
1057     }
1058     else if ( m_hWnd == hwndDeact )
1059     {
1060         wxASSERT_MSG( parent->m_currentChild == this,
1061                       wxT("can't deactivate MDI child which wasn't active!") );
1062
1063         activated = false;
1064         parent->m_currentChild = NULL;
1065
1066         HMENU parent_menu = (HMENU)parent->GetWinMenu();
1067
1068         // activate the the parent menu only when there is no other child
1069         // that has been activated
1070         if ( parent_menu && !hwndAct )
1071         {
1072             parent->m_parentFrameActive = true;
1073
1074             menuToSet = parent_menu;
1075         }
1076     }
1077     else
1078     {
1079         // we have nothing to do with it
1080         return false;
1081     }
1082
1083     if ( menuToSet )
1084     {
1085         MDISetMenu(parent->GetClientWindow(),
1086                    menuToSet, GetMDIWindowMenu(parent));
1087     }
1088
1089     wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
1090     event.SetEventObject( this );
1091
1092     ResetWindowStyle((void *)NULL);
1093
1094     return GetEventHandler()->ProcessEvent(event);
1095 }
1096
1097 bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
1098 {
1099     WINDOWPOS *lpPos = (WINDOWPOS *)pos;
1100
1101     if (!(lpPos->flags & SWP_NOSIZE))
1102     {
1103         RECT rectClient;
1104         DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1105         DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1106         if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
1107         {
1108             ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle);
1109             lpPos->x = rectClient.left;
1110             lpPos->y = rectClient.top;
1111             lpPos->cx = rectClient.right - rectClient.left;
1112             lpPos->cy = rectClient.bottom - rectClient.top;
1113         }
1114     }
1115
1116     return false;
1117 }
1118
1119 bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo)
1120 {
1121     MINMAXINFO *info = (MINMAXINFO *)mmInfo;
1122
1123     // let the default window proc calculate the size of MDI children
1124     // frames because it is based on the size of the MDI client window,
1125     // not on the values specified in wxWindow m_max variables
1126     bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0;
1127
1128     int minWidth = GetMinWidth(),
1129         minHeight = GetMinHeight();
1130
1131     // but allow GetSizeHints() to set the min size
1132     if ( minWidth != wxDefaultCoord )
1133     {
1134         info->ptMinTrackSize.x = minWidth;
1135
1136         processed = true;
1137     }
1138
1139     if ( minHeight != wxDefaultCoord )
1140     {
1141         info->ptMinTrackSize.y = minHeight;
1142
1143         processed = true;
1144     }
1145
1146     return processed;
1147 }
1148
1149 // ---------------------------------------------------------------------------
1150 // MDI specific message translation/preprocessing
1151 // ---------------------------------------------------------------------------
1152
1153 WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
1154 {
1155     return DefMDIChildProc(GetHwnd(),
1156                            (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
1157 }
1158
1159 bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
1160 {
1161     // we must pass the parent frame to ::TranslateAccelerator(), otherwise it
1162     // doesn't do its job correctly for MDI child menus
1163     return MSWDoTranslateMessage((wxMDIChildFrame *)GetParent(), msg);
1164 }
1165
1166 // ---------------------------------------------------------------------------
1167 // misc
1168 // ---------------------------------------------------------------------------
1169
1170 void wxMDIChildFrame::MSWDestroyWindow()
1171 {
1172     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
1173
1174     // Must make sure this handle is invalidated (set to NULL) since all sorts
1175     // of things could happen after the child client is destroyed, but before
1176     // the wxFrame is destroyed.
1177
1178     HWND oldHandle = (HWND)GetHWND();
1179     SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
1180                 (WPARAM)oldHandle, 0);
1181
1182     if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL)
1183         ResetWindowStyle((void*) NULL);
1184
1185     if (m_hMenu)
1186     {
1187         ::DestroyMenu((HMENU) m_hMenu);
1188         m_hMenu = 0;
1189     }
1190     wxRemoveHandleAssociation(this);
1191     m_hWnd = 0;
1192 }
1193
1194 // Change the client window's extended style so we don't get a client edge
1195 // style when a child is maximised (a double border looks silly.)
1196 bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
1197 {
1198     RECT *rect = (RECT *)vrect;
1199     wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
1200     wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
1201
1202     if (!pChild || (pChild == this))
1203     {
1204         HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow());
1205         DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE);
1206
1207         // we want to test whether there is a maximized child, so just set
1208         // dwThisStyle to 0 if there is no child at all
1209         DWORD dwThisStyle = pChild
1210             ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0;
1211         DWORD dwNewStyle = dwStyle;
1212         if ( dwThisStyle & WS_MAXIMIZE )
1213             dwNewStyle &= ~(WS_EX_CLIENTEDGE);
1214         else
1215             dwNewStyle |= WS_EX_CLIENTEDGE;
1216
1217         if (dwStyle != dwNewStyle)
1218         {
1219             // force update of everything
1220             ::RedrawWindow(hwndClient, NULL, NULL,
1221                            RDW_INVALIDATE | RDW_ALLCHILDREN);
1222             ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle);
1223             ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0,
1224                            SWP_FRAMECHANGED | SWP_NOACTIVATE |
1225                            SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1226                            SWP_NOCOPYBITS);
1227             if (rect)
1228                 ::GetClientRect(hwndClient, rect);
1229
1230             return true;
1231         }
1232     }
1233
1234     return false;
1235 }
1236
1237 // ===========================================================================
1238 // wxMDIClientWindow: the window of predefined (by Windows) class which
1239 // contains the child frames
1240 // ===========================================================================
1241
1242 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
1243 {
1244     m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
1245
1246     CLIENTCREATESTRUCT ccs;
1247     m_windowStyle = style;
1248     m_parent = parent;
1249
1250     ccs.hWindowMenu = GetMDIWindowMenu(parent);
1251     ccs.idFirstChild = wxFIRST_MDI_CHILD;
1252
1253     DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD |
1254                     WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
1255
1256     if ( style & wxHSCROLL )
1257         msStyle |= WS_HSCROLL;
1258     if ( style & wxVSCROLL )
1259         msStyle |= WS_VSCROLL;
1260
1261     DWORD exStyle = WS_EX_CLIENTEDGE;
1262
1263     wxWindowCreationHook hook(this);
1264     m_hWnd = (WXHWND)::CreateWindowEx
1265                        (
1266                         exStyle,
1267                         wxT("MDICLIENT"),
1268                         NULL,
1269                         msStyle,
1270                         0, 0, 0, 0,
1271                         GetWinHwnd(parent),
1272                         NULL,
1273                         wxGetInstance(),
1274                         (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
1275     if ( !m_hWnd )
1276     {
1277         wxLogLastError(wxT("CreateWindowEx(MDI client)"));
1278
1279         return false;
1280     }
1281
1282     SubclassWin(m_hWnd);
1283
1284     return true;
1285 }
1286
1287 // Explicitly call default scroll behaviour
1288 void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
1289 {
1290     // Note: for client windows, the scroll position is not set in
1291     // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
1292     // scroll position we're at.
1293     // This makes it hard to paint patterns or bitmaps in the background,
1294     // and have the client area scrollable as well.
1295
1296     if ( event.GetOrientation() == wxHORIZONTAL )
1297         m_scrollX = event.GetPosition(); // Always returns zero!
1298     else
1299         m_scrollY = event.GetPosition(); // Always returns zero!
1300
1301     event.Skip();
1302 }
1303
1304 void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1305 {
1306     // Try to fix a problem whereby if you show an MDI child frame, then reposition the
1307     // client area, you can end up with a non-refreshed portion in the client window
1308     // (see OGL studio sample). So check if the position is changed and if so,
1309     // redraw the MDI child frames.
1310
1311     const wxPoint oldPos = GetPosition();
1312
1313     wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE);
1314
1315     const wxPoint newPos = GetPosition();
1316
1317     if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
1318     {
1319         if (GetParent())
1320         {
1321             wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst();
1322             while (node)
1323             {
1324                 wxWindow *child = node->GetData();
1325                 if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
1326                 {
1327                    ::RedrawWindow(GetHwndOf(child),
1328                                   NULL,
1329                                   NULL,
1330                                   RDW_FRAME |
1331                                   RDW_ALLCHILDREN |
1332                                   RDW_INVALIDATE);
1333                 }
1334                 node = node->GetNext();
1335             }
1336         }
1337     }
1338 }
1339
1340 void wxMDIChildFrame::OnIdle(wxIdleEvent& event)
1341 {
1342     // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted
1343     // in flicker e.g. when the frame contained controls with non-trivial
1344     // layout. Since 2.5.3, the frame is created hidden as all other top level
1345     // windows. In order to maintain backward compatibility, the frame is shown
1346     // in OnIdle, unless Show(false) was called by the programmer before.
1347     if ( m_needsInitialShow )
1348     {
1349         Show(true);
1350     }
1351
1352     // MDI child frames get their WM_SIZE when they're constructed but at this
1353     // moment they don't have any children yet so all child windows will be
1354     // positioned incorrectly when they are added later - to fix this, we
1355     // generate an artificial size event here
1356     if ( m_needsResize )
1357     {
1358         m_needsResize = false; // avoid any possibility of recursion
1359
1360         SendSizeEvent();
1361     }
1362
1363     event.Skip();
1364 }
1365
1366 // ---------------------------------------------------------------------------
1367 // non member functions
1368 // ---------------------------------------------------------------------------
1369
1370 static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
1371 {
1372     if ( hmenuFrame || hmenuWindow )
1373     {
1374         if ( !::SendMessage(GetWinHwnd(win),
1375                             WM_MDISETMENU,
1376                             (WPARAM)hmenuFrame,
1377                             (LPARAM)hmenuWindow) )
1378         {
1379             wxLogLastError(_T("SendMessage(WM_MDISETMENU)"));
1380         }
1381     }
1382
1383     // update menu bar of the parent window
1384     wxWindow *parent = win->GetParent();
1385     wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
1386
1387     ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L);
1388
1389     ::DrawMenuBar(GetWinHwnd(parent));
1390 }
1391
1392 static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu)
1393 {
1394     // Try to insert Window menu in front of Help, otherwise append it.
1395     HMENU hmenu = (HMENU)menu;
1396
1397     if (subMenu)
1398     {
1399         int N = GetMenuItemCount(hmenu);
1400         bool success = false;
1401         for ( int i = 0; i < N; i++ )
1402         {
1403             wxChar buf[256];
1404             int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
1405             if ( chars == 0 )
1406             {
1407                 wxLogLastError(wxT("GetMenuString"));
1408
1409                 continue;
1410             }
1411
1412             wxString strBuf(buf);
1413             if ( wxStripMenuCodes(strBuf) == wxGetStockLabel(wxID_HELP,false) )
1414             {
1415                 success = true;
1416                 ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
1417                              (UINT)subMenu, _("&Window"));
1418                 break;
1419             }
1420         }
1421
1422         if ( !success )
1423         {
1424             ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window"));
1425         }
1426     }
1427
1428     MDISetMenu(win, hmenu, subMenu);
1429 }
1430
1431 static void RemoveWindowMenu(wxWindow *win, WXHMENU menu)
1432 {
1433     HMENU hMenu = (HMENU)menu;
1434
1435     if ( hMenu )
1436     {
1437         wxChar buf[1024];
1438
1439         int N = ::GetMenuItemCount(hMenu);
1440         for ( int i = 0; i < N; i++ )
1441         {
1442             if ( !::GetMenuString(hMenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) )
1443             {
1444                 // Ignore successful read of menu string with length 0 which
1445                 // occurs, for example, for a maximized MDI childs system menu
1446                 if ( ::GetLastError() != 0 )
1447                 {
1448                     wxLogLastError(wxT("GetMenuString"));
1449                 }
1450
1451                 continue;
1452             }
1453
1454             if ( wxStrcmp(buf, _("&Window")) == 0 )
1455             {
1456                 if ( !::RemoveMenu(hMenu, i, MF_BYPOSITION) )
1457                 {
1458                     wxLogLastError(wxT("RemoveMenu"));
1459                 }
1460
1461                 break;
1462             }
1463         }
1464     }
1465
1466     if ( win )
1467     {
1468         // we don't change the windows menu, but we update the main one
1469         MDISetMenu(win, hMenu, NULL);
1470     }
1471 }
1472
1473 static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
1474                               WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
1475 {
1476     *activate = true;
1477     *hwndAct = (WXHWND)lParam;
1478     *hwndDeact = (WXHWND)wParam;
1479 }
1480
1481 #endif // wxUSE_MDI && !defined(__WXUNIVERSAL__)