Commit | Line | Data |
---|---|---|
2bda0e17 | 1 | ///////////////////////////////////////////////////////////////////////////// |
a967ef9d VZ |
2 | // Name: src/msw/mdi.cpp |
3 | // Purpose: MDI classes for wxMSW | |
2bda0e17 KB |
4 | // Author: Julian Smart |
5 | // Modified by: | |
6 | // Created: 04/01/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart and Markus Holzem | |
c2dcfdef | 9 | // Licence: wxWindows license |
2bda0e17 KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
a23fd0e1 VZ |
12 | // =========================================================================== |
13 | // declarations | |
14 | // =========================================================================== | |
15 | ||
16 | // --------------------------------------------------------------------------- | |
17 | // headers | |
18 | // --------------------------------------------------------------------------- | |
19 | ||
2bda0e17 | 20 | #ifdef __GNUG__ |
a23fd0e1 | 21 | #pragma implementation "mdi.h" |
2bda0e17 KB |
22 | #endif |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
a23fd0e1 | 28 | #pragma hdrstop |
2bda0e17 KB |
29 | #endif |
30 | ||
31 | #ifndef WX_PRECOMP | |
a23fd0e1 VZ |
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" | |
7c0ea335 VZ |
38 | #if wxUSE_STATUSBAR |
39 | #include "wx/statusbr.h" | |
40 | #endif | |
a23fd0e1 | 41 | #include "wx/settings.h" |
0c589ad0 BM |
42 | #include "wx/intl.h" |
43 | #include "wx/log.h" | |
2bda0e17 KB |
44 | #endif |
45 | ||
46 | #include "wx/mdi.h" | |
47 | #include "wx/msw/private.h" | |
48 | ||
7c0ea335 | 49 | #if wxUSE_STATUSBAR && wxUSE_NATIVE_STATUSBAR |
3096bd2f | 50 | #include "wx/msw/statbr95.h" |
2bda0e17 KB |
51 | #endif |
52 | ||
7c0ea335 VZ |
53 | #if wxUSE_TOOLBAR |
54 | #include "wx/toolbar.h" | |
55 | #endif // wxUSE_TOOLBAR | |
56 | ||
2bda0e17 KB |
57 | #include <string.h> |
58 | ||
a23fd0e1 VZ |
59 | // --------------------------------------------------------------------------- |
60 | // global variables | |
61 | // --------------------------------------------------------------------------- | |
62 | ||
63 | extern wxWindowList wxModelessWindows; // from dialog.cpp | |
e1a6fc11 | 64 | extern wxMenu *wxCurrentPopupMenu; |
2bda0e17 | 65 | |
3ca6a5f0 | 66 | extern const wxChar *wxMDIFrameClassName; // from app.cpp |
2ffa221c | 67 | extern const wxChar *wxMDIChildFrameClassName; |
3ca6a5f0 BP |
68 | extern const wxChar *wxMDIChildFrameClassNameNoRedraw; |
69 | ||
a23fd0e1 VZ |
70 | extern wxWindow *wxWndHook; // from window.cpp |
71 | ||
c7527e3f | 72 | extern void wxAssociateWinWithHandle(HWND hWnd, wxWindow *win); |
ac6482e0 | 73 | extern void wxRemoveHandleAssociation(wxWindow *win); |
a23fd0e1 | 74 | |
42e69d6b VZ |
75 | static HWND invalidHandle = 0; |
76 | ||
a23fd0e1 VZ |
77 | // --------------------------------------------------------------------------- |
78 | // constants | |
79 | // --------------------------------------------------------------------------- | |
80 | ||
81 | static const int IDM_WINDOWTILE = 4001; | |
42e69d6b | 82 | static const int IDM_WINDOWTILEHOR = 4001; |
a23fd0e1 VZ |
83 | static const int IDM_WINDOWCASCADE = 4002; |
84 | static const int IDM_WINDOWICONS = 4003; | |
85 | static const int IDM_WINDOWNEXT = 4004; | |
42e69d6b | 86 | static const int IDM_WINDOWTILEVERT = 4005; |
a23fd0e1 VZ |
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; | |
2bda0e17 KB |
91 | |
92 | // Status border dimensions | |
a23fd0e1 VZ |
93 | static const int wxTHICK_LINE_BORDER = 3; |
94 | static const int wxTHICK_LINE_WIDTH = 1; | |
2bda0e17 | 95 | |
42e69d6b VZ |
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 | ||
df61c009 JS |
108 | // Remove the window menu |
109 | static void RemoveWindowMenu(wxWindow *win, WXHMENU menu); | |
110 | ||
42e69d6b VZ |
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 | ||
2917e920 BM |
117 | static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, |
118 | WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact); | |
42e69d6b | 119 | |
a23fd0e1 VZ |
120 | // =========================================================================== |
121 | // implementation | |
122 | // =========================================================================== | |
123 | ||
124 | // --------------------------------------------------------------------------- | |
125 | // wxWin macros | |
126 | // --------------------------------------------------------------------------- | |
2bda0e17 | 127 | |
225fe9d6 VZ |
128 | IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame) |
129 | IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame) | |
130 | IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow) | |
2bda0e17 KB |
131 | |
132 | BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame) | |
a23fd0e1 | 133 | EVT_SIZE(wxMDIParentFrame::OnSize) |
a23fd0e1 | 134 | EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged) |
2bda0e17 KB |
135 | END_EVENT_TABLE() |
136 | ||
f6bcfd97 BP |
137 | BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame) |
138 | EVT_IDLE(wxMDIChildFrame::OnIdle) | |
139 | END_EVENT_TABLE() | |
140 | ||
2bda0e17 | 141 | BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow) |
a23fd0e1 | 142 | EVT_SCROLL(wxMDIClientWindow::OnScroll) |
2bda0e17 KB |
143 | END_EVENT_TABLE() |
144 | ||
42e69d6b VZ |
145 | // =========================================================================== |
146 | // wxMDIParentFrame: the frame which contains the client window which manages | |
147 | // the children | |
148 | // =========================================================================== | |
2bda0e17 | 149 | |
c2dcfdef | 150 | wxMDIParentFrame::wxMDIParentFrame() |
2bda0e17 KB |
151 | { |
152 | m_clientWindow = NULL; | |
153 | m_currentChild = NULL; | |
df61c009 | 154 | m_windowMenu = (wxMenu*) NULL; |
2bda0e17 | 155 | m_parentFrameActive = TRUE; |
2bda0e17 KB |
156 | } |
157 | ||
158 | bool wxMDIParentFrame::Create(wxWindow *parent, | |
a23fd0e1 VZ |
159 | wxWindowID id, |
160 | const wxString& title, | |
161 | const wxPoint& pos, | |
162 | const wxSize& size, | |
163 | long style, | |
164 | const wxString& name) | |
2bda0e17 | 165 | { |
3d8dea7e VZ |
166 | m_defaultIcon = (WXHICON) (wxSTD_MDIPARENTFRAME_ICON |
167 | ? wxSTD_MDIPARENTFRAME_ICON | |
168 | : wxDEFAULT_MDIPARENTFRAME_ICON); | |
2bda0e17 | 169 | |
2bda0e17 KB |
170 | m_clientWindow = NULL; |
171 | m_currentChild = NULL; | |
df61c009 | 172 | |
3d8dea7e VZ |
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 | |
df61c009 | 180 | { |
df61c009 JS |
181 | m_windowMenu = new wxMenu; |
182 | ||
b0a2157c VZ |
183 | m_windowMenu->Append(IDM_WINDOWCASCADE, _("&Cascade")); |
184 | m_windowMenu->Append(IDM_WINDOWTILEHOR, _("Tile &Horizontally")); | |
185 | m_windowMenu->Append(IDM_WINDOWTILEVERT, _("Tile &Vertically")); | |
df61c009 | 186 | m_windowMenu->AppendSeparator(); |
b0a2157c VZ |
187 | m_windowMenu->Append(IDM_WINDOWICONS, _("&Arrange Icons")); |
188 | m_windowMenu->Append(IDM_WINDOWNEXT, _("&Next")); | |
df61c009 JS |
189 | } |
190 | ||
2bda0e17 KB |
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 | ||
42e69d6b | 211 | DWORD msflags = WS_OVERLAPPED; |
2bda0e17 KB |
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; | |
46851318 | 226 | |
0655ad29 VZ |
227 | if (style & wxCLIP_CHILDREN) |
228 | msflags |= WS_CLIPCHILDREN; | |
2bda0e17 | 229 | |
3ca6a5f0 BP |
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 | } | |
2bda0e17 KB |
240 | |
241 | wxModelessWindows.Append(this); | |
242 | ||
f6bcfd97 BP |
243 | // unlike (almost?) all other windows, frames are created hidden |
244 | m_isShown = FALSE; | |
245 | ||
2bda0e17 KB |
246 | return TRUE; |
247 | } | |
248 | ||
c2dcfdef | 249 | wxMDIParentFrame::~wxMDIParentFrame() |
2bda0e17 | 250 | { |
42e69d6b | 251 | DestroyChildren(); |
f048e32f VZ |
252 | // already delete by DestroyChildren() |
253 | m_frameToolBar = NULL; | |
c0bcc480 | 254 | m_frameStatusBar = NULL; |
f048e32f | 255 | |
df61c009 JS |
256 | // ::DestroyMenu((HMENU)m_windowMenu); |
257 | if (m_windowMenu) | |
258 | { | |
259 | delete m_windowMenu; | |
260 | m_windowMenu = (wxMenu*) NULL; | |
261 | } | |
2bda0e17 | 262 | |
42e69d6b VZ |
263 | if ( m_clientWindow ) |
264 | { | |
265 | if ( m_clientWindow->MSWGetOldWndProc() ) | |
266 | m_clientWindow->UnsubclassWin(); | |
2bda0e17 | 267 | |
42e69d6b VZ |
268 | m_clientWindow->SetHWND(0); |
269 | delete m_clientWindow; | |
270 | } | |
2bda0e17 KB |
271 | } |
272 | ||
1e6feb95 VZ |
273 | #if wxUSE_MENUS_NATIVE |
274 | ||
42e69d6b | 275 | void wxMDIParentFrame::InternalSetMenuBar() |
2bda0e17 | 276 | { |
42e69d6b | 277 | m_parentFrameActive = TRUE; |
2bda0e17 | 278 | |
1e6feb95 VZ |
279 | wxMenu *menu = GetWindowMenu(); |
280 | HMENU subMenu = menu ? GetHmenuOf(menu) : 0; | |
df61c009 | 281 | |
42e69d6b | 282 | InsertWindowMenu(GetClientWindow(), m_hMenu, subMenu); |
2bda0e17 KB |
283 | } |
284 | ||
1e6feb95 VZ |
285 | #endif // wxUSE_MENUS_NATIVE |
286 | ||
df61c009 JS |
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()) | |
b0a2157c VZ |
304 | { |
305 | InsertWindowMenu(GetClientWindow(), m_hMenu, | |
88c49a0f | 306 | GetHmenuOf(m_windowMenu)); |
b0a2157c | 307 | } |
df61c009 JS |
308 | } |
309 | } | |
310 | ||
a967ef9d | 311 | void wxMDIParentFrame::OnSize(wxSizeEvent&) |
2bda0e17 | 312 | { |
2bda0e17 | 313 | if ( GetClientWindow() ) |
42e69d6b VZ |
314 | { |
315 | int width, height; | |
316 | GetClientSize(&width, &height); | |
2bda0e17 | 317 | |
42e69d6b VZ |
318 | GetClientWindow()->SetSize(0, 0, width, height); |
319 | } | |
2bda0e17 KB |
320 | } |
321 | ||
2bda0e17 | 322 | // Returns the active MDI child window |
c2dcfdef | 323 | wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const |
2bda0e17 | 324 | { |
a23fd0e1 VZ |
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); | |
2bda0e17 KB |
331 | } |
332 | ||
a23fd0e1 VZ |
333 | // Create the client window class (don't Create the window, just return a new |
334 | // class) | |
c2dcfdef | 335 | wxMDIClientWindow *wxMDIParentFrame::OnCreateClient() |
2bda0e17 | 336 | { |
a23fd0e1 | 337 | return new wxMDIClientWindow; |
2bda0e17 KB |
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 | } | |
2bda0e17 | 348 | |
42e69d6b | 349 | event.Skip(); |
2bda0e17 KB |
350 | } |
351 | ||
42e69d6b | 352 | // --------------------------------------------------------------------------- |
2bda0e17 | 353 | // MDI operations |
42e69d6b VZ |
354 | // --------------------------------------------------------------------------- |
355 | ||
c2dcfdef | 356 | void wxMDIParentFrame::Cascade() |
2bda0e17 | 357 | { |
a23fd0e1 | 358 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDICASCADE, 0, 0); |
2bda0e17 KB |
359 | } |
360 | ||
42e69d6b | 361 | // TODO: add a direction argument (hor/vert) |
c2dcfdef | 362 | void wxMDIParentFrame::Tile() |
2bda0e17 | 363 | { |
a23fd0e1 | 364 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDITILE, MDITILE_HORIZONTAL, 0); |
2bda0e17 KB |
365 | } |
366 | ||
c2dcfdef | 367 | void wxMDIParentFrame::ArrangeIcons() |
2bda0e17 | 368 | { |
a23fd0e1 | 369 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDIICONARRANGE, 0, 0); |
2bda0e17 KB |
370 | } |
371 | ||
c2dcfdef | 372 | void wxMDIParentFrame::ActivateNext() |
2bda0e17 | 373 | { |
a23fd0e1 | 374 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 0); |
2bda0e17 KB |
375 | } |
376 | ||
c2dcfdef | 377 | void wxMDIParentFrame::ActivatePrevious() |
2bda0e17 | 378 | { |
a23fd0e1 | 379 | ::SendMessage(GetWinHwnd(GetClientWindow()), WM_MDINEXT, 0, 1); |
2bda0e17 KB |
380 | } |
381 | ||
42e69d6b | 382 | // --------------------------------------------------------------------------- |
a23fd0e1 | 383 | // the MDI parent frame window proc |
42e69d6b VZ |
384 | // --------------------------------------------------------------------------- |
385 | ||
a23fd0e1 VZ |
386 | long wxMDIParentFrame::MSWWindowProc(WXUINT message, |
387 | WXWPARAM wParam, | |
388 | WXLPARAM lParam) | |
2bda0e17 | 389 | { |
a23fd0e1 VZ |
390 | long rc = 0; |
391 | bool processed = FALSE; | |
2bda0e17 | 392 | |
a23fd0e1 VZ |
393 | switch ( message ) |
394 | { | |
42e69d6b VZ |
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 | } | |
b3818fbe VZ |
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); | |
42e69d6b VZ |
422 | break; |
423 | ||
a23fd0e1 VZ |
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.")); | |
2bda0e17 | 430 | |
a23fd0e1 VZ |
431 | rc = -1; |
432 | } | |
2bda0e17 | 433 | |
a23fd0e1 VZ |
434 | processed = TRUE; |
435 | break; | |
2bda0e17 | 436 | |
a23fd0e1 VZ |
437 | case WM_ERASEBKGND: |
438 | processed = TRUE; | |
2bda0e17 | 439 | |
a23fd0e1 VZ |
440 | // we erase background ourselves |
441 | rc = TRUE; | |
442 | break; | |
443 | ||
444 | case WM_MENUSELECT: | |
445 | { | |
42e69d6b VZ |
446 | WXWORD item, flags; |
447 | WXHMENU hmenu; | |
448 | UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu); | |
449 | ||
a23fd0e1 VZ |
450 | if ( m_parentFrameActive ) |
451 | { | |
42e69d6b | 452 | processed = HandleMenuSelect(item, flags, hmenu); |
a23fd0e1 VZ |
453 | } |
454 | else if (m_currentChild) | |
455 | { | |
456 | processed = m_currentChild-> | |
42e69d6b | 457 | HandleMenuSelect(item, flags, hmenu); |
a23fd0e1 VZ |
458 | } |
459 | } | |
460 | break; | |
b3818fbe VZ |
461 | |
462 | case WM_SIZE: | |
0655ad29 VZ |
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 | |
b3818fbe | 466 | break; |
a23fd0e1 | 467 | } |
2bda0e17 | 468 | |
a23fd0e1 VZ |
469 | if ( !processed ) |
470 | rc = wxFrame::MSWWindowProc(message, wParam, lParam); | |
2bda0e17 | 471 | |
a23fd0e1 | 472 | return rc; |
2bda0e17 KB |
473 | } |
474 | ||
42e69d6b | 475 | bool wxMDIParentFrame::HandleActivate(int state, bool minimized, WXHWND activate) |
2bda0e17 | 476 | { |
a23fd0e1 VZ |
477 | bool processed = FALSE; |
478 | ||
42e69d6b | 479 | if ( wxWindow::HandleActivate(state, minimized, activate) ) |
a23fd0e1 VZ |
480 | { |
481 | // already processed | |
482 | processed = TRUE; | |
483 | } | |
2bda0e17 KB |
484 | |
485 | // If this window is an MDI parent, we must also send an OnActivate message | |
486 | // to the current child. | |
42e69d6b | 487 | if ( (m_currentChild != NULL) && |
a23fd0e1 | 488 | ((state == WA_ACTIVE) || (state == WA_CLICKACTIVE)) ) |
c2dcfdef | 489 | { |
debe6624 JS |
490 | wxActivateEvent event(wxEVT_ACTIVATE, TRUE, m_currentChild->GetId()); |
491 | event.SetEventObject( m_currentChild ); | |
a23fd0e1 VZ |
492 | if ( m_currentChild->GetEventHandler()->ProcessEvent(event) ) |
493 | processed = TRUE; | |
2bda0e17 | 494 | } |
a23fd0e1 VZ |
495 | |
496 | return processed; | |
2bda0e17 KB |
497 | } |
498 | ||
42e69d6b | 499 | bool wxMDIParentFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd) |
2bda0e17 | 500 | { |
2bda0e17 | 501 | // In case it's e.g. a toolbar. |
42e69d6b | 502 | if ( hwnd ) |
e1a6fc11 | 503 | { |
42e69d6b VZ |
504 | wxWindow *win = wxFindWinFromHandle(hwnd); |
505 | if ( win ) | |
506 | return win->MSWCommand(cmd, id); | |
e1a6fc11 JS |
507 | } |
508 | ||
42e69d6b VZ |
509 | // is it one of standard MDI commands? |
510 | WXWPARAM wParam = 0; | |
511 | int msg; | |
512 | switch ( id ) | |
2bda0e17 | 513 | { |
42e69d6b VZ |
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; | |
2bda0e17 | 540 | } |
c2dcfdef | 541 | |
42e69d6b | 542 | if ( msg ) |
2bda0e17 | 543 | { |
42e69d6b VZ |
544 | ::SendMessage(GetWinHwnd(GetClientWindow()), msg, wParam, 0); |
545 | ||
546 | return TRUE; | |
2bda0e17 | 547 | } |
42e69d6b VZ |
548 | |
549 | // FIXME VZ: what does this test do?? | |
550 | if (id >= 0xF000) | |
2bda0e17 | 551 | { |
42e69d6b | 552 | return FALSE; // Get WndProc to call default proc |
2bda0e17 | 553 | } |
42e69d6b VZ |
554 | |
555 | if ( IsMdiCommandId(id) ) | |
2bda0e17 | 556 | { |
42e69d6b VZ |
557 | wxWindowList::Node* node = GetChildren().GetFirst(); |
558 | while ( node ) | |
2bda0e17 | 559 | { |
42e69d6b VZ |
560 | wxWindow* child = node->GetData(); |
561 | if ( child->GetHWND() ) | |
2bda0e17 | 562 | { |
42e69d6b | 563 | long childId = wxGetWindowId(child->GetHWND()); |
48c12cb1 | 564 | if (childId == (long)id) |
42e69d6b VZ |
565 | { |
566 | ::SendMessage( GetWinHwnd(GetClientWindow()), | |
567 | WM_MDIACTIVATE, | |
568 | (WPARAM)child->GetHWND(), 0); | |
569 | return TRUE; | |
570 | } | |
2bda0e17 | 571 | } |
42e69d6b | 572 | node = node->GetNext(); |
2bda0e17 | 573 | } |
2bda0e17 | 574 | } |
42e69d6b | 575 | else if ( m_parentFrameActive ) |
2bda0e17 | 576 | { |
42e69d6b VZ |
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) | |
f6bcfd97 | 587 | wxFAIL_MSG(wxT("MDI parent frame is not active, yet there is no active MDI child?")); |
2bda0e17 | 588 | } |
2bda0e17 | 589 | |
42e69d6b | 590 | return FALSE; |
2bda0e17 KB |
591 | } |
592 | ||
42e69d6b VZ |
593 | long wxMDIParentFrame::MSWDefWindowProc(WXUINT message, |
594 | WXWPARAM wParam, | |
595 | WXLPARAM lParam) | |
2bda0e17 | 596 | { |
c2dcfdef VZ |
597 | WXHWND clientWnd; |
598 | if ( GetClientWindow() ) | |
599 | clientWnd = GetClientWindow()->GetHWND(); | |
600 | else | |
601 | clientWnd = 0; | |
2bda0e17 | 602 | |
a23fd0e1 | 603 | return DefFrameProc(GetHwnd(), (HWND)clientWnd, message, wParam, lParam); |
2bda0e17 KB |
604 | } |
605 | ||
57a7b7c1 JS |
606 | bool wxMDIParentFrame::MSWTranslateMessage(WXMSG* msg) |
607 | { | |
a23fd0e1 | 608 | MSG *pMsg = (MSG *)msg; |
2bda0e17 | 609 | |
f6bcfd97 | 610 | // first let the current child get it |
a23fd0e1 VZ |
611 | if ( m_currentChild && m_currentChild->GetHWND() && |
612 | m_currentChild->MSWTranslateMessage(msg) ) | |
613 | { | |
614 | return TRUE; | |
615 | } | |
2bda0e17 | 616 | |
f6bcfd97 BP |
617 | // then try out accel table (will also check the menu accels) |
618 | if ( wxFrame::MSWTranslateMessage(msg) ) | |
a23fd0e1 VZ |
619 | { |
620 | return TRUE; | |
621 | } | |
2bda0e17 | 622 | |
f6bcfd97 | 623 | // finally, check for MDI specific built in accel keys |
a23fd0e1 VZ |
624 | if ( pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN ) |
625 | { | |
626 | if ( ::TranslateMDISysAccel(GetWinHwnd(GetClientWindow()), pMsg)) | |
627 | return TRUE; | |
628 | } | |
57a7b7c1 | 629 | |
a23fd0e1 | 630 | return FALSE; |
2bda0e17 KB |
631 | } |
632 | ||
42e69d6b | 633 | // =========================================================================== |
a23fd0e1 | 634 | // wxMDIChildFrame |
42e69d6b | 635 | // =========================================================================== |
2bda0e17 | 636 | |
f6bcfd97 | 637 | void wxMDIChildFrame::Init() |
2bda0e17 | 638 | { |
f6bcfd97 | 639 | m_needsResize = TRUE; |
2bda0e17 KB |
640 | } |
641 | ||
642 | bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, | |
a23fd0e1 VZ |
643 | wxWindowID id, |
644 | const wxString& title, | |
645 | const wxPoint& pos, | |
646 | const wxSize& size, | |
647 | long style, | |
648 | const wxString& name) | |
2bda0e17 | 649 | { |
42e69d6b VZ |
650 | m_defaultIcon = (WXHICON)(wxSTD_MDICHILDFRAME_ICON ? wxSTD_MDICHILDFRAME_ICON |
651 | : wxDEFAULT_MDICHILDFRAME_ICON); | |
2bda0e17 KB |
652 | |
653 | SetName(name); | |
e949bf13 | 654 | wxWindowBase::Show(TRUE); // MDI child frame starts off shown |
2bda0e17 KB |
655 | |
656 | if ( id > -1 ) | |
657 | m_windowId = id; | |
658 | else | |
659 | m_windowId = (int)NewControlId(); | |
660 | ||
42e69d6b VZ |
661 | if ( parent ) |
662 | { | |
663 | parent->AddChild(this); | |
664 | } | |
2bda0e17 KB |
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; | |
c2dcfdef | 674 | |
3ca6a5f0 BP |
675 | mcs.szClass = style & wxNO_FULL_REPAINT_ON_RESIZE |
676 | ? wxMDIChildFrameClassNameNoRedraw | |
677 | : wxMDIChildFrameClassName; | |
2bda0e17 KB |
678 | mcs.szTitle = title; |
679 | mcs.hOwner = wxGetInstance(); | |
42e69d6b VZ |
680 | if (x > -1) |
681 | mcs.x = x; | |
682 | else | |
683 | mcs.x = CW_USEDEFAULT; | |
2bda0e17 | 684 | |
42e69d6b VZ |
685 | if (y > -1) |
686 | mcs.y = y; | |
687 | else | |
688 | mcs.y = CW_USEDEFAULT; | |
2bda0e17 | 689 | |
42e69d6b VZ |
690 | if (width > -1) |
691 | mcs.cx = width; | |
692 | else | |
693 | mcs.cx = CW_USEDEFAULT; | |
2bda0e17 | 694 | |
42e69d6b VZ |
695 | if (height > -1) |
696 | mcs.cy = height; | |
697 | else | |
698 | mcs.cy = CW_USEDEFAULT; | |
2bda0e17 | 699 | |
5c44cd05 | 700 | DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN | WS_THICKFRAME | WS_VISIBLE ; |
2bda0e17 KB |
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 | ||
3ca6a5f0 BP |
720 | m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()), |
721 | WM_MDICREATE, 0, (LONG)(LPSTR)&mcs); | |
2bda0e17 | 722 | |
2bda0e17 | 723 | wxWndHook = NULL; |
c7527e3f | 724 | wxAssociateWinWithHandle((HWND) GetHWND(), this); |
2bda0e17 | 725 | |
b3818fbe VZ |
726 | // VZ: what's this? an act of piracy? |
727 | //SetWindowLong(GetHwnd(), 0, (long)this); | |
2bda0e17 KB |
728 | |
729 | wxModelessWindows.Append(this); | |
921a43c1 | 730 | |
2bda0e17 KB |
731 | return TRUE; |
732 | } | |
733 | ||
c2dcfdef | 734 | wxMDIChildFrame::~wxMDIChildFrame() |
2bda0e17 | 735 | { |
627a3091 JS |
736 | DestroyChildren(); |
737 | ||
738 | // already delete by DestroyChildren() | |
739 | m_frameToolBar = NULL; | |
740 | m_frameStatusBar = NULL; | |
741 | ||
c2dcfdef | 742 | MSWDestroyWindow(); |
2bda0e17 KB |
743 | } |
744 | ||
745 | // Set the client size (i.e. leave the calculation of borders etc. | |
746 | // to wxWindows) | |
cc2b7472 | 747 | void wxMDIChildFrame::DoSetClientSize(int width, int height) |
2bda0e17 | 748 | { |
b3818fbe | 749 | HWND hWnd = GetHwnd(); |
2bda0e17 KB |
750 | |
751 | RECT rect; | |
2de8030d | 752 | ::GetClientRect(hWnd, &rect); |
2bda0e17 KB |
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 | ||
a2327a9f | 763 | if (GetStatusBar() && GetStatusBar()->IsShown()) |
2bda0e17 | 764 | { |
c2dcfdef VZ |
765 | int sx, sy; |
766 | GetStatusBar()->GetSize(&sx, &sy); | |
2bda0e17 KB |
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); | |
debe6624 | 780 | |
2bda0e17 | 781 | wxSizeEvent event(wxSize(width, height), m_windowId); |
debe6624 | 782 | event.SetEventObject( this ); |
2bda0e17 | 783 | GetEventHandler()->ProcessEvent(event); |
2bda0e17 KB |
784 | } |
785 | ||
cc2b7472 | 786 | void wxMDIChildFrame::DoGetPosition(int *x, int *y) const |
2bda0e17 KB |
787 | { |
788 | RECT rect; | |
b3818fbe | 789 | GetWindowRect(GetHwnd(), &rect); |
2bda0e17 KB |
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 | ||
42e69d6b | 803 | void wxMDIChildFrame::InternalSetMenuBar() |
2bda0e17 | 804 | { |
42e69d6b | 805 | wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); |
2bda0e17 | 806 | |
df61c009 JS |
807 | // HMENU subMenu = GetSubMenu((HMENU)parent->GetWindowMenu(), 0); |
808 | HMENU subMenu = (HMENU) 0; | |
809 | if (parent->GetWindowMenu()) | |
810 | subMenu = (HMENU) parent->GetWindowMenu()->GetHMenu(); | |
2bda0e17 | 811 | |
42e69d6b | 812 | InsertWindowMenu(parent->GetClientWindow(), m_hMenu, subMenu); |
2bda0e17 | 813 | |
42e69d6b | 814 | parent->m_parentFrameActive = FALSE; |
2bda0e17 KB |
815 | } |
816 | ||
42e69d6b | 817 | // --------------------------------------------------------------------------- |
2bda0e17 | 818 | // MDI operations |
42e69d6b VZ |
819 | // --------------------------------------------------------------------------- |
820 | ||
9b73db3c | 821 | void wxMDIChildFrame::Maximize(bool maximize) |
2bda0e17 KB |
822 | { |
823 | wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); | |
824 | if ( parent && parent->GetClientWindow() ) | |
9b73db3c VZ |
825 | { |
826 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), | |
827 | maximize ? WM_MDIMAXIMIZE : WM_MDIRESTORE, | |
828 | (WPARAM)GetHwnd(), 0); | |
829 | } | |
2bda0e17 KB |
830 | } |
831 | ||
c2dcfdef | 832 | void wxMDIChildFrame::Restore() |
2bda0e17 KB |
833 | { |
834 | wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); | |
835 | if ( parent && parent->GetClientWindow() ) | |
9b73db3c VZ |
836 | { |
837 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIRESTORE, | |
838 | (WPARAM) GetHwnd(), 0); | |
839 | } | |
2bda0e17 KB |
840 | } |
841 | ||
c2dcfdef | 842 | void wxMDIChildFrame::Activate() |
2bda0e17 KB |
843 | { |
844 | wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); | |
845 | if ( parent && parent->GetClientWindow() ) | |
9b73db3c VZ |
846 | { |
847 | ::SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIACTIVATE, | |
848 | (WPARAM) GetHwnd(), 0); | |
849 | } | |
2bda0e17 KB |
850 | } |
851 | ||
42e69d6b VZ |
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 | ||
42e69d6b | 876 | case WM_GETMINMAXINFO: |
3ebcfb76 VZ |
877 | processed = HandleGetMinMaxInfo((MINMAXINFO *)lParam); |
878 | break; | |
42e69d6b VZ |
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 | } | |
b3818fbe VZ |
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); | |
42e69d6b VZ |
900 | break; |
901 | ||
b3818fbe VZ |
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 | ||
42e69d6b VZ |
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 | ||
42e69d6b | 918 | bool wxMDIChildFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND hwnd) |
2bda0e17 | 919 | { |
2bda0e17 | 920 | // In case it's e.g. a toolbar. |
42e69d6b VZ |
921 | if ( hwnd ) |
922 | { | |
923 | wxWindow *win = wxFindWinFromHandle(hwnd); | |
924 | if (win) | |
925 | return win->MSWCommand(cmd, id); | |
926 | } | |
2bda0e17 | 927 | |
e1a6fc11 JS |
928 | if (wxCurrentPopupMenu) |
929 | { | |
930 | wxMenu *popupMenu = wxCurrentPopupMenu; | |
931 | wxCurrentPopupMenu = NULL; | |
932 | if (popupMenu->MSWCommand(cmd, id)) | |
933 | return TRUE; | |
934 | } | |
935 | ||
3ca6a5f0 | 936 | bool processed; |
dd60b9ec | 937 | if (GetMenuBar() && GetMenuBar()->FindItem(id)) |
2bda0e17 | 938 | { |
3ca6a5f0 | 939 | processed = ProcessCommand(id); |
2bda0e17 KB |
940 | } |
941 | else | |
3ca6a5f0 BP |
942 | { |
943 | processed = FALSE; | |
944 | } | |
42e69d6b | 945 | |
3ca6a5f0 | 946 | return processed; |
2bda0e17 KB |
947 | } |
948 | ||
42e69d6b VZ |
949 | bool wxMDIChildFrame::HandleMDIActivate(long WXUNUSED(activate), |
950 | WXHWND hwndAct, | |
951 | WXHWND hwndDeact) | |
2bda0e17 | 952 | { |
42e69d6b | 953 | wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); |
2bda0e17 | 954 | |
42e69d6b | 955 | HMENU menuToSet = 0; |
57a7b7c1 | 956 | |
42e69d6b | 957 | bool activated; |
57a7b7c1 | 958 | |
42e69d6b VZ |
959 | if ( m_hWnd == hwndAct ) |
960 | { | |
961 | activated = TRUE; | |
962 | parent->m_currentChild = this; | |
2bda0e17 | 963 | |
42e69d6b VZ |
964 | HMENU child_menu = (HMENU)GetWinMenu(); |
965 | if ( child_menu ) | |
966 | { | |
967 | parent->m_parentFrameActive = FALSE; | |
2bda0e17 | 968 | |
42e69d6b VZ |
969 | menuToSet = child_menu; |
970 | } | |
971 | } | |
972 | else if ( m_hWnd == hwndDeact ) | |
2bda0e17 | 973 | { |
42e69d6b | 974 | wxASSERT_MSG( parent->m_currentChild == this, |
223d09f6 | 975 | wxT("can't deactivate MDI child which wasn't active!") ); |
42e69d6b VZ |
976 | |
977 | activated = FALSE; | |
978 | parent->m_currentChild = NULL; | |
2bda0e17 | 979 | |
42e69d6b | 980 | HMENU parent_menu = (HMENU)parent->GetWinMenu(); |
f4075804 VZ |
981 | |
982 | // activate the the parent menu only when there is no other child | |
983 | // that has been activated | |
984 | if ( parent_menu && !hwndAct ) | |
42e69d6b VZ |
985 | { |
986 | parent->m_parentFrameActive = TRUE; | |
987 | ||
988 | menuToSet = parent_menu; | |
989 | } | |
990 | } | |
991 | else | |
992 | { | |
18d2e170 | 993 | // we have nothing to do with it |
42e69d6b | 994 | return FALSE; |
2bda0e17 | 995 | } |
debe6624 | 996 | |
42e69d6b VZ |
997 | if ( menuToSet ) |
998 | { | |
df61c009 JS |
999 | HMENU subMenu = (HMENU) 0; |
1000 | if (parent->GetWindowMenu()) | |
1001 | subMenu = (HMENU) parent->GetWindowMenu()->GetHMenu(); | |
42e69d6b VZ |
1002 | |
1003 | MDISetMenu(parent->GetClientWindow(), menuToSet, subMenu); | |
1004 | } | |
1005 | ||
1006 | wxActivateEvent event(wxEVT_ACTIVATE, activated, m_windowId); | |
debe6624 | 1007 | event.SetEventObject( this ); |
2bda0e17 | 1008 | |
c03b48d7 GT |
1009 | ResetWindowStyle((void *)NULL); |
1010 | ||
42e69d6b VZ |
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)) | |
2bda0e17 | 1019 | { |
42e69d6b | 1020 | RECT rectClient; |
b3818fbe VZ |
1021 | DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE); |
1022 | DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE); | |
42e69d6b VZ |
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(); | |
a2327a9f | 1032 | if (pFrameWnd && pFrameWnd->GetToolBar() && pFrameWnd->GetToolBar()->IsShown()) |
42e69d6b VZ |
1033 | { |
1034 | pFrameWnd->GetToolBar()->Refresh(); | |
1035 | } | |
1036 | } | |
1037 | #endif // Win95 | |
1038 | ||
1039 | return FALSE; | |
1040 | } | |
1041 | ||
3ebcfb76 VZ |
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 | |
d9f9aa2d | 1049 | bool processed = MSWDefWindowProc(WM_GETMINMAXINFO, 0, (LPARAM)mmInfo) != 0; |
3ebcfb76 VZ |
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 | ||
42e69d6b VZ |
1069 | // --------------------------------------------------------------------------- |
1070 | // MDI specific message translation/preprocessing | |
1071 | // --------------------------------------------------------------------------- | |
2bda0e17 | 1072 | |
42e69d6b VZ |
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 | { | |
5a2762f0 | 1081 | return wxFrame::MSWTranslateMessage(msg); |
2bda0e17 KB |
1082 | } |
1083 | ||
42e69d6b VZ |
1084 | // --------------------------------------------------------------------------- |
1085 | // misc | |
1086 | // --------------------------------------------------------------------------- | |
1087 | ||
c2dcfdef | 1088 | void wxMDIChildFrame::MSWDestroyWindow() |
2bda0e17 | 1089 | { |
42e69d6b | 1090 | MSWDetachWindowMenu(); |
b3818fbe | 1091 | invalidHandle = GetHwnd(); |
2bda0e17 | 1092 | |
42e69d6b | 1093 | wxMDIParentFrame *parent = (wxMDIParentFrame *)GetParent(); |
2bda0e17 | 1094 | |
42e69d6b VZ |
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. | |
2bda0e17 | 1098 | |
42e69d6b | 1099 | HWND oldHandle = (HWND)GetHWND(); |
b3818fbe VZ |
1100 | SendMessage(GetWinHwnd(parent->GetClientWindow()), WM_MDIDESTROY, |
1101 | (WPARAM)oldHandle, 0); | |
18d2e170 JS |
1102 | |
1103 | if (parent->GetActiveChild() == (wxMDIChildFrame*) NULL) | |
1104 | ResetWindowStyle((void*) NULL); | |
1105 | ||
42e69d6b | 1106 | invalidHandle = 0; |
2bda0e17 | 1107 | |
42e69d6b VZ |
1108 | if (m_hMenu) |
1109 | { | |
1110 | ::DestroyMenu((HMENU) m_hMenu); | |
1111 | m_hMenu = 0; | |
1112 | } | |
ac6482e0 | 1113 | wxRemoveHandleAssociation(this); |
42e69d6b | 1114 | m_hWnd = 0; |
2bda0e17 KB |
1115 | } |
1116 | ||
42e69d6b VZ |
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.) | |
2bda0e17 KB |
1119 | bool wxMDIChildFrame::ResetWindowStyle(void *vrect) |
1120 | { | |
1121 | #if defined(__WIN95__) | |
1122 | RECT *rect = (RECT *)vrect; | |
c2dcfdef VZ |
1123 | wxMDIParentFrame* pFrameWnd = (wxMDIParentFrame *)GetParent(); |
1124 | wxMDIChildFrame* pChild = pFrameWnd->GetActiveChild(); | |
1125 | if (!pChild || (pChild == this)) | |
1126 | { | |
47ca6bfb | 1127 | HWND hwndClient = GetWinHwnd(pFrameWnd->GetClientWindow()); |
8082a771 VZ |
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 | |
1f3943e0 | 1133 | ? ::GetWindowLong(GetWinHwnd(pChild), GWL_STYLE) : 0; |
c2dcfdef | 1134 | DWORD dwNewStyle = dwStyle; |
8082a771 | 1135 | if ( dwThisStyle & WS_MAXIMIZE ) |
c2dcfdef VZ |
1136 | dwNewStyle &= ~(WS_EX_CLIENTEDGE); |
1137 | else | |
1138 | dwNewStyle |= WS_EX_CLIENTEDGE; | |
1139 | ||
1140 | if (dwStyle != dwNewStyle) | |
1141 | { | |
47ca6bfb VZ |
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, | |
42e69d6b VZ |
1147 | SWP_FRAMECHANGED | SWP_NOACTIVATE | |
1148 | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | | |
1149 | SWP_NOCOPYBITS); | |
c2dcfdef | 1150 | if (rect) |
47ca6bfb | 1151 | ::GetClientRect(hwndClient, rect); |
2bda0e17 | 1152 | |
42e69d6b | 1153 | return TRUE; |
2bda0e17 | 1154 | } |
c2dcfdef | 1155 | } |
42e69d6b | 1156 | #endif // Win95 |
a23fd0e1 VZ |
1157 | |
1158 | return FALSE; | |
2bda0e17 KB |
1159 | } |
1160 | ||
42e69d6b VZ |
1161 | // =========================================================================== |
1162 | // wxMDIClientWindow: the window of predefined (by Windows) class which | |
1163 | // contains the child frames | |
1164 | // =========================================================================== | |
2bda0e17 | 1165 | |
debe6624 | 1166 | bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) |
2bda0e17 | 1167 | { |
42e69d6b | 1168 | m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE); |
2bda0e17 | 1169 | |
42e69d6b VZ |
1170 | CLIENTCREATESTRUCT ccs; |
1171 | m_windowStyle = style; | |
1172 | m_parent = parent; | |
c2dcfdef | 1173 | |
df61c009 JS |
1174 | ccs.hWindowMenu = (HMENU) 0; |
1175 | if (parent->GetWindowMenu()) | |
1176 | ccs.hWindowMenu = (HMENU) parent->GetWindowMenu()->GetHMenu(); | |
42e69d6b | 1177 | ccs.idFirstChild = wxFIRST_MDI_CHILD; |
2bda0e17 | 1178 | |
5c44cd05 | 1179 | DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD | |
b0766406 JS |
1180 | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; |
1181 | ||
42e69d6b VZ |
1182 | if ( style & wxHSCROLL ) |
1183 | msStyle |= WS_HSCROLL; | |
1184 | if ( style & wxVSCROLL ) | |
1185 | msStyle |= WS_VSCROLL; | |
2bda0e17 KB |
1186 | |
1187 | #if defined(__WIN95__) | |
42e69d6b | 1188 | DWORD exStyle = WS_EX_CLIENTEDGE; |
2bda0e17 | 1189 | #else |
42e69d6b | 1190 | DWORD exStyle = 0; |
2bda0e17 KB |
1191 | #endif |
1192 | ||
42e69d6b VZ |
1193 | wxWndHook = this; |
1194 | m_hWnd = (WXHWND)::CreateWindowEx | |
1195 | ( | |
1196 | exStyle, | |
223d09f6 | 1197 | wxT("MDICLIENT"), |
42e69d6b VZ |
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 | { | |
f6bcfd97 | 1207 | wxLogLastError(wxT("CreateWindowEx(MDI client)")); |
2bda0e17 | 1208 | |
42e69d6b VZ |
1209 | return FALSE; |
1210 | } | |
2bda0e17 | 1211 | |
42e69d6b VZ |
1212 | SubclassWin(m_hWnd); |
1213 | wxWndHook = NULL; | |
2bda0e17 | 1214 | |
42e69d6b | 1215 | return TRUE; |
2bda0e17 KB |
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 | ||
42e69d6b VZ |
1232 | event.Skip(); |
1233 | } | |
1234 | ||
ec06b234 JS |
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 | ||
f6bcfd97 BP |
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 | ||
42e69d6b VZ |
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__ | |
f6bcfd97 | 1291 | (WPARAM)hmenuFrame, (LPARAM)hmenuWindow |
42e69d6b | 1292 | #else |
f6bcfd97 | 1293 | 0, MAKELPARAM(hmenuFrame, hmenuWindow) |
42e69d6b | 1294 | #endif |
f6bcfd97 | 1295 | ); |
42e69d6b VZ |
1296 | |
1297 | // update menu bar of the parent window | |
1298 | wxWindow *parent = win->GetParent(); | |
223d09f6 | 1299 | wxCHECK_RET( parent, wxT("MDI client without parent frame? weird...") ); |
42e69d6b | 1300 | |
788722ac | 1301 | #ifndef __WIN16__ |
a967ef9d | 1302 | ::SendMessage(GetWinHwnd(win), WM_MDIREFRESHMENU, 0, 0L); |
788722ac JS |
1303 | #endif |
1304 | ||
42e69d6b VZ |
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; | |
df61c009 JS |
1312 | |
1313 | if (subMenu) | |
1314 | { | |
42e69d6b VZ |
1315 | int N = GetMenuItemCount(hmenu); |
1316 | bool success = FALSE; | |
1317 | for ( int i = 0; i < N; i++ ) | |
1318 | { | |
837e5743 | 1319 | wxChar buf[256]; |
42e69d6b VZ |
1320 | int chars = GetMenuString(hmenu, i, buf, WXSIZEOF(buf), MF_BYPOSITION); |
1321 | if ( chars == 0 ) | |
1322 | { | |
223d09f6 | 1323 | wxLogLastError(wxT("GetMenuString")); |
42e69d6b VZ |
1324 | |
1325 | continue; | |
1326 | } | |
1327 | ||
f6bcfd97 | 1328 | if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Help")) ) |
42e69d6b VZ |
1329 | { |
1330 | success = TRUE; | |
1331 | ::InsertMenu(hmenu, i, MF_BYPOSITION | MF_POPUP | MF_STRING, | |
f6bcfd97 | 1332 | (UINT)subMenu, _("&Window")); |
42e69d6b VZ |
1333 | break; |
1334 | } | |
1335 | } | |
1336 | ||
1337 | if ( !success ) | |
1338 | { | |
f6bcfd97 | 1339 | ::AppendMenu(hmenu, MF_POPUP, (UINT)subMenu, _("&Window")); |
42e69d6b | 1340 | } |
df61c009 | 1341 | } |
42e69d6b VZ |
1342 | |
1343 | MDISetMenu(win, hmenu, subMenu); | |
1344 | } | |
1345 | ||
df61c009 JS |
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); | |
df61c009 JS |
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 | ||
f6bcfd97 | 1362 | if ( wxStripMenuCodes(wxString(buf)).IsSameAs(_("Window")) ) |
df61c009 | 1363 | { |
df61c009 JS |
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 | ||
2917e920 BM |
1373 | static void UnpackMDIActivate(WXWPARAM wParam, WXLPARAM lParam, |
1374 | WXWORD *activate, WXHWND *hwndAct, WXHWND *hwndDeact) | |
42e69d6b VZ |
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 | |
2bda0e17 | 1385 | } |