src/aui/tabmdi.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/aui/tabmdi.cpp
   3 // Purpose:     Generic MDI (Multiple Document Interface) classes
   4 // Author:      Hans Van Leemputten
   5 // Modified by: Benjamin I. Williams / Kirix Corporation
   6 // Created:     29/07/2002
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Hans Van Leemputten
   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_AUI
  28 #if wxUSE_MDI
  29
  30 #include "wx/aui/tabmdi.h"
  31
  32 #ifndef WX_PRECOMP
  33     #include "wx/panel.h"
  34     #include "wx/menu.h"
  35     #include "wx/intl.h"
  36     #include "wx/log.h"
  37     #include "wx/settings.h"
  38 #endif //WX_PRECOMP
  39
  40 #include "wx/stockitem.h"
  41
  42 enum MDI_MENU_ID
  43 {
  44     wxWINDOWCLOSE = 4001,
  45     wxWINDOWCLOSEALL,
  46     wxWINDOWNEXT,
  47     wxWINDOWPREV
  48 };
  49
  50 //-----------------------------------------------------------------------------
  51 // wxAuiMDIParentFrame
  52 //-----------------------------------------------------------------------------
  53
  54 IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIParentFrame, wxFrame)
  55
  56 BEGIN_EVENT_TABLE(wxAuiMDIParentFrame, wxFrame)
  57 #if wxUSE_MENUS
  58     EVT_MENU (wxID_ANY, wxAuiMDIParentFrame::DoHandleMenu)
  59 #endif
  60 END_EVENT_TABLE()
  61
  62 wxAuiMDIParentFrame::wxAuiMDIParentFrame()
  63 {
  64     Init();
  65 }
  66
  67 wxAuiMDIParentFrame::wxAuiMDIParentFrame(wxWindow *parent,
  68                                          wxWindowID id,
  69                                          const wxString& title,
  70                                          const wxPoint& pos,
  71                                          const wxSize& size,
  72                                          long style,
  73                                          const wxString& name)
  74 {
  75     Init();
  76     (void)Create(parent, id, title, pos, size, style, name);
  77 }
  78
  79 wxAuiMDIParentFrame::~wxAuiMDIParentFrame()
  80 {
  81     // Make sure the client window is destructed before the menu bars are!
  82     wxDELETE(m_pClientWindow);
  83
  84 #if wxUSE_MENUS
  85     RemoveWindowMenu(GetMenuBar());
  86     delete m_pWindowMenu;
  87 #endif // wxUSE_MENUS
  88 }
  89
  90 bool wxAuiMDIParentFrame::Create(wxWindow *parent,
  91                                  wxWindowID id,
  92                                  const wxString& title,
  93                                  const wxPoint& pos,
  94                                  const wxSize& size,
  95                                  long style,
  96                                  const wxString& name)
  97 {
  98 #if wxUSE_MENUS
  99     // this style can be used to prevent a window from having the standard MDI
 100     // "Window" menu
 101     if (!(style & wxFRAME_NO_WINDOW_MENU))
 102     {
 103         m_pWindowMenu = new wxMenu;
 104         m_pWindowMenu->Append(wxWINDOWCLOSE,    _("Cl&ose"));
 105         m_pWindowMenu->Append(wxWINDOWCLOSEALL, _("Close All"));
 106         m_pWindowMenu->AppendSeparator();
 107         m_pWindowMenu->Append(wxWINDOWNEXT,     _("&Next"));
 108         m_pWindowMenu->Append(wxWINDOWPREV,     _("&Previous"));
 109     }
 110 #endif // wxUSE_MENUS
 111
 112     wxFrame::Create(parent, id, title, pos, size, style, name);
 113     OnCreateClient();
 114     return true;
 115 }
 116
 117
 118 void wxAuiMDIParentFrame::SetArtProvider(wxAuiTabArt* provider)
 119 {
 120     if (m_pClientWindow)
 121     {
 122         m_pClientWindow->SetArtProvider(provider);
 123     }
 124 }
 125
 126 wxAuiTabArt* wxAuiMDIParentFrame::GetArtProvider()
 127 {
 128     if (!m_pClientWindow)
 129         return NULL;
 130
 131     return m_pClientWindow->GetArtProvider();
 132 }
 133
 134 wxAuiNotebook* wxAuiMDIParentFrame::GetNotebook() const
 135 {
 136     return static_cast<wxAuiNotebook*>(m_pClientWindow);
 137 }
 138
 139
 140
 141 #if wxUSE_MENUS
 142 void wxAuiMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
 143 {
 144     // Replace the window menu from the currently loaded menu bar.
 145     wxMenuBar *pMenuBar = GetMenuBar();
 146
 147     if (m_pWindowMenu)
 148     {
 149         RemoveWindowMenu(pMenuBar);
 150         wxDELETE(m_pWindowMenu);
 151     }
 152
 153     if (pMenu)
 154     {
 155         m_pWindowMenu = pMenu;
 156         AddWindowMenu(pMenuBar);
 157     }
 158 }
 159
 160 void wxAuiMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)
 161 {
 162     // Remove the Window menu from the old menu bar
 163     RemoveWindowMenu(GetMenuBar());
 164
 165     // Add the Window menu to the new menu bar.
 166     AddWindowMenu(pMenuBar);
 167
 168     wxFrame::SetMenuBar(pMenuBar);
 169     m_pMyMenuBar = GetMenuBar();
 170 }
 171 #endif // wxUSE_MENUS
 172
 173 void wxAuiMDIParentFrame::SetChildMenuBar(wxAuiMDIChildFrame* pChild)
 174 {
 175 #if wxUSE_MENUS
 176     if (!pChild)
 177     {
 178         // No Child, set Our menu bar back.
 179         SetMenuBar(m_pMyMenuBar);
 180
 181         // Make sure we know our menu bar is in use
 182         //m_pMyMenuBar = NULL;
 183     }
 184      else
 185     {
 186         if (pChild->GetMenuBar() == NULL)
 187             return;
 188
 189         // Do we need to save the current bar?
 190         if (m_pMyMenuBar == NULL)
 191             m_pMyMenuBar = GetMenuBar();
 192
 193         SetMenuBar(pChild->GetMenuBar());
 194     }
 195 #endif // wxUSE_MENUS
 196 }
 197
 198 bool wxAuiMDIParentFrame::ProcessEvent(wxEvent& event)
 199 {
 200     // stops the same event being processed repeatedly
 201     if (m_pLastEvt == &event)
 202         return false;
 203     m_pLastEvt = &event;
 204
 205     // let the active child (if any) process the event first.
 206     bool res = false;
 207     if (m_pActiveChild &&
 208         event.IsCommandEvent() &&
 209         event.GetEventObject() != m_pClientWindow &&
 210            !(event.GetEventType() == wxEVT_ACTIVATE ||
 211              event.GetEventType() == wxEVT_SET_FOCUS ||
 212              event.GetEventType() == wxEVT_KILL_FOCUS ||
 213              event.GetEventType() == wxEVT_CHILD_FOCUS ||
 214              event.GetEventType() == wxEVT_COMMAND_SET_FOCUS ||
 215              event.GetEventType() == wxEVT_COMMAND_KILL_FOCUS )
 216        )
 217     {
 218         res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
 219     }
 220
 221     if (!res)
 222     {
 223         // if the event was not handled this frame will handle it,
 224         // which is why we need the protection code at the beginning
 225         // of this method
 226         res = wxEvtHandler::ProcessEvent(event);
 227     }
 228
 229     m_pLastEvt = NULL;
 230
 231     return res;
 232 }
 233
 234 wxAuiMDIChildFrame *wxAuiMDIParentFrame::GetActiveChild() const
 235 {
 236     return m_pActiveChild;
 237 }
 238
 239 void wxAuiMDIParentFrame::SetActiveChild(wxAuiMDIChildFrame* pChildFrame)
 240 {
 241     m_pActiveChild = pChildFrame;
 242 }
 243
 244 wxAuiMDIClientWindow *wxAuiMDIParentFrame::GetClientWindow() const
 245 {
 246     return m_pClientWindow;
 247 }
 248
 249 wxAuiMDIClientWindow *wxAuiMDIParentFrame::OnCreateClient()
 250 {
 251     m_pClientWindow = new wxAuiMDIClientWindow( this );
 252     return m_pClientWindow;
 253 }
 254
 255 void wxAuiMDIParentFrame::ActivateNext()
 256 {
 257     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
 258     {
 259         size_t active = m_pClientWindow->GetSelection() + 1;
 260         if (active >= m_pClientWindow->GetPageCount())
 261             active = 0;
 262
 263         m_pClientWindow->SetSelection(active);
 264     }
 265 }
 266
 267 void wxAuiMDIParentFrame::ActivatePrevious()
 268 {
 269     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
 270     {
 271         int active = m_pClientWindow->GetSelection() - 1;
 272         if (active < 0)
 273             active = m_pClientWindow->GetPageCount() - 1;
 274
 275         m_pClientWindow->SetSelection(active);
 276     }
 277 }
 278
 279 void wxAuiMDIParentFrame::Init()
 280 {
 281     m_pLastEvt = NULL;
 282     m_pClientWindow = NULL;
 283     m_pActiveChild = NULL;
 284 #if wxUSE_MENUS
 285     m_pWindowMenu = NULL;
 286     m_pMyMenuBar = NULL;
 287 #endif // wxUSE_MENUS
 288 }
 289
 290 #if wxUSE_MENUS
 291 void wxAuiMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
 292 {
 293     if (pMenuBar && m_pWindowMenu)
 294     {
 295         // Remove old window menu
 296         int pos = pMenuBar->FindMenu(_("&Window"));
 297         if (pos != wxNOT_FOUND)
 298         {
 299             // DBG:: We're going to delete the wrong menu!!!
 300             wxASSERT(m_pWindowMenu == pMenuBar->GetMenu(pos));
 301             pMenuBar->Remove(pos);
 302         }
 303     }
 304 }
 305
 306 void wxAuiMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
 307 {
 308     if (pMenuBar && m_pWindowMenu)
 309     {
 310         int pos = pMenuBar->FindMenu(wxGetStockLabel(wxID_HELP,wxSTOCK_NOFLAGS));
 311         if (pos == wxNOT_FOUND)
 312             pMenuBar->Append(m_pWindowMenu, _("&Window"));
 313              else
 314             pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
 315     }
 316 }
 317
 318 void wxAuiMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
 319 {
 320     switch (event.GetId())
 321     {
 322         case wxWINDOWCLOSE:
 323             if (m_pActiveChild)
 324                 m_pActiveChild->Close();
 325             break;
 326         case wxWINDOWCLOSEALL:
 327             while (m_pActiveChild)
 328             {
 329                 if (!m_pActiveChild->Close())
 330                 {
 331                     return; // failure
 332                 }
 333                  else
 334                 {
 335                     delete m_pActiveChild;
 336                     m_pActiveChild = NULL;
 337                 }
 338             }
 339             break;
 340         case wxWINDOWNEXT:
 341             ActivateNext();
 342             break;
 343         case wxWINDOWPREV:
 344             ActivatePrevious();
 345             break;
 346         default:
 347             event.Skip();
 348     }
 349 }
 350 #endif // wxUSE_MENUS
 351
 352 void wxAuiMDIParentFrame::DoGetClientSize(int* width, int* height) const
 353 {
 354     wxFrame::DoGetClientSize(width, height);
 355 }
 356
 357 void wxAuiMDIParentFrame::Tile(wxOrientation orient)
 358 {
 359     wxAuiMDIClientWindow* client_window = GetClientWindow();
 360     wxASSERT_MSG(client_window, wxT("Missing MDI Client Window"));
 361
 362     int cur_idx = client_window->GetSelection();
 363     if (cur_idx == -1)
 364         return;
 365
 366     if (orient == wxVERTICAL)
 367     {
 368         client_window->Split(cur_idx, wxLEFT);
 369     }
 370      else if (orient == wxHORIZONTAL)
 371     {
 372         client_window->Split(cur_idx, wxTOP);
 373     }
 374 }
 375
 376
 377 //-----------------------------------------------------------------------------
 378 // wxAuiMDIChildFrame
 379 //-----------------------------------------------------------------------------
 380
 381 IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIChildFrame, wxPanel)
 382
 383 BEGIN_EVENT_TABLE(wxAuiMDIChildFrame, wxPanel)
 384     EVT_MENU_HIGHLIGHT_ALL(wxAuiMDIChildFrame::OnMenuHighlight)
 385     EVT_ACTIVATE(wxAuiMDIChildFrame::OnActivate)
 386     EVT_CLOSE(wxAuiMDIChildFrame::OnCloseWindow)
 387 END_EVENT_TABLE()
 388
 389 wxAuiMDIChildFrame::wxAuiMDIChildFrame()
 390 {
 391     Init();
 392 }
 393
 394 wxAuiMDIChildFrame::wxAuiMDIChildFrame(wxAuiMDIParentFrame *parent,
 395                                        wxWindowID id,
 396                                        const wxString& title,
 397                                        const wxPoint& WXUNUSED(pos),
 398                                        const wxSize& size,
 399                                        long style,
 400                                        const wxString& name)
 401 {
 402     Init();
 403
 404     // There are two ways to create an tabbed mdi child fram without
 405     // making it the active document.  Either Show(false) can be called
 406     // before Create() (as is customary on some ports with wxFrame-type
 407     // windows), or wxMINIMIZE can be passed in the style flags.  Note that
 408     // wxAuiMDIChildFrame is not really derived from wxFrame, as wxMDIChildFrame
 409     // is, but those are the expected symantics.  No style flag is passed
 410     // onto the panel underneath.
 411     if (style & wxMINIMIZE)
 412         m_activate_on_create = false;
 413
 414     Create(parent, id, title, wxDefaultPosition, size, 0, name);
 415 }
 416
 417 wxAuiMDIChildFrame::~wxAuiMDIChildFrame()
 418 {
 419 #if wxUSE_MENUS
 420     wxDELETE(m_pMenuBar);
 421 #endif // wxUSE_MENUS
 422 }
 423
 424 bool wxAuiMDIChildFrame::Create(wxAuiMDIParentFrame* parent,
 425                                 wxWindowID id,
 426                                 const wxString& title,
 427                                 const wxPoint& WXUNUSED(pos),
 428                                 const wxSize& size,
 429                                 long style,
 430                                 const wxString& name)
 431 {
 432     wxAuiMDIClientWindow* pClientWindow = parent->GetClientWindow();
 433     wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window."));
 434
 435     // see comment in constructor
 436     if (style & wxMINIMIZE)
 437         m_activate_on_create = false;
 438
 439     wxSize cli_size = pClientWindow->GetClientSize();
 440
 441     // create the window off-screen to prevent flicker
 442     wxPanel::Create(pClientWindow,
 443                     id,
 444                     wxPoint(cli_size.x+1, cli_size.y+1),
 445                     size,
 446                     wxNO_BORDER, name);
 447
 448     DoShow(false);
 449
 450     SetMDIParentFrame(parent);
 451
 452     // this is the currently active child
 453     parent->SetActiveChild(this);
 454
 455     m_title = title;
 456
 457     pClientWindow->AddPage(this, title, m_activate_on_create);
 458     pClientWindow->Refresh();
 459
 460     return true;
 461 }
 462
 463 bool wxAuiMDIChildFrame::Destroy()
 464 {
 465     wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
 466     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 467
 468     wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
 469     wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
 470
 471     if (pParentFrame->GetActiveChild() == this)
 472     {
 473         // deactivate ourself
 474         wxActivateEvent event(wxEVT_ACTIVATE, false, GetId());
 475         event.SetEventObject(this);
 476         GetEventHandler()->ProcessEvent(event);
 477
 478         pParentFrame->SetActiveChild(NULL);
 479         pParentFrame->SetChildMenuBar(NULL);
 480     }
 481
 482     size_t page_count = pClientWindow->GetPageCount();
 483     for (size_t pos = 0; pos < page_count; pos++)
 484     {
 485         if (pClientWindow->GetPage(pos) == this)
 486             return pClientWindow->DeletePage(pos);
 487     }
 488
 489     return false;
 490 }
 491
 492 #if wxUSE_MENUS
 493 void wxAuiMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
 494 {
 495     wxMenuBar *pOldMenuBar = m_pMenuBar;
 496     m_pMenuBar = menu_bar;
 497
 498     if (m_pMenuBar)
 499     {
 500         wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
 501         wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 502
 503         m_pMenuBar->SetParent(pParentFrame);
 504         if (pParentFrame->GetActiveChild() == this)
 505         {
 506             // replace current menu bars
 507             if (pOldMenuBar)
 508                 pParentFrame->SetChildMenuBar(NULL);
 509             pParentFrame->SetChildMenuBar(this);
 510         }
 511     }
 512 }
 513
 514 wxMenuBar *wxAuiMDIChildFrame::GetMenuBar() const
 515 {
 516     return m_pMenuBar;
 517 }
 518 #endif // wxUSE_MENUS
 519
 520 void wxAuiMDIChildFrame::SetTitle(const wxString& title)
 521 {
 522     m_title = title;
 523
 524     wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
 525     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 526
 527     wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
 528     if (pClientWindow != NULL)
 529     {
 530         size_t pos;
 531         for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
 532         {
 533             if (pClientWindow->GetPage(pos) == this)
 534             {
 535                 pClientWindow->SetPageText(pos, m_title);
 536                 break;
 537             }
 538         }
 539     }
 540 }
 541
 542 wxString wxAuiMDIChildFrame::GetTitle() const
 543 {
 544     return m_title;
 545 }
 546
 547 void wxAuiMDIChildFrame::SetIcons(const wxIconBundle& icons)
 548 {
 549     // get icon with the system icon size
 550     SetIcon(icons.GetIcon(-1));
 551     m_icon_bundle = icons;
 552 }
 553
 554 const wxIconBundle& wxAuiMDIChildFrame::GetIcons() const
 555 {
 556     return m_icon_bundle;
 557 }
 558
 559 void wxAuiMDIChildFrame::SetIcon(const wxIcon& icon)
 560 {
 561     wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
 562     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 563
 564     m_icon = icon;
 565
 566     wxBitmap bmp;
 567     bmp.CopyFromIcon(m_icon);
 568
 569     wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
 570     if (pClientWindow != NULL)
 571     {
 572         int idx = pClientWindow->GetPageIndex(this);
 573
 574         if (idx != -1)
 575         {
 576             pClientWindow->SetPageBitmap((size_t)idx, bmp);
 577         }
 578     }
 579 }
 580
 581 const wxIcon& wxAuiMDIChildFrame::GetIcon() const
 582 {
 583     return m_icon;
 584 }
 585
 586
 587 void wxAuiMDIChildFrame::Activate()
 588 {
 589     wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
 590     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 591
 592     wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
 593
 594     if (pClientWindow != NULL)
 595     {
 596         size_t pos;
 597         for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
 598         {
 599             if (pClientWindow->GetPage(pos) == this)
 600             {
 601                 pClientWindow->SetSelection(pos);
 602                 break;
 603             }
 604         }
 605     }
 606 }
 607
 608 void wxAuiMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
 609 {
 610 #if wxUSE_STATUSBAR
 611     if (m_pMDIParentFrame)
 612     {
 613         // we don't have any help text for this item,
 614         // but may be the MDI frame does?
 615         m_pMDIParentFrame->OnMenuHighlight(event);
 616     }
 617 #else
 618     wxUnusedVar(event);
 619 #endif // wxUSE_STATUSBAR
 620 }
 621
 622 void wxAuiMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
 623 {
 624     // do nothing
 625 }
 626
 627 void wxAuiMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 628 {
 629     Destroy();
 630 }
 631
 632 void wxAuiMDIChildFrame::SetMDIParentFrame(wxAuiMDIParentFrame* parentFrame)
 633 {
 634     m_pMDIParentFrame = parentFrame;
 635 }
 636
 637 wxAuiMDIParentFrame* wxAuiMDIChildFrame::GetMDIParentFrame() const
 638 {
 639     return m_pMDIParentFrame;
 640 }
 641
 642 void wxAuiMDIChildFrame::Init()
 643 {
 644     m_activate_on_create = true;
 645     m_pMDIParentFrame = NULL;
 646 #if wxUSE_MENUS
 647     m_pMenuBar = NULL;
 648 #endif // wxUSE_MENUS
 649 }
 650
 651 bool wxAuiMDIChildFrame::Show(bool show)
 652 {
 653     m_activate_on_create = show;
 654
 655     // do nothing
 656     return true;
 657 }
 658
 659 void wxAuiMDIChildFrame::DoShow(bool show)
 660 {
 661     wxWindow::Show(show);
 662 }
 663
 664 void wxAuiMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 665 {
 666     m_mdi_newrect = wxRect(x, y, width, height);
 667 #ifdef __WXGTK__
 668     wxPanel::DoSetSize(x,y,width, height, sizeFlags);
 669 #else
 670     wxUnusedVar(sizeFlags);
 671 #endif
 672 }
 673
 674 void wxAuiMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
 675 {
 676     m_mdi_newrect = wxRect(x, y, width, height);
 677 }
 678
 679 void wxAuiMDIChildFrame::ApplyMDIChildFrameRect()
 680 {
 681     if (m_mdi_currect != m_mdi_newrect)
 682     {
 683         wxPanel::DoMoveWindow(m_mdi_newrect.x, m_mdi_newrect.y,
 684                               m_mdi_newrect.width, m_mdi_newrect.height);
 685         m_mdi_currect = m_mdi_newrect;
 686     }
 687 }
 688
 689
 690 //-----------------------------------------------------------------------------
 691 // wxAuiMDIClientWindow
 692 //-----------------------------------------------------------------------------
 693
 694 IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIClientWindow, wxAuiNotebook)
 695
 696 BEGIN_EVENT_TABLE(wxAuiMDIClientWindow, wxAuiNotebook)
 697     EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, wxAuiMDIClientWindow::OnPageChanged)
 698     EVT_AUINOTEBOOK_PAGE_CLOSE(wxID_ANY, wxAuiMDIClientWindow::OnPageClose)
 699     EVT_SIZE(wxAuiMDIClientWindow::OnSize)
 700 END_EVENT_TABLE()
 701
 702 wxAuiMDIClientWindow::wxAuiMDIClientWindow()
 703 {
 704 }
 705
 706 wxAuiMDIClientWindow::wxAuiMDIClientWindow(wxAuiMDIParentFrame* parent, long style)
 707 {
 708     CreateClient(parent, style);
 709 }
 710
 711 wxAuiMDIClientWindow::~wxAuiMDIClientWindow()
 712 {
 713     DestroyChildren();
 714 }
 715
 716 bool wxAuiMDIClientWindow::CreateClient(wxAuiMDIParentFrame* parent, long style)
 717 {
 718     SetWindowStyleFlag(style);
 719
 720     wxSize caption_icon_size =
 721             wxSize(wxSystemSettings::GetMetric(wxSYS_SMALLICON_X),
 722                    wxSystemSettings::GetMetric(wxSYS_SMALLICON_Y));
 723     SetUniformBitmapSize(caption_icon_size);
 724
 725     if (!wxAuiNotebook::Create(parent,
 726                                wxID_ANY,
 727                                wxPoint(0,0),
 728                                wxSize(100, 100),
 729                                wxAUI_NB_DEFAULT_STYLE | wxNO_BORDER))
 730     {
 731         return false;
 732     }
 733
 734     wxColour bkcolour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
 735     SetOwnBackgroundColour(bkcolour);
 736
 737     m_mgr.GetArtProvider()->SetColour(wxAUI_DOCKART_BACKGROUND_COLOUR, bkcolour);
 738
 739     return true;
 740 }
 741
 742 int wxAuiMDIClientWindow::SetSelection(size_t nPage)
 743 {
 744     return wxAuiNotebook::SetSelection(nPage);
 745 }
 746
 747 void wxAuiMDIClientWindow::PageChanged(int old_selection, int new_selection)
 748 {
 749     // don't do anything if the page doesn't actually change
 750     if (old_selection == new_selection)
 751         return;
 752
 753     /*
 754     // don't do anything if the new page is already active
 755     if (new_selection != -1)
 756     {
 757         wxAuiMDIChildFrame* child = (wxAuiMDIChildFrame*)GetPage(new_selection);
 758         if (child->GetMDIParentFrame()->GetActiveChild() == child)
 759             return;
 760     }*/
 761
 762
 763     // notify old active child that it has been deactivated
 764     if (old_selection != -1)
 765     {
 766         wxAuiMDIChildFrame* old_child = (wxAuiMDIChildFrame*)GetPage(old_selection);
 767         wxASSERT_MSG(old_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
 768
 769         wxActivateEvent event(wxEVT_ACTIVATE, false, old_child->GetId());
 770         event.SetEventObject(old_child);
 771         old_child->GetEventHandler()->ProcessEvent(event);
 772     }
 773
 774     // notify new active child that it has been activated
 775     if (new_selection != -1)
 776     {
 777         wxAuiMDIChildFrame* active_child = (wxAuiMDIChildFrame*)GetPage(new_selection);
 778         wxASSERT_MSG(active_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
 779
 780         wxActivateEvent event(wxEVT_ACTIVATE, true, active_child->GetId());
 781         event.SetEventObject(active_child);
 782         active_child->GetEventHandler()->ProcessEvent(event);
 783
 784         if (active_child->GetMDIParentFrame())
 785         {
 786             active_child->GetMDIParentFrame()->SetActiveChild(active_child);
 787             active_child->GetMDIParentFrame()->SetChildMenuBar(active_child);
 788         }
 789     }
 790
 791
 792 }
 793
 794 void wxAuiMDIClientWindow::OnPageClose(wxAuiNotebookEvent& evt)
 795 {
 796     wxAuiMDIChildFrame* wnd;
 797     wnd = static_cast<wxAuiMDIChildFrame*>(GetPage(evt.GetSelection()));
 798
 799     wnd->Close();
 800
 801     // regardless of the result of wnd->Close(), we've
 802     // already taken care of the close operations, so
 803     // suppress further processing
 804     evt.Veto();
 805 }
 806
 807 void wxAuiMDIClientWindow::OnPageChanged(wxAuiNotebookEvent& evt)
 808 {
 809     PageChanged(evt.GetOldSelection(), evt.GetSelection());
 810 }
 811
 812 void wxAuiMDIClientWindow::OnSize(wxSizeEvent& evt)
 813 {
 814     wxAuiNotebook::OnSize(evt);
 815
 816     for (size_t pos = 0; pos < GetPageCount(); pos++)
 817         ((wxAuiMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
 818 }
 819
 820 #endif //wxUSE_AUI
 821 #endif // wxUSE_MDI