]>
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 | { | |
545 | WXWORD id, cmd; | |
546 | WXHWND hwnd; | |
547 | UnpackCommand(wParam, lParam, &id, &hwnd, &cmd); | |
548 | ||
549 | (void)HandleCommand(id, cmd, hwnd); | |
550 | ||
551 | // even if the frame didn't process it, there is no need to try it | |
552 | // once again (i.e. call wxFrame::HandleCommand()) - we just did it, | |
553 | // so pretend we processed the message anyhow | |
554 | processed = true; | |
555 | } | |
556 | ||
557 | // always pass this message DefFrameProc(), otherwise MDI menu | |
558 | // commands (and sys commands - more surprisingly!) won't work | |
559 | MSWDefWindowProc(message, wParam, lParam); | |
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 the | |
584 | // client area we need to pass this one to DefFrameProc to allow the children to show | |
585 | break; | |
586 | } | |
587 | ||
588 | if ( !processed ) | |
589 | rc = wxFrame::MSWWindowProc(message, wParam, lParam); | |
590 | ||
591 | return rc; | |
592 | } | |
593 | ||
594 | bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate) | |
595 | { | |
596 | bool processed = false; | |
597 | ||
598 | if ( wxWindow::HandleActivate(state, minimized, activate) ) | |
599 | { | |
600 | // already processed | |
601 | processed = true; | |
602 | } | |
603 | ||
604 | // If this window is an MDI parent, we must also send an OnActivate message | |
605 | // to the current child. | |
606 | if ( GetActiveChild() && | |
607 | ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) ) | |
608 | { | |
609 | wxActivateEvent event(wxEVT_ACTIVATE, true, GetActiveChild()->GetId()); | |
610 | event.SetEventObject( GetActiveChild() ); | |
611 | if ( GetActiveChild()->HandleWindowEvent(event) ) | |
612 | processed = true; | |
613 | } | |
614 | ||
615 | return processed; | |
616 | } | |
617 | ||
618 | #if wxUSE_MENUS | |
619 | ||
620 | void wxMDIParentFrame::OnMDIChild(wxCommandEvent& event) | |
621 | { | |
622 | wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); | |
623 | while ( node ) | |
624 | { | |
625 | wxWindow *child = node->GetData(); | |
626 | if ( child->GetHWND() ) | |
627 | { | |
628 | int childId = wxGetWindowId(child->GetHWND()); | |
629 | if ( childId == event.GetId() ) | |
630 | { | |
631 | ::SendMessage( GetWinHwnd(GetClientWindow()), | |
632 | WM_MDIACTIVATE, | |
633 | (WPARAM)child->GetHWND(), 0); | |
634 | return; | |
635 | } | |
636 | } | |
637 | ||
638 | node = node->GetNext(); | |
639 | } | |
640 | ||
641 | wxFAIL_MSG( "unknown MDI child selected?" ); | |
642 | } | |
643 | ||
644 | void wxMDIParentFrame::OnMDICommand(wxCommandEvent& event) | |
645 | { | |
646 | WXWPARAM wParam = 0; | |
647 | WXLPARAM lParam = 0; | |
648 | int msg; | |
649 | switch ( event.GetId() ) | |
650 | { | |
651 | case wxID_MDI_WINDOW_CASCADE: | |
652 | msg = WM_MDICASCADE; | |
653 | wParam = MDITILE_SKIPDISABLED; | |
654 | break; | |
655 | ||
656 | case wxID_MDI_WINDOW_TILE_HORZ: | |
657 | wParam |= MDITILE_HORIZONTAL; | |
658 | // fall through | |
659 | ||
660 | case wxID_MDI_WINDOW_TILE_VERT: | |
661 | if ( !wParam ) | |
662 | wParam = MDITILE_VERTICAL; | |
663 | msg = WM_MDITILE; | |
664 | wParam |= MDITILE_SKIPDISABLED; | |
665 | break; | |
666 | ||
667 | case wxID_MDI_WINDOW_ARRANGE_ICONS: | |
668 | msg = WM_MDIICONARRANGE; | |
669 | break; | |
670 | ||
671 | case wxID_MDI_WINDOW_NEXT: | |
672 | msg = WM_MDINEXT; | |
673 | lParam = 0; // next child | |
674 | break; | |
675 | ||
676 | case wxID_MDI_WINDOW_PREV: | |
677 | msg = WM_MDINEXT; | |
678 | lParam = 1; // previous child | |
679 | break; | |
680 | ||
681 | default: | |
682 | wxFAIL_MSG( "unknown MDI command" ); | |
683 | return; | |
684 | } | |
685 | ||
686 | ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, lParam); | |
687 | } | |
688 | ||
689 | #endif // wxUSE_MENUS | |
690 | ||
691 | bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd) | |
692 | { | |
693 | wxMDIChildFrame * const child = GetActiveChild(); | |
694 | if ( child && child->HandleCommand(id, cmd, hwnd) ) | |
695 | return true; | |
696 | ||
697 | return wxFrame::HandleCommand(id, cmd, hwnd); | |
698 | } | |
699 | ||
700 | WXLRESULT wxMDIParentFrame::MSWDefWindowProc(WXUINT message, | |
701 | WXWPARAM wParam, | |
702 | WXLPARAM lParam) | |
703 | { | |
704 | WXHWND clientWnd; | |
705 | if ( GetClientWindow() ) | |
706 | clientWnd = GetClientWindow()->GetHWND(); | |
707 | else | |
708 | clientWnd = 0; | |
709 | ||
710 | return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam); | |
711 | } | |
712 | ||
713 | bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg) | |
714 | { | |
715 | MSG *pMsg = (MSG *)msg; | |
716 | ||
717 | // first let the current child get it | |
718 | wxMDIChildFrame * const child = GetActiveChild(); | |
719 | if ( child && child->MSWTranslateMessage(msg) ) | |
720 | { | |
721 | return true; | |
722 | } | |
723 | ||
724 | // then try out accelerator table (will also check the accelerators for the | |
725 | // normal menu items) | |
726 | if ( wxFrame::MSWTranslateMessage(msg) ) | |
727 | { | |
728 | return true; | |
729 | } | |
730 | ||
731 | #if wxUSE_MENUS && wxUSE_ACCEL | |
732 | // but it doesn't check for the (custom) accelerators of the window menu | |
733 | // items as it's not part of the menu bar as it's handled by Windows itself | |
734 | // so we need to do this explicitly | |
735 | if ( m_accelWindowMenu && m_accelWindowMenu->Translate(this, msg) ) | |
736 | return true; | |
737 | #endif // wxUSE_MENUS && wxUSE_ACCEL | |
738 | ||
739 | // finally, check for MDI specific built-in accelerators | |
740 | if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN ) | |
741 | { | |
742 | if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg)) | |
743 | return true; | |
744 | } | |
745 | ||
746 | return false; | |
747 | } | |
748 | ||
749 | // =========================================================================== | |
750 | // wxMDIChildFrame | |
751 | // =========================================================================== | |
752 | ||
753 | void wxMDIChildFrame::Init() | |
754 | { | |
755 | m_needsResize = true; | |
756 | m_needsInitialShow = true; | |
757 | } | |
758 | ||
759 | bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, | |
760 | wxWindowID id, | |
761 | const wxString& title, | |
762 | const wxPoint& pos, | |
763 | const wxSize& size, | |
764 | long style, | |
765 | const wxString& name) | |
766 | { | |
767 | m_mdiParent = parent; | |
768 | ||
769 | SetName(name); | |
770 | ||
771 | if ( id != wxID_ANY ) | |
772 | m_windowId = id; | |
773 | else | |
774 | m_windowId = NewControlId(); | |
775 | ||
776 | if ( parent ) | |
777 | { | |
778 | parent->AddChild(this); | |
779 | } | |
780 | ||
781 | int x = pos.x; | |
782 | int y = pos.y; | |
783 | int width = size.x; | |
784 | int height = size.y; | |
785 | ||
786 | MDICREATESTRUCT mcs; | |
787 | ||
788 | wxString className = | |
789 | wxApp::GetRegisteredClassName(_T("wxMDIChildFrame"), COLOR_WINDOW); | |
790 | if ( !(style & wxFULL_REPAINT_ON_RESIZE) ) | |
791 | className += wxApp::GetNoRedrawClassSuffix(); | |
792 | ||
793 | mcs.szClass = className.wx_str(); | |
794 | mcs.szTitle = title.wx_str(); | |
795 | mcs.hOwner = wxGetInstance(); | |
796 | if (x != wxDefaultCoord) | |
797 | mcs.x = x; | |
798 | else | |
799 | mcs.x = CW_USEDEFAULT; | |
800 | ||
801 | if (y != wxDefaultCoord) | |
802 | mcs.y = y; | |
803 | else | |
804 | mcs.y = CW_USEDEFAULT; | |
805 | ||
806 | if (width != wxDefaultCoord) | |
807 | mcs.cx = width; | |
808 | else | |
809 | mcs.cx = CW_USEDEFAULT; | |
810 | ||
811 | if (height != wxDefaultCoord) | |
812 | mcs.cy = height; | |
813 | else | |
814 | mcs.cy = CW_USEDEFAULT; | |
815 | ||
816 | DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN; | |
817 | if (style & wxMINIMIZE_BOX) | |
818 | msflags |= WS_MINIMIZEBOX; | |
819 | if (style & wxMAXIMIZE_BOX) | |
820 | msflags |= WS_MAXIMIZEBOX; | |
821 | if (style & wxRESIZE_BORDER) | |
822 | msflags |= WS_THICKFRAME; | |
823 | if (style & wxSYSTEM_MENU) | |
824 | msflags |= WS_SYSMENU; | |
825 | if ((style & wxMINIMIZE) || (style & wxICONIZE)) | |
826 | msflags |= WS_MINIMIZE; | |
827 | if (style & wxMAXIMIZE) | |
828 | msflags |= WS_MAXIMIZE; | |
829 | if (style & wxCAPTION) | |
830 | msflags |= WS_CAPTION; | |
831 | ||
832 | mcs.style = msflags; | |
833 | ||
834 | mcs.lParam = 0; | |
835 | ||
836 | wxWindowCreationHook hook(this); | |
837 | ||
838 | m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()), | |
839 | WM_MDICREATE, 0, (LPARAM)&mcs); | |
840 | ||
841 | if ( !m_hWnd ) | |
842 | { | |
843 | wxLogLastError(_T("WM_MDICREATE")); | |
844 | return false; | |
845 | } | |
846 | ||
847 | SubclassWin(m_hWnd); | |
848 | ||
849 | parent->AddMDIChild(this); | |
850 | ||
851 | return true; | |
852 | } | |
853 | ||
854 | wxMDIChildFrame::~wxMDIChildFrame() | |
855 | { | |
856 | // if we hadn't been created, there is nothing to destroy | |
857 | if ( !m_hWnd ) | |
858 | return; | |
859 | ||
860 | GetMDIParent()->RemoveMDIChild(this); | |
861 | ||
862 | // will be destroyed by DestroyChildren() but reset them before calling it | |
863 | // to avoid using dangling pointers if a callback comes in the meanwhile | |
864 | #if wxUSE_TOOLBAR | |
865 | m_frameToolBar = NULL; | |
866 | #endif | |
867 | #if wxUSE_STATUSBAR | |
868 | m_frameStatusBar = NULL; | |
869 | #endif // wxUSE_STATUSBAR | |
870 | ||
871 | DestroyChildren(); | |
872 | ||
873 | MDIRemoveWindowMenu(NULL, m_hMenu); | |
874 | ||
875 | MSWDestroyWindow(); | |
876 | } | |
877 | ||
878 | bool wxMDIChildFrame::Show(bool show) | |
879 | { | |
880 | m_needsInitialShow = false; | |
881 | ||
882 | if (!wxFrame::Show(show)) | |
883 | return false; | |
884 | ||
885 | // KH: Without this call, new MDI children do not become active. | |
886 | // This was added here after the same BringWindowToTop call was | |
887 | // removed from wxTopLevelWindow::Show (November 2005) | |
888 | if ( show ) | |
889 | ::BringWindowToTop(GetHwnd()); | |
890 | ||
891 | // we need to refresh the MDI frame window menu to include (or exclude if | |
892 | // we've been hidden) this frame | |
893 | wxMDIParentFrame * const parent = GetMDIParent(); | |
894 | MDISetMenu(parent->GetClientWindow(), NULL, NULL); | |
895 | ||
896 | return true; | |
897 | } | |
898 | ||
899 | // Set the client size (i.e. leave the calculation of borders etc. | |
900 | // to wxWidgets) | |
901 | void wxMDIChildFrame::DoSetClientSize(int width, int height) | |
902 | { | |
903 | HWND hWnd = GetHwnd(); | |
904 | ||
905 | RECT rect; | |
906 | ::GetClientRect(hWnd, &rect); | |
907 | ||
908 | RECT rect2; | |
909 | GetWindowRect(hWnd, &rect2); | |
910 | ||
911 | // Find the difference between the entire window (title bar and all) | |
912 | // and the client area; add this to the new client size to move the | |
913 | // window | |
914 | int actual_width = rect2.right - rect2.left - rect.right + width; | |
915 | int actual_height = rect2.bottom - rect2.top - rect.bottom + height; | |
916 | ||
917 | #if wxUSE_STATUSBAR | |
918 | if (GetStatusBar() && GetStatusBar()->IsShown()) | |
919 | { | |
920 | int sx, sy; | |
921 | GetStatusBar()->GetSize(&sx, &sy); | |
922 | actual_height += sy; | |
923 | } | |
924 | #endif // wxUSE_STATUSBAR | |
925 | ||
926 | POINT point; | |
927 | point.x = rect2.left; | |
928 | point.y = rect2.top; | |
929 | ||
930 | // If there's an MDI parent, must subtract the parent's top left corner | |
931 | // since MoveWindow moves relative to the parent | |
932 | wxMDIParentFrame * const mdiParent = GetMDIParent(); | |
933 | ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point); | |
934 | ||
935 | MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)true); | |
936 | ||
937 | wxSize size(width, height); | |
938 | wxSizeEvent event(size, m_windowId); | |
939 | event.SetEventObject( this ); | |
940 | HandleWindowEvent(event); | |
941 | } | |
942 | ||
943 | // Unlike other wxTopLevelWindowBase, the mdi child's "GetPosition" is not the | |
944 | // same as its GetScreenPosition | |
945 | void wxMDIChildFrame::DoGetScreenPosition(int *x, int *y) const | |
946 | { | |
947 | HWND hWnd = GetHwnd(); | |
948 | ||
949 | RECT rect; | |
950 | ::GetWindowRect(hWnd, &rect); | |
951 | if (x) | |
952 | *x = rect.left; | |
953 | if (y) | |
954 | *y = rect.top; | |
955 | } | |
956 | ||
957 | ||
958 | void wxMDIChildFrame::DoGetPosition(int *x, int *y) const | |
959 | { | |
960 | RECT rect; | |
961 | GetWindowRect(GetHwnd(), &rect); | |
962 | POINT point; | |
963 | point.x = rect.left; | |
964 | point.y = rect.top; | |
965 | ||
966 | // Since we now have the absolute screen coords, | |
967 | // if there's a parent we must subtract its top left corner | |
968 | wxMDIParentFrame * const mdiParent = GetMDIParent(); | |
969 | ::ScreenToClient(GetHwndOf(mdiParent->GetClientWindow()), &point); | |
970 | ||
971 | if (x) | |
972 | *x = point.x; | |
973 | if (y) | |
974 | *y = point.y; | |
975 | } | |
976 | ||
977 | void wxMDIChildFrame::InternalSetMenuBar() | |
978 | { | |
979 | wxMDIParentFrame * const parent = GetMDIParent(); | |
980 | ||
981 | MDIInsertWindowMenu(parent->GetClientWindow(), | |
982 | m_hMenu, GetMDIWindowMenu(parent)); | |
983 | } | |
984 | ||
985 | void wxMDIChildFrame::DetachMenuBar() | |
986 | { | |
987 | MDIRemoveWindowMenu(NULL, m_hMenu); | |
988 | wxFrame::DetachMenuBar(); | |
989 | } | |
990 | ||
991 | WXHICON wxMDIChildFrame::GetDefaultIcon() const | |
992 | { | |
993 | // we don't have any standard icons (any more) | |
994 | return (WXHICON)0; | |
995 | } | |
996 | ||
997 | // --------------------------------------------------------------------------- | |
998 | // MDI operations | |
999 | // --------------------------------------------------------------------------- | |
1000 | ||
1001 | void wxMDIChildFrame::Maximize(bool maximize) | |
1002 | { | |
1003 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1004 | if ( parent && parent->GetClientWindow() ) | |
1005 | { | |
1006 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), | |
1007 | maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE, | |
1008 | (WPARAM)GetHwnd(), 0); | |
1009 | } | |
1010 | } | |
1011 | ||
1012 | void wxMDIChildFrame::Restore() | |
1013 | { | |
1014 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1015 | if ( parent && parent->GetClientWindow() ) | |
1016 | { | |
1017 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE, | |
1018 | (WPARAM) GetHwnd(), 0); | |
1019 | } | |
1020 | } | |
1021 | ||
1022 | void wxMDIChildFrame::Activate() | |
1023 | { | |
1024 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1025 | if ( parent && parent->GetClientWindow() ) | |
1026 | { | |
1027 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE, | |
1028 | (WPARAM) GetHwnd(), 0); | |
1029 | } | |
1030 | } | |
1031 | ||
1032 | // --------------------------------------------------------------------------- | |
1033 | // MDI window proc and message handlers | |
1034 | // --------------------------------------------------------------------------- | |
1035 | ||
1036 | WXLRESULT wxMDIChildFrame::MSWWindowProc(WXUINT message, | |
1037 | WXWPARAM wParam, | |
1038 | WXLPARAM lParam) | |
1039 | { | |
1040 | WXLRESULT rc = 0; | |
1041 | bool processed = false; | |
1042 | ||
1043 | switch ( message ) | |
1044 | { | |
1045 | case WM_GETMINMAXINFO: | |
1046 | processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam); | |
1047 | break; | |
1048 | ||
1049 | case WM_MDIACTIVATE: | |
1050 | { | |
1051 | WXWORD act; | |
1052 | WXHWND hwndAct, hwndDeact; | |
1053 | UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact); | |
1054 | ||
1055 | processed = HandleMDIActivate(act, hwndAct, hwndDeact); | |
1056 | } | |
1057 | // fall through | |
1058 | ||
1059 | case WM_MOVE: | |
1060 | // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client | |
1061 | // scrollbars if necessary | |
1062 | ||
1063 | // fall through | |
1064 | ||
1065 | case WM_SIZE: | |
1066 | // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird | |
1067 | // things happen | |
1068 | MSWDefWindowProc(message, wParam, lParam); | |
1069 | break; | |
1070 | ||
1071 | case WM_SYSCOMMAND: | |
1072 | // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it | |
1073 | // the message (the base class version does not) | |
1074 | return MSWDefWindowProc(message, wParam, lParam); | |
1075 | ||
1076 | case WM_WINDOWPOSCHANGING: | |
1077 | processed = HandleWindowPosChanging((LPWINDOWPOS)lParam); | |
1078 | break; | |
1079 | } | |
1080 | ||
1081 | if ( !processed ) | |
1082 | rc = wxFrame::MSWWindowProc(message, wParam, lParam); | |
1083 | ||
1084 | return rc; | |
1085 | } | |
1086 | ||
1087 | bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate), | |
1088 | WXHWND hwndAct, | |
1089 | WXHWND hwndDeact) | |
1090 | { | |
1091 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1092 | ||
1093 | WXHMENU hMenuToSet = 0; | |
1094 | ||
1095 | bool activated; | |
1096 | ||
1097 | if ( m_hWnd == hwndAct ) | |
1098 | { | |
1099 | activated = true; | |
1100 | parent->SetActiveChild(this); | |
1101 | ||
1102 | WXHMENU hMenuChild = m_hMenu; | |
1103 | if ( hMenuChild ) | |
1104 | hMenuToSet = hMenuChild; | |
1105 | } | |
1106 | else if ( m_hWnd == hwndDeact ) | |
1107 | { | |
1108 | wxASSERT_MSG( parent->GetActiveChild() == this, | |
1109 | wxT("can't deactivate MDI child which wasn't active!") ); | |
1110 | ||
1111 | activated = false; | |
1112 | parent->SetActiveChild(NULL); | |
1113 | ||
1114 | WXHMENU hMenuParent = parent->m_hMenu; | |
1115 | ||
1116 | // activate the the parent menu only when there is no other child | |
1117 | // that has been activated | |
1118 | if ( hMenuParent && !hwndAct ) | |
1119 | hMenuToSet = hMenuParent; | |
1120 | } | |
1121 | else | |
1122 | { | |
1123 | // we have nothing to do with it | |
1124 | return false; | |
1125 | } | |
1126 | ||
1127 | if ( hMenuToSet ) | |
1128 | { | |
1129 | MDISetMenu(parent->GetClientWindow(), | |
1130 | (HMENU)hMenuToSet, GetMDIWindowMenu(parent)); | |
1131 | } | |
1132 | ||
1133 | wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId); | |
1134 | event.SetEventObject( this ); | |
1135 | ||
1136 | ResetWindowStyle(NULL); | |
1137 | ||
1138 | return HandleWindowEvent(event); | |
1139 | } | |
1140 | ||
1141 | bool wxMDIChildFrame::HandleWindowPosChanging(void *pos) | |
1142 | { | |
1143 | WINDOWPOS *lpPos = (WINDOWPOS *)pos; | |
1144 | ||
1145 | if (!(lpPos->flags & SWP_NOSIZE)) | |
1146 | { | |
1147 | RECT rectClient; | |
1148 | DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE); | |
1149 | DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE); | |
1150 | if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE)) | |
1151 | { | |
1152 | ::AdjustWindowRectEx(&rectClient, dwStyle, false, dwExStyle); | |
1153 | lpPos->x = rectClient.left; | |
1154 | lpPos->y = rectClient.top; | |
1155 | lpPos->cx = rectClient.right - rectClient.left; | |
1156 | lpPos->cy = rectClient.bottom - rectClient.top; | |
1157 | } | |
1158 | } | |
1159 | ||
1160 | return false; | |
1161 | } | |
1162 | ||
1163 | bool wxMDIChildFrame::HandleGetMinMaxInfo(void *mmInfo) | |
1164 | { | |
1165 | MINMAXINFO *info = (MINMAXINFO *)mmInfo; | |
1166 | ||
1167 | // let the default window proc calculate the size of MDI children | |
1168 | // frames because it is based on the size of the MDI client window, | |
1169 | // not on the values specified in wxWindow m_max variables | |
1170 | bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0; | |
1171 | ||
1172 | int minWidth = GetMinWidth(), | |
1173 | minHeight = GetMinHeight(); | |
1174 | ||
1175 | // but allow GetSizeHints() to set the min size | |
1176 | if ( minWidth != wxDefaultCoord ) | |
1177 | { | |
1178 | info->ptMinTrackSize.x = minWidth; | |
1179 | ||
1180 | processed = true; | |
1181 | } | |
1182 | ||
1183 | if ( minHeight != wxDefaultCoord ) | |
1184 | { | |
1185 | info->ptMinTrackSize.y = minHeight; | |
1186 | ||
1187 | processed = true; | |
1188 | } | |
1189 | ||
1190 | return processed; | |
1191 | } | |
1192 | ||
1193 | // --------------------------------------------------------------------------- | |
1194 | // MDI specific message translation/preprocessing | |
1195 | // --------------------------------------------------------------------------- | |
1196 | ||
1197 | WXLRESULT wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) | |
1198 | { | |
1199 | return DefMDIChildProc(GetHwnd(), | |
1200 | (UINT)message, (WPARAM)wParam, (LPARAM)lParam); | |
1201 | } | |
1202 | ||
1203 | bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg) | |
1204 | { | |
1205 | // we must pass the parent frame to ::TranslateAccelerator(), otherwise it | |
1206 | // doesn't do its job correctly for MDI child menus | |
1207 | return MSWDoTranslateMessage(GetMDIParent(), msg); | |
1208 | } | |
1209 | ||
1210 | // --------------------------------------------------------------------------- | |
1211 | // misc | |
1212 | // --------------------------------------------------------------------------- | |
1213 | ||
1214 | void wxMDIChildFrame::MSWDestroyWindow() | |
1215 | { | |
1216 | wxMDIParentFrame * const parent = GetMDIParent(); | |
1217 | ||
1218 | // Must make sure this handle is invalidated (set to NULL) since all sorts | |
1219 | // of things could happen after the child client is destroyed, but before | |
1220 | // the wxFrame is destroyed. | |
1221 | ||
1222 | HWND oldHandle = (HWND)GetHWND(); | |
1223 | SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY, | |
1224 | (WPARAM)oldHandle, 0); | |
1225 | ||
1226 | if (parent->GetActiveChild() == NULL) | |
1227 | ResetWindowStyle(NULL); | |
1228 | ||
1229 | if (m_hMenu) | |
1230 | { | |
1231 | ::DestroyMenu((HMENU) m_hMenu); | |
1232 | m_hMenu = 0; | |
1233 | } | |
1234 | wxRemoveHandleAssociation(this); | |
1235 | m_hWnd = 0; | |
1236 | } | |
1237 | ||
1238 | // Change the client window's extended style so we don't get a client edge | |
1239 | // style when a child is maximised (a double border looks silly.) | |
1240 | bool wxMDIChildFrame::ResetWindowStyle(void *vrect) | |
1241 | { | |
1242 | RECT *rect = (RECT *)vrect; | |
1243 | wxMDIParentFrame * const pFrameWnd = GetMDIParent(); | |
1244 | wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild(); | |
1245 | ||
1246 | if (!pChild || (pChild == this)) | |
1247 | { | |
1248 | HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow()); | |
1249 | DWORD dwStyle = ::GetWindowLong(hwndClient, GWL_EXSTYLE); | |
1250 | ||
1251 | // we want to test whether there is a maximized child, so just set | |
1252 | // dwThisStyle to 0 if there is no child at all | |
1253 | DWORD dwThisStyle = pChild | |
1254 | ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0; | |
1255 | DWORD dwNewStyle = dwStyle; | |
1256 | if ( dwThisStyle & WS_MAXIMIZE ) | |
1257 | dwNewStyle &= ~(WS_EX_CLIENTEDGE); | |
1258 | else | |
1259 | dwNewStyle |= WS_EX_CLIENTEDGE; | |
1260 | ||
1261 | if (dwStyle != dwNewStyle) | |
1262 | { | |
1263 | // force update of everything | |
1264 | ::RedrawWindow(hwndClient, NULL, NULL, | |
1265 | RDW_INVALIDATE | RDW_ALLCHILDREN); | |
1266 | ::SetWindowLong(hwndClient, GWL_EXSTYLE, dwNewStyle); | |
1267 | ::SetWindowPos(hwndClient, NULL, 0, 0, 0, 0, | |
1268 | SWP_FRAMECHANGED | SWP_NOACTIVATE | | |
1269 | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | | |
1270 | SWP_NOCOPYBITS); | |
1271 | if (rect) | |
1272 | ::GetClientRect(hwndClient, rect); | |
1273 | ||
1274 | return true; | |
1275 | } | |
1276 | } | |
1277 | ||
1278 | return false; | |
1279 | } | |
1280 | ||
1281 | // =========================================================================== | |
1282 | // wxMDIClientWindow: the window of predefined (by Windows) class which | |
1283 | // contains the child frames | |
1284 | // =========================================================================== | |
1285 | ||
1286 | bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) | |
1287 | { | |
1288 | m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE); | |
1289 | ||
1290 | CLIENTCREATESTRUCT ccs; | |
1291 | m_windowStyle = style; | |
1292 | m_parent = parent; | |
1293 | ||
1294 | ccs.hWindowMenu = GetMDIWindowMenu(parent); | |
1295 | ccs.idFirstChild = wxFIRST_MDI_CHILD; | |
1296 | ||
1297 | DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD | | |
1298 | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; | |
1299 | ||
1300 | if ( style & wxHSCROLL ) | |
1301 | msStyle |= WS_HSCROLL; | |
1302 | if ( style & wxVSCROLL ) | |
1303 | msStyle |= WS_VSCROLL; | |
1304 | ||
1305 | DWORD exStyle = WS_EX_CLIENTEDGE; | |
1306 | ||
1307 | wxWindowCreationHook hook(this); | |
1308 | m_hWnd = (WXHWND)::CreateWindowEx | |
1309 | ( | |
1310 | exStyle, | |
1311 | wxT("MDICLIENT"), | |
1312 | NULL, | |
1313 | msStyle, | |
1314 | 0, 0, 0, 0, | |
1315 | GetWinHwnd(parent), | |
1316 | NULL, | |
1317 | wxGetInstance(), | |
1318 | (LPSTR)(LPCLIENTCREATESTRUCT)&ccs); | |
1319 | if ( !m_hWnd ) | |
1320 | { | |
1321 | wxLogLastError(wxT("CreateWindowEx(MDI client)")); | |
1322 | ||
1323 | return false; | |
1324 | } | |
1325 | ||
1326 | SubclassWin(m_hWnd); | |
1327 | ||
1328 | return true; | |
1329 | } | |
1330 | ||
1331 | // Explicitly call default scroll behaviour | |
1332 | void wxMDIClientWindow::OnScroll(wxScrollEvent& event) | |
1333 | { | |
1334 | // Note: for client windows, the scroll position is not set in | |
1335 | // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what | |
1336 | // scroll position we're at. | |
1337 | // This makes it hard to paint patterns or bitmaps in the background, | |
1338 | // and have the client area scrollable as well. | |
1339 | ||
1340 | if ( event.GetOrientation() == wxHORIZONTAL ) | |
1341 | m_scrollX = event.GetPosition(); // Always returns zero! | |
1342 | else | |
1343 | m_scrollY = event.GetPosition(); // Always returns zero! | |
1344 | ||
1345 | event.Skip(); | |
1346 | } | |
1347 | ||
1348 | void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags) | |
1349 | { | |
1350 | // Try to fix a problem whereby if you show an MDI child frame, then reposition the | |
1351 | // client area, you can end up with a non-refreshed portion in the client window | |
1352 | // (see OGL studio sample). So check if the position is changed and if so, | |
1353 | // redraw the MDI child frames. | |
1354 | ||
1355 | const wxPoint oldPos = GetPosition(); | |
1356 | ||
1357 | wxWindow::DoSetSize(x, y, width, height, sizeFlags | wxSIZE_FORCE); | |
1358 | ||
1359 | const wxPoint newPos = GetPosition(); | |
1360 | ||
1361 | if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y)) | |
1362 | { | |
1363 | if (GetParent()) | |
1364 | { | |
1365 | wxWindowList::compatibility_iterator node = GetParent()->GetChildren().GetFirst(); | |
1366 | while (node) | |
1367 | { | |
1368 | wxWindow *child = node->GetData(); | |
1369 | if (child->IsKindOf(CLASSINFO(wxMDIChildFrame))) | |
1370 | { | |
1371 | ::RedrawWindow(GetHwndOf(child), | |
1372 | NULL, | |
1373 | NULL, | |
1374 | RDW_FRAME | | |
1375 | RDW_ALLCHILDREN | | |
1376 | RDW_INVALIDATE); | |
1377 | } | |
1378 | node = node->GetNext(); | |
1379 | } | |
1380 | } | |
1381 | } | |
1382 | } | |
1383 | ||
1384 | void wxMDIChildFrame::OnIdle(wxIdleEvent& event) | |
1385 | { | |
1386 | // wxMSW prior to 2.5.3 created MDI child frames as visible, which resulted | |
1387 | // in flicker e.g. when the frame contained controls with non-trivial | |
1388 | // layout. Since 2.5.3, the frame is created hidden as all other top level | |
1389 | // windows. In order to maintain backward compatibility, the frame is shown | |
1390 | // in OnIdle, unless Show(false) was called by the programmer before. | |
1391 | if ( m_needsInitialShow ) | |
1392 | { | |
1393 | Show(true); | |
1394 | } | |
1395 | ||
1396 | // MDI child frames get their WM_SIZE when they're constructed but at this | |
1397 | // moment they don't have any children yet so all child windows will be | |
1398 | // positioned incorrectly when they are added later - to fix this, we | |
1399 | // generate an artificial size event here | |
1400 | if ( m_needsResize ) | |
1401 | { | |
1402 | m_needsResize = false; // avoid any possibility of recursion | |
1403 | ||
1404 | SendSizeEvent(); | |
1405 | } | |
1406 | ||
1407 | event.Skip(); | |
1408 | } | |
1409 | ||
1410 | // --------------------------------------------------------------------------- | |
1411 | // private helper functions | |
1412 | // --------------------------------------------------------------------------- | |
1413 | ||
1414 | namespace | |
1415 | { | |
1416 | ||
1417 | void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow) | |
1418 | { | |
1419 | if ( hmenuFrame || hmenuWindow ) | |
1420 | { | |
1421 | if ( !::SendMessage(GetWinHwnd(win), | |
1422 | WM_MDISETMENU, | |
1423 | (WPARAM)hmenuFrame, | |
1424 | (LPARAM)hmenuWindow) ) | |
1425 | { | |
1426 | #ifdef __WXDEBUG__ | |
1427 | DWORD err = ::GetLastError(); | |
1428 | if ( err ) | |
1429 | wxLogApiError(_T("SendMessage(WM_MDISETMENU)"), err); | |
1430 | #endif // __WXDEBUG__ | |
1431 | } | |
1432 | } | |
1433 | ||
1434 | // update menu bar of the parent window | |
1435 | wxWindow *parent = win->GetParent(); | |
1436 | wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") ); | |
1437 | ||
1438 | ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L); | |
1439 | ||
1440 | ::DrawMenuBar(GetWinHwnd(parent)); | |
1441 | } | |
1442 | ||
1443 | void MDIInsertWindowMenu(wxWindow *win, WXHMENU hMenu, HMENU menuWin) | |
1444 | { | |
1445 | HMENU hmenu = (HMENU)hMenu; | |
1446 | ||
1447 | if ( menuWin ) | |
1448 | { | |
1449 | // Try to insert Window menu in front of Help, otherwise append it. | |
1450 | int N = GetMenuItemCount(hmenu); | |
1451 | bool inserted = false; | |
1452 | for ( int i = 0; i < N; i++ ) | |
1453 | { | |
1454 | wxChar buf[256]; | |
1455 | if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) | |
1456 | { | |
1457 | wxLogLastError(wxT("GetMenuString")); | |
1458 | ||
1459 | continue; | |
1460 | } | |
1461 | ||
1462 | const wxString label = wxStripMenuCodes(buf); | |
1463 | if ( label == wxGetStockLabel(wxID_HELP, wxSTOCK_NOFLAGS) ) | |
1464 | { | |
1465 | inserted = true; | |
1466 | ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING, | |
1467 | (UINT_PTR)menuWin, | |
1468 | wxGetTranslation(WINDOW_MENU_LABEL).wx_str()); | |
1469 | break; | |
1470 | } | |
1471 | } | |
1472 | ||
1473 | if ( !inserted ) | |
1474 | { | |
1475 | ::AppendMenu(hmenu, MF_POPUP, | |
1476 | (UINT_PTR)menuWin, | |
1477 | wxGetTranslation(WINDOW_MENU_LABEL).wx_str()); | |
1478 | } | |
1479 | } | |
1480 | ||
1481 | MDISetMenu(win, hmenu, menuWin); | |
1482 | } | |
1483 | ||
1484 | void MDIRemoveWindowMenu(wxWindow *win, WXHMENU hMenu) | |
1485 | { | |
1486 | HMENU hmenu = (HMENU)hMenu; | |
1487 | ||
1488 | if ( hmenu ) | |
1489 | { | |
1490 | wxChar buf[1024]; | |
1491 | ||
1492 | int N = ::GetMenuItemCount(hmenu); | |
1493 | for ( int i = 0; i < N; i++ ) | |
1494 | { | |
1495 | if ( !::GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION) ) | |
1496 | { | |
1497 | // Ignore successful read of menu string with length 0 which | |
1498 | // occurs, for example, for a maximized MDI child system menu | |
1499 | if ( ::GetLastError() != 0 ) | |
1500 | { | |
1501 | wxLogLastError(wxT("GetMenuString")); | |
1502 | } | |
1503 | ||
1504 | continue; | |
1505 | } | |
1506 | ||
1507 | if ( wxStrcmp(buf, wxGetTranslation(WINDOW_MENU_LABEL)) == 0 ) | |
1508 | { | |
1509 | if ( !::RemoveMenu(hmenu, i, MF_BYPOSITION) ) | |
1510 | { | |
1511 | wxLogLastError(wxT("RemoveMenu")); | |
1512 | } | |
1513 | ||
1514 | break; | |
1515 | } | |
1516 | } | |
1517 | } | |
1518 | ||
1519 | if ( win ) | |
1520 | { | |
1521 | // we don't change the windows menu, but we update the main one | |
1522 | MDISetMenu(win, hmenu, NULL); | |
1523 | } | |
1524 | } | |
1525 | ||
1526 | void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, | |
1527 | WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact) | |
1528 | { | |
1529 | *activate = true; | |
1530 | *hwndAct = (WXHWND)lParam; | |
1531 | *hwndDeact = (WXHWND)wParam; | |
1532 | } | |
1533 | ||
1534 | } // anonymous namespace | |
1535 | ||
1536 | #endif // wxUSE_MDI && !defined(__WXUNIVERSAL__) |