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