]> git.saurik.com Git - wxWidgets.git/blob - src/generic/mdig.cpp
added possibility to throw different objects and crash directly from the main frame...
[wxWidgets.git] / src / generic / mdig.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/mdig.cpp
3 // Purpose: Generic MDI (Multiple Document Interface) classes
4 // Author: Hans Van Leemputten
5 // Modified by:
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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "mdig.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/panel.h"
33 #include "wx/menu.h"
34 #include "wx/intl.h"
35 #endif //WX_PRECOMP
36
37 #include "wx/generic/mdig.h"
38
39 enum MDI_MENU_ID
40 {
41 wxWINDOWCLOSE = 4001,
42 wxWINDOWCLOSEALL,
43 wxWINDOWNEXT,
44 wxWINDOWPREV
45 };
46
47 //-----------------------------------------------------------------------------
48 // wxGenericMDIParentFrame
49 //-----------------------------------------------------------------------------
50
51 IMPLEMENT_DYNAMIC_CLASS(wxGenericMDIParentFrame, wxFrame)
52
53 BEGIN_EVENT_TABLE(wxGenericMDIParentFrame, wxFrame)
54 #if wxUSE_MENUS
55 EVT_MENU (wxID_ANY, wxGenericMDIParentFrame::DoHandleMenu)
56 #endif
57 END_EVENT_TABLE()
58
59 wxGenericMDIParentFrame::wxGenericMDIParentFrame()
60 {
61 Init();
62 }
63
64 wxGenericMDIParentFrame::wxGenericMDIParentFrame(wxWindow *parent,
65 wxWindowID id,
66 const wxString& title,
67 const wxPoint& pos,
68 const wxSize& size,
69 long style,
70 const wxString& name)
71 {
72 Init();
73
74 (void)Create(parent, id, title, pos, size, style, name);
75 }
76
77 wxGenericMDIParentFrame::~wxGenericMDIParentFrame()
78 {
79 // Make sure the client window is destructed before the menu bars are!
80 wxDELETE(m_pClientWindow);
81
82 #if wxUSE_MENUS
83 if (m_pMyMenuBar)
84 {
85 delete m_pMyMenuBar;
86 m_pMyMenuBar = (wxMenuBar *) NULL;
87 }
88
89 RemoveWindowMenu(GetMenuBar());
90
91 if (m_pWindowMenu)
92 {
93 delete m_pWindowMenu;
94 m_pWindowMenu = (wxMenu*) NULL;
95 }
96 #endif // wxUSE_MENUS
97 }
98
99 bool wxGenericMDIParentFrame::Create(wxWindow *parent,
100 wxWindowID id,
101 const wxString& title,
102 const wxPoint& pos,
103 const wxSize& size,
104 long style,
105 const wxString& name)
106 {
107 // this style can be used to prevent a window from having the standard MDI
108 // "Window" menu
109 if ( !(style & wxFRAME_NO_WINDOW_MENU) )
110 {
111 #if wxUSE_MENUS
112 m_pWindowMenu = new wxMenu;
113
114 m_pWindowMenu->Append(wxWINDOWCLOSE, _("Cl&ose"));
115 m_pWindowMenu->Append(wxWINDOWCLOSEALL, _("Close All"));
116 m_pWindowMenu->AppendSeparator();
117 m_pWindowMenu->Append(wxWINDOWNEXT, _("&Next"));
118 m_pWindowMenu->Append(wxWINDOWPREV, _("&Previous"));
119 #endif // wxUSE_MENUS
120 }
121
122 wxFrame::Create( parent, id, title, pos, size, style, name );
123
124 OnCreateClient();
125
126 return true;
127 }
128
129 #if wxUSE_MENUS
130 void wxGenericMDIParentFrame::SetWindowMenu(wxMenu* pMenu)
131 {
132 // Replace the window menu from the currently loaded menu bar.
133 wxMenuBar *pMenuBar = GetMenuBar();
134
135 if (m_pWindowMenu)
136 {
137 RemoveWindowMenu(pMenuBar);
138
139 wxDELETE(m_pWindowMenu);
140 }
141
142 if (pMenu)
143 {
144 m_pWindowMenu = pMenu;
145
146 AddWindowMenu(pMenuBar);
147 }
148 }
149
150 void wxGenericMDIParentFrame::SetMenuBar(wxMenuBar *pMenuBar)
151 {
152 // Remove the Window menu from the old menu bar
153 RemoveWindowMenu(GetMenuBar());
154 // Add the Window menu to the new menu bar.
155 AddWindowMenu(pMenuBar);
156
157 wxFrame::SetMenuBar(pMenuBar);
158 }
159 #endif // wxUSE_MENUS
160
161 void wxGenericMDIParentFrame::SetChildMenuBar(wxGenericMDIChildFrame *pChild)
162 {
163 #if wxUSE_MENUS
164 if (pChild == (wxGenericMDIChildFrame *) NULL)
165 {
166 // No Child, set Our menu bar back.
167 SetMenuBar(m_pMyMenuBar);
168
169 // Make sure we know our menu bar is in use
170 m_pMyMenuBar = (wxMenuBar*) NULL;
171 }
172 else
173 {
174 if (pChild->GetMenuBar() == (wxMenuBar*) NULL)
175 return;
176
177 // Do we need to save the current bar?
178 if (m_pMyMenuBar == NULL)
179 m_pMyMenuBar = GetMenuBar();
180
181 SetMenuBar(pChild->GetMenuBar());
182 }
183 #endif // wxUSE_MENUS
184 }
185
186 bool wxGenericMDIParentFrame::ProcessEvent(wxEvent& event)
187 {
188 /*
189 * Redirect events to active child first.
190 */
191
192 // Stops the same event being processed repeatedly
193 static wxEventType inEvent = wxEVT_NULL;
194 if (inEvent == event.GetEventType())
195 return false;
196
197 inEvent = event.GetEventType();
198
199 // Let the active child (if any) process the event first.
200 bool res = false;
201 if (m_pActiveChild && event.IsKindOf(CLASSINFO(wxCommandEvent))
202 #if 0
203 /* This is sure to not give problems... */
204 && (event.GetEventType() == wxEVT_COMMAND_MENU_SELECTED ||
205 event.GetEventType() == wxEVT_UPDATE_UI )
206 #else
207 /* This was tested on wxMSW and worked... */
208 && event.GetEventObject() != m_pClientWindow
209 && !(event.GetEventType() == wxEVT_ACTIVATE ||
210 event.GetEventType() == wxEVT_SET_FOCUS ||
211 event.GetEventType() == wxEVT_KILL_FOCUS ||
212 event.GetEventType() == wxEVT_CHILD_FOCUS ||
213 event.GetEventType() == wxEVT_COMMAND_SET_FOCUS ||
214 event.GetEventType() == wxEVT_COMMAND_KILL_FOCUS )
215 #endif
216 )
217 {
218 res = m_pActiveChild->GetEventHandler()->ProcessEvent(event);
219 }
220
221 // If the event was not handled this frame will handle it!
222 if (!res)
223 {
224 res = GetEventHandler()->wxEvtHandler::ProcessEvent(event);
225 }
226
227 inEvent = wxEVT_NULL;
228
229 return res;
230 }
231
232 wxGenericMDIChildFrame *wxGenericMDIParentFrame::GetActiveChild() const
233 {
234 return m_pActiveChild;
235 }
236
237 void wxGenericMDIParentFrame::SetActiveChild(wxGenericMDIChildFrame* pChildFrame)
238 {
239 m_pActiveChild = pChildFrame;
240 }
241
242 wxGenericMDIClientWindow *wxGenericMDIParentFrame::GetClientWindow() const
243 {
244 return m_pClientWindow;
245 }
246
247 wxGenericMDIClientWindow *wxGenericMDIParentFrame::OnCreateClient()
248 {
249 #if wxUSE_GENERIC_MDI_AS_NATIVE
250 m_pClientWindow = new wxMDIClientWindow( this );
251 #else
252 m_pClientWindow = new wxGenericMDIClientWindow( this );
253 #endif
254 return m_pClientWindow;
255 }
256
257 void wxGenericMDIParentFrame::ActivateNext()
258 {
259 if (m_pClientWindow && m_pClientWindow->GetSelection() != -1)
260 {
261 size_t active = m_pClientWindow->GetSelection() + 1;
262 if (active >= m_pClientWindow->GetPageCount())
263 active = 0;
264
265 m_pClientWindow->SetSelection(active);
266 }
267 }
268
269 void wxGenericMDIParentFrame::ActivatePrevious()
270 {
271 if (m_pClientWindow && m_pClientWindow->GetSelection() != -1)
272 {
273 int active = m_pClientWindow->GetSelection() - 1;
274 if (active < 0)
275 active = m_pClientWindow->GetPageCount() - 1;
276
277 m_pClientWindow->SetSelection(active);
278 }
279 }
280
281 void wxGenericMDIParentFrame::Init()
282 {
283 m_pClientWindow = (wxGenericMDIClientWindow *) NULL;
284 m_pActiveChild = (wxGenericMDIChildFrame *) NULL;
285 #if wxUSE_MENUS
286 m_pWindowMenu = (wxMenu *) NULL;
287 m_pMyMenuBar = (wxMenuBar*) NULL;
288 #endif // wxUSE_MENUS
289 }
290
291 #if wxUSE_MENUS
292 void wxGenericMDIParentFrame::RemoveWindowMenu(wxMenuBar *pMenuBar)
293 {
294 if (pMenuBar && m_pWindowMenu)
295 {
296 // Remove old window menu
297 int pos = pMenuBar->FindMenu(_("&Window"));
298 if (pos != wxNOT_FOUND)
299 {
300 wxASSERT(m_pWindowMenu == pMenuBar->GetMenu(pos)); // DBG:: We're going to delete the wrong menu!!!
301 pMenuBar->Remove(pos);
302 }
303 }
304 }
305
306 void wxGenericMDIParentFrame::AddWindowMenu(wxMenuBar *pMenuBar)
307 {
308 if (pMenuBar && m_pWindowMenu)
309 {
310 int pos = pMenuBar->FindMenu(_("Help"));
311 if (pos == wxNOT_FOUND)
312 {
313 pMenuBar->Append(m_pWindowMenu, _("&Window"));
314 }
315 else
316 {
317 pMenuBar->Insert(pos, m_pWindowMenu, _("&Window"));
318 }
319 }
320 }
321
322 void wxGenericMDIParentFrame::DoHandleMenu(wxCommandEvent &event)
323 {
324 switch (event.GetId())
325 {
326 case wxWINDOWCLOSE:
327 if (m_pActiveChild)
328 {
329 m_pActiveChild->Close();
330 }
331 break;
332 case wxWINDOWCLOSEALL:
333 {
334 #if 0 // code is only needed if next #if is set to 0!
335 wxGenericMDIChildFrame *pFirstActiveChild = m_pActiveChild;
336 #endif
337 while (m_pActiveChild)
338 {
339 if (!m_pActiveChild->Close())
340 {
341 return; // We failed...
342 }
343 else
344 {
345 #if 1 // What's best? Delayed deleting or immediate deleting?
346 delete m_pActiveChild;
347 #else
348 ActivateNext();
349
350 if (pFirstActiveChild == m_pActiveChild)
351 return; // We've called Close on all items, no need to continue.
352 #endif
353 }
354 }
355 }
356 break;
357 case wxWINDOWNEXT:
358 ActivateNext();
359 break;
360 case wxWINDOWPREV:
361 ActivatePrevious();
362 break;
363 default :
364 event.Skip();
365 }
366 }
367 #endif // wxUSE_MENUS
368
369 void wxGenericMDIParentFrame::DoGetClientSize(int *width, int *height) const
370 {
371 wxFrame::DoGetClientSize( width, height );
372 }
373
374
375 //-----------------------------------------------------------------------------
376 // wxGenericMDIChildFrame
377 //-----------------------------------------------------------------------------
378
379 IMPLEMENT_DYNAMIC_CLASS(wxGenericMDIChildFrame, wxPanel)
380
381 BEGIN_EVENT_TABLE(wxGenericMDIChildFrame, wxPanel)
382 EVT_MENU_HIGHLIGHT_ALL(wxGenericMDIChildFrame::OnMenuHighlight)
383 EVT_ACTIVATE(wxGenericMDIChildFrame::OnActivate)
384
385 EVT_CLOSE(wxGenericMDIChildFrame::OnCloseWindow)
386 EVT_SIZE(wxGenericMDIChildFrame::OnSize)
387 END_EVENT_TABLE()
388
389 wxGenericMDIChildFrame::wxGenericMDIChildFrame()
390 {
391 Init();
392 }
393
394 wxGenericMDIChildFrame::wxGenericMDIChildFrame( wxGenericMDIParentFrame *parent,
395 wxWindowID id, const wxString& title,
396 const wxPoint& WXUNUSED(pos), const wxSize& size,
397 long style, const wxString& name )
398 {
399 Init();
400
401 Create( parent, id, title, wxDefaultPosition, size, style, name );
402 }
403
404 #include "wx/log.h"
405 wxGenericMDIChildFrame::~wxGenericMDIChildFrame()
406 {
407 wxGenericMDIParentFrame *pParentFrame = GetMDIParentFrame();
408
409 if (pParentFrame != NULL)
410 {
411 bool bActive = false;
412 if (pParentFrame->GetActiveChild() == this)
413 {
414 pParentFrame->SetActiveChild((wxGenericMDIChildFrame*) NULL);
415 pParentFrame->SetChildMenuBar((wxGenericMDIChildFrame*) NULL);
416 bActive = true;
417 }
418
419 wxGenericMDIClientWindow *pClientWindow = pParentFrame->GetClientWindow();
420
421 // Remove page if still there
422 size_t pos;
423 for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
424 {
425 if (pClientWindow->GetPage(pos) == this)
426 {
427 if (pClientWindow->RemovePage(pos))
428 pClientWindow->Refresh();
429 break;
430 }
431 }
432
433 if (bActive)
434 {
435 // Set the new selection to the a remaining page
436 if (pClientWindow->GetPageCount() > pos)
437 {
438 pClientWindow->SetSelection(pos);
439 }
440 else
441 {
442 if ((int)pClientWindow->GetPageCount() - 1 >= 0)
443 pClientWindow->SetSelection(pClientWindow->GetPageCount() - 1);
444 }
445 }
446 }
447
448 #if wxUSE_MENUS
449 wxDELETE(m_pMenuBar);
450 #endif // wxUSE_MENUS
451 }
452
453 bool wxGenericMDIChildFrame::Create( wxGenericMDIParentFrame *parent,
454 wxWindowID id, const wxString& title,
455 const wxPoint& WXUNUSED(pos), const wxSize& size,
456 long style, const wxString& name )
457 {
458 wxGenericMDIClientWindow* pClientWindow = parent->GetClientWindow();
459
460 wxASSERT_MSG((pClientWindow != (wxWindow*) NULL), wxT("Missing MDI client window.") );
461
462 wxPanel::Create(pClientWindow, id, wxDefaultPosition, size, style, name);
463
464 SetMDIParentFrame(parent);
465
466 // This is the currently active child
467 parent->SetActiveChild(this);
468
469 m_Title = title;
470
471 pClientWindow->AddPage(this, title, true);
472 ApplyMDIChildFrameRect(); // Ok confirme the size change!
473 pClientWindow->Refresh();
474
475 return true;
476 }
477
478 #if wxUSE_MENUS
479 void wxGenericMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
480 {
481 wxMenuBar *pOldMenuBar = m_pMenuBar;
482 m_pMenuBar = menu_bar;
483
484 if (m_pMenuBar)
485 {
486 wxGenericMDIParentFrame *pParentFrame = GetMDIParentFrame();
487
488 if (pParentFrame != NULL)
489 {
490 m_pMenuBar->SetParent(pParentFrame);
491
492 if (pParentFrame->GetActiveChild() == this)
493 {
494 // Replace current menu bars
495 if (pOldMenuBar)
496 pParentFrame->SetChildMenuBar((wxGenericMDIChildFrame*) NULL);
497 pParentFrame->SetChildMenuBar((wxGenericMDIChildFrame*) this);
498 }
499 }
500 }
501 }
502
503 wxMenuBar *wxGenericMDIChildFrame::GetMenuBar() const
504 {
505 return m_pMenuBar;
506 }
507 #endif // wxUSE_MENUS
508
509 void wxGenericMDIChildFrame::SetTitle(const wxString& title)
510 {
511 m_Title = title;
512
513 wxGenericMDIParentFrame *pParentFrame = GetMDIParentFrame();
514
515 if (pParentFrame != NULL)
516 {
517 wxGenericMDIClientWindow * pClientWindow = pParentFrame->GetClientWindow();
518
519 if (pClientWindow != NULL)
520 {
521 size_t pos;
522 for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
523 {
524 if (pClientWindow->GetPage(pos) == this)
525 {
526 pClientWindow->SetPageText(pos, m_Title);
527 break;
528 }
529 }
530 }
531 }
532 }
533
534 wxString wxGenericMDIChildFrame::GetTitle() const
535 {
536 return m_Title;
537 }
538
539 void wxGenericMDIChildFrame::Activate()
540 {
541 wxGenericMDIParentFrame *pParentFrame = GetMDIParentFrame();
542
543 if (pParentFrame != NULL)
544 {
545 wxGenericMDIClientWindow * pClientWindow = pParentFrame->GetClientWindow();
546
547 if (pClientWindow != NULL)
548 {
549 size_t pos;
550 for (pos = 0; pos < pClientWindow->GetPageCount(); pos++)
551 {
552 if (pClientWindow->GetPage(pos) == this)
553 {
554 pClientWindow->SetSelection(pos);
555 break;
556 }
557 }
558 }
559 }
560 }
561
562 void wxGenericMDIChildFrame::OnMenuHighlight(wxMenuEvent& event)
563 {
564 #if wxUSE_STATUSBAR
565 if ( m_pMDIParentFrame)
566 {
567 // we don't have any help text for this item,
568 // but may be the MDI frame does?
569 m_pMDIParentFrame->OnMenuHighlight(event);
570 }
571 #else
572 wxUnusedVar(event);
573 #endif // wxUSE_STATUSBAR
574 }
575
576 void wxGenericMDIChildFrame::OnActivate(wxActivateEvent& WXUNUSED(event))
577 {
578 // Do mothing.
579 }
580
581 /*** Copied from top level..! ***/
582 // default resizing behaviour - if only ONE subwindow, resize to fill the
583 // whole client area
584 void wxGenericMDIChildFrame::OnSize(wxSizeEvent& WXUNUSED(event))
585 {
586 // if we're using constraints or sizers - do use them
587 if ( GetAutoLayout() )
588 {
589 Layout();
590 }
591 else
592 {
593 // do we have _exactly_ one child?
594 wxWindow *child = (wxWindow *)NULL;
595 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
596 node;
597 node = node->GetNext() )
598 {
599 wxWindow *win = node->GetData();
600
601 // exclude top level and managed windows (status bar isn't
602 // currently in the children list except under wxMac anyhow, but
603 // it makes no harm to test for it)
604 if ( !win->IsTopLevel() /*&& !IsOneOfBars(win)*/ )
605 {
606 if ( child )
607 {
608 return; // it's our second subwindow - nothing to do
609 }
610
611 child = win;
612 }
613 }
614
615 // do we have any children at all?
616 if ( child )
617 {
618 // exactly one child - set it's size to fill the whole frame
619 int clientW, clientH;
620 DoGetClientSize(&clientW, &clientH);
621
622 // for whatever reasons, wxGTK wants to have a small offset - it
623 // probably looks better with it?
624 #ifdef __WXGTK__
625 static const int ofs = 1;
626 #else
627 static const int ofs = 0;
628 #endif
629
630 child->SetSize(ofs, ofs, clientW - 2*ofs, clientH - 2*ofs);
631 }
632 }
633 }
634
635 /*** Copied from top level..! ***/
636 // The default implementation for the close window event.
637 void wxGenericMDIChildFrame::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
638 {
639 Destroy();
640 }
641
642 void wxGenericMDIChildFrame::SetMDIParentFrame(wxGenericMDIParentFrame* parentFrame)
643 {
644 m_pMDIParentFrame = parentFrame;
645 }
646
647 wxGenericMDIParentFrame* wxGenericMDIChildFrame::GetMDIParentFrame() const
648 {
649 return m_pMDIParentFrame;
650 }
651
652 void wxGenericMDIChildFrame::Init()
653 {
654 m_pMDIParentFrame = (wxGenericMDIParentFrame *) NULL;
655 #if wxUSE_MENUS
656 m_pMenuBar = (wxMenuBar *) NULL;
657 #endif // wxUSE_MENUS
658 }
659
660 void wxGenericMDIChildFrame::DoMoveWindow(int x, int y, int width, int height)
661 {
662 m_MDIRect = wxRect(x, y, width, height);
663 }
664
665 void wxGenericMDIChildFrame::ApplyMDIChildFrameRect()
666 {
667 wxPanel::DoMoveWindow(m_MDIRect.x, m_MDIRect.y, m_MDIRect.width, m_MDIRect.height);
668 }
669
670 //-----------------------------------------------------------------------------
671 // wxGenericMDIClientWindow
672 //-----------------------------------------------------------------------------
673
674 #define wxID_NOTEBOOK_CLIENT_AREA wxID_HIGHEST + 100
675
676 IMPLEMENT_DYNAMIC_CLASS(wxGenericMDIClientWindow, wxNotebook)
677
678 BEGIN_EVENT_TABLE(wxGenericMDIClientWindow, wxNotebook)
679 EVT_NOTEBOOK_PAGE_CHANGED(wxID_NOTEBOOK_CLIENT_AREA, wxGenericMDIClientWindow::OnPageChanged)
680 EVT_SIZE(wxGenericMDIClientWindow::OnSize)
681 END_EVENT_TABLE()
682
683
684 wxGenericMDIClientWindow::wxGenericMDIClientWindow()
685 {
686 }
687
688 wxGenericMDIClientWindow::wxGenericMDIClientWindow( wxGenericMDIParentFrame *parent, long style )
689 {
690 CreateClient( parent, style );
691 }
692
693 wxGenericMDIClientWindow::~wxGenericMDIClientWindow()
694 {
695 DestroyChildren();
696 }
697
698 bool wxGenericMDIClientWindow::CreateClient( wxGenericMDIParentFrame *parent, long style )
699 {
700 SetWindowStyleFlag(style);
701
702 bool success = wxNotebook::Create(parent, wxID_NOTEBOOK_CLIENT_AREA, wxPoint(), wxSize(100, 100), 0);
703 if (success)
704 {
705 /*
706 wxFont font(10, wxSWISS, wxNORMAL, wxNORMAL);
707 wxFont selFont(10, wxSWISS, wxNORMAL, wxBOLD);
708 GetTabView()->SetTabFont(font);
709 GetTabView()->SetSelectedTabFont(selFont);
710 GetTabView()->SetTabSize(120, 18);
711 GetTabView()->SetTabSelectionHeight(20);
712 */
713 return true;
714 }
715 else
716 return false;
717 }
718
719 int wxGenericMDIClientWindow::SetSelection(size_t nPage)
720 {
721 int oldSelection = wxNotebook::SetSelection(nPage);
722
723 #if !defined(__WXMSW__) // No need to do this for wxMSW as wxNotebook::SetSelection()
724 // will already cause this to be done!
725 // Handle the page change.
726 PageChanged(oldSelection, nPage);
727 #endif
728
729 return oldSelection;
730 }
731
732 void wxGenericMDIClientWindow::PageChanged(int OldSelection, int newSelection)
733 {
734 // Don't do to much work, only when something realy should change!
735 if (OldSelection == newSelection)
736 return;
737 // Again check if we realy need to do this...
738 if (newSelection != -1)
739 {
740 wxGenericMDIChildFrame* child = (wxGenericMDIChildFrame *)GetPage(newSelection);
741
742 if (child->GetMDIParentFrame()->GetActiveChild() == child)
743 return;
744 }
745
746 // Notify old active child that it has been deactivated
747 if (OldSelection != -1)
748 {
749 wxGenericMDIChildFrame* oldChild = (wxGenericMDIChildFrame *)GetPage(OldSelection);
750 if (oldChild)
751 {
752 wxActivateEvent event(wxEVT_ACTIVATE, false, oldChild->GetId());
753 event.SetEventObject( oldChild );
754 oldChild->GetEventHandler()->ProcessEvent(event);
755 }
756 }
757
758 // Notify new active child that it has been activated
759 if (newSelection != -1)
760 {
761 wxGenericMDIChildFrame* activeChild = (wxGenericMDIChildFrame *)GetPage(newSelection);
762 if (activeChild)
763 {
764 wxActivateEvent event(wxEVT_ACTIVATE, true, activeChild->GetId());
765 event.SetEventObject( activeChild );
766 activeChild->GetEventHandler()->ProcessEvent(event);
767
768 if (activeChild->GetMDIParentFrame())
769 {
770 activeChild->GetMDIParentFrame()->SetActiveChild(activeChild);
771 activeChild->GetMDIParentFrame()->SetChildMenuBar(activeChild);
772 }
773 }
774 }
775 }
776
777 void wxGenericMDIClientWindow::OnPageChanged(wxNotebookEvent& event)
778 {
779 PageChanged(event.GetOldSelection(), event.GetSelection());
780
781 event.Skip();
782 }
783
784 void wxGenericMDIClientWindow::OnSize(wxSizeEvent& event)
785 {
786 wxNotebook::OnSize(event);
787
788 size_t pos;
789 for (pos = 0; pos < GetPageCount(); pos++)
790 {
791 ((wxGenericMDIChildFrame *)GetPage(pos))->ApplyMDIChildFrameRect();
792 }
793 }
794
795
796 /*
797 * Define normal wxMDI classes based on wxGenericMDI
798 */
799
800 #if wxUSE_GENERIC_MDI_AS_NATIVE
801
802 wxMDIChildFrame * wxMDIParentFrame::GetActiveChild() const
803 {
804 wxGenericMDIChildFrame *pGFrame = wxGenericMDIParentFrame::GetActiveChild();
805 wxMDIChildFrame *pFrame = wxDynamicCast(pGFrame, wxMDIChildFrame);
806
807 wxASSERT_MSG(!(pFrame == NULL && pGFrame != NULL), wxT("Active frame is class not derived from wxMDIChildFrame!"));
808
809 return pFrame;
810 }
811
812 IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxGenericMDIParentFrame)
813 IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxGenericMDIChildFrame)
814 IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxGenericMDIClientWindow)
815
816 #endif
817