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