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 // wxTabMDIParentFrame
  52 //-----------------------------------------------------------------------------
  53
  54 IMPLEMENT_DYNAMIC_CLASS(wxTabMDIParentFrame, wxFrame)
  55
  56 BEGIN_EVENT_TABLE(wxTabMDIParentFrame, wxFrame)
  57 #if wxUSE_MENUS
  58     EVT_MENU (wxID_ANY, wxTabMDIParentFrame::DoHandleMenu)
  59 #endif
  60 END_EVENT_TABLE()
  61
  62 wxTabMDIParentFrame::wxTabMDIParentFrame()
  63 {
  64     Init();
  65 }
  66
  67 wxTabMDIParentFrame::wxTabMDIParentFrame(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 wxTabMDIParentFrame::~wxTabMDIParentFrame()
  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 wxTabMDIParentFrame::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 #if wxUSE_MENUS
 118 void wxTabMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
 119 {
 120     // Replace the window menu from the currently loaded menu bar.
 121     wxMenuBar *pMenuBar = GetMenuBar();
 122
 123     if (m_pWindowMenu)
 124     {
 125         RemoveWindowMenu(pMenuBar);
 126         wxDELETE(m_pWindowMenu);
 127     }
 128
 129     if (pMenu)
 130     {
 131         m_pWindowMenu = pMenu;
 132         AddWindowMenu(pMenuBar);
 133     }
 134 }
 135
 136 void wxTabMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)
 137 {
 138     // Remove the Window menu from the old menu bar
 139     RemoveWindowMenu(GetMenuBar());
 140
 141     // Add the Window menu to the new menu bar.
 142     AddWindowMenu(pMenuBar);
 143
 144     wxFrame::SetMenuBar(pMenuBar);
 145     m_pMyMenuBar = GetMenuBar();
 146 }
 147 #endif // wxUSE_MENUS
 148
 149 void wxTabMDIParentFrame::SetChildMenuBar(wxTabMDIChildFrame* pChild)
 150 {
 151 #if wxUSE_MENUS
 152     if (!pChild)
 153     {
 154         // No Child, set Our menu bar back.
 155         SetMenuBar(m_pMyMenuBar);
 156
 157         // Make sure we know our menu bar is in use
 158         //m_pMyMenuBar = NULL;
 159     }
 160      else
 161     {
 162         if (pChild->GetMenuBar() == NULL)
 163             return;
 164
 165         // Do we need to save the current bar?
 166         if (m_pMyMenuBar == NULL)
 167             m_pMyMenuBar = GetMenuBar();
 168
 169         SetMenuBar(pChild->GetMenuBar());
 170     }
 171 #endif // wxUSE_MENUS
 172 }
 173
 174 bool wxTabMDIParentFrame::ProcessEvent(wxEvent& event)
 175 {
 176     // Stops the same event being processed repeatedly
 177     static wxEventType inEvent = wxEVT_NULL;
 178     if (inEvent == event.GetEventType())
 179         return false;
 180
 181     inEvent = event.GetEventType();
 182
 183     // Let the active child (if any) process the event first.
 184     bool res = false;
 185     if (m_pActiveChild &&
 186         event.IsCommandEvent() &&
 187         event.GetEventObject() != m_pClientWindow &&
 188            !(event.GetEventType() == wxEVT_ACTIVATE ||
 189              event.GetEventType() == wxEVT_SET_FOCUS ||
 190              event.GetEventType() == wxEVT_KILL_FOCUS ||
 191              event.GetEventType() == wxEVT_CHILD_FOCUS ||
 192              event.GetEventType() == wxEVT_COMMAND_SET_FOCUS ||
 193              event.GetEventType() == wxEVT_COMMAND_KILL_FOCUS )
 194        )
 195     {
 196         res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
 197     }
 198
 199     // If the event was not handled this frame will handle it!
 200     if (!res)
 201     {
 202         //res = GetEventHandler()->ProcessEvent(event);
 203         res = wxEvtHandler::ProcessEvent(event);
 204     }
 205
 206     inEvent = wxEVT_NULL;
 207
 208     return res;
 209 }
 210
 211 wxTabMDIChildFrame *wxTabMDIParentFrame::GetActiveChild() const
 212 {
 213     return m_pActiveChild;
 214 }
 215
 216 void wxTabMDIParentFrame::SetActiveChild(wxTabMDIChildFrame* pChildFrame)
 217 {
 218     m_pActiveChild = pChildFrame;
 219 }
 220
 221 wxTabMDIClientWindow *wxTabMDIParentFrame::GetClientWindow() const
 222 {
 223     return m_pClientWindow;
 224 }
 225
 226 wxTabMDIClientWindow *wxTabMDIParentFrame::OnCreateClient()
 227 {
 228     m_pClientWindow = new wxTabMDIClientWindow( this );
 229     return m_pClientWindow;
 230 }
 231
 232 void wxTabMDIParentFrame::ActivateNext()
 233 {
 234     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
 235     {
 236         size_t active = m_pClientWindow->GetSelection() + 1;
 237         if (active >= m_pClientWindow->GetPageCount())
 238             active = 0;
 239
 240         m_pClientWindow->SetSelection(active);
 241     }
 242 }
 243
 244 void wxTabMDIParentFrame::ActivatePrevious()
 245 {
 246     if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
 247     {
 248         int active = m_pClientWindow->GetSelection() - 1;
 249         if (active < 0)
 250             active = m_pClientWindow->GetPageCount() - 1;
 251
 252         m_pClientWindow->SetSelection(active);
 253     }
 254 }
 255
 256 void wxTabMDIParentFrame::Init()
 257 {
 258     m_pClientWindow = NULL;
 259     m_pActiveChild = NULL;
 260 #if wxUSE_MENUS
 261     m_pWindowMenu = NULL;
 262     m_pMyMenuBar = NULL;
 263 #endif // wxUSE_MENUS
 264 }
 265
 266 #if wxUSE_MENUS
 267 void wxTabMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
 268 {
 269     if (pMenuBar && m_pWindowMenu)
 270     {
 271         // Remove old window menu
 272         int pos = pMenuBar->FindMenu(_("&Window"));
 273         if (pos != wxNOT_FOUND)
 274         {
 275             // DBG:: We're going to delete the wrong menu!!!
 276             wxASSERT(m_pWindowMenu == pMenuBar->GetMenu(pos));
 277             pMenuBar->Remove(pos);
 278         }
 279     }
 280 }
 281
 282 void wxTabMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
 283 {
 284     if (pMenuBar && m_pWindowMenu)
 285     {
 286         int pos = pMenuBar->FindMenu(wxGetStockLabel(wxID_HELP,false));
 287         if (pos == wxNOT_FOUND)
 288             pMenuBar->Append(m_pWindowMenu, _("&Window"));
 289              else
 290             pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
 291     }
 292 }
 293
 294 void wxTabMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
 295 {
 296     switch (event.GetId())
 297     {
 298         case wxWINDOWCLOSE:
 299             if (m_pActiveChild)
 300                 m_pActiveChild->Close();
 301             break;
 302         case wxWINDOWCLOSEALL:
 303             while (m_pActiveChild)
 304             {
 305                 if (!m_pActiveChild->Close())
 306                 {
 307                     return; // failure
 308                 }
 309                  else
 310                 {
 311                     delete m_pActiveChild;
 312                     m_pActiveChild = NULL;
 313                 }
 314             }
 315             break;
 316         case wxWINDOWNEXT:
 317             ActivateNext();
 318             break;
 319         case wxWINDOWPREV:
 320             ActivatePrevious();
 321             break;
 322         default:
 323             event.Skip();
 324     }
 325 }
 326 #endif // wxUSE_MENUS
 327
 328 void wxTabMDIParentFrame::DoGetClientSize(int* width, int* height) const
 329 {
 330     wxFrame::DoGetClientSize(width, height);
 331 }
 332
 333 //-----------------------------------------------------------------------------
 334 // wxTabMDIChildFrame
 335 //-----------------------------------------------------------------------------
 336
 337 IMPLEMENT_DYNAMIC_CLASS(wxTabMDIChildFrame, wxPanel)
 338
 339 BEGIN_EVENT_TABLE(wxTabMDIChildFrame, wxPanel)
 340     EVT_MENU_HIGHLIGHT_ALL(wxTabMDIChildFrame::OnMenuHighlight)
 341     EVT_ACTIVATE(wxTabMDIChildFrame::OnActivate)
 342     EVT_CLOSE(wxTabMDIChildFrame::OnCloseWindow)
 343 END_EVENT_TABLE()
 344
 345 wxTabMDIChildFrame::wxTabMDIChildFrame()
 346 {
 347     Init();
 348 }
 349
 350 wxTabMDIChildFrame::wxTabMDIChildFrame(wxTabMDIParentFrame *parent,
 351                                        wxWindowID id,
 352                                        const wxString& title,
 353                                        const wxPoint& WXUNUSED(pos),
 354                                        const wxSize& size,
 355                                        long style,
 356                                        const wxString& name)
 357 {
 358     Init();
 359     Create(parent, id, title, wxDefaultPosition, size, style, name);
 360 }
 361
 362 wxTabMDIChildFrame::~wxTabMDIChildFrame()
 363 {
 364 #if wxUSE_MENUS
 365     wxDELETE(m_pMenuBar);
 366 #endif // wxUSE_MENUS
 367 }
 368
 369 bool wxTabMDIChildFrame::Create(wxTabMDIParentFrame* parent,
 370                                 wxWindowID id,
 371                                 const wxString& title,
 372                                 const wxPoint& WXUNUSED(pos),
 373                                 const wxSize& size,
 374                                 long style,
 375                                 const wxString& name)
 376 {
 377     wxTabMDIClientWindow* pClientWindow = parent->GetClientWindow();
 378     wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window."));
 379
 380     wxPanel::Create(pClientWindow, id, wxDefaultPosition, size, style|wxNO_BORDER, name);
 381
 382     SetMDIParentFrame(parent);
 383
 384     // this is the currently active child
 385     parent->SetActiveChild(this);
 386
 387     m_title = title;
 388
 389     pClientWindow->AddPage(this, title, true);
 390     pClientWindow->Refresh();
 391
 392     return true;
 393 }
 394
 395 bool wxTabMDIChildFrame::Destroy()
 396 {
 397     wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
 398     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 399
 400     wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
 401     wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
 402
 403     bool bActive = false;
 404     if (pParentFrame->GetActiveChild() == this)
 405     {
 406         pParentFrame->SetActiveChild(NULL);
 407         pParentFrame->SetChildMenuBar(NULL);
 408         bActive = true;
 409     }
 410
 411     size_t pos, page_count = pClientWindow->GetPageCount();
 412     for (pos = 0; pos < page_count; pos++)
 413     {
 414         if (pClientWindow->GetPage(pos) == this)
 415             return pClientWindow->DeletePage(pos);
 416     }
 417
 418     return false;
 419 }
 420
 421 #if wxUSE_MENUS
 422 void wxTabMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
 423 {
 424     wxMenuBar *pOldMenuBar = m_pMenuBar;
 425     m_pMenuBar = menu_bar;
 426
 427     if (m_pMenuBar)
 428     {
 429         wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
 430         wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 431
 432         m_pMenuBar->SetParent(pParentFrame);
 433         if (pParentFrame->GetActiveChild() == this)
 434         {
 435             // replace current menu bars
 436             if (pOldMenuBar)
 437                 pParentFrame->SetChildMenuBar(NULL);
 438             pParentFrame->SetChildMenuBar(this);
 439         }
 440     }
 441 }
 442
 443 wxMenuBar *wxTabMDIChildFrame::GetMenuBar() const
 444 {
 445     return m_pMenuBar;
 446 }
 447 #endif // wxUSE_MENUS
 448
 449 void wxTabMDIChildFrame::SetTitle(const wxString& title)
 450 {
 451     m_title = title;
 452
 453     wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
 454     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 455
 456     wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
 457     if (pClientWindow != NULL)
 458     {
 459         size_t pos;
 460         for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
 461         {
 462             if (pClientWindow->GetPage(pos) == this)
 463             {
 464                 pClientWindow->SetPageText(pos, m_title);
 465                 break;
 466             }
 467         }
 468     }
 469 }
 470
 471 wxString wxTabMDIChildFrame::GetTitle() const
 472 {
 473     return m_title;
 474 }
 475
 476 void wxTabMDIChildFrame::Activate()
 477 {
 478     wxTabMDIParentFrame* pParentFrame = GetMDIParentFrame();
 479     wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
 480
 481     wxTabMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
 482
 483     if (pClientWindow != NULL)
 484     {
 485         size_t pos;
 486         for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
 487         {
 488             if (pClientWindow->GetPage(pos) == this)
 489             {
 490                 pClientWindow->SetSelection(pos);
 491                 break;
 492             }
 493         }
 494     }
 495 }
 496
 497 void wxTabMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
 498 {
 499 #if wxUSE_STATUSBAR
 500     if (m_pMDIParentFrame)
 501     {
 502         // we don't have any help text for this item,
 503         // but may be the MDI frame does?
 504         m_pMDIParentFrame->OnMenuHighlight(event);
 505     }
 506 #else
 507     wxUnusedVar(event);
 508 #endif // wxUSE_STATUSBAR
 509 }
 510
 511 void wxTabMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
 512 {
 513     // do nothing
 514 }
 515
 516 void wxTabMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 517 {
 518     Destroy();
 519 }
 520
 521 void wxTabMDIChildFrame::SetMDIParentFrame(wxTabMDIParentFrame* parentFrame)
 522 {
 523     m_pMDIParentFrame = parentFrame;
 524 }
 525
 526 wxTabMDIParentFrame* wxTabMDIChildFrame::GetMDIParentFrame() const
 527 {
 528     return m_pMDIParentFrame;
 529 }
 530
 531 void wxTabMDIChildFrame::Init()
 532 {
 533     m_pMDIParentFrame = NULL;
 534 #if wxUSE_MENUS
 535     m_pMenuBar = NULL;
 536 #endif // wxUSE_MENUS
 537 }
 538
 539 bool wxTabMDIChildFrame::Show(bool WXUNUSED(show))
 540 {
 541     // do nothing
 542     return true;
 543 }
 544
 545 void wxTabMDIChildFrame::DoShow(bool show)
 546 {
 547     wxWindow::Show(show);
 548 }
 549
 550 void wxTabMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 551 {
 552     m_mdi_newrect = wxRect(x, y, width, height);
 553 #ifdef __WXGTK__
 554     wxPanel::DoSetSize(x,y,width, height, sizeFlags);
 555 #else
 556     wxUnusedVar(sizeFlags);
 557 #endif
 558 }
 559
 560 void wxTabMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
 561 {
 562     m_mdi_newrect = wxRect(x, y, width, height);
 563 }
 564
 565 void wxTabMDIChildFrame::ApplyMDIChildFrameRect()
 566 {
 567     if (m_mdi_currect != m_mdi_newrect)
 568     {
 569         wxPanel::DoMoveWindow(m_mdi_newrect.x, m_mdi_newrect.y,
 570                               m_mdi_newrect.width, m_mdi_newrect.height);
 571         m_mdi_currect = m_mdi_newrect;
 572     }
 573 }
 574
 575
 576 //-----------------------------------------------------------------------------
 577 // wxTabMDIClientWindow
 578 //-----------------------------------------------------------------------------
 579
 580 IMPLEMENT_DYNAMIC_CLASS(wxTabMDIClientWindow, wxAuiMultiNotebook)
 581
 582 BEGIN_EVENT_TABLE(wxTabMDIClientWindow, wxAuiMultiNotebook)
 583     EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, wxTabMDIClientWindow::OnPageChanged)
 584     EVT_SIZE(wxTabMDIClientWindow::OnSize)
 585 END_EVENT_TABLE()
 586
 587 wxTabMDIClientWindow::wxTabMDIClientWindow()
 588 {
 589 }
 590
 591 wxTabMDIClientWindow::wxTabMDIClientWindow(wxTabMDIParentFrame* parent, long style)
 592 {
 593     CreateClient(parent, style);
 594 }
 595
 596 wxTabMDIClientWindow::~wxTabMDIClientWindow()
 597 {
 598     DestroyChildren();
 599 }
 600
 601 bool wxTabMDIClientWindow::CreateClient(wxTabMDIParentFrame* parent, long style)
 602 {
 603     SetWindowStyleFlag(style);
 604
 605     if (!wxAuiMultiNotebook::Create(parent,
 606                                     wxID_ANY,
 607                                     wxPoint(0,0),
 608                                     wxSize(100, 100),
 609                                     wxNO_BORDER))
 610     {
 611         return false;
 612     }
 613
 614     wxColour bkcolour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
 615     SetBackgroundColour(bkcolour);
 616
 617     m_mgr.GetArtProvider()->SetColour(wxAUI_ART_BACKGROUND_COLOUR, bkcolour);
 618
 619     return true;
 620 }
 621
 622 int wxTabMDIClientWindow::SetSelection(size_t nPage)
 623 {
 624     return wxAuiMultiNotebook::SetSelection(nPage);
 625 }
 626
 627 void wxTabMDIClientWindow::PageChanged(int old_selection, int new_selection)
 628 {
 629     // don't do anything if the page doesn't actually change
 630     if (old_selection == new_selection)
 631         return;
 632
 633     // don't do anything if the new page is already active
 634     if (new_selection != -1)
 635     {
 636         wxTabMDIChildFrame* child = (wxTabMDIChildFrame*)GetPage(new_selection);
 637         if (child->GetMDIParentFrame()->GetActiveChild() == child)
 638             return;
 639     }
 640
 641     // notify old active child that it has been deactivated
 642     if (old_selection != -1)
 643     {
 644         wxTabMDIChildFrame* old_child = (wxTabMDIChildFrame*)GetPage(old_selection);
 645         wxASSERT_MSG(old_child, wxT("wxTabMDIClientWindow::PageChanged - null page pointer"));
 646
 647         wxActivateEvent event(wxEVT_ACTIVATE, false, old_child->GetId());
 648         event.SetEventObject(old_child);
 649         old_child->GetEventHandler()->ProcessEvent(event);
 650     }
 651
 652     // notify new active child that it has been activated
 653     if (new_selection != -1)
 654     {
 655         wxTabMDIChildFrame* active_child = (wxTabMDIChildFrame*)GetPage(new_selection);
 656         wxASSERT_MSG(active_child, wxT("wxTabMDIClientWindow::PageChanged - null page pointer"));
 657
 658         wxActivateEvent event(wxEVT_ACTIVATE, true, active_child->GetId());
 659         event.SetEventObject(active_child);
 660         active_child->GetEventHandler()->ProcessEvent(event);
 661
 662         if (active_child->GetMDIParentFrame())
 663         {
 664             active_child->GetMDIParentFrame()->SetActiveChild(active_child);
 665             active_child->GetMDIParentFrame()->SetChildMenuBar(active_child);
 666         }
 667     }
 668 }
 669
 670 void wxTabMDIClientWindow::OnPageChanged(wxAuiNotebookEvent& evt)
 671 {
 672     PageChanged(evt.GetOldSelection(), evt.GetSelection());
 673     evt.Skip();
 674 }
 675
 676 void wxTabMDIClientWindow::OnSize(wxSizeEvent& evt)
 677 {
 678     wxAuiMultiNotebook::OnSize(evt);
 679
 680     for (size_t pos = 0; pos < GetPageCount(); pos++)
 681         ((wxTabMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
 682 }
 683
 684 #endif //wxUSE_AUI
 685 #endif // wxUSE_MDI