]>
Commit | Line | Data |
---|---|---|
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,wxSTOCK_NOFLAGS)); | |
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 |