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