src/msw/mdi.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        mdi.cpp
   3 // Purpose:     MDI classes
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "mdi.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/setup.h"
  33     #include "wx/frame.h"
  34     #include "wx/menu.h"
  35     #include "wx/app.h"
  36     #include "wx/utils.h"
  37     #include "wx/dialog.h"
  38     #if wxUSE_STATUSBAR
  39         #include "wx/statusbr.h"
  40     #endif
  41     #include "wx/settings.h"
  42     #include "wx/intl.h"
  43     #include "wx/log.h"
  44 #endif
  45
  46 #include "wx/mdi.h"
  47 #include "wx/msw/private.h"
  48
  49 #if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR
  50     #include "wx/msw/statbr95.h"
  51 #endif
  52
  53 #if wxUSE_TOOLBAR
  54     #include "wx/toolbar.h"
  55 #endif // wxUSE_TOOLBAR
  56
  57 #include <string.h>
  58
  59 // ---------------------------------------------------------------------------
  60 // global variables
  61 // ---------------------------------------------------------------------------
  62
  63 extern wxWindowList wxModelessWindows;      // from dialog.cpp
  64 extern wxMenu *wxCurrentPopupMenu;
  65
  66 extern const wxChar *wxMDIFrameClassName;
  67 extern const wxChar *wxMDIChildFrameClassName;
  68 extern wxWindow *wxWndHook;                 // from window.cpp
  69
  70 extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
  71
  72 static HWND invalidHandle = 0;
  73
  74 // ---------------------------------------------------------------------------
  75 // constants
  76 // ---------------------------------------------------------------------------
  77
  78 static const int IDM_WINDOWTILE  = 4001;
  79 static const int IDM_WINDOWTILEHOR  = 4001;
  80 static const int IDM_WINDOWCASCADE = 4002;
  81 static const int IDM_WINDOWICONS = 4003;
  82 static const int IDM_WINDOWNEXT = 4004;
  83 static const int IDM_WINDOWTILEVERT = 4005;
  84
  85 // This range gives a maximum of 500 MDI children. Should be enough :-)
  86 static const int wxFIRST_MDI_CHILD = 4100;
  87 static const int wxLAST_MDI_CHILD = 4600;
  88
  89 // Status border dimensions
  90 static const int wxTHICK_LINE_BORDER = 3;
  91 static const int wxTHICK_LINE_WIDTH  = 1;
  92
  93 // ---------------------------------------------------------------------------
  94 // private functions
  95 // ---------------------------------------------------------------------------
  96
  97 // set the MDI menus (by sending the WM_MDISETMENU message) and update the menu
  98 // of the parent of win (which is supposed to be the MDI client window)
  99 static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow);
 100
 101 // insert the window menu (subMenu) into menu just before "Help" submenu or at
 102 // the very end if not found
 103 static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu);
 104
 105 // Remove the window menu
 106 static void RemoveWindowMenu(wxWindow *win, WXHMENU menu);
 107
 108 // is this an id of an MDI child?
 109 inline bool IsMdiCommandId(int id)
 110 {
 111     return (id >= wxFIRST_MDI_CHILD) && (id <= wxLAST_MDI_CHILD);
 112 }
 113
 114 static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
 115                               WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact);
 116
 117 // ===========================================================================
 118 // implementation
 119 // ===========================================================================
 120
 121 // ---------------------------------------------------------------------------
 122 // wxWin macros
 123 // ---------------------------------------------------------------------------
 124
 125 IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
 126 IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
 127 IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
 128
 129 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
 130     EVT_SIZE(wxMDIParentFrame::OnSize)
 131     EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
 132 END_EVENT_TABLE()
 133
 134 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
 135     EVT_SCROLL(wxMDIClientWindow::OnScroll)
 136 END_EVENT_TABLE()
 137
 138 // ===========================================================================
 139 // wxMDIParentFrame: the frame which contains the client window which manages
 140 // the children
 141 // ===========================================================================
 142
 143 wxMDIParentFrame::wxMDIParentFrame()
 144 {
 145     m_clientWindow = NULL;
 146     m_currentChild = NULL;
 147     m_windowMenu = (wxMenu*) NULL;
 148     m_parentFrameActive = TRUE;
 149 }
 150
 151 bool wxMDIParentFrame::Create(wxWindow *parent,
 152                               wxWindowID id,
 153                               const wxString& title,
 154                               const wxPoint& pos,
 155                               const wxSize& size,
 156                               long style,
 157                               const wxString& name)
 158 {
 159   m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON);
 160
 161   m_clientWindow = NULL;
 162   m_currentChild = NULL;
 163
 164   if (style & wxFRAME_NO_WINDOW_MENU)
 165       m_windowMenu = (wxMenu*) NULL;
 166   else
 167   {
 168   // m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), wxT("wxWindowMenu"));
 169       m_windowMenu = new wxMenu;
 170
 171
 172       m_windowMenu->Append(4002, wxT("&Cascade"));
 173       m_windowMenu->Append(4001, wxT("Tile &Horizontally"));
 174       m_windowMenu->Append(4005, wxT("Tile &Vertically"));
 175       m_windowMenu->AppendSeparator();
 176       m_windowMenu->Append(4003, wxT("&Arrange Icons"));
 177       m_windowMenu->Append(4004, wxT("&Next"));
 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) parent->AddChild(this);
 189
 190   if ( id > -1 )
 191     m_windowId = id;
 192   else
 193     m_windowId = (int)NewControlId();
 194
 195   int x = pos.x;
 196   int y = pos.y;
 197   int width = size.x;
 198   int height = size.y;
 199
 200   DWORD msflags = WS_OVERLAPPED;
 201   if (style & wxMINIMIZE_BOX)
 202     msflags |= WS_MINIMIZEBOX;
 203   if (style & wxMAXIMIZE_BOX)
 204     msflags |= WS_MAXIMIZEBOX;
 205   if (style & wxTHICK_FRAME)
 206     msflags |= WS_THICKFRAME;
 207   if (style & wxSYSTEM_MENU)
 208     msflags |= WS_SYSMENU;
 209   if ((style & wxMINIMIZE) || (style & wxICONIZE))
 210     msflags |= WS_MINIMIZE;
 211   if (style & wxMAXIMIZE)
 212     msflags |= WS_MAXIMIZE;
 213   if (style & wxCAPTION)
 214     msflags |= WS_CAPTION;
 215
 216   if (style & wxCLIP_CHILDREN)
 217     msflags |= WS_CLIPCHILDREN;
 218
 219   wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
 220          msflags);
 221
 222   wxModelessWindows.Append(this);
 223
 224   return TRUE;
 225 }
 226
 227 wxMDIParentFrame::~wxMDIParentFrame()
 228 {
 229     DestroyChildren();
 230     // already delete by DestroyChildren()
 231     m_frameToolBar = NULL;
 232
 233     // ::DestroyMenu((HMENU)m_windowMenu);
 234     if (m_windowMenu)
 235     {
 236         delete m_windowMenu;
 237         m_windowMenu = (wxMenu*) NULL;
 238     }
 239
 240     if ( m_clientWindow )
 241     {
 242         if ( m_clientWindow->MSWGetOldWndProc() )
 243             m_clientWindow->UnsubclassWin();
 244
 245         m_clientWindow->SetHWND(0);
 246         delete m_clientWindow;
 247     }
 248 }
 249
 250 void wxMDIParentFrame::InternalSetMenuBar()
 251 {
 252 //    HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);
 253
 254     m_parentFrameActive = TRUE;
 255
 256     HMENU subMenu = (HMENU) 0;
 257     if (GetWindowMenu())
 258         subMenu = (HMENU) GetWindowMenu()->GetHMenu();
 259
 260     InsertWindowMenu(GetClientWindow(), m_hMenu, subMenu);
 261 }
 262
 263 void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
 264 {
 265     if (m_windowMenu)
 266     {
 267         if (GetMenuBar())
 268         {
 269             // Remove old window menu
 270             RemoveWindowMenu(GetClientWindow(), m_hMenu);
 271         }
 272
 273         delete m_windowMenu;
 274         m_windowMenu = (wxMenu*) NULL;
 275     }
 276     if (menu)
 277     {
 278         m_windowMenu = menu;
 279         if (GetMenuBar())
 280             InsertWindowMenu(GetClientWindow(), m_hMenu, (HMENU) m_windowMenu->GetHMenu());
 281     }
 282 }
 283
 284 void wxMDIParentFrame::OnSize(wxSizeEvent& event)
 285 {
 286     if ( GetClientWindow() )
 287     {
 288         int width, height;
 289         GetClientSize(&width, &height);
 290
 291         GetClientWindow()->SetSize(0, 0, width, height);
 292     }
 293 }
 294
 295 // Returns the active MDI child window
 296 wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
 297 {
 298     HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
 299                                     WM_MDIGETACTIVE, 0, 0L);
 300     if ( hWnd == 0 )
 301         return NULL;
 302     else
 303         return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd);
 304 }
 305
 306 // Create the client window class (don't Create the window, just return a new
 307 // class)
 308 wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
 309 {
 310     return new wxMDIClientWindow;
 311 }
 312
 313 // Responds to colour changes, and passes event on to children.
 314 void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
 315 {
 316     if ( m_clientWindow )
 317     {
 318         m_clientWindow->SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
 319         m_clientWindow->Refresh();
 320     }
 321
 322     event.Skip();
 323 }
 324
 325 // ---------------------------------------------------------------------------
 326 // MDI operations
 327 // ---------------------------------------------------------------------------
 328
 329 void wxMDIParentFrame::Cascade()
 330 {
 331     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
 332 }
 333
 334 // TODO: add a direction argument (hor/vert)
 335 void wxMDIParentFrame::Tile()
 336 {
 337     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0);
 338 }
 339
 340 void wxMDIParentFrame::ArrangeIcons()
 341 {
 342     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0);
 343 }
 344
 345 void wxMDIParentFrame::ActivateNext()
 346 {
 347     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0);
 348 }
 349
 350 void wxMDIParentFrame::ActivatePrevious()
 351 {
 352     ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);
 353 }
 354
 355 // ---------------------------------------------------------------------------
 356 // the MDI parent frame window proc
 357 // ---------------------------------------------------------------------------
 358
 359 long wxMDIParentFrame::MSWWindowProc(WXUINT message,
 360                                      WXWPARAM wParam,
 361                                      WXLPARAM lParam)
 362 {
 363     long rc = 0;
 364     bool processed = FALSE;
 365
 366     switch ( message )
 367     {
 368         case WM_ACTIVATE:
 369             {
 370                 WXWORD state, minimized;
 371                 WXHWND hwnd;
 372                 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
 373
 374                 processed = HandleActivate(state, minimized != 0, hwnd);
 375             }
 376             break;
 377
 378         case WM_COMMAND:
 379             {
 380                 WXWORD id, cmd;
 381                 WXHWND hwnd;
 382                 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
 383
 384                 (void)HandleCommand(id, cmd, hwnd);
 385
 386                 // even if the frame didn't process it, there is no need to try it
 387                 // once again (i.e. call wxFrame::HandleCommand()) - we just dud it,
 388                 // so pretend we processed the message anyhow
 389                 processed = TRUE;
 390             }
 391
 392             // always pass this message DefFrameProc(), otherwise MDI menu
 393             // commands (and sys commands - more surprizingly!) won't work
 394             MSWDefWindowProc(message, wParam, lParam);
 395             break;
 396
 397         case WM_CREATE:
 398             m_clientWindow = OnCreateClient();
 399             // Uses own style for client style
 400             if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
 401             {
 402                 wxLogMessage(_("Failed to create MDI parent frame."));
 403
 404                 rc = -1;
 405             }
 406
 407             processed = TRUE;
 408             break;
 409
 410         case WM_ERASEBKGND:
 411             processed = TRUE;
 412
 413             // we erase background ourselves
 414             rc = TRUE;
 415             break;
 416
 417         case WM_MENUSELECT:
 418             {
 419                 WXWORD item, flags;
 420                 WXHMENU hmenu;
 421                 UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
 422
 423                 if ( m_parentFrameActive )
 424                 {
 425                     processed = HandleMenuSelect(item, flags, hmenu);
 426                 }
 427                 else if (m_currentChild)
 428                 {
 429                     processed = m_currentChild->
 430                         HandleMenuSelect(item, flags, hmenu);
 431                 }
 432             }
 433             break;
 434
 435         case WM_SIZE:
 436             // as we don't (usually) resize the MDI client to exactly fit the
 437             // client area (we put it below the toolbar, above statusbar &c),
 438             // we should not pass this one to DefFrameProc
 439             break;
 440     }
 441
 442     if ( !processed )
 443         rc = wxFrame::MSWWindowProc(message, wParam, lParam);
 444
 445     return rc;
 446 }
 447
 448 bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
 449 {
 450     bool processed = FALSE;
 451
 452     if ( wxWindow::HandleActivate(state, minimized, activate) )
 453     {
 454         // already processed
 455         processed = TRUE;
 456     }
 457
 458     // If this window is an MDI parent, we must also send an OnActivate message
 459     // to the current child.
 460     if ( (m_currentChild != NULL) &&
 461          ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
 462     {
 463         wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId());
 464         event.SetEventObject( m_currentChild );
 465         if ( m_currentChild->GetEventHandler()->ProcessEvent(event) )
 466             processed = TRUE;
 467     }
 468
 469     return processed;
 470 }
 471
 472 bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
 473 {
 474     // In case it's e.g. a toolbar.
 475     if ( hwnd )
 476     {
 477         wxWindow *win = wxFindWinFromHandle(hwnd);
 478         if ( win )
 479             return win->MSWCommand(cmd, id);
 480     }
 481
 482     // is it one of standard MDI commands?
 483     WXWPARAM wParam = 0;
 484     int msg;
 485     switch ( id )
 486     {
 487         case IDM_WINDOWCASCADE:
 488             msg = WM_MDICASCADE;
 489             wParam = MDITILE_SKIPDISABLED;
 490             break;
 491
 492         case IDM_WINDOWTILEHOR:
 493             wParam |= MDITILE_HORIZONTAL;
 494             // fall through
 495
 496         case IDM_WINDOWTILEVERT:
 497             if ( !wParam )
 498                 wParam = MDITILE_VERTICAL;
 499             msg = WM_MDITILE;
 500             wParam |= MDITILE_SKIPDISABLED;
 501             break;
 502
 503         case IDM_WINDOWICONS:
 504             msg = WM_MDIICONARRANGE;
 505             break;
 506
 507         case IDM_WINDOWNEXT:
 508             msg = WM_MDINEXT;
 509             break;
 510
 511         default:
 512             msg = 0;
 513     }
 514
 515     if ( msg )
 516     {
 517         ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, 0);
 518
 519         return TRUE;
 520     }
 521
 522     // FIXME VZ: what does this test do??
 523     if (id >= 0xF000)
 524     {
 525         return FALSE; // Get WndProc to call default proc
 526     }
 527
 528     if ( IsMdiCommandId(id) )
 529     {
 530         wxWindowList::Node* node = GetChildren().GetFirst();
 531         while ( node )
 532         {
 533             wxWindow* child = node->GetData();
 534             if ( child->GetHWND() )
 535             {
 536                 long childId = wxGetWindowId(child->GetHWND());
 537                 if (childId == (long)id)
 538                 {
 539                     ::SendMessage( GetWinHwnd(GetClientWindow()),
 540                                    WM_MDIACTIVATE,
 541                                    (WPARAM)child->GetHWND(), 0);
 542                     return TRUE;
 543                 }
 544             }
 545             node = node->GetNext();
 546         }
 547     }
 548     else if ( m_parentFrameActive )
 549     {
 550         return ProcessCommand(id);
 551     }
 552     else if ( m_currentChild )
 553     {
 554         return m_currentChild->HandleCommand(id, cmd, hwnd);
 555     }
 556     else
 557     {
 558         // this shouldn't happen because it means that our messages are being
 559         // lost (they're not sent to the parent frame nor to the children)
 560         wxFAIL_MSG(wxT("MDI parent frame is not active, "
 561                       "yet there is no active MDI child?"));
 562     }
 563
 564     return FALSE;
 565 }
 566
 567 long wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
 568                                         WXWPARAM wParam,
 569                                         WXLPARAM lParam)
 570 {
 571     WXHWND clientWnd;
 572     if ( GetClientWindow() )
 573         clientWnd = GetClientWindow()->GetHWND();
 574     else
 575         clientWnd = 0;
 576
 577     return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
 578 }
 579
 580 bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
 581 {
 582     MSG *pMsg = (MSG *)msg;
 583
 584     if ( m_currentChild && m_currentChild->GetHWND() &&
 585          m_currentChild->MSWTranslateMessage(msg) )
 586     {
 587         return TRUE;
 588     }
 589
 590     if ( m_acceleratorTable.Translate(this, msg) )
 591     {
 592         return TRUE;
 593     }
 594
 595     if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
 596     {
 597         if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
 598             return TRUE;
 599     }
 600
 601     return FALSE;
 602 }
 603
 604 // ===========================================================================
 605 // wxMDIChildFrame
 606 // ===========================================================================
 607
 608 wxMDIChildFrame::wxMDIChildFrame()
 609 {
 610 }
 611
 612 bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
 613                              wxWindowID id,
 614                              const wxString& title,
 615                              const wxPoint& pos,
 616                              const wxSize& size,
 617                              long style,
 618                              const wxString& name)
 619 {
 620   m_defaultIcon = (WXHICON)(wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON
 621                                                      : wxDEFAULT_MDICHILDFRAME_ICON);
 622
 623   SetName(name);
 624
 625   if ( id > -1 )
 626     m_windowId = id;
 627   else
 628     m_windowId = (int)NewControlId();
 629
 630   if ( parent )
 631   {
 632       parent->AddChild(this);
 633   }
 634
 635   wxWndHook = this;
 636
 637   int x = pos.x;
 638   int y = pos.y;
 639   int width = size.x;
 640   int height = size.y;
 641
 642   MDICREATESTRUCT mcs;
 643
 644   mcs.szClass = wxMDIChildFrameClassName;
 645   mcs.szTitle = title;
 646   mcs.hOwner = wxGetInstance();
 647   if (x > -1)
 648       mcs.x = x;
 649   else
 650       mcs.x = CW_USEDEFAULT;
 651
 652   if (y > -1)
 653       mcs.y = y;
 654   else
 655       mcs.y = CW_USEDEFAULT;
 656
 657   if (width > -1)
 658       mcs.cx = width;
 659   else
 660       mcs.cx = CW_USEDEFAULT;
 661
 662   if (height > -1)
 663       mcs.cy = height;
 664   else
 665       mcs.cy = CW_USEDEFAULT;
 666
 667   DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
 668   if (style & wxMINIMIZE_BOX)
 669     msflags |= WS_MINIMIZEBOX;
 670   if (style & wxMAXIMIZE_BOX)
 671     msflags |= WS_MAXIMIZEBOX;
 672   if (style & wxTHICK_FRAME)
 673     msflags |= WS_THICKFRAME;
 674   if (style & wxSYSTEM_MENU)
 675     msflags |= WS_SYSMENU;
 676   if ((style & wxMINIMIZE) || (style & wxICONIZE))
 677     msflags |= WS_MINIMIZE;
 678   if (style & wxMAXIMIZE)
 679     msflags |= WS_MAXIMIZE;
 680   if (style & wxCAPTION)
 681     msflags |= WS_CAPTION;
 682
 683   mcs.style = msflags;
 684
 685   mcs.lParam = 0;
 686
 687   DWORD Return = SendMessage(GetWinHwnd(parent->GetClientWindow()),
 688                              WM_MDICREATE, 0, (LONG)(LPSTR)&mcs);
 689
 690   //handle = (HWND)LOWORD(Return);
 691   // Must be the DWORRD for WIN32. And in 16 bits, HIWORD=0 (says Microsoft)
 692   m_hWnd = (WXHWND)Return;
 693
 694   wxWndHook = NULL;
 695   wxAssociateWinWithHandle((HWND) GetHWND(), this);
 696
 697   // VZ: what's this? an act of piracy?
 698   //SetWindowLong(GetHwnd(), 0, (long)this);
 699
 700   wxModelessWindows.Append(this);
 701   return TRUE;
 702 }
 703
 704 wxMDIChildFrame::~wxMDIChildFrame()
 705 {
 706     MSWDestroyWindow();
 707 }
 708
 709 // Set the client size (i.e. leave the calculation of borders etc.
 710 // to wxWindows)
 711 void wxMDIChildFrame::DoSetClientSize(int width, int height)
 712 {
 713   HWND hWnd = GetHwnd();
 714
 715   RECT rect;
 716   ::GetClientRect(hWnd, &rect);
 717
 718   RECT rect2;
 719   GetWindowRect(hWnd, &rect2);
 720
 721   // Find the difference between the entire window (title bar and all)
 722   // and the client area; add this to the new client size to move the
 723   // window
 724   int actual_width = rect2.right - rect2.left - rect.right + width;
 725   int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
 726
 727   if (GetStatusBar() && GetStatusBar()->IsShown())
 728   {
 729     int sx, sy;
 730     GetStatusBar()->GetSize(&sx, &sy);
 731     actual_height += sy;
 732   }
 733
 734   POINT point;
 735   point.x = rect2.left;
 736   point.y = rect2.top;
 737
 738   // If there's an MDI parent, must subtract the parent's top left corner
 739   // since MoveWindow moves relative to the parent
 740   wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
 741   ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
 742
 743   MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)TRUE);
 744
 745   wxSizeEvent event(wxSize(width, height), m_windowId);
 746   event.SetEventObject( this );
 747   GetEventHandler()->ProcessEvent(event);
 748 }
 749
 750 void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
 751 {
 752   RECT rect;
 753   GetWindowRect(GetHwnd(), &rect);
 754   POINT point;
 755   point.x = rect.left;
 756   point.y = rect.top;
 757
 758   // Since we now have the absolute screen coords,
 759   // if there's a parent we must subtract its top left corner
 760   wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
 761   ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
 762
 763   *x = point.x;
 764   *y = point.y;
 765 }
 766
 767 void wxMDIChildFrame::InternalSetMenuBar()
 768 {
 769     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 770
 771     // HMENU subMenu = GetSubMenu((HMENU)parent->GetWindowMenu(), 0);
 772     HMENU subMenu = (HMENU) 0;
 773     if (parent->GetWindowMenu())
 774         subMenu = (HMENU) parent->GetWindowMenu()->GetHMenu();
 775
 776     InsertWindowMenu(parent->GetClientWindow(), m_hMenu, subMenu);
 777
 778     parent->m_parentFrameActive = FALSE;
 779 }
 780
 781 // ---------------------------------------------------------------------------
 782 // MDI operations
 783 // ---------------------------------------------------------------------------
 784
 785 void wxMDIChildFrame::Maximize(bool maximize)
 786 {
 787     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 788     if ( parent && parent->GetClientWindow() )
 789     {
 790         ::SendMessage(GetWinHwnd(parent->GetClientWindow()),
 791                       maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
 792                       (WPARAM)GetHwnd(), 0);
 793     }
 794 }
 795
 796 void wxMDIChildFrame::Restore()
 797 {
 798     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 799     if ( parent && parent->GetClientWindow() )
 800     {
 801         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
 802                       (WPARAM) GetHwnd(), 0);
 803     }
 804 }
 805
 806 void wxMDIChildFrame::Activate()
 807 {
 808     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 809     if ( parent && parent->GetClientWindow() )
 810     {
 811         ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
 812                       (WPARAM) GetHwnd(), 0);
 813     }
 814 }
 815
 816 // ---------------------------------------------------------------------------
 817 // MDI window proc and message handlers
 818 // ---------------------------------------------------------------------------
 819
 820 long wxMDIChildFrame::MSWWindowProc(WXUINT message,
 821                                     WXWPARAM wParam,
 822                                     WXLPARAM lParam)
 823 {
 824     long rc = 0;
 825     bool processed = FALSE;
 826
 827     switch ( message )
 828     {
 829         case WM_COMMAND:
 830             {
 831                 WORD id, cmd;
 832                 WXHWND hwnd;
 833                 UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
 834                               &id, &hwnd, &cmd);
 835
 836                 processed = HandleCommand(id, cmd, (WXHWND)hwnd);
 837             }
 838             break;
 839
 840         case WM_GETMINMAXINFO:
 841             // let the default window proc calculate the size of MDI children
 842             // frames because it is based on the size of the MDI client window,
 843             // not on the values specified in wxWindow m_min/max variables
 844             return MSWDefWindowProc(message, wParam, lParam);
 845
 846         case WM_MDIACTIVATE:
 847             {
 848                 WXWORD act;
 849                 WXHWND hwndAct, hwndDeact;
 850                 UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact);
 851
 852                 processed = HandleMDIActivate(act, hwndAct, hwndDeact);
 853             }
 854             // fall through
 855
 856         case WM_MOVE:
 857             // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
 858             // scrollbars if necessary
 859
 860             // fall through
 861
 862         case WM_SIZE:
 863             // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
 864             // things happen
 865             MSWDefWindowProc(message, wParam, lParam);
 866             break;
 867
 868         case WM_SYSCOMMAND:
 869             // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it
 870             // the message (the base class version does not)
 871             return MSWDefWindowProc(message, wParam, lParam);
 872
 873         case WM_WINDOWPOSCHANGING:
 874             processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);
 875             break;
 876     }
 877
 878     if ( !processed )
 879         rc = wxFrame::MSWWindowProc(message, wParam, lParam);
 880
 881     return rc;
 882 }
 883
 884 bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
 885 {
 886     // In case it's e.g. a toolbar.
 887     if ( hwnd )
 888     {
 889         wxWindow *win = wxFindWinFromHandle(hwnd);
 890         if (win)
 891             return win->MSWCommand(cmd, id);
 892     }
 893
 894     if (wxCurrentPopupMenu)
 895     {
 896         wxMenu *popupMenu = wxCurrentPopupMenu;
 897         wxCurrentPopupMenu = NULL;
 898         if (popupMenu->MSWCommand(cmd, id))
 899             return TRUE;
 900     }
 901
 902     if (GetMenuBar() && GetMenuBar()->FindItem(id))
 903     {
 904         ProcessCommand(id);
 905         return TRUE;
 906     }
 907     else
 908         return FALSE;
 909
 910     return TRUE;
 911 }
 912
 913 bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
 914                                         WXHWND hwndAct,
 915                                         WXHWND hwndDeact)
 916 {
 917     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
 918
 919     HMENU menuToSet = 0;
 920
 921     bool activated;
 922
 923     if ( m_hWnd == hwndAct )
 924     {
 925         activated = TRUE;
 926         parent->m_currentChild = this;
 927
 928         HMENU child_menu = (HMENU)GetWinMenu();
 929         if ( child_menu )
 930         {
 931             parent->m_parentFrameActive = FALSE;
 932
 933             menuToSet = child_menu;
 934         }
 935     }
 936     else if ( m_hWnd == hwndDeact )
 937     {
 938         wxASSERT_MSG( parent->m_currentChild == this,
 939                       wxT("can't deactivate MDI child which wasn't active!") );
 940
 941         activated = FALSE;
 942         parent->m_currentChild = NULL;
 943
 944         HMENU parent_menu = (HMENU)parent->GetWinMenu();
 945         if ( parent_menu )
 946         {
 947             parent->m_parentFrameActive = TRUE;
 948
 949             menuToSet = parent_menu;
 950         }
 951     }
 952     else
 953     {
 954         // we have nothing to do with it
 955         return FALSE;
 956     }
 957
 958     if ( menuToSet )
 959     {
 960         HMENU subMenu = (HMENU) 0;
 961         if (parent->GetWindowMenu())
 962             subMenu = (HMENU) parent->GetWindowMenu()->GetHMenu();
 963
 964         MDISetMenu(parent->GetClientWindow(), menuToSet, subMenu);
 965     }
 966
 967     wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
 968     event.SetEventObject( this );
 969
 970     return GetEventHandler()->ProcessEvent(event);
 971 }
 972
 973 bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
 974 {
 975     WINDOWPOS *lpPos = (WINDOWPOS *)pos;
 976 #if defined(__WIN95__)
 977     if (!(lpPos->flags & SWP_NOSIZE))
 978     {
 979         RECT rectClient;
 980         DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
 981         DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
 982         if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
 983         {
 984             ::AdjustWindowRectEx(&rectClient, dwStyle, FALSE, dwExStyle);
 985             lpPos->x = rectClient.left;
 986             lpPos->y = rectClient.top;
 987             lpPos->cx = rectClient.right - rectClient.left;
 988             lpPos->cy = rectClient.bottom - rectClient.top;
 989         }
 990         wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
 991         if (pFrameWnd && pFrameWnd->GetToolBar() && pFrameWnd->GetToolBar()->IsShown())
 992         {
 993             pFrameWnd->GetToolBar()->Refresh();
 994         }
 995     }
 996 #endif // Win95
 997
 998     return FALSE;
 999 }
1000
1001 // ---------------------------------------------------------------------------
1002 // MDI specific message translation/preprocessing
1003 // ---------------------------------------------------------------------------
1004
1005 long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam)
1006 {
1007     return DefMDIChildProc(GetHwnd(),
1008                            (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
1009 }
1010
1011 bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
1012 {
1013     return m_acceleratorTable.Translate(GetParent(), msg);
1014 }
1015
1016 // ---------------------------------------------------------------------------
1017 // misc
1018 // ---------------------------------------------------------------------------
1019
1020 void wxMDIChildFrame::MSWDestroyWindow()
1021 {
1022     MSWDetachWindowMenu();
1023     invalidHandle = GetHwnd();
1024
1025     wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
1026
1027     // Must make sure this handle is invalidated (set to NULL) since all sorts
1028     // of things could happen after the child client is destroyed, but before
1029     // the wxFrame is destroyed.
1030
1031     HWND oldHandle = (HWND)GetHWND();
1032     SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
1033                 (WPARAM)oldHandle, 0);
1034
1035     if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL)
1036         ResetWindowStyle((void*) NULL);
1037
1038     invalidHandle = 0;
1039
1040     if (m_hMenu)
1041     {
1042         ::DestroyMenu((HMENU) m_hMenu);
1043         m_hMenu = 0;
1044     }
1045     m_hWnd = 0;
1046 }
1047
1048 // Change the client window's extended style so we don't get a client edge
1049 // style when a child is maximised (a double border looks silly.)
1050 bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
1051 {
1052 #if defined(__WIN95__)
1053     RECT *rect = (RECT *)vrect;
1054     wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
1055     wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
1056     if (!pChild || (pChild == this))
1057     {
1058         DWORD dwStyle = ::GetWindowLong(GetWinHwnd(pFrameWnd->GetClientWindow()), GWL_EXSTYLE);
1059         DWORD dwThisStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1060         DWORD dwNewStyle = dwStyle;
1061         if (pChild != NULL && (dwThisStyle & WS_MAXIMIZE))
1062             dwNewStyle &= ~(WS_EX_CLIENTEDGE);
1063         else
1064             dwNewStyle |= WS_EX_CLIENTEDGE;
1065
1066         if (dwStyle != dwNewStyle)
1067         {
1068             HWND hwnd = GetWinHwnd(pFrameWnd->GetClientWindow());
1069             ::RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
1070             ::SetWindowLong(hwnd, GWL_EXSTYLE, dwNewStyle);
1071             ::SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
1072                            SWP_FRAMECHANGED | SWP_NOACTIVATE |
1073                            SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1074                            SWP_NOCOPYBITS);
1075             if (rect)
1076                 ::GetClientRect(hwnd, rect);
1077
1078             return TRUE;
1079         }
1080     }
1081 #endif // Win95
1082
1083     return FALSE;
1084 }
1085
1086 // ===========================================================================
1087 // wxMDIClientWindow: the window of predefined (by Windows) class which
1088 // contains the child frames
1089 // ===========================================================================
1090
1091 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
1092 {
1093     m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
1094
1095     CLIENTCREATESTRUCT ccs;
1096     m_windowStyle = style;
1097     m_parent = parent;
1098
1099     ccs.hWindowMenu = (HMENU) 0;
1100     if (parent->GetWindowMenu())
1101         ccs.hWindowMenu = (HMENU) parent->GetWindowMenu()->GetHMenu();
1102     ccs.idFirstChild = wxFIRST_MDI_CHILD;
1103
1104     DWORD msStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN;
1105     if ( style & wxHSCROLL )
1106         msStyle |= WS_HSCROLL;
1107     if ( style & wxVSCROLL )
1108         msStyle |= WS_VSCROLL;
1109
1110 #if defined(__WIN95__)
1111     DWORD exStyle = WS_EX_CLIENTEDGE;
1112 #else
1113     DWORD exStyle = 0;
1114 #endif
1115
1116     wxWndHook = this;
1117     m_hWnd = (WXHWND)::CreateWindowEx
1118                        (
1119                         exStyle,
1120                         wxT("MDICLIENT"),
1121                         NULL,
1122                         msStyle,
1123                         0, 0, 0, 0,
1124                         GetWinHwnd(parent),
1125                         NULL,
1126                         wxGetInstance(),
1127                         (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
1128     if ( !m_hWnd )
1129     {
1130         wxLogLastError("CreateWindowEx(MDI client)");
1131
1132         return FALSE;
1133     }
1134
1135     SubclassWin(m_hWnd);
1136     wxWndHook = NULL;
1137
1138     return TRUE;
1139 }
1140
1141 // Explicitly call default scroll behaviour
1142 void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
1143 {
1144     // Note: for client windows, the scroll position is not set in
1145     // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
1146     // scroll position we're at.
1147     // This makes it hard to paint patterns or bitmaps in the background,
1148     // and have the client area scrollable as well.
1149
1150     if ( event.GetOrientation() == wxHORIZONTAL )
1151         m_scrollX = event.GetPosition(); // Always returns zero!
1152     else
1153         m_scrollY = event.GetPosition(); // Always returns zero!
1154
1155     event.Skip();
1156 }
1157
1158 void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1159 {
1160     // Try to fix a problem whereby if you show an MDI child frame, then reposition the
1161     // client area, you can end up with a non-refreshed portion in the client window
1162     // (see OGL studio sample). So check if the position is changed and if so,
1163     // redraw the MDI child frames.
1164
1165     wxPoint oldPos = GetPosition();
1166
1167     wxWindow::DoSetSize(x, y, width, height, sizeFlags);
1168
1169     wxPoint newPos = GetPosition();
1170
1171     if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
1172     {
1173         if (GetParent())
1174         {
1175             wxNode* node = GetParent()->GetChildren().First();
1176             while (node)
1177             {
1178                 wxWindow* child = (wxWindow*) node->Data();
1179                 if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
1180                 {
1181                     HWND hWnd = (HWND) child->GetHWND();
1182                    ::RedrawWindow(hWnd, NULL, NULL, RDW_FRAME|RDW_ALLCHILDREN|RDW_INVALIDATE );
1183                 }
1184                 node = node->Next();
1185             }
1186         }
1187     }
1188 }
1189
1190 // ---------------------------------------------------------------------------
1191 // non member functions
1192 // ---------------------------------------------------------------------------
1193
1194 static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
1195 {
1196     ::SendMessage(GetWinHwnd(win), WM_MDISETMENU,
1197 #ifdef __WIN32__
1198                   (WPARAM)hmenuFrame, (LPARAM)hmenuWindow);
1199 #else
1200                   0, MAKELPARAM(hmenuFrame, hmenuWindow));
1201 #endif
1202
1203     // update menu bar of the parent window
1204     wxWindow *parent = win->GetParent();
1205     wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
1206
1207     ::DrawMenuBar(GetWinHwnd(parent));
1208 }
1209
1210 static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu)
1211 {
1212     // Try to insert Window menu in front of Help, otherwise append it.
1213     HMENU hmenu = (HMENU)menu;
1214
1215     if (subMenu)
1216     {
1217     int N = GetMenuItemCount(hmenu);
1218     bool success = FALSE;
1219     for ( int i = 0; i < N; i++ )
1220     {
1221         wxChar buf[256];
1222         int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
1223         if ( chars == 0 )
1224         {
1225             wxLogLastError(wxT("GetMenuString"));
1226
1227             continue;
1228         }
1229
1230         if ( wxStripMenuCodes(wxString(buf)).IsSameAs(wxT("Help")) )
1231         {
1232             success = TRUE;
1233             ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
1234                          (UINT)subMenu, wxT("&Window"));
1235             break;
1236         }
1237     }
1238
1239     if ( !success )
1240     {
1241         ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, wxT("&Window"));
1242     }
1243     }
1244
1245     MDISetMenu(win, hmenu, subMenu);
1246 }
1247
1248 static void RemoveWindowMenu(wxWindow *win, WXHMENU menu)
1249 {
1250     // Try to insert Window menu in front of Help, otherwise append it.
1251     HMENU hmenu = (HMENU)menu;
1252     int N = GetMenuItemCount(hmenu);
1253     bool success = FALSE;
1254     for ( int i = 0; i < N; i++ )
1255     {
1256         wxChar buf[256];
1257         int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
1258         if ( chars == 0 )
1259         {
1260             wxLogLastError(wxT("GetMenuString"));
1261
1262             continue;
1263         }
1264
1265         if ( wxStripMenuCodes(wxString(buf)).IsSameAs(wxT("Window")) )
1266         {
1267             success = TRUE;
1268             ::RemoveMenu(hmenu, i, MF_BYPOSITION);
1269             break;
1270         }
1271     }
1272
1273     // Does passing 0 for the window menu really work with WM_MDISETMENU?
1274     MDISetMenu(win, hmenu, 0);
1275 }
1276
1277 static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
1278                               WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
1279 {
1280 #ifdef __WIN32__
1281     *activate = TRUE;
1282     *hwndAct = (WXHWND)lParam;
1283     *hwndDeact = (WXHWND)wParam;
1284 #else // Win16
1285     *activate = (WXWORD)wParam;
1286     *hwndAct = (WXHWND)LOWORD(lParam);
1287     *hwndDeact = (WXHWND)HIWORD(lParam);
1288 #endif // Win32/Win16
1289 }