]> git.saurik.com Git - wxWidgets.git/blob - src/msw/mdi.cpp
Fixed wxWindow::HandleCommand so multiple toolbars work again (e.g. ogl/studio sample);
[wxWidgets.git] / src / msw / mdi.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: mdi.cpp
3 // Purpose: MDI classes
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "mdi.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/setup.h"
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 #if wxUSE_STATUSBAR
39 #include "wx/statusbr.h"
40 #endif
41 #include "wx/settings.h"
42 #include "wx/intl.h"
43 #include "wx/log.h"
44 #endif
45
46 #include "wx/mdi.h"
47 #include "wx/msw/private.h"
48
49 #if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR
50 #include "wx/msw/statbr95.h"
51 #endif
52
53 #if wxUSE_TOOLBAR
54 #include "wx/toolbar.h"
55 #endif // wxUSE_TOOLBAR
56
57 #include <string.h>
58
59 // ---------------------------------------------------------------------------
60 // global variables
61 // ---------------------------------------------------------------------------
62
63 extern wxWindowList wxModelessWindows; // from dialog.cpp
64 extern wxMenu *wxCurrentPopupMenu;
65
66 extern const wxChar *wxMDIFrameClassName;
67 extern const wxChar *wxMDIChildFrameClassName;
68 extern wxWindow *wxWndHook; // from window.cpp
69
70 extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win);
71
72 static HWND invalidHandle = 0;
73
74 // ---------------------------------------------------------------------------
75 // constants
76 // ---------------------------------------------------------------------------
77
78 static const int IDM_WINDOWTILE = 4001;
79 static const int IDM_WINDOWTILEHOR = 4001;
80 static const int IDM_WINDOWCASCADE = 4002;
81 static const int IDM_WINDOWICONS = 4003;
82 static const int IDM_WINDOWNEXT = 4004;
83 static const int IDM_WINDOWTILEVERT = 4005;
84
85 // This range gives a maximum of 500 MDI children. Should be enough :-)
86 static const int wxFIRST_MDI_CHILD = 4100;
87 static const int wxLAST_MDI_CHILD = 4600;
88
89 // Status border dimensions
90 static const int wxTHICK_LINE_BORDER = 3;
91 static const int wxTHICK_LINE_WIDTH = 1;
92
93 // ---------------------------------------------------------------------------
94 // private functions
95 // ---------------------------------------------------------------------------
96
97 // set the MDI menus (by sending the WM_MDISETMENU message) and update the menu
98 // of the parent of win (which is supposed to be the MDI client window)
99 static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow);
100
101 // insert the window menu (subMenu) into menu just before "Help" submenu or at
102 // the very end if not found
103 static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu);
104
105 // Remove the window menu
106 static void RemoveWindowMenu(wxWindow *win, WXHMENU menu);
107
108 // is this an id of an MDI child?
109 inline bool IsMdiCommandId(int id)
110 {
111 return (id >= wxFIRST_MDI_CHILD) && (id <= wxLAST_MDI_CHILD);
112 }
113
114 static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
115 WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact);
116
117 // ===========================================================================
118 // implementation
119 // ===========================================================================
120
121 // ---------------------------------------------------------------------------
122 // wxWin macros
123 // ---------------------------------------------------------------------------
124
125 IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
126 IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
127 IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
128
129 BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame)
130 EVT_SIZE(wxMDIParentFrame::OnSize)
131 EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged)
132 END_EVENT_TABLE()
133
134 BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
135 EVT_SCROLL(wxMDIClientWindow::OnScroll)
136 END_EVENT_TABLE()
137
138 // ===========================================================================
139 // wxMDIParentFrame: the frame which contains the client window which manages
140 // the children
141 // ===========================================================================
142
143 wxMDIParentFrame::wxMDIParentFrame()
144 {
145 m_clientWindow = NULL;
146 m_currentChild = NULL;
147 m_windowMenu = (wxMenu*) NULL;
148 m_parentFrameActive = TRUE;
149 }
150
151 bool wxMDIParentFrame::Create(wxWindow *parent,
152 wxWindowID id,
153 const wxString& title,
154 const wxPoint& pos,
155 const wxSize& size,
156 long style,
157 const wxString& name)
158 {
159 m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON ? wxSTD_MDIPARENTFRAME_ICON : wxDEFAULT_MDIPARENTFRAME_ICON);
160
161 m_clientWindow = NULL;
162 m_currentChild = NULL;
163
164 if (style & wxFRAME_NO_WINDOW_MENU)
165 m_windowMenu = (wxMenu*) NULL;
166 else
167 {
168 // m_windowMenu = (WXHMENU) ::LoadMenu(wxGetInstance(), wxT("wxWindowMenu"));
169 m_windowMenu = new wxMenu;
170
171
172 m_windowMenu->Append(4002, wxT("&Cascade"));
173 m_windowMenu->Append(4001, wxT("Tile &Horizontally"));
174 m_windowMenu->Append(4005, wxT("Tile &Vertically"));
175 m_windowMenu->AppendSeparator();
176 m_windowMenu->Append(4003, wxT("&Arrange Icons"));
177 m_windowMenu->Append(4004, wxT("&Next"));
178 }
179
180 m_parentFrameActive = TRUE;
181
182 if (!parent)
183 wxTopLevelWindows.Append(this);
184
185 SetName(name);
186 m_windowStyle = style;
187
188 if (parent) parent->AddChild(this);
189
190 if ( id > -1 )
191 m_windowId = id;
192 else
193 m_windowId = (int)NewControlId();
194
195 int x = pos.x;
196 int y = pos.y;
197 int width = size.x;
198 int height = size.y;
199
200 DWORD msflags = WS_OVERLAPPED;
201 if (style & wxMINIMIZE_BOX)
202 msflags |= WS_MINIMIZEBOX;
203 if (style & wxMAXIMIZE_BOX)
204 msflags |= WS_MAXIMIZEBOX;
205 if (style & wxTHICK_FRAME)
206 msflags |= WS_THICKFRAME;
207 if (style & wxSYSTEM_MENU)
208 msflags |= WS_SYSMENU;
209 if ((style & wxMINIMIZE) || (style & wxICONIZE))
210 msflags |= WS_MINIMIZE;
211 if (style & wxMAXIMIZE)
212 msflags |= WS_MAXIMIZE;
213 if (style & wxCAPTION)
214 msflags |= WS_CAPTION;
215
216 if (style & wxCLIP_CHILDREN)
217 msflags |= WS_CLIPCHILDREN;
218
219 wxWindow::MSWCreate(m_windowId, parent, wxMDIFrameClassName, this, title, x, y, width, height,
220 msflags);
221
222 wxModelessWindows.Append(this);
223
224 return TRUE;
225 }
226
227 wxMDIParentFrame::~wxMDIParentFrame()
228 {
229 DestroyChildren();
230 // already delete by DestroyChildren()
231 m_frameToolBar = NULL;
232
233 // ::DestroyMenu((HMENU)m_windowMenu);
234 if (m_windowMenu)
235 {
236 delete m_windowMenu;
237 m_windowMenu = (wxMenu*) NULL;
238 }
239
240 if ( m_clientWindow )
241 {
242 if ( m_clientWindow->MSWGetOldWndProc() )
243 m_clientWindow->UnsubclassWin();
244
245 m_clientWindow->SetHWND(0);
246 delete m_clientWindow;
247 }
248 }
249
250 void wxMDIParentFrame::InternalSetMenuBar()
251 {
252 // HMENU subMenu = GetSubMenu((HMENU) m_windowMenu, 0);
253
254 m_parentFrameActive = TRUE;
255
256 HMENU subMenu = (HMENU) 0;
257 if (GetWindowMenu())
258 subMenu = (HMENU) GetWindowMenu()->GetHMenu();
259
260 InsertWindowMenu(GetClientWindow(), m_hMenu, subMenu);
261 }
262
263 void wxMDIParentFrame::SetWindowMenu(wxMenu* menu)
264 {
265 if (m_windowMenu)
266 {
267 if (GetMenuBar())
268 {
269 // Remove old window menu
270 RemoveWindowMenu(GetClientWindow(), m_hMenu);
271 }
272
273 delete m_windowMenu;
274 m_windowMenu = (wxMenu*) NULL;
275 }
276 if (menu)
277 {
278 m_windowMenu = menu;
279 if (GetMenuBar())
280 InsertWindowMenu(GetClientWindow(), m_hMenu, (HMENU) m_windowMenu->GetHMenu());
281 }
282 }
283
284 void wxMDIParentFrame::OnSize(wxSizeEvent& event)
285 {
286 if ( GetClientWindow() )
287 {
288 int width, height;
289 GetClientSize(&width, &height);
290
291 GetClientWindow()->SetSize(0, 0, width, height);
292 }
293 }
294
295 // Returns the active MDI child window
296 wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
297 {
298 HWND hWnd = (HWND)::SendMessage(GetWinHwnd(GetClientWindow()),
299 WM_MDIGETACTIVE, 0, 0L);
300 if ( hWnd == 0 )
301 return NULL;
302 else
303 return (wxMDIChildFrame *)wxFindWinFromHandle((WXHWND) hWnd);
304 }
305
306 // Create the client window class (don't Create the window, just return a new
307 // class)
308 wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
309 {
310 return new wxMDIClientWindow;
311 }
312
313 // Responds to colour changes, and passes event on to children.
314 void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
315 {
316 if ( m_clientWindow )
317 {
318 m_clientWindow->SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
319 m_clientWindow->Refresh();
320 }
321
322 event.Skip();
323 }
324
325 // ---------------------------------------------------------------------------
326 // MDI operations
327 // ---------------------------------------------------------------------------
328
329 void wxMDIParentFrame::Cascade()
330 {
331 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0);
332 }
333
334 // TODO: add a direction argument (hor/vert)
335 void wxMDIParentFrame::Tile()
336 {
337 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0);
338 }
339
340 void wxMDIParentFrame::ArrangeIcons()
341 {
342 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0);
343 }
344
345 void wxMDIParentFrame::ActivateNext()
346 {
347 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0);
348 }
349
350 void wxMDIParentFrame::ActivatePrevious()
351 {
352 ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1);
353 }
354
355 // ---------------------------------------------------------------------------
356 // the MDI parent frame window proc
357 // ---------------------------------------------------------------------------
358
359 long wxMDIParentFrame::MSWWindowProc(WXUINT message,
360 WXWPARAM wParam,
361 WXLPARAM lParam)
362 {
363 long rc = 0;
364 bool processed = FALSE;
365
366 switch ( message )
367 {
368 case WM_ACTIVATE:
369 {
370 WXWORD state, minimized;
371 WXHWND hwnd;
372 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
373
374 processed = HandleActivate(state, minimized != 0, hwnd);
375 }
376 break;
377
378 case WM_COMMAND:
379 {
380 WXWORD id, cmd;
381 WXHWND hwnd;
382 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
383
384 (void)HandleCommand(id, cmd, hwnd);
385
386 // even if the frame didn't process it, there is no need to try it
387 // once again (i.e. call wxFrame::HandleCommand()) - we just dud it,
388 // so pretend we processed the message anyhow
389 processed = TRUE;
390 }
391
392 // always pass this message DefFrameProc(), otherwise MDI menu
393 // commands (and sys commands - more surprizingly!) won't work
394 MSWDefWindowProc(message, wParam, lParam);
395 break;
396
397 case WM_CREATE:
398 m_clientWindow = OnCreateClient();
399 // Uses own style for client style
400 if ( !m_clientWindow->CreateClient(this, GetWindowStyleFlag()) )
401 {
402 wxLogMessage(_("Failed to create MDI parent frame."));
403
404 rc = -1;
405 }
406
407 processed = TRUE;
408 break;
409
410 case WM_ERASEBKGND:
411 processed = TRUE;
412
413 // we erase background ourselves
414 rc = TRUE;
415 break;
416
417 case WM_MENUSELECT:
418 {
419 WXWORD item, flags;
420 WXHMENU hmenu;
421 UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
422
423 if ( m_parentFrameActive )
424 {
425 processed = HandleMenuSelect(item, flags, hmenu);
426 }
427 else if (m_currentChild)
428 {
429 processed = m_currentChild->
430 HandleMenuSelect(item, flags, hmenu);
431 }
432 }
433 break;
434
435 case WM_SIZE:
436 // as we don't (usually) resize the MDI client to exactly fit the
437 // client area (we put it below the toolbar, above statusbar &c),
438 // we should not pass this one to DefFrameProc
439 break;
440 }
441
442 if ( !processed )
443 rc = wxFrame::MSWWindowProc(message, wParam, lParam);
444
445 return rc;
446 }
447
448 bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate)
449 {
450 bool processed = FALSE;
451
452 if ( wxWindow::HandleActivate(state, minimized, activate) )
453 {
454 // already processed
455 processed = TRUE;
456 }
457
458 // If this window is an MDI parent, we must also send an OnActivate message
459 // to the current child.
460 if ( (m_currentChild != NULL) &&
461 ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) )
462 {
463 wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId());
464 event.SetEventObject( m_currentChild );
465 if ( m_currentChild->GetEventHandler()->ProcessEvent(event) )
466 processed = TRUE;
467 }
468
469 return processed;
470 }
471
472 bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
473 {
474 // In case it's e.g. a toolbar.
475 if ( hwnd )
476 {
477 wxWindow *win = wxFindWinFromHandle(hwnd);
478 if ( win )
479 return win->MSWCommand(cmd, id);
480 }
481
482 // is it one of standard MDI commands?
483 WXWPARAM wParam = 0;
484 int msg;
485 switch ( id )
486 {
487 case IDM_WINDOWCASCADE:
488 msg = WM_MDICASCADE;
489 wParam = MDITILE_SKIPDISABLED;
490 break;
491
492 case IDM_WINDOWTILEHOR:
493 wParam |= MDITILE_HORIZONTAL;
494 // fall through
495
496 case IDM_WINDOWTILEVERT:
497 if ( !wParam )
498 wParam = MDITILE_VERTICAL;
499 msg = WM_MDITILE;
500 wParam |= MDITILE_SKIPDISABLED;
501 break;
502
503 case IDM_WINDOWICONS:
504 msg = WM_MDIICONARRANGE;
505 break;
506
507 case IDM_WINDOWNEXT:
508 msg = WM_MDINEXT;
509 break;
510
511 default:
512 msg = 0;
513 }
514
515 if ( msg )
516 {
517 ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, 0);
518
519 return TRUE;
520 }
521
522 // FIXME VZ: what does this test do??
523 if (id >= 0xF000)
524 {
525 return FALSE; // Get WndProc to call default proc
526 }
527
528 if ( IsMdiCommandId(id) )
529 {
530 wxWindowList::Node* node = GetChildren().GetFirst();
531 while ( node )
532 {
533 wxWindow* child = node->GetData();
534 if ( child->GetHWND() )
535 {
536 long childId = wxGetWindowId(child->GetHWND());
537 if (childId == (long)id)
538 {
539 ::SendMessage( GetWinHwnd(GetClientWindow()),
540 WM_MDIACTIVATE,
541 (WPARAM)child->GetHWND(), 0);
542 return TRUE;
543 }
544 }
545 node = node->GetNext();
546 }
547 }
548 else if ( m_parentFrameActive )
549 {
550 return ProcessCommand(id);
551 }
552 else if ( m_currentChild )
553 {
554 return m_currentChild->HandleCommand(id, cmd, hwnd);
555 }
556 else
557 {
558 // this shouldn't happen because it means that our messages are being
559 // lost (they're not sent to the parent frame nor to the children)
560 wxFAIL_MSG(wxT("MDI parent frame is not active, "
561 "yet there is no active MDI child?"));
562 }
563
564 return FALSE;
565 }
566
567 long wxMDIParentFrame::MSWDefWindowProc(WXUINT message,
568 WXWPARAM wParam,
569 WXLPARAM lParam)
570 {
571 WXHWND clientWnd;
572 if ( GetClientWindow() )
573 clientWnd = GetClientWindow()->GetHWND();
574 else
575 clientWnd = 0;
576
577 return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam);
578 }
579
580 bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg)
581 {
582 MSG *pMsg = (MSG *)msg;
583
584 if ( m_currentChild && m_currentChild->GetHWND() &&
585 m_currentChild->MSWTranslateMessage(msg) )
586 {
587 return TRUE;
588 }
589
590 if ( m_acceleratorTable.Translate(this, msg) )
591 {
592 return TRUE;
593 }
594
595 if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN )
596 {
597 if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg))
598 return TRUE;
599 }
600
601 return FALSE;
602 }
603
604 // ===========================================================================
605 // wxMDIChildFrame
606 // ===========================================================================
607
608 wxMDIChildFrame::wxMDIChildFrame()
609 {
610 }
611
612 bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
613 wxWindowID id,
614 const wxString& title,
615 const wxPoint& pos,
616 const wxSize& size,
617 long style,
618 const wxString& name)
619 {
620 m_defaultIcon = (WXHICON)(wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON
621 : wxDEFAULT_MDICHILDFRAME_ICON);
622
623 SetName(name);
624
625 if ( id > -1 )
626 m_windowId = id;
627 else
628 m_windowId = (int)NewControlId();
629
630 if ( parent )
631 {
632 parent->AddChild(this);
633 }
634
635 wxWndHook = this;
636
637 int x = pos.x;
638 int y = pos.y;
639 int width = size.x;
640 int height = size.y;
641
642 MDICREATESTRUCT mcs;
643
644 mcs.szClass = wxMDIChildFrameClassName;
645 mcs.szTitle = title;
646 mcs.hOwner = wxGetInstance();
647 if (x > -1)
648 mcs.x = x;
649 else
650 mcs.x = CW_USEDEFAULT;
651
652 if (y > -1)
653 mcs.y = y;
654 else
655 mcs.y = CW_USEDEFAULT;
656
657 if (width > -1)
658 mcs.cx = width;
659 else
660 mcs.cx = CW_USEDEFAULT;
661
662 if (height > -1)
663 mcs.cy = height;
664 else
665 mcs.cy = CW_USEDEFAULT;
666
667 DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
668 if (style & wxMINIMIZE_BOX)
669 msflags |= WS_MINIMIZEBOX;
670 if (style & wxMAXIMIZE_BOX)
671 msflags |= WS_MAXIMIZEBOX;
672 if (style & wxTHICK_FRAME)
673 msflags |= WS_THICKFRAME;
674 if (style & wxSYSTEM_MENU)
675 msflags |= WS_SYSMENU;
676 if ((style & wxMINIMIZE) || (style & wxICONIZE))
677 msflags |= WS_MINIMIZE;
678 if (style & wxMAXIMIZE)
679 msflags |= WS_MAXIMIZE;
680 if (style & wxCAPTION)
681 msflags |= WS_CAPTION;
682
683 mcs.style = msflags;
684
685 mcs.lParam = 0;
686
687 DWORD Return = SendMessage(GetWinHwnd(parent->GetClientWindow()),
688 WM_MDICREATE, 0, (LONG)(LPSTR)&mcs);
689
690 //handle = (HWND)LOWORD(Return);
691 // Must be the DWORRD for WIN32. And in 16 bits, HIWORD=0 (says Microsoft)
692 m_hWnd = (WXHWND)Return;
693
694 wxWndHook = NULL;
695 wxAssociateWinWithHandle((HWND) GetHWND(), this);
696
697 // VZ: what's this? an act of piracy?
698 //SetWindowLong(GetHwnd(), 0, (long)this);
699
700 wxModelessWindows.Append(this);
701 return TRUE;
702 }
703
704 wxMDIChildFrame::~wxMDIChildFrame()
705 {
706 MSWDestroyWindow();
707 }
708
709 // Set the client size (i.e. leave the calculation of borders etc.
710 // to wxWindows)
711 void wxMDIChildFrame::DoSetClientSize(int width, int height)
712 {
713 HWND hWnd = GetHwnd();
714
715 RECT rect;
716 ::GetClientRect(hWnd, &rect);
717
718 RECT rect2;
719 GetWindowRect(hWnd, &rect2);
720
721 // Find the difference between the entire window (title bar and all)
722 // and the client area; add this to the new client size to move the
723 // window
724 int actual_width = rect2.right - rect2.left - rect.right + width;
725 int actual_height = rect2.bottom - rect2.top - rect.bottom + height;
726
727 if (GetStatusBar() && GetStatusBar()->IsShown())
728 {
729 int sx, sy;
730 GetStatusBar()->GetSize(&sx, &sy);
731 actual_height += sy;
732 }
733
734 POINT point;
735 point.x = rect2.left;
736 point.y = rect2.top;
737
738 // If there's an MDI parent, must subtract the parent's top left corner
739 // since MoveWindow moves relative to the parent
740 wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
741 ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
742
743 MoveWindow(hWnd, point.x, point.y, actual_width, actual_height, (BOOL)TRUE);
744
745 wxSizeEvent event(wxSize(width, height), m_windowId);
746 event.SetEventObject( this );
747 GetEventHandler()->ProcessEvent(event);
748 }
749
750 void wxMDIChildFrame::DoGetPosition(int *x, int *y) const
751 {
752 RECT rect;
753 GetWindowRect(GetHwnd(), &rect);
754 POINT point;
755 point.x = rect.left;
756 point.y = rect.top;
757
758 // Since we now have the absolute screen coords,
759 // if there's a parent we must subtract its top left corner
760 wxMDIParentFrame *mdiParent = (wxMDIParentFrame *)GetParent();
761 ::ScreenToClient((HWND) mdiParent->GetClientWindow()->GetHWND(), &point);
762
763 *x = point.x;
764 *y = point.y;
765 }
766
767 void wxMDIChildFrame::InternalSetMenuBar()
768 {
769 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
770
771 // HMENU subMenu = GetSubMenu((HMENU)parent->GetWindowMenu(), 0);
772 HMENU subMenu = (HMENU) 0;
773 if (parent->GetWindowMenu())
774 subMenu = (HMENU) parent->GetWindowMenu()->GetHMenu();
775
776 InsertWindowMenu(parent->GetClientWindow(), m_hMenu, subMenu);
777
778 parent->m_parentFrameActive = FALSE;
779 }
780
781 // ---------------------------------------------------------------------------
782 // MDI operations
783 // ---------------------------------------------------------------------------
784
785 void wxMDIChildFrame::Maximize(bool maximize)
786 {
787 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
788 if ( parent && parent->GetClientWindow() )
789 {
790 ::SendMessage(GetWinHwnd(parent->GetClientWindow()),
791 maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE,
792 (WPARAM)GetHwnd(), 0);
793 }
794 }
795
796 void wxMDIChildFrame::Restore()
797 {
798 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
799 if ( parent && parent->GetClientWindow() )
800 {
801 ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE,
802 (WPARAM) GetHwnd(), 0);
803 }
804 }
805
806 void wxMDIChildFrame::Activate()
807 {
808 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
809 if ( parent && parent->GetClientWindow() )
810 {
811 ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE,
812 (WPARAM) GetHwnd(), 0);
813 }
814 }
815
816 // ---------------------------------------------------------------------------
817 // MDI window proc and message handlers
818 // ---------------------------------------------------------------------------
819
820 long wxMDIChildFrame::MSWWindowProc(WXUINT message,
821 WXWPARAM wParam,
822 WXLPARAM lParam)
823 {
824 long rc = 0;
825 bool processed = FALSE;
826
827 switch ( message )
828 {
829 case WM_COMMAND:
830 {
831 WORD id, cmd;
832 WXHWND hwnd;
833 UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
834 &id, &hwnd, &cmd);
835
836 processed = HandleCommand(id, cmd, (WXHWND)hwnd);
837 }
838 break;
839
840 case WM_GETMINMAXINFO:
841 // let the default window proc calculate the size of MDI children
842 // frames because it is based on the size of the MDI client window,
843 // not on the values specified in wxWindow m_min/max variables
844 return MSWDefWindowProc(message, wParam, lParam);
845
846 case WM_MDIACTIVATE:
847 {
848 WXWORD act;
849 WXHWND hwndAct, hwndDeact;
850 UnpackMDIActivate(wParam, lParam, &act, &hwndAct, &hwndDeact);
851
852 processed = HandleMDIActivate(act, hwndAct, hwndDeact);
853 }
854 // fall through
855
856 case WM_MOVE:
857 // must pass WM_MOVE to DefMDIChildProc() to recalculate MDI client
858 // scrollbars if necessary
859
860 // fall through
861
862 case WM_SIZE:
863 // must pass WM_SIZE to DefMDIChildProc(), otherwise many weird
864 // things happen
865 MSWDefWindowProc(message, wParam, lParam);
866 break;
867
868 case WM_SYSCOMMAND:
869 // DefMDIChildProc handles SC_{NEXT/PREV}WINDOW here, so pass it
870 // the message (the base class version does not)
871 return MSWDefWindowProc(message, wParam, lParam);
872
873 case WM_WINDOWPOSCHANGING:
874 processed = HandleWindowPosChanging((LPWINDOWPOS)lParam);
875 break;
876 }
877
878 if ( !processed )
879 rc = wxFrame::MSWWindowProc(message, wParam, lParam);
880
881 return rc;
882 }
883
884 bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd)
885 {
886 // In case it's e.g. a toolbar.
887 if ( hwnd )
888 {
889 wxWindow *win = wxFindWinFromHandle(hwnd);
890 if (win)
891 return win->MSWCommand(cmd, id);
892 }
893
894 if (wxCurrentPopupMenu)
895 {
896 wxMenu *popupMenu = wxCurrentPopupMenu;
897 wxCurrentPopupMenu = NULL;
898 if (popupMenu->MSWCommand(cmd, id))
899 return TRUE;
900 }
901
902 if (GetMenuBar() && GetMenuBar()->FindItem(id))
903 {
904 ProcessCommand(id);
905 return TRUE;
906 }
907 else
908 return FALSE;
909
910 return TRUE;
911 }
912
913 bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate),
914 WXHWND hwndAct,
915 WXHWND hwndDeact)
916 {
917 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
918
919 HMENU menuToSet = 0;
920
921 bool activated;
922
923 if ( m_hWnd == hwndAct )
924 {
925 activated = TRUE;
926 parent->m_currentChild = this;
927
928 HMENU child_menu = (HMENU)GetWinMenu();
929 if ( child_menu )
930 {
931 parent->m_parentFrameActive = FALSE;
932
933 menuToSet = child_menu;
934 }
935 }
936 else if ( m_hWnd == hwndDeact )
937 {
938 wxASSERT_MSG( parent->m_currentChild == this,
939 wxT("can't deactivate MDI child which wasn't active!") );
940
941 activated = FALSE;
942 parent->m_currentChild = NULL;
943
944 HMENU parent_menu = (HMENU)parent->GetWinMenu();
945 if ( parent_menu )
946 {
947 parent->m_parentFrameActive = TRUE;
948
949 menuToSet = parent_menu;
950 }
951 }
952 else
953 {
954 // we have nothing to do with it
955 return FALSE;
956 }
957
958 if ( menuToSet )
959 {
960 HMENU subMenu = (HMENU) 0;
961 if (parent->GetWindowMenu())
962 subMenu = (HMENU) parent->GetWindowMenu()->GetHMenu();
963
964 MDISetMenu(parent->GetClientWindow(), menuToSet, subMenu);
965 }
966
967 wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId);
968 event.SetEventObject( this );
969
970 return GetEventHandler()->ProcessEvent(event);
971 }
972
973 bool wxMDIChildFrame::HandleWindowPosChanging(void *pos)
974 {
975 WINDOWPOS *lpPos = (WINDOWPOS *)pos;
976 #if defined(__WIN95__)
977 if (!(lpPos->flags & SWP_NOSIZE))
978 {
979 RECT rectClient;
980 DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
981 DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
982 if (ResetWindowStyle((void *) & rectClient) && (dwStyle & WS_MAXIMIZE))
983 {
984 ::AdjustWindowRectEx(&rectClient, dwStyle, FALSE, dwExStyle);
985 lpPos->x = rectClient.left;
986 lpPos->y = rectClient.top;
987 lpPos->cx = rectClient.right - rectClient.left;
988 lpPos->cy = rectClient.bottom - rectClient.top;
989 }
990 wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
991 if (pFrameWnd && pFrameWnd->GetToolBar() && pFrameWnd->GetToolBar()->IsShown())
992 {
993 pFrameWnd->GetToolBar()->Refresh();
994 }
995 }
996 #endif // Win95
997
998 return FALSE;
999 }
1000
1001 // ---------------------------------------------------------------------------
1002 // MDI specific message translation/preprocessing
1003 // ---------------------------------------------------------------------------
1004
1005 long wxMDIChildFrame::MSWDefWindowProc(WXUINT message, WXUINT wParam, WXLPARAM lParam)
1006 {
1007 return DefMDIChildProc(GetHwnd(),
1008 (UINT)message, (WPARAM)wParam, (LPARAM)lParam);
1009 }
1010
1011 bool wxMDIChildFrame::MSWTranslateMessage(WXMSG* msg)
1012 {
1013 return m_acceleratorTable.Translate(GetParent(), msg);
1014 }
1015
1016 // ---------------------------------------------------------------------------
1017 // misc
1018 // ---------------------------------------------------------------------------
1019
1020 void wxMDIChildFrame::MSWDestroyWindow()
1021 {
1022 MSWDetachWindowMenu();
1023 invalidHandle = GetHwnd();
1024
1025 wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent();
1026
1027 // Must make sure this handle is invalidated (set to NULL) since all sorts
1028 // of things could happen after the child client is destroyed, but before
1029 // the wxFrame is destroyed.
1030
1031 HWND oldHandle = (HWND)GetHWND();
1032 SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY,
1033 (WPARAM)oldHandle, 0);
1034
1035 if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL)
1036 ResetWindowStyle((void*) NULL);
1037
1038 invalidHandle = 0;
1039
1040 if (m_hMenu)
1041 {
1042 ::DestroyMenu((HMENU) m_hMenu);
1043 m_hMenu = 0;
1044 }
1045 m_hWnd = 0;
1046 }
1047
1048 // Change the client window's extended style so we don't get a client edge
1049 // style when a child is maximised (a double border looks silly.)
1050 bool wxMDIChildFrame::ResetWindowStyle(void *vrect)
1051 {
1052 #if defined(__WIN95__)
1053 RECT *rect = (RECT *)vrect;
1054 wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent();
1055 wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild();
1056 if (!pChild || (pChild == this))
1057 {
1058 DWORD dwStyle = ::GetWindowLong(GetWinHwnd(pFrameWnd->GetClientWindow()), GWL_EXSTYLE);
1059 DWORD dwThisStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1060 DWORD dwNewStyle = dwStyle;
1061 if (pChild != NULL && (dwThisStyle & WS_MAXIMIZE))
1062 dwNewStyle &= ~(WS_EX_CLIENTEDGE);
1063 else
1064 dwNewStyle |= WS_EX_CLIENTEDGE;
1065
1066 if (dwStyle != dwNewStyle)
1067 {
1068 HWND hwnd = GetWinHwnd(pFrameWnd->GetClientWindow());
1069 ::RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN);
1070 ::SetWindowLong(hwnd, GWL_EXSTYLE, dwNewStyle);
1071 ::SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
1072 SWP_FRAMECHANGED | SWP_NOACTIVATE |
1073 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
1074 SWP_NOCOPYBITS);
1075 if (rect)
1076 ::GetClientRect(hwnd, rect);
1077
1078 return TRUE;
1079 }
1080 }
1081 #endif // Win95
1082
1083 return FALSE;
1084 }
1085
1086 // ===========================================================================
1087 // wxMDIClientWindow: the window of predefined (by Windows) class which
1088 // contains the child frames
1089 // ===========================================================================
1090
1091 bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
1092 {
1093 m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE);
1094
1095 CLIENTCREATESTRUCT ccs;
1096 m_windowStyle = style;
1097 m_parent = parent;
1098
1099 ccs.hWindowMenu = (HMENU) 0;
1100 if (parent->GetWindowMenu())
1101 ccs.hWindowMenu = (HMENU) parent->GetWindowMenu()->GetHMenu();
1102 ccs.idFirstChild = wxFIRST_MDI_CHILD;
1103
1104 DWORD msStyle = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN;
1105 if ( style & wxHSCROLL )
1106 msStyle |= WS_HSCROLL;
1107 if ( style & wxVSCROLL )
1108 msStyle |= WS_VSCROLL;
1109
1110 #if defined(__WIN95__)
1111 DWORD exStyle = WS_EX_CLIENTEDGE;
1112 #else
1113 DWORD exStyle = 0;
1114 #endif
1115
1116 wxWndHook = this;
1117 m_hWnd = (WXHWND)::CreateWindowEx
1118 (
1119 exStyle,
1120 wxT("MDICLIENT"),
1121 NULL,
1122 msStyle,
1123 0, 0, 0, 0,
1124 GetWinHwnd(parent),
1125 NULL,
1126 wxGetInstance(),
1127 (LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
1128 if ( !m_hWnd )
1129 {
1130 wxLogLastError("CreateWindowEx(MDI client)");
1131
1132 return FALSE;
1133 }
1134
1135 SubclassWin(m_hWnd);
1136 wxWndHook = NULL;
1137
1138 return TRUE;
1139 }
1140
1141 // Explicitly call default scroll behaviour
1142 void wxMDIClientWindow::OnScroll(wxScrollEvent& event)
1143 {
1144 // Note: for client windows, the scroll position is not set in
1145 // WM_HSCROLL, WM_VSCROLL, so we can't easily determine what
1146 // scroll position we're at.
1147 // This makes it hard to paint patterns or bitmaps in the background,
1148 // and have the client area scrollable as well.
1149
1150 if ( event.GetOrientation() == wxHORIZONTAL )
1151 m_scrollX = event.GetPosition(); // Always returns zero!
1152 else
1153 m_scrollY = event.GetPosition(); // Always returns zero!
1154
1155 event.Skip();
1156 }
1157
1158 void wxMDIClientWindow::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1159 {
1160 // Try to fix a problem whereby if you show an MDI child frame, then reposition the
1161 // client area, you can end up with a non-refreshed portion in the client window
1162 // (see OGL studio sample). So check if the position is changed and if so,
1163 // redraw the MDI child frames.
1164
1165 wxPoint oldPos = GetPosition();
1166
1167 wxWindow::DoSetSize(x, y, width, height, sizeFlags);
1168
1169 wxPoint newPos = GetPosition();
1170
1171 if ((newPos.x != oldPos.x) || (newPos.y != oldPos.y))
1172 {
1173 if (GetParent())
1174 {
1175 wxNode* node = GetParent()->GetChildren().First();
1176 while (node)
1177 {
1178 wxWindow* child = (wxWindow*) node->Data();
1179 if (child->IsKindOf(CLASSINFO(wxMDIChildFrame)))
1180 {
1181 HWND hWnd = (HWND) child->GetHWND();
1182 ::RedrawWindow(hWnd, NULL, NULL, RDW_FRAME|RDW_ALLCHILDREN|RDW_INVALIDATE );
1183 }
1184 node = node->Next();
1185 }
1186 }
1187 }
1188 }
1189
1190 // ---------------------------------------------------------------------------
1191 // non member functions
1192 // ---------------------------------------------------------------------------
1193
1194 static void MDISetMenu(wxWindow *win, HMENU hmenuFrame, HMENU hmenuWindow)
1195 {
1196 ::SendMessage(GetWinHwnd(win), WM_MDISETMENU,
1197 #ifdef __WIN32__
1198 (WPARAM)hmenuFrame, (LPARAM)hmenuWindow);
1199 #else
1200 0, MAKELPARAM(hmenuFrame, hmenuWindow));
1201 #endif
1202
1203 // update menu bar of the parent window
1204 wxWindow *parent = win->GetParent();
1205 wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") );
1206
1207 ::DrawMenuBar(GetWinHwnd(parent));
1208 }
1209
1210 static void InsertWindowMenu(wxWindow *win, WXHMENU menu, HMENU subMenu)
1211 {
1212 // Try to insert Window menu in front of Help, otherwise append it.
1213 HMENU hmenu = (HMENU)menu;
1214
1215 if (subMenu)
1216 {
1217 int N = GetMenuItemCount(hmenu);
1218 bool success = FALSE;
1219 for ( int i = 0; i < N; i++ )
1220 {
1221 wxChar buf[256];
1222 int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
1223 if ( chars == 0 )
1224 {
1225 wxLogLastError(wxT("GetMenuString"));
1226
1227 continue;
1228 }
1229
1230 if ( wxStripMenuCodes(wxString(buf)).IsSameAs(wxT("Help")) )
1231 {
1232 success = TRUE;
1233 ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING,
1234 (UINT)subMenu, wxT("&Window"));
1235 break;
1236 }
1237 }
1238
1239 if ( !success )
1240 {
1241 ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, wxT("&Window"));
1242 }
1243 }
1244
1245 MDISetMenu(win, hmenu, subMenu);
1246 }
1247
1248 static void RemoveWindowMenu(wxWindow *win, WXHMENU menu)
1249 {
1250 // Try to insert Window menu in front of Help, otherwise append it.
1251 HMENU hmenu = (HMENU)menu;
1252 int N = GetMenuItemCount(hmenu);
1253 bool success = FALSE;
1254 for ( int i = 0; i < N; i++ )
1255 {
1256 wxChar buf[256];
1257 int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION);
1258 if ( chars == 0 )
1259 {
1260 wxLogLastError(wxT("GetMenuString"));
1261
1262 continue;
1263 }
1264
1265 if ( wxStripMenuCodes(wxString(buf)).IsSameAs(wxT("Window")) )
1266 {
1267 success = TRUE;
1268 ::RemoveMenu(hmenu, i, MF_BYPOSITION);
1269 break;
1270 }
1271 }
1272
1273 // Does passing 0 for the window menu really work with WM_MDISETMENU?
1274 MDISetMenu(win, hmenu, 0);
1275 }
1276
1277 static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam,
1278 WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact)
1279 {
1280 #ifdef __WIN32__
1281 *activate = TRUE;
1282 *hwndAct = (WXHWND)lParam;
1283 *hwndDeact = (WXHWND)wParam;
1284 #else // Win16
1285 *activate = (WXWORD)wParam;
1286 *hwndAct = (WXHWND)LOWORD(lParam);
1287 *hwndDeact = (WXHWND)HIWORD(lParam);
1288 #endif // Win32/Win16
1289 }