]> git.saurik.com Git - wxWidgets.git/blob - src/aui/tabmdi.cpp
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / 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 wxDELETE(m_pMyMenuBar);
86 RemoveWindowMenu(GetMenuBar());
87 wxDELETE(m_pWindowMenu);
88 #endif // wxUSE_MENUS
89 }
90
91 bool wxAuiMDIParentFrame::Create(wxWindow *parent,
92 wxWindowID id,
93 const wxString& title,
94 const wxPoint& pos,
95 const wxSize& size,
96 long style,
97 const wxString& name)
98 {
99 #if wxUSE_MENUS
100 // this style can be used to prevent a window from having the standard MDI
101 // "Window" menu
102 if (!(style & wxFRAME_NO_WINDOW_MENU))
103 {
104 m_pWindowMenu = new wxMenu;
105 m_pWindowMenu->Append(wxWINDOWCLOSE, _("Cl&ose"));
106 m_pWindowMenu->Append(wxWINDOWCLOSEALL, _("Close All"));
107 m_pWindowMenu->AppendSeparator();
108 m_pWindowMenu->Append(wxWINDOWNEXT, _("&Next"));
109 m_pWindowMenu->Append(wxWINDOWPREV, _("&Previous"));
110 }
111 #endif // wxUSE_MENUS
112
113 if ( !wxFrame::Create(parent, id, title, pos, size, style, name) )
114 return false;
115
116 m_pClientWindow = OnCreateClient();
117 return m_pClientWindow != NULL;
118 }
119
120
121 void wxAuiMDIParentFrame::SetArtProvider(wxAuiTabArt* provider)
122 {
123 if (m_pClientWindow)
124 {
125 m_pClientWindow->SetArtProvider(provider);
126 }
127 }
128
129 wxAuiTabArt* wxAuiMDIParentFrame::GetArtProvider()
130 {
131 if (!m_pClientWindow)
132 return NULL;
133
134 return m_pClientWindow->GetArtProvider();
135 }
136
137 wxAuiNotebook* wxAuiMDIParentFrame::GetNotebook() const
138 {
139 return static_cast<wxAuiNotebook*>(m_pClientWindow);
140 }
141
142
143
144 #if wxUSE_MENUS
145 void wxAuiMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
146 {
147 // Replace the window menu from the currently loaded menu bar.
148 wxMenuBar *pMenuBar = GetMenuBar();
149
150 if (m_pWindowMenu)
151 {
152 RemoveWindowMenu(pMenuBar);
153 wxDELETE(m_pWindowMenu);
154 }
155
156 if (pMenu)
157 {
158 m_pWindowMenu = pMenu;
159 AddWindowMenu(pMenuBar);
160 }
161 }
162
163 void wxAuiMDIParentFrame::SetMenuBar(wxMenuBar* pMenuBar)
164 {
165 // Remove the Window menu from the old menu bar
166 RemoveWindowMenu(GetMenuBar());
167
168 // Add the Window menu to the new menu bar.
169 AddWindowMenu(pMenuBar);
170
171 wxFrame::SetMenuBar(pMenuBar);
172 //m_pMyMenuBar = GetMenuBar();
173 }
174 #endif // wxUSE_MENUS
175
176 void wxAuiMDIParentFrame::SetChildMenuBar(wxAuiMDIChildFrame* pChild)
177 {
178 #if wxUSE_MENUS
179 if (!pChild)
180 {
181 // No Child, set Our menu bar back.
182 if (m_pMyMenuBar)
183 SetMenuBar(m_pMyMenuBar);
184 else
185 SetMenuBar(GetMenuBar());
186
187 // Make sure we know our menu bar is in use
188 m_pMyMenuBar = NULL;
189 }
190 else
191 {
192 if (pChild->GetMenuBar() == NULL)
193 return;
194
195 // Do we need to save the current bar?
196 if (m_pMyMenuBar == NULL)
197 m_pMyMenuBar = GetMenuBar();
198
199 SetMenuBar(pChild->GetMenuBar());
200 }
201 #endif // wxUSE_MENUS
202 }
203
204 bool wxAuiMDIParentFrame::ProcessEvent(wxEvent& event)
205 {
206 // stops the same event being processed repeatedly
207 if (m_pLastEvt == &event)
208 return false;
209 m_pLastEvt = &event;
210
211 // let the active child (if any) process the event first.
212 bool res = false;
213 if (m_pActiveChild &&
214 event.IsCommandEvent() &&
215 event.GetEventObject() != m_pClientWindow &&
216 !(event.GetEventType() == wxEVT_ACTIVATE ||
217 event.GetEventType() == wxEVT_SET_FOCUS ||
218 event.GetEventType() == wxEVT_KILL_FOCUS ||
219 event.GetEventType() == wxEVT_CHILD_FOCUS ||
220 event.GetEventType() == wxEVT_COMMAND_SET_FOCUS ||
221 event.GetEventType() == wxEVT_COMMAND_KILL_FOCUS )
222 )
223 {
224 res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
225 }
226
227 if (!res)
228 {
229 // if the event was not handled this frame will handle it,
230 // which is why we need the protection code at the beginning
231 // of this method
232 res = wxEvtHandler::ProcessEvent(event);
233 }
234
235 m_pLastEvt = NULL;
236
237 return res;
238 }
239
240 wxAuiMDIChildFrame *wxAuiMDIParentFrame::GetActiveChild() const
241 {
242 return m_pActiveChild;
243 }
244
245 void wxAuiMDIParentFrame::SetActiveChild(wxAuiMDIChildFrame* pChildFrame)
246 {
247 m_pActiveChild = pChildFrame;
248 }
249
250 wxAuiMDIClientWindow *wxAuiMDIParentFrame::GetClientWindow() const
251 {
252 return m_pClientWindow;
253 }
254
255 wxAuiMDIClientWindow *wxAuiMDIParentFrame::OnCreateClient()
256 {
257 return new wxAuiMDIClientWindow( this );
258 }
259
260 void wxAuiMDIParentFrame::ActivateNext()
261 {
262 if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
263 {
264 size_t active = m_pClientWindow->GetSelection() + 1;
265 if (active >= m_pClientWindow->GetPageCount())
266 active = 0;
267
268 m_pClientWindow->SetSelection(active);
269 }
270 }
271
272 void wxAuiMDIParentFrame::ActivatePrevious()
273 {
274 if (m_pClientWindow && m_pClientWindow->GetSelection() != wxNOT_FOUND)
275 {
276 int active = m_pClientWindow->GetSelection() - 1;
277 if (active < 0)
278 active = m_pClientWindow->GetPageCount() - 1;
279
280 m_pClientWindow->SetSelection(active);
281 }
282 }
283
284 void wxAuiMDIParentFrame::Init()
285 {
286 m_pLastEvt = NULL;
287 m_pClientWindow = NULL;
288 m_pActiveChild = NULL;
289 #if wxUSE_MENUS
290 m_pWindowMenu = NULL;
291 m_pMyMenuBar = NULL;
292 #endif // wxUSE_MENUS
293 }
294
295 #if wxUSE_MENUS
296 void wxAuiMDIParentFrame::RemoveWindowMenu(wxMenuBar* pMenuBar)
297 {
298 if (pMenuBar && m_pWindowMenu)
299 {
300 // Remove old window menu
301 int pos = pMenuBar->FindMenu(_("&Window"));
302 if (pos != wxNOT_FOUND)
303 {
304 // DBG:: We're going to delete the wrong menu!!!
305 wxASSERT(m_pWindowMenu == pMenuBar->GetMenu(pos));
306 pMenuBar->Remove(pos);
307 }
308 }
309 }
310
311 void wxAuiMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
312 {
313 if (pMenuBar && m_pWindowMenu)
314 {
315 int pos = pMenuBar->FindMenu(wxGetStockLabel(wxID_HELP,wxSTOCK_NOFLAGS));
316 if (pos == wxNOT_FOUND)
317 pMenuBar->Append(m_pWindowMenu, _("&Window"));
318 else
319 pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
320 }
321 }
322
323 void wxAuiMDIParentFrame::DoHandleMenu(wxCommandEvent& event)
324 {
325 switch (event.GetId())
326 {
327 case wxWINDOWCLOSE:
328 if (m_pActiveChild)
329 m_pActiveChild->Close();
330 break;
331 case wxWINDOWCLOSEALL:
332 while (m_pActiveChild)
333 {
334 if (!m_pActiveChild->Close())
335 {
336 return; // failure
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 wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
420 if (pParentFrame)
421 {
422 if (pParentFrame->GetActiveChild() == this)
423 {
424 pParentFrame->SetActiveChild(NULL);
425 pParentFrame->SetChildMenuBar(NULL);
426 }
427 wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
428 wxASSERT(pClientWindow);
429 int idx = pClientWindow->GetPageIndex(this);
430 if (idx != wxNOT_FOUND)
431 {
432 pClientWindow->RemovePage(idx);
433 }
434 }
435
436 #if wxUSE_MENUS
437 wxDELETE(m_pMenuBar);
438 #endif // wxUSE_MENUS
439 }
440
441 bool wxAuiMDIChildFrame::Create(wxAuiMDIParentFrame* parent,
442 wxWindowID id,
443 const wxString& title,
444 const wxPoint& WXUNUSED(pos),
445 const wxSize& size,
446 long style,
447 const wxString& name)
448 {
449 wxAuiMDIClientWindow* pClientWindow = parent->GetClientWindow();
450 wxASSERT_MSG((pClientWindow != NULL), wxT("Missing MDI client window."));
451
452 // see comment in constructor
453 if (style & wxMINIMIZE)
454 m_activate_on_create = false;
455
456 wxSize cli_size = pClientWindow->GetClientSize();
457
458 // create the window off-screen to prevent flicker
459 wxPanel::Create(pClientWindow,
460 id,
461 wxPoint(cli_size.x+1, cli_size.y+1),
462 size,
463 wxNO_BORDER, name);
464
465 DoShow(false);
466
467 SetMDIParentFrame(parent);
468
469 // this is the currently active child
470 parent->SetActiveChild(this);
471
472 m_title = title;
473
474 pClientWindow->AddPage(this, title, m_activate_on_create);
475 pClientWindow->Refresh();
476
477 return true;
478 }
479
480 bool wxAuiMDIChildFrame::Destroy()
481 {
482 wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
483 wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
484
485 wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
486 wxASSERT_MSG(pClientWindow, wxT("Missing MDI Client Window"));
487
488 if (pParentFrame->GetActiveChild() == this)
489 {
490 // deactivate ourself
491 wxActivateEvent event(wxEVT_ACTIVATE, false, GetId());
492 event.SetEventObject(this);
493 GetEventHandler()->ProcessEvent(event);
494
495 pParentFrame->SetActiveChild(NULL);
496 pParentFrame->SetChildMenuBar(NULL);
497 }
498
499 size_t page_count = pClientWindow->GetPageCount();
500 for (size_t pos = 0; pos < page_count; pos++)
501 {
502 if (pClientWindow->GetPage(pos) == this)
503 return pClientWindow->DeletePage(pos);
504 }
505
506 return false;
507 }
508
509 #if wxUSE_MENUS
510 void wxAuiMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar)
511 {
512 wxMenuBar *pOldMenuBar = m_pMenuBar;
513 m_pMenuBar = menu_bar;
514
515 if (m_pMenuBar)
516 {
517 wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
518 wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
519
520 m_pMenuBar->SetParent(pParentFrame);
521 if (pParentFrame->GetActiveChild() == this)
522 {
523 // replace current menu bars
524 if (pOldMenuBar)
525 pParentFrame->SetChildMenuBar(NULL);
526 pParentFrame->SetChildMenuBar(this);
527 }
528 }
529 }
530
531 wxMenuBar *wxAuiMDIChildFrame::GetMenuBar() const
532 {
533 return m_pMenuBar;
534 }
535 #endif // wxUSE_MENUS
536
537 void wxAuiMDIChildFrame::SetTitle(const wxString& title)
538 {
539 m_title = title;
540
541 wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
542 wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
543
544 wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
545 if (pClientWindow != NULL)
546 {
547 size_t pos;
548 for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
549 {
550 if (pClientWindow->GetPage(pos) == this)
551 {
552 pClientWindow->SetPageText(pos, m_title);
553 break;
554 }
555 }
556 }
557 }
558
559 wxString wxAuiMDIChildFrame::GetTitle() const
560 {
561 return m_title;
562 }
563
564 void wxAuiMDIChildFrame::SetIcons(const wxIconBundle& icons)
565 {
566 // get icon with the system icon size
567 SetIcon(icons.GetIcon(-1));
568 m_icon_bundle = icons;
569 }
570
571 const wxIconBundle& wxAuiMDIChildFrame::GetIcons() const
572 {
573 return m_icon_bundle;
574 }
575
576 void wxAuiMDIChildFrame::SetIcon(const wxIcon& icon)
577 {
578 wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
579 wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
580
581 m_icon = icon;
582
583 wxBitmap bmp;
584 bmp.CopyFromIcon(m_icon);
585
586 wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
587 if (pClientWindow != NULL)
588 {
589 int idx = pClientWindow->GetPageIndex(this);
590
591 if (idx != -1)
592 {
593 pClientWindow->SetPageBitmap((size_t)idx, bmp);
594 }
595 }
596 }
597
598 const wxIcon& wxAuiMDIChildFrame::GetIcon() const
599 {
600 return m_icon;
601 }
602
603
604 void wxAuiMDIChildFrame::Activate()
605 {
606 wxAuiMDIParentFrame* pParentFrame = GetMDIParentFrame();
607 wxASSERT_MSG(pParentFrame, wxT("Missing MDI Parent Frame"));
608
609 wxAuiMDIClientWindow* pClientWindow = pParentFrame->GetClientWindow();
610
611 if (pClientWindow != NULL)
612 {
613 size_t pos;
614 for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
615 {
616 if (pClientWindow->GetPage(pos) == this)
617 {
618 pClientWindow->SetSelection(pos);
619 break;
620 }
621 }
622 }
623 }
624
625 void wxAuiMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
626 {
627 #if wxUSE_STATUSBAR
628 if (m_pMDIParentFrame)
629 {
630 // we don't have any help text for this item,
631 // but may be the MDI frame does?
632 m_pMDIParentFrame->OnMenuHighlight(event);
633 }
634 #else
635 wxUnusedVar(event);
636 #endif // wxUSE_STATUSBAR
637 }
638
639 void wxAuiMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
640 {
641 // do nothing
642 }
643
644 void wxAuiMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
645 {
646 Destroy();
647 }
648
649 void wxAuiMDIChildFrame::SetMDIParentFrame(wxAuiMDIParentFrame* parentFrame)
650 {
651 m_pMDIParentFrame = parentFrame;
652 }
653
654 wxAuiMDIParentFrame* wxAuiMDIChildFrame::GetMDIParentFrame() const
655 {
656 return m_pMDIParentFrame;
657 }
658
659 void wxAuiMDIChildFrame::Init()
660 {
661 m_activate_on_create = true;
662 m_pMDIParentFrame = NULL;
663 #if wxUSE_MENUS
664 m_pMenuBar = NULL;
665 #endif // wxUSE_MENUS
666 }
667
668 bool wxAuiMDIChildFrame::Show(bool show)
669 {
670 m_activate_on_create = show;
671
672 // do nothing
673 return true;
674 }
675
676 void wxAuiMDIChildFrame::DoShow(bool show)
677 {
678 wxWindow::Show(show);
679 }
680
681 void wxAuiMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags)
682 {
683 m_mdi_newrect = wxRect(x, y, width, height);
684 #ifdef __WXGTK__
685 wxPanel::DoSetSize(x,y,width, height, sizeFlags);
686 #else
687 wxUnusedVar(sizeFlags);
688 #endif
689 }
690
691 void wxAuiMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
692 {
693 m_mdi_newrect = wxRect(x, y, width, height);
694 }
695
696 void wxAuiMDIChildFrame::ApplyMDIChildFrameRect()
697 {
698 if (m_mdi_currect != m_mdi_newrect)
699 {
700 wxPanel::DoMoveWindow(m_mdi_newrect.x, m_mdi_newrect.y,
701 m_mdi_newrect.width, m_mdi_newrect.height);
702 m_mdi_currect = m_mdi_newrect;
703 }
704 }
705
706
707 //-----------------------------------------------------------------------------
708 // wxAuiMDIClientWindow
709 //-----------------------------------------------------------------------------
710
711 IMPLEMENT_DYNAMIC_CLASS(wxAuiMDIClientWindow, wxAuiNotebook)
712
713 BEGIN_EVENT_TABLE(wxAuiMDIClientWindow, wxAuiNotebook)
714 EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, wxAuiMDIClientWindow::OnPageChanged)
715 EVT_AUINOTEBOOK_PAGE_CLOSE(wxID_ANY, wxAuiMDIClientWindow::OnPageClose)
716 EVT_SIZE(wxAuiMDIClientWindow::OnSize)
717 END_EVENT_TABLE()
718
719 wxAuiMDIClientWindow::wxAuiMDIClientWindow()
720 {
721 }
722
723 wxAuiMDIClientWindow::wxAuiMDIClientWindow(wxAuiMDIParentFrame* parent, long style)
724 {
725 CreateClient(parent, style);
726 }
727
728 wxAuiMDIClientWindow::~wxAuiMDIClientWindow()
729 {
730 DestroyChildren();
731 }
732
733 bool wxAuiMDIClientWindow::CreateClient(wxAuiMDIParentFrame* parent, long style)
734 {
735 SetWindowStyleFlag(style);
736
737 wxSize caption_icon_size =
738 wxSize(wxSystemSettings::GetMetric(wxSYS_SMALLICON_X),
739 wxSystemSettings::GetMetric(wxSYS_SMALLICON_Y));
740 SetUniformBitmapSize(caption_icon_size);
741
742 if (!wxAuiNotebook::Create(parent,
743 wxID_ANY,
744 wxPoint(0,0),
745 wxSize(100, 100),
746 wxAUI_NB_DEFAULT_STYLE | wxNO_BORDER))
747 {
748 return false;
749 }
750
751 wxColour bkcolour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
752 SetOwnBackgroundColour(bkcolour);
753
754 m_mgr.GetArtProvider()->SetColour(wxAUI_DOCKART_BACKGROUND_COLOUR, bkcolour);
755
756 return true;
757 }
758
759 int wxAuiMDIClientWindow::SetSelection(size_t nPage)
760 {
761 return wxAuiNotebook::SetSelection(nPage);
762 }
763
764 void wxAuiMDIClientWindow::PageChanged(int old_selection, int new_selection)
765 {
766 // don't do anything if the page doesn't actually change
767 if (old_selection == new_selection)
768 return;
769
770 /*
771 // don't do anything if the new page is already active
772 if (new_selection != -1)
773 {
774 wxAuiMDIChildFrame* child = (wxAuiMDIChildFrame*)GetPage(new_selection);
775 if (child->GetMDIParentFrame()->GetActiveChild() == child)
776 return;
777 }*/
778
779
780 // notify old active child that it has been deactivated
781 if ((old_selection != -1) && (old_selection < (int)GetPageCount()))
782 {
783 wxAuiMDIChildFrame* old_child = (wxAuiMDIChildFrame*)GetPage(old_selection);
784 wxASSERT_MSG(old_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
785
786 wxActivateEvent event(wxEVT_ACTIVATE, false, old_child->GetId());
787 event.SetEventObject(old_child);
788 old_child->GetEventHandler()->ProcessEvent(event);
789 }
790
791 // notify new active child that it has been activated
792 if (new_selection != -1)
793 {
794 wxAuiMDIChildFrame* active_child = (wxAuiMDIChildFrame*)GetPage(new_selection);
795 wxASSERT_MSG(active_child, wxT("wxAuiMDIClientWindow::PageChanged - null page pointer"));
796
797 wxActivateEvent event(wxEVT_ACTIVATE, true, active_child->GetId());
798 event.SetEventObject(active_child);
799 active_child->GetEventHandler()->ProcessEvent(event);
800
801 if (active_child->GetMDIParentFrame())
802 {
803 active_child->GetMDIParentFrame()->SetActiveChild(active_child);
804 active_child->GetMDIParentFrame()->SetChildMenuBar(active_child);
805 }
806 }
807
808
809 }
810
811 void wxAuiMDIClientWindow::OnPageClose(wxAuiNotebookEvent& evt)
812 {
813 wxAuiMDIChildFrame* wnd;
814 wnd = static_cast<wxAuiMDIChildFrame*>(GetPage(evt.GetSelection()));
815
816 wnd->Close();
817
818 // regardless of the result of wnd->Close(), we've
819 // already taken care of the close operations, so
820 // suppress further processing
821 evt.Veto();
822 }
823
824 void wxAuiMDIClientWindow::OnPageChanged(wxAuiNotebookEvent& evt)
825 {
826 PageChanged(evt.GetOldSelection(), evt.GetSelection());
827 }
828
829 void wxAuiMDIClientWindow::OnSize(wxSizeEvent& evt)
830 {
831 wxAuiNotebook::OnSize(evt);
832
833 for (size_t pos = 0; pos < GetPageCount(); pos++)
834 ((wxAuiMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
835 }
836
837 #endif //wxUSE_AUI
838 #endif // wxUSE_MDI