]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/msw/mdi.cpp | |
3 | // Purpose: MDI classes for wxMSW | |
4 | // Author: Julian Smart | |
5 | // Modified by: Vadim Zeitlin on 2008-11-04 to use the base classes | |
6 | // Created: 04/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998 Julian Smart | |
9 | // (c) 2008-2009 Vadim Zeitlin | |
10 | // Licence: wxWindows licence | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | // =========================================================================== | |
14 | // declarations | |
15 | // =========================================================================== | |
16 | ||
17 | // --------------------------------------------------------------------------- | |
18 | // headers | |
19 | // --------------------------------------------------------------------------- | |
20 | ||
21 | // For compilers that support precompilation, includes "wx.h". | |
22 | #include "wx/wxprec.h" | |
23 | ||
24 | #ifdef __BORLANDC__ | |
25 | #pragma hdrstop | |
26 | #endif | |
27 | ||
28 | #if wxUSE_MDI && !defined(__WXUNIVERSAL__) | |
29 | ||
30 | #include "wx/mdi.h" | |
31 | ||
32 | #ifndef WX_PRECOMP | |
33 | #include "wx/frame.h" | |
34 | #include "wx/menu.h" | |
35 | #include "wx/app.h" | |
36 | #include "wx/utils.h" | |
37 | #include "wx/dialog.h" | |
38 | #include "wx/statusbr.h" | |
39 | #include "wx/settings.h" | |
40 | #include "wx/intl.h" | |
41 | #include "wx/log.h" | |
42 | #include "wx/toolbar.h" | |
43 | #endif | |
44 | ||
45 | #include "wx/stockitem.h" | |
46 | #include "wx/msw/private.h" | |
47 | ||
48 | #include <string.h> | |
49 | ||
50 | // --------------------------------------------------------------------------- | |
51 | // global variables | |
52 | // --------------------------------------------------------------------------- | |
53 | ||
54 | extern wxMenu *wxCurrentPopupMenu; | |
55 | ||
56 | extern void wxRemoveHandleAssociation(wxWindow *win); | |
57 | ||
58 | namespace | |
59 | { | |
60 | ||
61 | // --------------------------------------------------------------------------- | |
62 | // constants | |
63 | // --------------------------------------------------------------------------- | |
64 | ||
65 | // This range gives a maximum of 500 MDI children. Should be enough :-) | |
66 | const int wxFIRST_MDI_CHILD = 4100; | |
67 | const int wxLAST_MDI_CHILD = 4600; | |
68 | ||
69 | // The MDI "Window" menu label | |
70 | const char *WINDOW_MENU_LABEL = gettext_noop("&Window"); | |
71 | ||
72 | // --------------------------------------------------------------------------- | |
73 | // private functions | |
74 | // --------------------------------------------------------------------------- | |
75 | ||
76 | // set the MDI menus (by sending the WM_MDISETMENU message) and update the menu | |
77 | // of the parent of win (which is supposed to be the MDI client window) | |
78 | void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow); | |
79 | ||
80 | // insert the window menu (subMenu) into menu just before "Help" submenu or at | |
81 | // the very end if not found | |
82 | void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU subMenu); | |
83 | ||
84 | // Remove the window menu | |
85 | void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu); | |
86 | ||
87 | // unpack the parameters of WM_MDIACTIVATE message | |
88 | void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, | |
89 | WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact); | |
90 | ||
91 | // return the HMENU of the MDI menu | |
92 | // | |
93 | // this function works correctly even when we don't have a window menu and just | |
94 | // returns 0 then | |
95 | inline HMENU GetMDIWindowMenu(wxMDIParentFrame *frame) | |
96 | { | |
97 | wxMenu *menu = frame->GetWindowMenu(); | |
98 | return menu ? GetHmenuOf(menu) : 0; | |
99 | } | |
100 | ||
101 | } // anonymous namespace | |
102 | ||
103 | // =========================================================================== | |
104 | // implementation | |
105 | // =========================================================================== | |
106 | ||
107 | // --------------------------------------------------------------------------- | |
108 | // wxWin macros | |
109 | // --------------------------------------------------------------------------- | |
110 | ||
111 | IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame) | |
112 | IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame) | |
113 | IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow) | |
114 | ||
115 | BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame) | |
116 | EVT_SIZE(wxMDIParentFrame::OnSize) | |
117 | EVT_ICONIZE(wxMDIParentFrame::OnIconized) | |
118 | EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged) | |
119 | ||
120 | #if wxUSE_MENUS | |
121 | EVT_MENU_RANGE(wxFIRST_MDI_CHILD, wxLAST_MDI_CHILD, | |
122 | wxMDIParentFrame::OnMDIChild) | |
123 | EVT_MENU_RANGE(wxID_MDI_WINDOW_FIRST, wxID_MDI_WINDOW_LAST, | |
124 | wxMDIParentFrame::OnMDICommand) | |
125 | #endif // wxUSE_MENUS | |
126 | END_EVENT_TABLE() | |
127 | ||
128 | BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame) | |
129 | EVT_IDLE(wxMDIChildFrame::OnIdle) | |
130 | END_EVENT_TABLE() | |
131 | ||
132 | BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow) | |
133 | EVT_SCROLL(wxMDIClientWindow::OnScroll) | |
134 | END_EVENT_TABLE() | |
135 | ||
136 | // =========================================================================== | |
137 | // wxMDIParentFrame: the frame which contains the client window which manages | |
138 | // the children | |
139 | // =========================================================================== | |
140 | ||
141 | bool wxMDIParentFrame::Create(wxWindow *parent, | |
142 | wxWindowID id, | |
143 | const wxString& title, | |
144 | const wxPoint& pos, | |
145 | const wxSize& size, | |
146 | long style, | |
147 | const wxString& name) | |
148 | { | |
149 | // this style can be used to prevent a window from having the standard MDI | |
150 | // "Window" menu | |
151 | if ( !(style & wxFRAME_NO_WINDOW_MENU) ) | |
152 | { | |
153 | // normal case: we have the window menu, so construct it | |
154 | m_windowMenu = new wxMenu; | |
155 | ||
156 | m_windowMenu->Append(wxID_MDI_WINDOW_CASCADE, _("&Cascade")); | |
157 | m_windowMenu->Append(wxID_MDI_WINDOW_TILE_HORZ, _("Tile &Horizontally")); | |
158 | m_windowMenu->Append(wxID_MDI_WINDOW_TILE_VERT, _("Tile &Vertically")); | |
159 | m_windowMenu->AppendSeparator(); | |
160 | m_windowMenu->Append(wxID_MDI_WINDOW_ARRANGE_ICONS, _("&Arrange Icons")); | |
161 | m_windowMenu->Append(wxID_MDI_WINDOW_NEXT, _("&Next")); | |
162 | m_windowMenu->Append(wxID_MDI_WINDOW_PREV, _("&Previous")); | |
163 | } | |
164 | ||
165 | #if wxUSE_MENUS && wxUSE_ACCEL | |
166 | // the default menu doesn't have any accelerators (even if we have it) | |
167 | m_accelWindowMenu = NULL; | |
168 | #endif // wxUSE_MENUS && wxUSE_ACCEL | |
169 | ||
170 | if (!parent) | |
171 | wxTopLevelWindows.Append(this); | |
172 | ||
173 | SetName(name); | |
174 | m_windowStyle = style; | |
175 | ||
176 | if ( parent ) | |
177 | parent->AddChild(this); | |
178 | ||
179 | if ( id != wxID_ANY ) | |
180 | m_windowId = id; | |
181 | else | |
182 | m_windowId = NewControlId(); | |
183 | ||
184 | WXDWORD exflags; | |
185 | WXDWORD msflags = MSWGetCreateWindowFlags(&exflags); | |
186 | msflags &= ~WS_VSCROLL; | |
187 | msflags &= ~WS_HSCROLL; | |
188 | ||
189 | if ( !wxWindow::MSWCreate(wxApp::GetRegisteredClassName(_T("wxMDIFrame")), | |
190 | title.wx_str(), | |
191 | pos, size, | |
192 | msflags, | |
193 | exflags) ) | |
194 | { | |
195 | return false; | |
196 | } | |
197 | ||
198 | SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE)); | |
199 | ||
200 | // unlike (almost?) all other windows, frames are created hidden | |
201 | m_isShown = false; | |
202 | ||
203 | return true; | |
204 | } | |
205 | ||
206 | wxMDIParentFrame::~wxMDIParentFrame() | |
207 | { | |
208 | // see comment in ~wxMDIChildFrame | |
209 | #if wxUSE_TOOLBAR | |
210 | m_frameToolBar = NULL; | |
211 | #endif | |
212 | #if wxUSE_STATUSBAR | |
213 | m_frameStatusBar = NULL; | |
214 | #endif // wxUSE_STATUSBAR | |
215 | ||
216 | #if wxUSE_MENUS && wxUSE_ACCEL | |
217 | delete m_accelWindowMenu; | |
218 | #endif // wxUSE_MENUS && wxUSE_ACCEL | |
219 | ||
220 | DestroyChildren(); | |
221 | ||
222 | // the MDI frame menubar is not automatically deleted by Windows unlike for | |
223 | // the normal frames | |
224 | if ( m_hMenu ) | |
225 | ::DestroyMenu((HMENU)m_hMenu); | |
226 | ||
227 | if ( m_clientWindow ) | |
228 | { | |
229 | if ( m_clientWindow->MSWGetOldWndProc() ) | |
230 | m_clientWindow->UnsubclassWin(); | |
231 | ||
232 | m_clientWindow->SetHWND(0); | |
233 | delete m_clientWindow; | |
234 | } | |
235 | } | |
236 | ||
237 | // ---------------------------------------------------------------------------- | |
238 | // wxMDIParentFrame child management | |
239 | // ---------------------------------------------------------------------------- | |
240 | ||
241 | wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const | |
242 | { | |
243 | HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()), | |
244 | WM_MDIGETACTIVE, 0, 0L); | |
245 | if ( !hWnd ) | |
246 | return NULL; | |
247 | ||
248 | return static_cast<wxMDIChildFrame *>(wxFindWinFromHandle(hWnd)); | |
249 | } | |
250 | ||
251 | int wxMDIParentFrame::GetChildFramesCount() const | |
252 | { | |
253 | int count = 0; | |
254 | for ( wxWindowList::const_iterator i = GetChildren().begin(); | |
255 | i != GetChildren().end(); | |
256 | ++i ) | |
257 | { | |
258 | if ( wxDynamicCast(*i, wxMDIChildFrame) ) | |
259 | count++; | |
260 | } | |
261 | ||
262 | return count; | |
263 | } | |
264 | ||
265 | #if wxUSE_MENUS | |
266 | ||
267 | void wxMDIParentFrame::AddMDIChild(wxMDIChildFrame * WXUNUSED(child)) | |
268 | { | |
269 | switch ( GetChildFramesCount() ) | |
270 | { | |
271 | case 1: | |
272 | // first MDI child was just added, we need to insert the window | |
273 | // menu now if we have it | |
274 | AddWindowMenu(); | |
275 | ||
276 | // and disable the items which can't be used until we have more | |
277 | // than one child | |
278 | UpdateWindowMenu(false); | |
279 | break; | |
280 | ||
281 | case 2: | |
282 | // second MDI child was added, enable the menu items which were | |
283 | // disabled because they didn't make sense for a single window | |
284 | UpdateWindowMenu(true); | |
285 | break; | |
286 | } | |
287 | } | |
288 | ||
289 | void wxMDIParentFrame::RemoveMDIChild(wxMDIChildFrame * WXUNUSED(child)) | |
290 | { | |
291 | switch ( GetChildFramesCount() ) | |
292 | { | |
293 | case 1: | |
294 | // last MDI child is being removed, remove the now unnecessary | |
295 | // window menu too | |
296 | RemoveWindowMenu(); | |
297 | ||
298 | // there is no need to call UpdateWindowMenu(true) here so this is | |
299 | // not quite symmetric to AddMDIChild() above | |
300 | break; | |
301 | ||
302 | case 2: | |
303 | // only one MDI child is going to remain, disable the menu commands | |
304 | // which don't make sense for a single child window | |
305 | UpdateWindowMenu(false); | |
306 | break; | |
307 | } | |
308 | } | |
309 | ||
310 | // ---------------------------------------------------------------------------- | |
311 | // wxMDIParentFrame window menu handling | |
312 | // ---------------------------------------------------------------------------- | |
313 | ||
314 | void wxMDIParentFrame::AddWindowMenu() | |
315 | { | |
316 | if ( m_windowMenu ) | |
317 | MDIInsertWindowMenu(GetClientWindow(), m_hMenu, GetMDIWindowMenu(this)); | |
318 | } | |
319 | ||
320 | void wxMDIParentFrame::RemoveWindowMenu() | |
321 | { | |
322 | if ( m_windowMenu ) | |
323 | MDIRemoveWindowMenu(GetClientWindow(), m_hMenu); | |
324 | } | |
325 | ||
326 | void wxMDIParentFrame::UpdateWindowMenu(bool enable) | |
327 | { | |
328 | if ( m_windowMenu ) | |
329 | { | |
330 | m_windowMenu->Enable(wxID_MDI_WINDOW_NEXT, enable); | |
331 | m_windowMenu->Enable(wxID_MDI_WINDOW_PREV, enable); | |
332 | } | |
333 | } | |
334 | ||
335 | #if wxUSE_MENUS_NATIVE | |
336 | ||
337 | void wxMDIParentFrame::InternalSetMenuBar() | |
338 | { | |
339 | if ( GetActiveChild() ) | |
340 | { | |
341 | AddWindowMenu(); | |
342 | } | |
343 | else // we don't have any MDI children yet | |
344 | { | |
345 | // wait until we do to add the window menu but do set the main menu for | |
346 | // now (this is done by AddWindowMenu() as a side effect) | |
347 | MDISetMenu(GetClientWindow(), (HMENU)m_hMenu, NULL); | |
348 | } | |
349 | } | |
350 | ||
351 | #endif // wxUSE_MENUS_NATIVE | |
352 | ||
353 | void wxMDIParentFrame::SetWindowMenu(wxMenu* menu) | |
354 | { | |
355 | if ( menu != m_windowMenu ) | |
356 | { | |
357 | // notice that Remove/AddWindowMenu() are safe to call even when | |
358 | // m_windowMenu is NULL | |
359 | RemoveWindowMenu(); | |
360 | ||
361 | delete m_windowMenu; | |
362 | ||
363 | m_windowMenu = menu; | |
364 | ||
365 | AddWindowMenu(); | |
366 | } | |
367 | ||
368 | #if wxUSE_ACCEL | |
369 | delete m_accelWindowMenu; | |
370 | m_accelWindowMenu = NULL; | |
371 | ||
372 | if ( menu && menu->HasAccels() ) | |
373 | m_accelWindowMenu = menu->CreateAccelTable(); | |
374 | #endif // wxUSE_ACCEL | |
375 | } | |
376 | ||
377 | // ---------------------------------------------------------------------------- | |
378 | // wxMDIParentFrame other menu-related stuff | |
379 | // ---------------------------------------------------------------------------- | |
380 | ||
381 | void wxMDIParentFrame::DoMenuUpdates(wxMenu* menu) | |
382 | { | |
383 | wxMDIChildFrame *child = GetActiveChild(); | |
384 | if ( child ) | |
385 | { | |
386 | wxEvtHandler* source = child->GetEventHandler(); | |
387 | wxMenuBar* bar = child->GetMenuBar(); | |
388 | ||
389 | if (menu) | |
390 | { | |
391 | menu->UpdateUI(source); | |
392 | } | |
393 | else | |
394 | { | |
395 | if ( bar != NULL ) | |
396 | { | |
397 | int nCount = bar->GetMenuCount(); | |
398 | for (int n = 0; n < nCount; n++) | |
399 | bar->GetMenu(n)->UpdateUI(source); | |
400 | } | |
401 | } | |
402 | } | |
403 | else | |
404 | { | |
405 | wxFrameBase::DoMenuUpdates(menu); | |
406 | } | |
407 | } | |
408 | ||
409 | wxMenuItem *wxMDIParentFrame::FindItemInMenuBar(int menuId) const | |
410 | { | |
411 | wxMenuItem *item = wxFrame::FindItemInMenuBar(menuId); | |
412 | if ( !item && GetActiveChild() ) | |
413 | { | |
414 | item = GetActiveChild()->FindItemInMenuBar(menuId); | |
415 | } | |
416 | ||
417 | if ( !item && m_windowMenu ) | |
418 | item = m_windowMenu->FindItem(menuId); | |
419 | ||
420 | return item; | |
421 | } | |
422 | ||
423 | WXHMENU wxMDIParentFrame::MSWGetActiveMenu() const | |
424 | { | |
425 | wxMDIChildFrame * const child = GetActiveChild(); | |
426 | if ( child ) | |
427 | { | |
428 | const WXHMENU hmenu = child->MSWGetActiveMenu(); | |
429 | if ( hmenu ) | |
430 | return hmenu; | |
431 | } | |
432 | ||
433 | return wxFrame::MSWGetActiveMenu(); | |
434 | } | |
435 | ||
436 | #endif // wxUSE_MENUS | |
437 | ||
438 | // ---------------------------------------------------------------------------- | |
439 | // wxMDIParentFrame event handling | |
440 | // ---------------------------------------------------------------------------- | |
441 | ||
442 | void wxMDIParentFrame::UpdateClientSize() | |
443 | { | |
444 | if ( GetClientWindow() ) | |
445 | { | |
446 | int width, height; | |
447 | GetClientSize(&width, &height); | |
448 | ||
449 | GetClientWindow()->SetSize(0, 0, width, height); | |
450 | } | |
451 | } | |
452 | ||
453 | void wxMDIParentFrame::OnSize(wxSizeEvent& WXUNUSED(event)) | |
454 | { | |
455 | UpdateClientSize(); | |
456 | ||
457 | // do not call event.Skip() here, it somehow messes up MDI client window | |
458 | } | |
459 | ||
460 | void wxMDIParentFrame::OnIconized(wxIconizeEvent& event) | |
461 | { | |
462 | event.Skip(); | |
463 | ||
464 | if ( !event.IsIconized() ) | |
465 | UpdateClientSize(); | |
466 | } | |
467 | ||
468 | // Responds to colour changes, and passes event on to children. | |
469 | void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event) | |
470 | { | |
471 | if ( m_clientWindow ) | |
472 | { | |
473 | m_clientWindow->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE)); | |
474 | m_clientWindow->Refresh(); | |
475 | } | |
476 | ||
477 | event.Skip(); | |
478 | } | |
479 | ||
480 | WXHICON wxMDIParentFrame::GetDefaultIcon() const | |
481 | { | |
482 | // we don't have any standard icons (any more) | |
483 | return (WXHICON)0; | |
484 | } | |
485 | ||
486 | // --------------------------------------------------------------------------- | |
487 | // MDI operations | |
488 | // --------------------------------------------------------------------------- | |
489 | ||
490 | void wxMDIParentFrame::Cascade() | |
491 | { | |
492 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0); | |
493 | } | |
494 | ||
495 | void wxMDIParentFrame::Tile(wxOrientation orient) | |
496 | { | |
497 | wxASSERT_MSG( orient == wxHORIZONTAL || orient == wxVERTICAL, | |
498 | _T("invalid orientation value") ); | |
499 | ||
500 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, | |
501 | orient == wxHORIZONTAL ? MDITILE_HORIZONTAL | |
502 | : MDITILE_VERTICAL, 0); | |
503 | } | |
504 | ||
505 | void wxMDIParentFrame::ArrangeIcons() | |
506 | { | |
507 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0); | |
508 | } | |
509 | ||
510 | void wxMDIParentFrame::ActivateNext() | |
511 | { | |
512 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0); | |
513 | } | |
514 | ||
515 | void wxMDIParentFrame::ActivatePrevious() | |
516 | { | |
517 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1); | |
518 | } | |
519 | ||
520 | // --------------------------------------------------------------------------- | |
521 | // the MDI parent frame window proc | |
522 | // --------------------------------------------------------------------------- | |
523 | ||
524 | WXLRESULT wxMDIParentFrame::MSWWindowProc(WXUINT message, | |
525 | WXWPARAM wParam, | |
526 | WXLPARAM lParam) | |
527 | { | |
528 | WXLRESULT rc = 0; | |
529 | bool processed = false; | |
530 | ||
531 | switch ( message ) | |
532 | { | |
533 | case WM_ACTIVATE: | |
534 | { | |
535 | WXWORD state, minimized; | |
536 | WXHWND hwnd; | |
537 | UnpackActivate(wParam, lParam, &state, &minimized, &hwnd); | |
538 | ||
539 | processed = HandleActivate(state, minimized != 0, hwnd); | |
540 | } | |
541 | break; | |
542 | ||
543 | case WM_COMMAND: | |
544 | // system messages such as SC_CLOSE are sent as WM_COMMANDs to the | |
545 | // parent MDI frame and we must let the DefFrameProc() have them | |
546 | // for these commands to work (without it, closing the maximized | |
547 | // MDI children doesn't work, for example) | |
548 | { | |
549 | WXWORD id, cmd; | |
550 | WXHWND hwnd; | |
551 | UnpackCommand(wParam, lParam, &id, &hwnd, &cmd); | |
552 | ||
553 | if ( cmd == 0 /* menu */ && | |
554 | id >= SC_SIZE /* first system menu command */ ) | |
555 | { | |
556 | MSWDefWindowProc(message, wParam, lParam); | |
557 | processed = true; | |
558 | } | |
559 | } | |
560 | break; | |
561 | ||
562 | case WM_CREATE: | |
563 | m_clientWindow = OnCreateClient(); | |
564 | // Uses own style for client style | |
565 | if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) ) | |
566 | { | |
567 | wxLogMessage(_("Failed to create MDI parent frame.")); | |
568 | ||
569 | rc = -1; | |
570 | } | |
571 | ||
572 | processed = true; | |
573 | break; | |
574 | ||
575 | case WM_ERASEBKGND: | |
576 | processed = true; | |
577 | ||
578 | // we erase background ourselves | |
579 | rc = true; | |
580 | break; | |
581 | ||
582 | case WM_SIZE: | |
583 | // though we don't (usually) resize the MDI client to exactly fit | |
584 | // the client area we need to pass this one to DefFrameProc to | |
585 | // allow the children to show | |
586 | break; | |
587 | } | |
588 | ||
589 | if ( !processed ) | |
590 | rc = wxFrame::MSWWindowProc(message, wParam, lParam); | |
591 | ||
592 | return rc; | |
593 | } | |
594 | ||
595 | bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate) | |
596 | { | |
597 | bool processed = false; | |
598 | ||
599 | if ( wxWindow::HandleActivate(state, minimized, activate) ) | |
600 | { | |
601 | // already processed | |
602 | processed = true; | |
603 | } | |
604 | ||
605 | // If this window is an MDI parent, we must also send an OnActivate message | |
606 | // to the current child. | |
607 | if ( GetActiveChild() && | |
608 | ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) ) | |
609 | { | |
610 | wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId()); | |
611 | event.SetEventObject( GetActiveChild() ); | |
612 | if ( GetActiveChild()->HandleWindowEvent(event) ) | |
613 | processed = true; | |
614 | } | |
615 | ||
616 | return processed; | |
617 | } | |
618 | ||
619 | #if wxUSE_MENUS | |
620 | ||
621 | void wxMDIParentFrame::OnMDIChild(wxCommandEvent& event) | |
622 | { | |
623 | wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); | |
624 | while ( node ) | |
625 | { | |
626 | wxWindow *child = node->GetData(); | |
627 | if ( child->GetHWND() ) | |
628 | { | |
629 | int childId = wxGetWindowId(child->GetHWND()); | |
630 | if ( childId == event.GetId() ) | |
631 | { | |
632 | ::SendMessage( GetWinHwnd(GetClientWindow()), | |
633 | WM_MDIACTIVATE, | |
634 | (WPARAM)child->GetHWND(), 0); | |
635 | return; | |
636 | } | |
637 | } | |
638 | ||
639 | node = node->GetNext(); | |
640 | } | |
641 | ||
642 | wxFAIL_MSG( "unknown MDI child selected?" ); | |
643 | } | |
644 | ||
645 | void wxMDIParentFrame::OnMDICommand(wxCommandEvent& event) | |
646 | { | |
647 | WXWPARAM wParam = 0; | |
648 | WXLPARAM lParam = 0; | |
649 | int msg; | |
650 | switch ( event.GetId() ) | |
651 | { | |
652 | case wxID_MDI_WINDOW_CASCADE: | |
653 | msg = WM_MDICASCADE; | |
654 | wParam = MDITILE_SKIPDISABLED; | |
655 | break; | |
656 | ||
657 | case wxID_MDI_WINDOW_TILE_HORZ: | |
658 | wParam |= MDITILE_HORIZONTAL; | |
659 | // fall through | |
660 | ||
661 | case wxID_MDI_WINDOW_TILE_VERT: | |
662 | if ( !wParam ) | |
663 | wParam = MDITILE_VERTICAL; | |
664 | msg = WM_MDITILE; | |
665 | wParam |= MDITILE_SKIPDISABLED; | |
666 | break; | |
667 | ||
668 | case wxID_MDI_WINDOW_ARRANGE_ICONS: | |
669 | msg = WM_MDIICONARRANGE; | |
670 | break; | |
671 | ||
672 | case wxID_MDI_WINDOW_NEXT: | |
673 | msg = WM_MDINEXT; | |
674 | lParam = 0; // next child | |
675 | break; | |
676 | ||
677 | case wxID_MDI_WINDOW_PREV: | |
678 | msg = WM_MDINEXT; | |
679 | lParam = 1; // previous child | |
680 | break; | |
681 | ||
682 | default: | |
683 | wxFAIL_MSG( "unknown MDI command" ); | |
684 | return; | |
685 | } | |
686 | ||
687 | ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam); | |
688 | } | |
689 | ||
690 | #endif // wxUSE_MENUS | |
691 | ||
692 | bool wxMDIParentFrame::TryBefore(wxEvent& event) | |
693 | { | |
694 | // menu (and toolbar) events should be sent to the active child frame | |
695 | // first, if any | |
696 | if ( event.GetEventType() == wxEVT_COMMAND_MENU_SELECTED ) | |
697 | { | |
698 | wxMDIChildFrame * const child = GetActiveChild(); | |
699 | if ( child && child->ProcessEventHere(event) ) | |
700 | return true; | |
701 | } | |
702 | ||
703 | return wxMDIParentFrameBase::TryBefore(event); | |
704 | } | |
705 | ||
706 | WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message, | |
707 | WXWPARAM wParam, | |
708 | WXLPARAM lParam) | |
709 | { | |
710 | WXHWND clientWnd; | |
711 | if ( GetClientWindow() ) | |
712 | clientWnd = GetClientWindow()->GetHWND(); | |
713 | else | |
714 | clientWnd = 0; | |
715 | ||
716 | return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam); | |
717 | } | |
718 | ||
719 | bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg) | |
720 | { | |
721 | MSG *pMsg = (MSG *)msg; | |
722 | ||
723 | // first let the current child get it | |
724 | wxMDIChildFrame * const child = GetActiveChild(); | |
725 | if ( child && child->MSWTranslateMessage(msg) ) | |
726 | { | |
727 | return true; | |
728 | } | |
729 | ||
730 | // then try out accelerator table (will also check the accelerators for the | |
731 | // normal menu items) | |
732 | if ( wxFrame::MSWTranslateMessage(msg) ) | |
733 | { | |
734 | return true; | |
735 | } | |
736 | ||
737 | #if wxUSE_MENUS && wxUSE_ACCEL | |
738 | // but it doesn't check for the (custom) accelerators of the window menu | |
739 | // items as it's not part of the menu bar as it's handled by Windows itself | |
740 | // so we need to do this explicitly | |
741 | if ( m_accelWindowMenu && m_accelWindowMenu->Translate(this, msg) ) | |
742 | return true; | |
743 | #endif // wxUSE_MENUS && wxUSE_ACCEL | |
744 | ||
745 | // finally, check for MDI specific built-in accelerators | |
746 | if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN ) | |
747 | { | |
748 | if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg)) | |
749 | return true; | |
750 | } | |
751 | ||
752 | return false; | |
753 | } | |
754 | ||
755 | // =========================================================================== | |
756 | // wxMDIChildFrame | |
757 | // =========================================================================== | |
758 | ||
759 | void wxMDIChildFrame::Init() | |
760 | { | |
761 | m_needsResize = true; | |
762 | m_needsInitialShow = true; | |
763 | } | |
764 | ||
765 | bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, | |
766 | wxWindowID id, | |
767 | const wxString& title, | |
768 | const wxPoint& pos, | |
769 | const wxSize& size, | |
770 | long style, | |
771 | const wxString& name) | |
772 | { | |
773 | m_mdiParent = parent; | |
774 | ||
775 | SetName(name); | |
776 | ||
777 | if ( id != wxID_ANY ) | |
778 | m_windowId = id; | |
779 | else | |
780 | m_windowId = NewControlId(); | |
781 | ||
782 | if ( parent ) | |
783 | { | |
784 | parent->AddChild(this); | |
785 | } | |
786 | ||
787 | int x = pos.x; | |
788 | int y = pos.y; | |
789 | int width = size.x; | |
790 | int height = size.y; | |
791 | ||
792 | MDICREATESTRUCT mcs; | |
793 | ||
794 | wxString className = | |
795 | wxApp::GetRegisteredClassName(_T("wxMDIChildFrame"), COLOR_WINDOW); | |
796 | if ( !(style & wxFULL_REPAINT_ON_RESIZE) ) | |
797 | className += wxApp::GetNoRedrawClassSuffix(); | |
798 | ||
799 | mcs.szClass = className.wx_str(); | |
800 | mcs.szTitle = title.wx_str(); | |
801 | mcs.hOwner = wxGetInstance(); | |
802 | if (x != wxDefaultCoord) | |
803 | mcs.x = x; | |
804 | else | |
805 | mcs.x = CW_USEDEFAULT; | |
806 | ||
807 | if (y != wxDefaultCoord) | |
808 | mcs.y = y; | |
809 | else | |
810 | mcs.y = CW_USEDEFAULT; | |
811 | ||
812 | if (width != wxDefaultCoord) | |
813 | mcs.cx = width; | |
814 | else | |
815 | mcs.cx = CW_USEDEFAULT; | |
816 | ||
817 | if (height != wxDefaultCoord) | |
818 | mcs.cy = height; | |
819 | else | |
820 | mcs.cy = CW_USEDEFAULT; | |
821 | ||
822 | DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN; | |
823 | if (style & wxMINIMIZE_BOX) | |
824 | msflags |= WS_MINIMIZEBOX; | |
825 | if (style & wxMAXIMIZE_BOX) | |
826 | msflags |= WS_MAXIMIZEBOX; | |
827 | if (style & wxRESIZE_BORDER) | |
828 | msflags |= WS_THICKFRAME; | |
829 | if (style & wxSYSTEM_MENU) | |
830 | msflags |= WS_SYSMENU; | |
831 | if ((style & wxMINIMIZE) || (style & wxICONIZE)) | |
832 | msflags |= WS_MINIMIZE; | |
833 | if (style & wxMAXIMIZE) | |
834 | msflags |= WS_MAXIMIZE; | |
835 | if (style & wxCAPTION) | |
836 | msflags |= WS_CAPTION; | |
837 | ||
838 | mcs.style = msflags; | |
839 | ||
840 | mcs.lParam = 0; | |
841 | ||
842 | wxWindowCreationHook hook(this); | |
843 | ||
844 | m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()), | |
845 | WM_MDICREATE, 0, (LPARAM)&mcs); | |
846 | ||
847 | if ( !m_hWnd ) | |
848 | { | |
849 | wxLogLastError(_T("WM_MDICREATE")); | |
850 | return false; | |
851 | } | |
852 | ||
853 | SubclassWin(m_hWnd); | |
854 | ||
855 | parent->AddMDIChild(this); | |
856 | ||
857 | return true; | |
858 | } | |
859 | ||
860 | wxMDIChildFrame::~wxMDIChildFrame() | |
861 | { | |
862 | // if we hadn't been created, there is nothing to destroy | |
863 | if ( !m_hWnd ) | |
864 | return; | |
865 | ||
866 | GetMDIParent()->RemoveMDIChild(this); | |
867 | ||
868 | // will be destroyed by DestroyChildren() but reset them before calling it | |
869 | // to avoid using dangling pointers if a callback comes in the meanwhile | |
870 | #if wxUSE_TOOLBAR | |
871 | m_frameToolBar = NULL; | |
872 | #endif | |
873 | #if wxUSE_STATUSBAR | |
874 | m_frameStatusBar = NULL; | |
875 | #endif // wxUSE_STATUSBAR | |
876 | ||
877 | DestroyChildren(); | |
878 | ||
879 | MDIRemoveWindowMenu(NULL, m_hMenu); | |
880 | ||
881 | MSWDestroyWindow(); | |
882 | } | |
883 | ||
884 | bool wxMDIChildFrame::Show(bool show) | |
885 | { | |
886 | m_needsInitialShow = false; | |
887 | ||
888 | if (!wxFrame::Show(show)) | |
889 | return false; | |
890 | ||
891 | // KH: Without this call, new MDI children do not become active. | |
892 | // This was added here after the same BringWindowToTop call was | |
893 | // removed from wxTopLevelWindow::Show (November 2005) | |
894 | if ( show ) | |
895 | ::BringWindowToTop(GetHwnd()); | |
896 | ||
897 | // we need to refresh the MDI frame window menu to include (or exclude if | |
898 | // we've been hidden) this frame | |
899 | wxMDIParentFrame * const parent = GetMDIParent(); | |
900 | MDISetMenu(parent->GetClientWindow(), NULL, NULL); | |
901 | ||
902 | return true; | |
903 | } | |
904 | ||
905 | void | |
906 | wxMDIChildFrame::DoSetSize(int x, int y, int width, int height, int sizeFlags) | |
907 | { | |
908 | // we need to disable client area origin adjustments used for the child | |
909 | // windows for the frame itself | |
910 | wxMDIChildFrameBase::DoSetSize(x, y, width, height, sizeFlags); | |
911 | } | |
912 | ||
913 | // Set the client size (i.e. leave the calculation of borders etc. | |
914 | // to wxWidgets) | |
915 | void wxMDIChildFrame::DoSetClientSize(int width, int height) | |
916 | { | |
917 | HWND hWnd = GetHwnd(); | |
918 | ||
919 | RECT rect; | |
920 | ::GetClientRect(hWnd, &rect); | |
921 | ||
922 | RECT rect2; | |
923 | GetWindowRect(hWnd, &rect2); | |
924 | ||
925 | // Find the difference between the entire window (title bar and all) | |
926 | // and the client area; add this to the new client size to move the | |
927 | // window | |
928 | int actual_width = rect2.right - rect2.left - rect.right + width; | |
929 | int actual_height = rect2.bottom - rect2.top - rect.bottom + height; | |
930 | ||
931 | #if wxUSE_STATUSBAR | |
932 | if (GetStatusBar() && GetStatusBar()->IsShown()) | |
933 | { | |
934 | int sx, sy; | |
935 | GetStatusBar()->GetSize(&sx, &sy); | |
936 | actual_height += sy; | |
937 | } | |
938 | #endif // wxUSE_STATUSBAR | |
939 | ||
940 | POINT point; | |
941 | point.x = rect2.left; | |
942 | point.y = rect2.top; | |
943 | ||
944 | // If there's an MDI parent, must subtract the parent's top left corner | |
945 | // since MoveWindow moves relative to the parent | |
946 | wxMDIParentFrame * const mdiParent = GetMDIParent(); | |
947 | ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point); | |
948 | ||
949 | MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true); | |
950 | ||
951 | wxSize size(width, height); | |
952 | wxSizeEvent event(size, m_windowId); | |
953 | event.SetEventObject( this ); | |
954 | HandleWindowEvent(event); | |
955 | } | |
956 | ||
957 | // Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the | |
958 | // same as its GetScreenPosition | |
959 | void wxMDIChildFrame::DoGetScreenPosition(int *x, int *y) const | |
960 | { | |
961 | HWND hWnd = GetHwnd(); | |
962 | ||
963 | RECT rect; | |
964 | ::GetWindowRect(hWnd, &rect); | |
965 | if (x) | |
966 | *x = rect.left; | |
967 | if (y) | |
968 | *y = rect.top; | |
969 | } | |
970 | ||
971 | ||
972 | void wxMDIChildFrame::DoGetPosition(int *x, int *y) const | |
973 | { | |
974 | RECT rect; | |
975 | GetWindowRect(GetHwnd(), &rect); | |
976 | POINT point; | |
977 | point.x = rect.left; | |
978 | point.y = rect.top; | |
979 | ||
980 | // Since we now have the absolute screen coords, | |
981 | // if there's a parent we must subtract its top left corner | |
982 | wxMDIParentFrame * const mdiParent = GetMDIParent(); | |
983 | ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point); | |
984 | ||
985 | if (x) | |
986 | *x = point.x; | |
987 | if (y) | |
988 | *y = point.y; | |
989 | } | |
990 | ||
991 | void wxMDIChildFrame::InternalSetMenuBar() | |
992 | { | |
993 | wxMDIParentFrame * const parent = GetMDIParent(); | |
994 | ||
995 | MDIInsertWindowMenu(parent->GetClientWindow(), | |
996 | m_hMenu, GetMDIWindowMenu(parent)); | |
997 | } | |
998 | ||
999 | void wxMDIChildFrame::DetachMenuBar() | |
1000 | { | |
1001 | MDIRemoveWindowMenu(NULL, m_hMenu); | |
1002 | wxFrame::DetachMenuBar(); | |
1003 | } | |
1004 | ||
1005 | WXHICON wxMDIChildFrame::GetDefaultIcon() const | |
1006 | { | |
1007 | // we don't have any standard icons (any more) | |
1008 | return (WXHICON)0; | |
1009 | } | |
1010 | ||
1011 | // --------------------------------------------------------------------------- | |
1012 | // MDI operations | |
1013 | // --------------------------------------------------------------------------- | |
1014 | ||
1015 | void wxMDIChildFrame::Maximize(bool maximize) | |
1016 | { | |
1017 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1018 | if ( parent && parent->GetClientWindow() ) | |
1019 | { | |
1020 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), | |
1021 | maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE, | |
1022 | (WPARAM)GetHwnd(), 0); | |
1023 | } | |
1024 | } | |
1025 | ||
1026 | void wxMDIChildFrame::Restore() | |
1027 | { | |
1028 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1029 | if ( parent && parent->GetClientWindow() ) | |
1030 | { | |
1031 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE, | |
1032 | (WPARAM) GetHwnd(), 0); | |
1033 | } | |
1034 | } | |
1035 | ||
1036 | void wxMDIChildFrame::Activate() | |
1037 | { | |
1038 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1039 | if ( parent && parent->GetClientWindow() ) | |
1040 | { | |
1041 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE, | |
1042 | (WPARAM) GetHwnd(), 0); | |
1043 | } | |
1044 | } | |
1045 | ||
1046 | // --------------------------------------------------------------------------- | |
1047 | // MDI window proc and message handlers | |
1048 | // --------------------------------------------------------------------------- | |
1049 | ||
1050 | WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message, | |
1051 | WXWPARAM wParam, | |
1052 | WXLPARAM lParam) | |
1053 | { | |
1054 | WXLRESULT rc = 0; | |
1055 | bool processed = false; | |
1056 | ||
1057 | switch ( message ) | |
1058 | { | |
1059 | case WM_GETMINMAXINFO: | |
1060 | processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam); | |
1061 | break; | |
1062 | ||
1063 | case WM_MDIACTIVATE: | |
1064 | { | |
1065 | WXWORD act; | |
1066 | WXHWND hwndAct, hwndDeact; | |
1067 | UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact); | |
1068 | ||
1069 | processed = HandleMDIActivate(act, hwndAct, hwndDeact); | |
1070 | } | |
1071 | // fall through | |
1072 | ||
1073 | case WM_MOVE: | |
1074 | // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client | |
1075 | // scrollbars if necessary | |
1076 | ||
1077 | // fall through | |
1078 | ||
1079 | case WM_SIZE: | |
1080 | // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird | |
1081 | // things happen | |
1082 | MSWDefWindowProc(message, wParam, lParam); | |
1083 | break; | |
1084 | ||
1085 | case WM_WINDOWPOSCHANGING: | |
1086 | processed = HandleWindowPosChanging((LPWINDOWPOS)lParam); | |
1087 | break; | |
1088 | } | |
1089 | ||
1090 | if ( !processed ) | |
1091 | rc = wxFrame::MSWWindowProc(message, wParam, lParam); | |
1092 | ||
1093 | return rc; | |
1094 | } | |
1095 | ||
1096 | bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate), | |
1097 | WXHWND hwndAct, | |
1098 | WXHWND hwndDeact) | |
1099 | { | |
1100 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1101 | ||
1102 | WXHMENU hMenuToSet = 0; | |
1103 | ||
1104 | bool activated; | |
1105 | ||
1106 | if ( m_hWnd == hwndAct ) | |
1107 | { | |
1108 | activated = true; | |
1109 | parent->SetActiveChild(this); | |
1110 | ||
1111 | WXHMENU hMenuChild = m_hMenu; | |
1112 | if ( hMenuChild ) | |
1113 | hMenuToSet = hMenuChild; | |
1114 | } | |
1115 | else if ( m_hWnd == hwndDeact ) | |
1116 | { | |
1117 | wxASSERT_MSG( parent->GetActiveChild() == this, | |
1118 | wxT("can't deactivate MDI child which wasn't active!") ); | |
1119 | ||
1120 | activated = false; | |
1121 | parent->SetActiveChild(NULL); | |
1122 | ||
1123 | WXHMENU hMenuParent = parent->m_hMenu; | |
1124 | ||
1125 | // activate the the parent menu only when there is no other child | |
1126 | // that has been activated | |
1127 | if ( hMenuParent && !hwndAct ) | |
1128 | hMenuToSet = hMenuParent; | |
1129 | } | |
1130 | else | |
1131 | { | |
1132 | // we have nothing to do with it | |
1133 | return false; | |
1134 | } | |
1135 | ||
1136 | if ( hMenuToSet ) | |
1137 | { | |
1138 | MDISetMenu(parent->GetClientWindow(), | |
1139 | (HMENU)hMenuToSet, GetMDIWindowMenu(parent)); | |
1140 | } | |
1141 | ||
1142 | wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId); | |
1143 | event.SetEventObject( this ); | |
1144 | ||
1145 | ResetWindowStyle(NULL); | |
1146 | ||
1147 | return HandleWindowEvent(event); | |
1148 | } | |
1149 | ||
1150 | bool wxMDIChildFrame::HandleWindowPosChanging(void *pos) | |
1151 | { | |
1152 | WINDOWPOS *lpPos = (WINDOWPOS *)pos; | |
1153 | ||
1154 | if (!(lpPos->flags & SWP_NOSIZE)) | |
1155 | { | |
1156 | RECT rectClient; | |
1157 | DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE); | |
1158 | DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE); | |
1159 | if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE)) | |
1160 | { | |
1161 | ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle); | |
1162 | lpPos->x = rectClient.left; | |
1163 | lpPos->y = rectClient.top; | |
1164 | lpPos->cx = rectClient.right - rectClient.left; | |
1165 | lpPos->cy = rectClient.bottom - rectClient.top; | |
1166 | } | |
1167 | } | |
1168 | ||
1169 | return false; | |
1170 | } | |
1171 | ||
1172 | bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo) | |
1173 | { | |
1174 | MINMAXINFO *info = (MINMAXINFO *)mmInfo; | |
1175 | ||
1176 | // let the default window proc calculate the size of MDI children | |
1177 | // frames because it is based on the size of the MDI client window, | |
1178 | // not on the values specified in wxWindow m_max variables | |
1179 | bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0; | |
1180 | ||
1181 | int minWidth = GetMinWidth(), | |
1182 | minHeight = GetMinHeight(); | |
1183 | ||
1184 | // but allow GetSizeHints() to set the min size | |
1185 | if ( minWidth != wxDefaultCoord ) | |
1186 | { | |
1187 | info->ptMinTrackSize.x = minWidth; | |
1188 | ||
1189 | processed = true; | |
1190 | } | |
1191 | ||
1192 | if ( minHeight != wxDefaultCoord ) | |
1193 | { | |
1194 | info->ptMinTrackSize.y = minHeight; | |
1195 | ||
1196 | processed = true; | |
1197 | } | |
1198 | ||
1199 | return processed; | |
1200 | } | |
1201 | ||
1202 | // --------------------------------------------------------------------------- | |
1203 | // MDI specific message translation/preprocessing | |
1204 | // --------------------------------------------------------------------------- | |
1205 | ||
1206 | WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) | |
1207 | { | |
1208 | return DefMDIChildProc(GetHwnd(), | |
1209 | (UINT)message, (WPARAM)wParam, (LPARAM)lParam); | |
1210 | } | |
1211 | ||
1212 | bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg) | |
1213 | { | |
1214 | // we must pass the parent frame to ::TranslateAccelerator(), otherwise it | |
1215 | // doesn't do its job correctly for MDI child menus | |
1216 | return MSWDoTranslateMessage(GetMDIParent(), msg); | |
1217 | } | |
1218 | ||
1219 | // --------------------------------------------------------------------------- | |
1220 | // misc | |
1221 | // --------------------------------------------------------------------------- | |
1222 | ||
1223 | void wxMDIChildFrame::MSWDestroyWindow() | |
1224 | { | |
1225 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1226 | ||
1227 | // Must make sure this handle is invalidated (set to NULL) since all sorts | |
1228 | // of things could happen after the child client is destroyed, but before | |
1229 | // the wxFrame is destroyed. | |
1230 | ||
1231 | HWND oldHandle = (HWND)GetHWND(); | |
1232 | SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY, | |
1233 | (WPARAM)oldHandle, 0); | |
1234 | ||
1235 | if (parent->GetActiveChild() == NULL) | |
1236 | ResetWindowStyle(NULL); | |
1237 | ||
1238 | if (m_hMenu) | |
1239 | { | |
1240 | ::DestroyMenu((HMENU) m_hMenu); | |
1241 | m_hMenu = 0; | |
1242 | } | |
1243 | wxRemoveHandleAssociation(this); | |
1244 | m_hWnd = 0; | |
1245 | } | |
1246 | ||
1247 | // Change the client window's extended style so we don't get a client edge | |
1248 | // style when a child is maximised (a double border looks silly.) | |
1249 | bool wxMDIChildFrame::ResetWindowStyle(void *vrect) | |
1250 | { | |
1251 | RECT *rect = (RECT *)vrect; | |
1252 | wxMDIParentFrame * const pFrameWnd = GetMDIParent(); | |
1253 | wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild(); | |
1254 | ||
1255 | if (!pChild || (pChild == this)) | |
1256 | { | |
1257 | HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow()); | |
1258 | DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE); | |
1259 | ||
1260 | // we want to test whether there is a maximized child, so just set | |
1261 | // dwThisStyle to 0 if there is no child at all | |
1262 | DWORD dwThisStyle = pChild | |
1263 | ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0; | |
1264 | DWORD dwNewStyle = dwStyle; | |
1265 | if ( dwThisStyle & WS_MAXIMIZE ) | |
1266 | dwNewStyle &= ~(WS_EX_CLIENTEDGE); | |
1267 | else | |
1268 | dwNewStyle |= WS_EX_CLIENTEDGE; | |
1269 | ||
1270 | if (dwStyle != dwNewStyle) | |
1271 | { | |
1272 | // force update of everything | |
1273 | ::RedrawWindow(hwndClient, NULL, NULL, | |
1274 | RDW_INVALIDATE | RDW_ALLCHILDREN); | |
1275 | ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle); | |
1276 | ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0, | |
1277 | SWP_FRAMECHANGED | SWP_NOACTIVATE | | |
1278 | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | | |
1279 | SWP_NOCOPYBITS); | |
1280 | if (rect) | |
1281 | ::GetClientRect(hwndClient, rect); | |
1282 | ||
1283 | return true; | |
1284 | } | |
1285 | } | |
1286 | ||
1287 | return false; | |
1288 | } | |
1289 | ||
1290 | // =========================================================================== | |
1291 | // wxMDIClientWindow: the window of predefined (by Windows) class which | |
1292 | // contains the child frames | |
1293 | // =========================================================================== | |
1294 | ||
1295 | bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) | |
1296 | { | |
1297 | m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE); | |
1298 | ||
1299 | CLIENTCREATESTRUCT ccs; | |
1300 | m_windowStyle = style; | |
1301 | m_parent = parent; | |
1302 | ||
1303 | ccs.hWindowMenu = GetMDIWindowMenu(parent); | |
1304 | ccs.idFirstChild = wxFIRST_MDI_CHILD; | |
1305 | ||
1306 | DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD | | |
1307 | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; | |
1308 | ||
1309 | if ( style & wxHSCROLL ) | |
1310 | msStyle |= WS_HSCROLL; | |
1311 | if ( style & wxVSCROLL ) | |
1312 | msStyle |= WS_VSCROLL; | |
1313 | ||
1314 | DWORD exStyle = WS_EX_CLIENTEDGE; | |
1315 | ||
1316 | wxWindowCreationHook hook(this); | |
1317 | m_hWnd = (WXHWND)::CreateWindowEx | |
1318 | ( | |
1319 | exStyle, | |
1320 | wxT("MDICLIENT"), | |
1321 | NULL, | |
1322 | msStyle, | |
1323 | 0, 0, 0, 0, | |
1324 | GetWinHwnd(parent), | |
1325 | NULL, | |
1326 | wxGetInstance(), | |
1327 | (LPSTR)(LPCLIENTCREATESTRUCT)&ccs); | |
1328 | if ( !m_hWnd ) | |
1329 | { | |
1330 | wxLogLastError(wxT("CreateWindowEx(MDI client)")); | |
1331 | ||
1332 | return false; | |
1333 | } | |
1334 | ||
1335 | SubclassWin(m_hWnd); | |
1336 | ||
1337 | return true; | |
1338 | } | |
1339 | ||
1340 | // Explicitly call default scroll behaviour | |
1341 | void wxMDIClientWindow::OnScroll(wxScrollEvent& event) | |
1342 | { | |
1343 | // Note: for client windows, the scroll position is not set in | |
1344 | // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what | |
1345 | // scroll position we're at. | |
1346 | // This makes it hard to paint patterns or bitmaps in the background, | |
1347 | // and have the client area scrollable as well. | |
1348 | ||
1349 | if ( event.GetOrientation() == wxHORIZONTAL ) | |
1350 | m_scrollX = event.GetPosition(); // Always returns zero! | |
1351 | else | |
1352 | m_scrollY = event.GetPosition(); // Always returns zero! | |
1353 | ||
1354 | event.Skip(); | |
1355 | } | |
1356 | ||
1357 | void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags) | |
1358 | { | |
1359 | // Try to fix a problem whereby if you show an MDI child frame, then reposition the | |
1360 | // client area, you can end up with a non-refreshed portion in the client window | |
1361 | // (see OGL studio sample). So check if the position is changed and if so, | |
1362 | // redraw the MDI child frames. | |
1363 | ||
1364 | const wxPoint oldPos = GetPosition(); | |
1365 | ||
1366 | wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE); | |
1367 | ||
1368 | const wxPoint newPos = GetPosition(); | |
1369 | ||
1370 | if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y)) | |
1371 | { | |
1372 | if (GetParent()) | |
1373 | { | |
1374 | wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst(); | |
1375 | while (node) | |
1376 | { | |
1377 | wxWindow *child = node->GetData(); | |
1378 | if (child->IsKindOf(CLASSINFO(wxMDIChildFrame))) | |
1379 | { | |
1380 | ::RedrawWindow(GetHwndOf(child), | |
1381 | NULL, | |
1382 | NULL, | |
1383 | RDW_FRAME | | |
1384 | RDW_ALLCHILDREN | | |
1385 | RDW_INVALIDATE); | |
1386 | } | |
1387 | node = node->GetNext(); | |
1388 | } | |
1389 | } | |
1390 | } | |
1391 | } | |
1392 | ||
1393 | void wxMDIChildFrame::OnIdle(wxIdleEvent& event) | |
1394 | { | |
1395 | // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted | |
1396 | // in flicker e.g. when the frame contained controls with non-trivial | |
1397 | // layout. Since 2.5.3, the frame is created hidden as all other top level | |
1398 | // windows. In order to maintain backward compatibility, the frame is shown | |
1399 | // in OnIdle, unless Show(false) was called by the programmer before. | |
1400 | if ( m_needsInitialShow ) | |
1401 | { | |
1402 | Show(true); | |
1403 | } | |
1404 | ||
1405 | // MDI child frames get their WM_SIZE when they're constructed but at this | |
1406 | // moment they don't have any children yet so all child windows will be | |
1407 | // positioned incorrectly when they are added later - to fix this, we | |
1408 | // generate an artificial size event here | |
1409 | if ( m_needsResize ) | |
1410 | { | |
1411 | m_needsResize = false; // avoid any possibility of recursion | |
1412 | ||
1413 | SendSizeEvent(); | |
1414 | } | |
1415 | ||
1416 | event.Skip(); | |
1417 | } | |
1418 | ||
1419 | // --------------------------------------------------------------------------- | |
1420 | // private helper functions | |
1421 | // --------------------------------------------------------------------------- | |
1422 | ||
1423 | namespace | |
1424 | { | |
1425 | ||
1426 | void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow) | |
1427 | { | |
1428 | if ( hmenuFrame || hmenuWindow ) | |
1429 | { | |
1430 | if ( !::SendMessage(GetWinHwnd(win), | |
1431 | WM_MDISETMENU, | |
1432 | (WPARAM)hmenuFrame, | |
1433 | (LPARAM)hmenuWindow) ) | |
1434 | { | |
1435 | DWORD err = ::GetLastError(); | |
1436 | if ( err ) | |
1437 | wxLogApiError(_T("SendMessage(WM_MDISETMENU)"), err); | |
1438 | } | |
1439 | } | |
1440 | ||
1441 | // update menu bar of the parent window | |
1442 | wxWindow *parent = win->GetParent(); | |
1443 | wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") ); | |
1444 | ||
1445 | ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L); | |
1446 | ||
1447 | ::DrawMenuBar(GetWinHwnd(parent)); | |
1448 | } | |
1449 | ||
1450 | void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU menuWin) | |
1451 | { | |
1452 | HMENU hmenu = (HMENU)hMenu; | |
1453 | ||
1454 | if ( menuWin ) | |
1455 | { | |
1456 | // Try to insert Window menu in front of Help, otherwise append it. | |
1457 | int N = GetMenuItemCount(hmenu); | |
1458 | bool inserted = false; | |
1459 | for ( int i = 0; i < N; i++ ) | |
1460 | { | |
1461 | wxChar buf[256]; | |
1462 | if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) | |
1463 | { | |
1464 | wxLogLastError(wxT("GetMenuString")); | |
1465 | ||
1466 | continue; | |
1467 | } | |
1468 | ||
1469 | const wxString label = wxStripMenuCodes(buf); | |
1470 | if ( label == wxGetStockLabel(wxID_HELP, wxSTOCK_NOFLAGS) ) | |
1471 | { | |
1472 | inserted = true; | |
1473 | ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING, | |
1474 | (UINT_PTR)menuWin, | |
1475 | wxGetTranslation(WINDOW_MENU_LABEL).wx_str()); | |
1476 | break; | |
1477 | } | |
1478 | } | |
1479 | ||
1480 | if ( !inserted ) | |
1481 | { | |
1482 | ::AppendMenu(hmenu, MF_POPUP, | |
1483 | (UINT_PTR)menuWin, | |
1484 | wxGetTranslation(WINDOW_MENU_LABEL).wx_str()); | |
1485 | } | |
1486 | } | |
1487 | ||
1488 | MDISetMenu(win, hmenu, menuWin); | |
1489 | } | |
1490 | ||
1491 | void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu) | |
1492 | { | |
1493 | HMENU hmenu = (HMENU)hMenu; | |
1494 | ||
1495 | if ( hmenu ) | |
1496 | { | |
1497 | wxChar buf[1024]; | |
1498 | ||
1499 | int N = ::GetMenuItemCount(hmenu); | |
1500 | for ( int i = 0; i < N; i++ ) | |
1501 | { | |
1502 | if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) | |
1503 | { | |
1504 | // Ignore successful read of menu string with length 0 which | |
1505 | // occurs, for example, for a maximized MDI child system menu | |
1506 | if ( ::GetLastError() != 0 ) | |
1507 | { | |
1508 | wxLogLastError(wxT("GetMenuString")); | |
1509 | } | |
1510 | ||
1511 | continue; | |
1512 | } | |
1513 | ||
1514 | if ( wxStrcmp(buf, wxGetTranslation(WINDOW_MENU_LABEL)) == 0 ) | |
1515 | { | |
1516 | if ( !::RemoveMenu(hmenu, i, MF_BYPOSITION) ) | |
1517 | { | |
1518 | wxLogLastError(wxT("RemoveMenu")); | |
1519 | } | |
1520 | ||
1521 | break; | |
1522 | } | |
1523 | } | |
1524 | } | |
1525 | ||
1526 | if ( win ) | |
1527 | { | |
1528 | // we don't change the windows menu, but we update the main one | |
1529 | MDISetMenu(win, hmenu, NULL); | |
1530 | } | |
1531 | } | |
1532 | ||
1533 | void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, | |
1534 | WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact) | |
1535 | { | |
1536 | *activate = true; | |
1537 | *hwndAct = (WXHWND)lParam; | |
1538 | *hwndDeact = (WXHWND)wParam; | |
1539 | } | |
1540 | ||
1541 | } // anonymous namespace | |
1542 | ||
1543 | #endif // wxUSE_MDI && !defined(__WXUNIVERSAL__) |