]>
Commit | Line | Data |
---|---|---|
2bda0e17 | 1 | ///////////////////////////////////////////////////////////////////////////// |
08b97268 | 2 | // Name: src/msw/frame.cpp |
0d53fc34 | 3 | // Purpose: wxFrame |
2bda0e17 KB |
4 | // Author: Julian Smart |
5 | // Modified by: | |
6 | // Created: 01/02/97 | |
7 | // RCS-ID: $Id$ | |
6c9a19aa | 8 | // Copyright: (c) Julian Smart |
65571936 | 9 | // Licence: wxWindows licence |
2bda0e17 KB |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
7c0ea335 VZ |
12 | // ============================================================================ |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
2bda0e17 KB |
20 | // For compilers that support precompilation, includes "wx.h". |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
9f3362c4 | 24 | #pragma hdrstop |
2bda0e17 KB |
25 | #endif |
26 | ||
76b49cf4 WS |
27 | #include "wx/frame.h" |
28 | ||
2bda0e17 | 29 | #ifndef WX_PRECOMP |
57bd4c60 | 30 | #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly" |
9f3362c4 | 31 | #include "wx/app.h" |
1e6feb95 | 32 | #include "wx/menu.h" |
9f3362c4 VZ |
33 | #include "wx/utils.h" |
34 | #include "wx/dialog.h" | |
35 | #include "wx/settings.h" | |
36 | #include "wx/dcclient.h" | |
d3cc7c65 | 37 | #include "wx/mdi.h" |
f6bcfd97 | 38 | #include "wx/panel.h" |
e4db172a | 39 | #include "wx/log.h" |
4e3e485b | 40 | #include "wx/toolbar.h" |
3304646d | 41 | #include "wx/statusbr.h" |
25466131 | 42 | #include "wx/menuitem.h" |
9f3362c4 | 43 | #endif // WX_PRECOMP |
2bda0e17 KB |
44 | |
45 | #include "wx/msw/private.h" | |
7c0ea335 | 46 | |
afafd942 | 47 | #if defined(__POCKETPC__) || defined(__SMARTPHONE__) |
855ec944 VZ |
48 | #include <ole2.h> |
49 | #include <aygshell.h> | |
50 | #include "wx/msw/winundef.h" | |
afafd942 JS |
51 | #endif |
52 | ||
8f62e633 RD |
53 | #include "wx/generic/statusbr.h" |
54 | ||
1e6feb95 VZ |
55 | #ifdef __WXUNIVERSAL__ |
56 | #include "wx/univ/theme.h" | |
57 | #include "wx/univ/colschem.h" | |
58 | #endif // __WXUNIVERSAL__ | |
59 | ||
7c0ea335 VZ |
60 | // ---------------------------------------------------------------------------- |
61 | // globals | |
62 | // ---------------------------------------------------------------------------- | |
2bda0e17 | 63 | |
1e6feb95 | 64 | #if wxUSE_MENUS_NATIVE |
03baf031 | 65 | extern wxMenu *wxCurrentPopupMenu; |
1e6feb95 | 66 | #endif // wxUSE_MENUS_NATIVE |
2bda0e17 | 67 | |
7c0ea335 VZ |
68 | // ---------------------------------------------------------------------------- |
69 | // event tables | |
70 | // ---------------------------------------------------------------------------- | |
71 | ||
0d53fc34 | 72 | BEGIN_EVENT_TABLE(wxFrame, wxFrameBase) |
0d53fc34 | 73 | EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged) |
2bda0e17 KB |
74 | END_EVENT_TABLE() |
75 | ||
51596bcb | 76 | #if wxUSE_EXTENDED_RTTI |
bc9fb572 JS |
77 | WX_DEFINE_FLAGS( wxFrameStyle ) |
78 | ||
3ff066a4 | 79 | wxBEGIN_FLAGS( wxFrameStyle ) |
bc9fb572 JS |
80 | // new style border flags, we put them first to |
81 | // use them for streaming out | |
3ff066a4 SC |
82 | wxFLAGS_MEMBER(wxBORDER_SIMPLE) |
83 | wxFLAGS_MEMBER(wxBORDER_SUNKEN) | |
84 | wxFLAGS_MEMBER(wxBORDER_DOUBLE) | |
85 | wxFLAGS_MEMBER(wxBORDER_RAISED) | |
86 | wxFLAGS_MEMBER(wxBORDER_STATIC) | |
87 | wxFLAGS_MEMBER(wxBORDER_NONE) | |
cbe874bd | 88 | |
bc9fb572 | 89 | // old style border flags |
3ff066a4 SC |
90 | wxFLAGS_MEMBER(wxSIMPLE_BORDER) |
91 | wxFLAGS_MEMBER(wxSUNKEN_BORDER) | |
92 | wxFLAGS_MEMBER(wxDOUBLE_BORDER) | |
93 | wxFLAGS_MEMBER(wxRAISED_BORDER) | |
94 | wxFLAGS_MEMBER(wxSTATIC_BORDER) | |
cb0afb26 | 95 | wxFLAGS_MEMBER(wxBORDER) |
bc9fb572 JS |
96 | |
97 | // standard window styles | |
3ff066a4 SC |
98 | wxFLAGS_MEMBER(wxTAB_TRAVERSAL) |
99 | wxFLAGS_MEMBER(wxCLIP_CHILDREN) | |
100 | wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) | |
101 | wxFLAGS_MEMBER(wxWANTS_CHARS) | |
cb0afb26 | 102 | wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) |
3ff066a4 SC |
103 | wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) |
104 | wxFLAGS_MEMBER(wxVSCROLL) | |
105 | wxFLAGS_MEMBER(wxHSCROLL) | |
bc9fb572 JS |
106 | |
107 | // frame styles | |
3ff066a4 SC |
108 | wxFLAGS_MEMBER(wxSTAY_ON_TOP) |
109 | wxFLAGS_MEMBER(wxCAPTION) | |
1c067fe3 | 110 | #if WXWIN_COMPATIBILITY_2_6 |
3ff066a4 | 111 | wxFLAGS_MEMBER(wxTHICK_FRAME) |
1c067fe3 | 112 | #endif // WXWIN_COMPATIBILITY_2_6 |
3ff066a4 SC |
113 | wxFLAGS_MEMBER(wxSYSTEM_MENU) |
114 | wxFLAGS_MEMBER(wxRESIZE_BORDER) | |
1c067fe3 | 115 | #if WXWIN_COMPATIBILITY_2_6 |
3ff066a4 | 116 | wxFLAGS_MEMBER(wxRESIZE_BOX) |
1c067fe3 | 117 | #endif // WXWIN_COMPATIBILITY_2_6 |
3ff066a4 SC |
118 | wxFLAGS_MEMBER(wxCLOSE_BOX) |
119 | wxFLAGS_MEMBER(wxMAXIMIZE_BOX) | |
120 | wxFLAGS_MEMBER(wxMINIMIZE_BOX) | |
bc9fb572 | 121 | |
3ff066a4 SC |
122 | wxFLAGS_MEMBER(wxFRAME_TOOL_WINDOW) |
123 | wxFLAGS_MEMBER(wxFRAME_FLOAT_ON_PARENT) | |
bc9fb572 | 124 | |
3ff066a4 | 125 | wxFLAGS_MEMBER(wxFRAME_SHAPED) |
bc9fb572 | 126 | |
3ff066a4 | 127 | wxEND_FLAGS( wxFrameStyle ) |
bc9fb572 | 128 | |
51596bcb SC |
129 | IMPLEMENT_DYNAMIC_CLASS_XTI(wxFrame, wxTopLevelWindow,"wx/frame.h") |
130 | ||
3ff066a4 | 131 | wxBEGIN_PROPERTIES_TABLE(wxFrame) |
fb8a56b7 | 132 | wxEVENT_PROPERTY( Menu , wxEVT_COMMAND_MENU_SELECTED , wxCommandEvent) |
c5ca409b | 133 | |
3ff066a4 | 134 | wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) |
af498247 VZ |
135 | wxPROPERTY_FLAGS( WindowStyle , wxFrameStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style |
136 | wxPROPERTY( MenuBar , wxMenuBar * , SetMenuBar , GetMenuBar , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) | |
3ff066a4 | 137 | wxEND_PROPERTIES_TABLE() |
51596bcb | 138 | |
3ff066a4 SC |
139 | wxBEGIN_HANDLERS_TABLE(wxFrame) |
140 | wxEND_HANDLERS_TABLE() | |
51596bcb | 141 | |
cbe874bd | 142 | wxCONSTRUCTOR_6( wxFrame , wxWindow* , Parent , wxWindowID , Id , wxString , Title , wxPoint , Position , wxSize , Size , long , WindowStyle) |
51596bcb SC |
143 | |
144 | #else | |
58b43418 | 145 | IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow) |
51596bcb | 146 | #endif |
2bda0e17 | 147 | |
7c0ea335 VZ |
148 | // ============================================================================ |
149 | // implementation | |
150 | // ============================================================================ | |
151 | ||
152 | // ---------------------------------------------------------------------------- | |
153 | // static class members | |
154 | // ---------------------------------------------------------------------------- | |
155 | ||
1e6feb95 VZ |
156 | #if wxUSE_STATUSBAR |
157 | #if wxUSE_NATIVE_STATUSBAR | |
cbe874bd | 158 | bool wxFrame::m_useNativeStatusBar = true; |
1e6feb95 | 159 | #else |
cbe874bd | 160 | bool wxFrame::m_useNativeStatusBar = false; |
1e6feb95 VZ |
161 | #endif |
162 | #endif // wxUSE_NATIVE_STATUSBAR | |
2bda0e17 | 163 | |
7c0ea335 VZ |
164 | // ---------------------------------------------------------------------------- |
165 | // creation/destruction | |
166 | // ---------------------------------------------------------------------------- | |
2bda0e17 | 167 | |
0d53fc34 | 168 | void wxFrame::Init() |
2bda0e17 | 169 | { |
cf8ff92f VZ |
170 | #if wxUSE_MENUS |
171 | m_hMenu = NULL; | |
172 | #endif // wxUSE_MENUS | |
173 | ||
9f3362c4 VZ |
174 | #if wxUSE_TOOLTIPS |
175 | m_hwndToolTip = 0; | |
176 | #endif | |
a2327a9f | 177 | |
cbe874bd | 178 | m_wasMinimized = false; |
7c0ea335 | 179 | } |
9f3362c4 | 180 | |
0d53fc34 | 181 | bool wxFrame::Create(wxWindow *parent, |
7c0ea335 VZ |
182 | wxWindowID id, |
183 | const wxString& title, | |
184 | const wxPoint& pos, | |
185 | const wxSize& size, | |
186 | long style, | |
187 | const wxString& name) | |
188 | { | |
82c9f85c | 189 | if ( !wxTopLevelWindow::Create(parent, id, title, pos, size, style, name) ) |
ef6d716b | 190 | return false; |
d2aef312 | 191 | |
98a02e87 | 192 | SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE)); |
b9691677 | 193 | |
aaf803e9 | 194 | #if defined(__SMARTPHONE__) |
ef6d716b WS |
195 | SetLeftMenu(wxID_EXIT, _("Done")); |
196 | #endif | |
197 | ||
855ec944 | 198 | #if wxUSE_ACCEL && defined(__POCKETPC__) |
aaf803e9 JS |
199 | // The guidelines state that Ctrl+Q should quit the app. |
200 | // Let's define an accelerator table to send wxID_EXIT. | |
201 | wxAcceleratorEntry entries[1]; | |
202 | entries[0].Set(wxACCEL_CTRL, 'Q', wxID_EXIT); | |
203 | wxAcceleratorTable accel(1, entries); | |
204 | SetAcceleratorTable(accel); | |
855ec944 | 205 | #endif // wxUSE_ACCEL && __POCKETPC__ |
aaf803e9 | 206 | |
ef6d716b | 207 | return true; |
2bda0e17 KB |
208 | } |
209 | ||
0d53fc34 | 210 | wxFrame::~wxFrame() |
2bda0e17 | 211 | { |
c6212a0c VZ |
212 | SendDestroyEvent(); |
213 | ||
82c9f85c | 214 | DeleteAllBars(); |
2bda0e17 KB |
215 | } |
216 | ||
d4597e13 VZ |
217 | // ---------------------------------------------------------------------------- |
218 | // wxFrame client size calculations | |
219 | // ---------------------------------------------------------------------------- | |
2bda0e17 | 220 | |
0d53fc34 | 221 | void wxFrame::DoSetClientSize(int width, int height) |
2bda0e17 | 222 | { |
82c9f85c | 223 | // leave enough space for the status bar if we have (and show) it |
7c0ea335 | 224 | #if wxUSE_STATUSBAR |
8d8bd249 VZ |
225 | wxStatusBar *statbar = GetStatusBar(); |
226 | if ( statbar && statbar->IsShown() ) | |
227 | { | |
8d8bd249 VZ |
228 | height += statbar->GetSize().y; |
229 | } | |
7c0ea335 | 230 | #endif // wxUSE_STATUSBAR |
2bda0e17 | 231 | |
68d02db3 VZ |
232 | // call GetClientAreaOrigin() to take the toolbar into account |
233 | wxPoint pt = GetClientAreaOrigin(); | |
234 | width += pt.x; | |
235 | height += pt.y; | |
3882e746 | 236 | |
7a976304 | 237 | #if wxUSE_TOOLBAR |
3882e746 VZ |
238 | wxToolBar * const toolbar = GetToolBar(); |
239 | if ( toolbar ) | |
7a976304 | 240 | { |
3882e746 | 241 | if ( toolbar->HasFlag(wxTB_RIGHT | wxTB_BOTTOM) ) |
7a976304 | 242 | { |
3882e746 VZ |
243 | const wxSize sizeTB = toolbar->GetSize(); |
244 | if ( toolbar->HasFlag(wxTB_RIGHT) ) | |
245 | width -= sizeTB.x; | |
246 | else // wxTB_BOTTOM | |
247 | height -= sizeTB.y; | |
7a976304 | 248 | } |
3882e746 | 249 | //else: toolbar already taken into account by GetClientAreaOrigin() |
7a976304 | 250 | } |
3882e746 | 251 | #endif // wxUSE_TOOLBAR |
68d02db3 | 252 | |
82c9f85c | 253 | wxTopLevelWindow::DoSetClientSize(width, height); |
2bda0e17 KB |
254 | } |
255 | ||
d4597e13 VZ |
256 | // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc. |
257 | void wxFrame::DoGetClientSize(int *x, int *y) const | |
258 | { | |
259 | wxTopLevelWindow::DoGetClientSize(x, y); | |
260 | ||
68d02db3 VZ |
261 | // account for the possible toolbar |
262 | wxPoint pt = GetClientAreaOrigin(); | |
263 | if ( x ) | |
264 | *x -= pt.x; | |
265 | ||
266 | if ( y ) | |
267 | *y -= pt.y; | |
3882e746 | 268 | |
5b2acc3a | 269 | #if wxUSE_TOOLBAR |
3882e746 VZ |
270 | wxToolBar * const toolbar = GetToolBar(); |
271 | if ( toolbar ) | |
5b2acc3a | 272 | { |
3882e746 | 273 | if ( toolbar->HasFlag(wxTB_RIGHT | wxTB_BOTTOM) ) |
5b2acc3a | 274 | { |
3882e746 VZ |
275 | const wxSize sizeTB = toolbar->GetSize(); |
276 | if ( toolbar->HasFlag(wxTB_RIGHT) ) | |
277 | { | |
278 | if ( x ) | |
279 | *x -= sizeTB.x; | |
280 | } | |
281 | else // wxTB_BOTTOM | |
282 | { | |
283 | if ( y ) | |
284 | *y -= sizeTB.y; | |
285 | } | |
7a976304 | 286 | } |
3882e746 | 287 | //else: toolbar already taken into account by GetClientAreaOrigin() |
7a976304 | 288 | } |
3882e746 VZ |
289 | #endif // wxUSE_TOOLBAR |
290 | ||
d4597e13 VZ |
291 | #if wxUSE_STATUSBAR |
292 | // adjust client area height to take the status bar into account | |
293 | if ( y ) | |
294 | { | |
295 | wxStatusBar *statbar = GetStatusBar(); | |
296 | if ( statbar && statbar->IsShown() ) | |
297 | { | |
298 | *y -= statbar->GetClientSize().y; | |
299 | } | |
300 | } | |
301 | #endif // wxUSE_STATUSBAR | |
302 | } | |
303 | ||
7c0ea335 | 304 | // ---------------------------------------------------------------------------- |
0d53fc34 | 305 | // wxFrame: various geometry-related functions |
7c0ea335 VZ |
306 | // ---------------------------------------------------------------------------- |
307 | ||
0d53fc34 | 308 | void wxFrame::Raise() |
c48926e1 | 309 | { |
c48926e1 | 310 | ::SetForegroundWindow(GetHwnd()); |
c48926e1 VZ |
311 | } |
312 | ||
67bd5bad | 313 | // generate an artificial resize event |
ecdc1183 | 314 | void wxFrame::SendSizeEvent(int flags) |
67bd5bad | 315 | { |
67bd5bad GT |
316 | if ( !m_iconized ) |
317 | { | |
82c9f85c VZ |
318 | RECT r = wxGetWindowRect(GetHwnd()); |
319 | ||
ecdc1183 VZ |
320 | if ( flags & wxSEND_EVENT_POST ) |
321 | { | |
322 | ::PostMessage(GetHwnd(), WM_SIZE, | |
323 | IsMaximized() ? SIZE_MAXIMIZED : SIZE_RESTORED, | |
324 | MAKELPARAM(r.right - r.left, r.bottom - r.top)); | |
325 | } | |
326 | else // send it | |
327 | { | |
328 | ::SendMessage(GetHwnd(), WM_SIZE, | |
329 | IsMaximized() ? SIZE_MAXIMIZED : SIZE_RESTORED, | |
330 | MAKELPARAM(r.right - r.left, r.bottom - r.top)); | |
331 | } | |
67bd5bad GT |
332 | } |
333 | } | |
334 | ||
d427503c | 335 | #if wxUSE_STATUSBAR |
0d53fc34 | 336 | wxStatusBar *wxFrame::OnCreateStatusBar(int number, |
7c0ea335 VZ |
337 | long style, |
338 | wxWindowID id, | |
339 | const wxString& name) | |
2bda0e17 | 340 | { |
5cb598ae | 341 | wxStatusBar *statusBar wxDUMMY_INITIALIZE(NULL); |
2bda0e17 | 342 | |
47d67540 | 343 | #if wxUSE_NATIVE_STATUSBAR |
1f0500b3 | 344 | if ( !UsesNativeStatusBar() ) |
2bda0e17 | 345 | { |
1f0500b3 | 346 | statusBar = (wxStatusBar *)new wxStatusBarGeneric(this, id, style); |
2bda0e17 KB |
347 | } |
348 | else | |
349 | #endif | |
350 | { | |
1f0500b3 VZ |
351 | statusBar = new wxStatusBar(this, id, style, name); |
352 | } | |
ed791986 | 353 | |
1f0500b3 | 354 | statusBar->SetFieldsCount(number); |
2bda0e17 | 355 | |
7c0ea335 | 356 | return statusBar; |
2bda0e17 KB |
357 | } |
358 | ||
0d53fc34 | 359 | void wxFrame::PositionStatusBar() |
2bda0e17 | 360 | { |
d4597e13 | 361 | if ( !m_frameStatusBar || !m_frameStatusBar->IsShown() ) |
ed791986 VZ |
362 | return; |
363 | ||
cbc66a27 VZ |
364 | int w, h; |
365 | GetClientSize(&w, &h); | |
3882e746 | 366 | |
cbc66a27 VZ |
367 | int sw, sh; |
368 | m_frameStatusBar->GetSize(&sw, &sh); | |
369 | ||
8efbb8ad VZ |
370 | int x = 0; |
371 | #if wxUSE_TOOLBAR | |
372 | wxToolBar * const toolbar = GetToolBar(); | |
373 | if ( toolbar && !toolbar->HasFlag(wxTB_TOP) ) | |
374 | { | |
375 | const wxSize sizeTB = toolbar->GetSize(); | |
376 | ||
377 | if ( toolbar->HasFlag(wxTB_LEFT | wxTB_RIGHT) ) | |
378 | { | |
379 | if ( toolbar->HasFlag(wxTB_LEFT) ) | |
380 | x -= sizeTB.x; | |
381 | ||
382 | w += sizeTB.x; | |
383 | } | |
384 | else // wxTB_BOTTOM | |
385 | { | |
386 | // we need to position the status bar below the toolbar | |
387 | h += sizeTB.y; | |
388 | } | |
389 | } | |
390 | //else: no adjustments necessary for the toolbar on top | |
391 | #endif // wxUSE_TOOLBAR | |
392 | ||
cbc66a27 VZ |
393 | // Since we wish the status bar to be directly under the client area, |
394 | // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS. | |
8efbb8ad | 395 | m_frameStatusBar->SetSize(x, h, w, sh); |
2bda0e17 | 396 | } |
3882e746 | 397 | |
d427503c | 398 | #endif // wxUSE_STATUSBAR |
2bda0e17 | 399 | |
6522713c | 400 | #if wxUSE_MENUS_NATIVE |
ea9a4296 | 401 | |
0d53fc34 | 402 | void wxFrame::AttachMenuBar(wxMenuBar *menubar) |
2bda0e17 | 403 | { |
3180bc0e | 404 | #if defined(__SMARTPHONE__) && defined(__WXWINCE__) |
fb8a56b7 | 405 | |
ed679e74 WS |
406 | wxMenu *autoMenu = NULL; |
407 | ||
408 | if( menubar->GetMenuCount() == 1 ) | |
409 | { | |
410 | autoMenu = wxTopLevelWindowMSW::ButtonMenu::DuplicateMenu(menubar->GetMenu(0)); | |
52af3158 | 411 | SetRightMenu(wxID_ANY, menubar->GetMenuLabel(0), autoMenu); |
ed679e74 WS |
412 | } |
413 | else | |
fb8a56b7 | 414 | { |
ed679e74 WS |
415 | autoMenu = new wxMenu; |
416 | ||
417 | for( size_t n = 0; n < menubar->GetMenuCount(); n++ ) | |
418 | { | |
419 | wxMenu *item = menubar->GetMenu(n); | |
52af3158 | 420 | wxString label = menubar->GetMenuLabel(n); |
ed679e74 WS |
421 | wxMenu *new_item = wxTopLevelWindowMSW::ButtonMenu::DuplicateMenu(item); |
422 | autoMenu->Append(wxID_ANY, label, new_item); | |
423 | } | |
424 | ||
425 | SetRightMenu(wxID_ANY, _("Menu"), autoMenu); | |
fb8a56b7 WS |
426 | } |
427 | ||
fb8a56b7 | 428 | #elif defined(WINCE_WITHOUT_COMMANDBAR) |
a96b4743 JS |
429 | if (!GetToolBar()) |
430 | { | |
a9102b36 | 431 | wxToolMenuBar* toolBar = new wxToolMenuBar(this, wxID_ANY, |
a96b4743 JS |
432 | wxDefaultPosition, wxDefaultSize, |
433 | wxBORDER_NONE | wxTB_HORIZONTAL, | |
af5454a4 | 434 | wxToolBarNameStr, menubar); |
a96b4743 JS |
435 | SetToolBar(toolBar); |
436 | menubar->SetToolBar(toolBar); | |
437 | } | |
fb8a56b7 | 438 | |
c0a91b51 VZ |
439 | // When the main window is created using CW_USEDEFAULT the height of the |
440 | // menubar is not taken into account, so we resize it afterwards if a | |
441 | // menubar is present | |
442 | HWND hwndMenuBar = SHFindMenuBar(GetHwnd()); | |
443 | if ( hwndMenuBar ) | |
fb8a56b7 | 444 | { |
c0a91b51 VZ |
445 | RECT mbRect; |
446 | ::GetWindowRect(hwndMenuBar, &mbRect); | |
447 | const int menuHeight = mbRect.bottom - mbRect.top; | |
448 | ||
fb8a56b7 | 449 | RECT rc; |
c0a91b51 | 450 | ::GetWindowRect(GetHwnd(), &rc); |
fb8a56b7 WS |
451 | // adjust for menu / titlebar height |
452 | rc.bottom -= (2*menuHeight-1); | |
453 | ||
c0a91b51 | 454 | ::MoveWindow(Gethwnd(), rc.left, rc.top, rc.right, rc.bottom, FALSE); |
fb8a56b7 | 455 | } |
a96b4743 JS |
456 | #endif |
457 | ||
f008af16 | 458 | wxFrameBase::AttachMenuBar(menubar); |
6beb85c0 | 459 | |
f6bcfd97 | 460 | if ( !menubar ) |
c2dcfdef | 461 | { |
f6bcfd97 BP |
462 | // actually remove the menu from the frame |
463 | m_hMenu = (WXHMENU)0; | |
464 | InternalSetMenuBar(); | |
065de612 | 465 | } |
f6bcfd97 | 466 | else // set new non NULL menu bar |
065de612 | 467 | { |
3d487566 | 468 | #if !defined(__WXWINCE__) || defined(WINCE_WITH_COMMANDBAR) |
f6bcfd97 | 469 | // Can set a menubar several times. |
f6bcfd97 BP |
470 | if ( menubar->GetHMenu() ) |
471 | { | |
472 | m_hMenu = menubar->GetHMenu(); | |
473 | } | |
f008af16 | 474 | else // no HMENU yet |
f6bcfd97 | 475 | { |
f6bcfd97 | 476 | m_hMenu = menubar->Create(); |
065de612 | 477 | |
f6bcfd97 | 478 | if ( !m_hMenu ) |
f008af16 | 479 | { |
9a83f860 | 480 | wxFAIL_MSG( wxT("failed to create menu bar") ); |
f6bcfd97 | 481 | return; |
f008af16 | 482 | } |
f6bcfd97 | 483 | } |
39d2f9a7 | 484 | #endif |
f6bcfd97 | 485 | InternalSetMenuBar(); |
1e6feb95 | 486 | } |
2bda0e17 KB |
487 | } |
488 | ||
0d53fc34 | 489 | void wxFrame::InternalSetMenuBar() |
2bda0e17 | 490 | { |
a96b4743 | 491 | #if defined(__WXMICROWIN__) || defined(__WXWINCE__) |
4676948b | 492 | // Nothing |
4676948b | 493 | #else |
42e69d6b | 494 | if ( !::SetMenu(GetHwnd(), (HMENU)m_hMenu) ) |
2bda0e17 | 495 | { |
f6bcfd97 | 496 | wxLogLastError(wxT("SetMenu")); |
2bda0e17 | 497 | } |
04ef50df | 498 | #endif |
2bda0e17 KB |
499 | } |
500 | ||
1e6feb95 VZ |
501 | #endif // wxUSE_MENUS_NATIVE |
502 | ||
2bda0e17 | 503 | // Responds to colour changes, and passes event on to children. |
0d53fc34 | 504 | void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event) |
2bda0e17 | 505 | { |
98a02e87 | 506 | SetOwnBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE)); |
2bda0e17 KB |
507 | Refresh(); |
508 | ||
1e6feb95 | 509 | #if wxUSE_STATUSBAR |
2bda0e17 KB |
510 | if ( m_frameStatusBar ) |
511 | { | |
512 | wxSysColourChangedEvent event2; | |
513 | event2.SetEventObject( m_frameStatusBar ); | |
937013e0 | 514 | m_frameStatusBar->HandleWindowEvent(event2); |
2bda0e17 | 515 | } |
1e6feb95 | 516 | #endif // wxUSE_STATUSBAR |
2bda0e17 KB |
517 | |
518 | // Propagate the event to the non-top-level children | |
519 | wxWindow::OnSysColourChanged(event); | |
520 | } | |
521 | ||
cbe874bd | 522 | // Pass true to show full screen, false to restore. |
0d53fc34 | 523 | bool wxFrame::ShowFullScreen(bool show, long style) |
a2327a9f | 524 | { |
b01a88e0 VZ |
525 | // TODO-CE: add support for CE |
526 | #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__) | |
085ad686 | 527 | if ( IsFullScreen() == show ) |
cbe874bd | 528 | return false; |
c641b1d2 | 529 | |
a2327a9f JS |
530 | if (show) |
531 | { | |
b01a88e0 VZ |
532 | // zap the toolbar, menubar, and statusbar if needed |
533 | // | |
534 | // TODO: hide commandbar for WINCE_WITH_COMMANDBAR | |
1e6feb95 | 535 | #if wxUSE_TOOLBAR |
f6bcfd97 | 536 | wxToolBar *theToolBar = GetToolBar(); |
a2327a9f JS |
537 | |
538 | if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar) | |
539 | { | |
b01a88e0 VZ |
540 | if ( theToolBar->IsShown() ) |
541 | { | |
542 | theToolBar->SetSize(wxDefaultCoord,0); | |
543 | theToolBar->Show(false); | |
544 | } | |
545 | else // prevent it from being restored later | |
546 | { | |
547 | style &= ~wxFULLSCREEN_NOTOOLBAR; | |
548 | } | |
a2327a9f | 549 | } |
1e6feb95 | 550 | #endif // wxUSE_TOOLBAR |
a2327a9f JS |
551 | |
552 | if (style & wxFULLSCREEN_NOMENUBAR) | |
553 | SetMenu((HWND)GetHWND(), (HMENU) NULL); | |
554 | ||
1e6feb95 VZ |
555 | #if wxUSE_STATUSBAR |
556 | wxStatusBar *theStatusBar = GetStatusBar(); | |
1e6feb95 | 557 | |
a2327a9f JS |
558 | // Save the number of fields in the statusbar |
559 | if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar) | |
560 | { | |
b01a88e0 VZ |
561 | if ( theStatusBar->IsShown() ) |
562 | theStatusBar->Show(false); | |
563 | else | |
564 | style &= ~wxFULLSCREEN_NOSTATUSBAR; | |
a2327a9f | 565 | } |
1e6feb95 | 566 | #endif // wxUSE_STATUSBAR |
a2327a9f | 567 | } |
b01a88e0 | 568 | else // restore to normal |
a2327a9f | 569 | { |
b01a88e0 | 570 | // restore the toolbar, menubar, and statusbar if we had hid them |
1e6feb95 | 571 | #if wxUSE_TOOLBAR |
a2327a9f JS |
572 | wxToolBar *theToolBar = GetToolBar(); |
573 | ||
b01a88e0 | 574 | if ((m_fsStyle & wxFULLSCREEN_NOTOOLBAR) && theToolBar) |
a2327a9f | 575 | { |
cbe874bd | 576 | theToolBar->Show(true); |
a2327a9f | 577 | } |
1e6feb95 | 578 | #endif // wxUSE_TOOLBAR |
a2327a9f | 579 | |
a8ff046b | 580 | #if wxUSE_MENUS |
bc88602a JS |
581 | if (m_fsStyle & wxFULLSCREEN_NOMENUBAR) |
582 | { | |
51181d29 VZ |
583 | const WXHMENU hmenu = MSWGetActiveMenu(); |
584 | if ( hmenu ) | |
585 | ::SetMenu(GetHwnd(), (HMENU)hmenu); | |
bc88602a | 586 | } |
a8ff046b | 587 | #endif // wxUSE_MENUS |
b01a88e0 | 588 | |
1e6feb95 | 589 | #if wxUSE_STATUSBAR |
b01a88e0 VZ |
590 | wxStatusBar *theStatusBar = GetStatusBar(); |
591 | ||
592 | if ((m_fsStyle & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar) | |
a2327a9f | 593 | { |
b01a88e0 VZ |
594 | theStatusBar->Show(true); |
595 | PositionStatusBar(); | |
a2327a9f | 596 | } |
1e6feb95 | 597 | #endif // wxUSE_STATUSBAR |
a2327a9f | 598 | } |
b01a88e0 | 599 | #endif // !defined(__WXMICROWIN__) && !defined(__WXWINCE__) |
f6bcfd97 | 600 | |
085ad686 | 601 | return wxFrameBase::ShowFullScreen(show, style); |
2bda0e17 KB |
602 | } |
603 | ||
7c0ea335 VZ |
604 | // ---------------------------------------------------------------------------- |
605 | // tool/status bar stuff | |
606 | // ---------------------------------------------------------------------------- | |
607 | ||
d427503c | 608 | #if wxUSE_TOOLBAR |
7c0ea335 | 609 | |
0d53fc34 | 610 | wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name) |
81d66cf3 | 611 | { |
3d487566 | 612 | #if defined(WINCE_WITHOUT_COMMANDBAR) |
39d2f9a7 JS |
613 | // We may already have a toolbar from calling SetMenuBar. |
614 | if (GetToolBar()) | |
615 | return GetToolBar(); | |
616 | #endif | |
7c0ea335 | 617 | if ( wxFrameBase::CreateToolBar(style, id, name) ) |
81d66cf3 | 618 | { |
81d66cf3 | 619 | PositionToolBar(); |
81d66cf3 | 620 | } |
81d66cf3 | 621 | |
7c0ea335 | 622 | return m_frameToolBar; |
81d66cf3 JS |
623 | } |
624 | ||
0d53fc34 | 625 | void wxFrame::PositionToolBar() |
81d66cf3 | 626 | { |
8898842f VZ |
627 | // TODO: we want to do something different in WinCE, because the toolbar |
628 | // should be associated with the commandbar, instead of being | |
629 | // independent window. | |
630 | #if !defined(WINCE_WITHOUT_COMMANDBAR) | |
d4597e13 VZ |
631 | wxToolBar *toolbar = GetToolBar(); |
632 | if ( toolbar && toolbar->IsShown() ) | |
633 | { | |
634 | // don't call our (or even wxTopLevelWindow) version because we want | |
635 | // the real (full) client area size, not excluding the tool/status bar | |
636 | int width, height; | |
637 | wxWindow::DoGetClientSize(&width, &height); | |
81d66cf3 | 638 | |
7c0ea335 | 639 | #if wxUSE_STATUSBAR |
d4597e13 VZ |
640 | wxStatusBar *statbar = GetStatusBar(); |
641 | if ( statbar && statbar->IsShown() ) | |
642 | { | |
643 | height -= statbar->GetClientSize().y; | |
644 | } | |
7c0ea335 | 645 | #endif // wxUSE_STATUSBAR |
3882e746 VZ |
646 | |
647 | int tx, ty, tw, th; | |
648 | toolbar->GetPosition( &tx, &ty ); | |
649 | toolbar->GetSize( &tw, &th ); | |
650 | ||
dd639a4f | 651 | int x, y; |
3882e746 VZ |
652 | if ( toolbar->HasFlag(wxTB_BOTTOM) ) |
653 | { | |
654 | x = 0; | |
655 | y = height - th; | |
656 | } | |
657 | else if ( toolbar->HasFlag(wxTB_RIGHT) ) | |
658 | { | |
659 | x = width - tw; | |
660 | y = 0; | |
661 | } | |
662 | else // left or top | |
663 | { | |
664 | x = 0; | |
665 | y = 0; | |
666 | } | |
667 | ||
3d487566 | 668 | #if defined(WINCE_WITH_COMMANDBAR) |
fb8a56b7 WS |
669 | // We're using a commandbar - so we have to allow for it. |
670 | if (GetMenuBar() && GetMenuBar()->GetCommandBar()) | |
671 | { | |
672 | RECT rect; | |
673 | ::GetWindowRect((HWND) GetMenuBar()->GetCommandBar(), &rect); | |
674 | y = rect.bottom - rect.top; | |
675 | } | |
3882e746 VZ |
676 | #endif // WINCE_WITH_COMMANDBAR |
677 | ||
678 | if ( toolbar->HasFlag(wxTB_BOTTOM) ) | |
679 | { | |
680 | if ( ty < 0 && ( -ty == th ) ) | |
681 | ty = height - th; | |
682 | if ( tx < 0 && (-tx == tw ) ) | |
683 | tx = 0; | |
684 | } | |
685 | else if ( toolbar->HasFlag(wxTB_RIGHT) ) | |
7a976304 VZ |
686 | { |
687 | if( ty < 0 && ( -ty == th ) ) | |
688 | ty = 0; | |
689 | if( tx < 0 && ( -tx == tw ) ) | |
690 | tx = width - tw; | |
691 | } | |
3882e746 VZ |
692 | else // left or top |
693 | { | |
694 | if (ty < 0 && (-ty == th)) | |
695 | ty = 0; | |
696 | if (tx < 0 && (-tx == tw)) | |
697 | tx = 0; | |
698 | } | |
cbe874bd | 699 | |
563f85a9 VZ |
700 | int desiredW, |
701 | desiredH; | |
81d66cf3 | 702 | |
7a976304 | 703 | if ( toolbar->IsVertical() ) |
81d66cf3 | 704 | { |
563f85a9 | 705 | desiredW = tw; |
229de929 | 706 | desiredH = height; |
81d66cf3 JS |
707 | } |
708 | else | |
709 | { | |
229de929 | 710 | desiredW = width; |
563f85a9 | 711 | desiredH = th; |
cbe874bd | 712 | } |
7c0ea335 | 713 | |
563f85a9 | 714 | // use the 'real' MSW position here, don't offset relatively to the |
d4597e13 | 715 | // client area origin |
563f85a9 | 716 | toolbar->SetSize(x, y, desiredW, desiredH, wxSIZE_NO_ADJUSTMENTS); |
cbe874bd | 717 | |
81d66cf3 | 718 | } |
8898842f | 719 | #endif // !WINCE_WITH_COMMANDBAR |
81d66cf3 | 720 | } |
d4597e13 | 721 | |
d427503c | 722 | #endif // wxUSE_TOOLBAR |
d2aef312 | 723 | |
7c0ea335 VZ |
724 | // ---------------------------------------------------------------------------- |
725 | // frame state (iconized/maximized/...) | |
726 | // ---------------------------------------------------------------------------- | |
727 | ||
a23fd0e1 VZ |
728 | // propagate our state change to all child frames: this allows us to emulate X |
729 | // Windows behaviour where child frames float independently of the parent one | |
730 | // on the desktop, but are iconized/restored with it | |
0d53fc34 | 731 | void wxFrame::IconizeChildFrames(bool bIconize) |
d2aef312 | 732 | { |
4bc0f25e VZ |
733 | m_iconized = bIconize; |
734 | ||
222ed1d6 | 735 | for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); |
a23fd0e1 VZ |
736 | node; |
737 | node = node->GetNext() ) | |
738 | { | |
739 | wxWindow *win = node->GetData(); | |
740 | ||
3ca6a5f0 BP |
741 | // iconizing the frames with this style under Win95 shell puts them at |
742 | // the bottom of the screen (as the MDI children) instead of making | |
743 | // them appear in the taskbar because they are, by virtue of this | |
744 | // style, not managed by the taskbar - instead leave Windows take care | |
745 | // of them | |
3ca6a5f0 BP |
746 | if ( win->GetWindowStyle() & wxFRAME_TOOL_WINDOW ) |
747 | continue; | |
3ca6a5f0 | 748 | |
3f7bc32b VZ |
749 | // the child MDI frames are a special case and should not be touched by |
750 | // the parent frame - instead, they are managed by the user | |
2e9f62da | 751 | wxFrame *frame = wxDynamicCast(win, wxFrame); |
1e6feb95 VZ |
752 | if ( frame |
753 | #if wxUSE_MDI_ARCHITECTURE | |
4ab2824c | 754 | && !frame->IsMDIChild() |
1e6feb95 VZ |
755 | #endif // wxUSE_MDI_ARCHITECTURE |
756 | ) | |
a23fd0e1 | 757 | { |
9327c3aa VZ |
758 | // we don't want to restore the child frames which had been |
759 | // iconized even before we were iconized, so save the child frame | |
760 | // status when iconizing the parent frame and check it when | |
761 | // restoring it | |
762 | if ( bIconize ) | |
763 | { | |
9c72ebec | 764 | frame->m_wasMinimized = frame->IsIconized(); |
9327c3aa VZ |
765 | } |
766 | ||
9c72ebec VZ |
767 | // note that we shouldn't touch the hidden frames neither because |
768 | // iconizing/restoring them would show them as a side effect | |
769 | if ( !frame->m_wasMinimized && frame->IsShown() ) | |
9327c3aa | 770 | frame->Iconize(bIconize); |
a23fd0e1 | 771 | } |
d2aef312 | 772 | } |
d2aef312 VZ |
773 | } |
774 | ||
0d53fc34 | 775 | WXHICON wxFrame::GetDefaultIcon() const |
82c9f85c | 776 | { |
94826170 VZ |
777 | // we don't have any standard icons (any more) |
778 | return (WXHICON)0; | |
82c9f85c VZ |
779 | } |
780 | ||
a23fd0e1 | 781 | // =========================================================================== |
42e69d6b | 782 | // message processing |
a23fd0e1 VZ |
783 | // =========================================================================== |
784 | ||
42e69d6b VZ |
785 | // --------------------------------------------------------------------------- |
786 | // preprocessing | |
787 | // --------------------------------------------------------------------------- | |
788 | ||
1ac76609 | 789 | bool wxFrame::MSWDoTranslateMessage(wxFrame *frame, WXMSG *pMsg) |
42e69d6b VZ |
790 | { |
791 | if ( wxWindow::MSWTranslateMessage(pMsg) ) | |
cbe874bd | 792 | return true; |
42e69d6b | 793 | |
1e6feb95 | 794 | #if wxUSE_MENUS && wxUSE_ACCEL && !defined(__WXUNIVERSAL__) |
7802da36 | 795 | // try the menu bar accelerators |
42e69d6b | 796 | wxMenuBar *menuBar = GetMenuBar(); |
7802da36 VZ |
797 | if ( menuBar && menuBar->GetAcceleratorTable()->Translate(frame, pMsg) ) |
798 | return true; | |
a1a1ca89 | 799 | #endif // wxUSE_MENUS && wxUSE_ACCEL |
42e69d6b | 800 | |
cbe874bd | 801 | return false; |
42e69d6b VZ |
802 | } |
803 | ||
804 | // --------------------------------------------------------------------------- | |
805 | // our private (non virtual) message handlers | |
806 | // --------------------------------------------------------------------------- | |
807 | ||
4bc0f25e | 808 | bool wxFrame::HandleSize(int WXUNUSED(x), int WXUNUSED(y), WXUINT id) |
42e69d6b | 809 | { |
4676948b | 810 | #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__) |
42e69d6b VZ |
811 | switch ( id ) |
812 | { | |
4bc0f25e VZ |
813 | case SIZE_RESTORED: |
814 | case SIZE_MAXIMIZED: | |
42e69d6b VZ |
815 | // only do it it if we were iconized before, otherwise resizing the |
816 | // parent frame has a curious side effect of bringing it under it's | |
817 | // children | |
818 | if ( !m_iconized ) | |
819 | break; | |
820 | ||
821 | // restore all child frames too | |
cbe874bd | 822 | IconizeChildFrames(false); |
42e69d6b | 823 | |
cbe874bd | 824 | (void)SendIconizeEvent(false); |
42e69d6b VZ |
825 | break; |
826 | ||
4bc0f25e | 827 | case SIZE_MINIMIZED: |
42e69d6b | 828 | // iconize all child frames too |
cbe874bd | 829 | IconizeChildFrames(true); |
42e69d6b VZ |
830 | break; |
831 | } | |
276c8cfb WS |
832 | #else |
833 | wxUnusedVar(id); | |
4bc0f25e | 834 | #endif // !__WXWINCE__ |
42e69d6b VZ |
835 | |
836 | if ( !m_iconized ) | |
837 | { | |
1e6feb95 | 838 | #if wxUSE_STATUSBAR |
42e69d6b | 839 | PositionStatusBar(); |
1e6feb95 VZ |
840 | #endif // wxUSE_STATUSBAR |
841 | ||
842 | #if wxUSE_TOOLBAR | |
42e69d6b | 843 | PositionToolBar(); |
1e6feb95 | 844 | #endif // wxUSE_TOOLBAR |
42e69d6b | 845 | |
3d487566 | 846 | #if defined(WINCE_WITH_COMMANDBAR) |
fb8a56b7 WS |
847 | // Position the menu command bar |
848 | if (GetMenuBar() && GetMenuBar()->GetCommandBar()) | |
849 | { | |
850 | RECT rect; | |
851 | ::GetWindowRect((HWND) GetMenuBar()->GetCommandBar(), &rect); | |
852 | wxSize clientSz = GetClientSize(); | |
853 | ||
854 | if ( !::MoveWindow((HWND) GetMenuBar()->GetCommandBar(), 0, 0, clientSz.x, rect.bottom - rect.top, true ) ) | |
855 | { | |
856 | wxLogLastError(wxT("MoveWindow")); | |
857 | } | |
858 | ||
859 | } | |
4bc0f25e | 860 | #endif // WINCE_WITH_COMMANDBAR |
42e69d6b VZ |
861 | } |
862 | ||
4bc0f25e VZ |
863 | // call the base class version to generate the appropriate events |
864 | return false; | |
42e69d6b VZ |
865 | } |
866 | ||
1483e5db | 867 | bool wxFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control) |
42e69d6b | 868 | { |
1483e5db | 869 | #if wxUSE_MENUS |
f8114048 JS |
870 | |
871 | #if defined(WINCE_WITHOUT_COMMANDBAR) | |
872 | if (GetToolBar() && GetToolBar()->FindById(id)) | |
873 | return GetToolBar()->MSWCommand(cmd, id); | |
874 | #endif | |
875 | ||
a6ac49b1 VZ |
876 | // we only need to handle the menu and accelerator commands from the items |
877 | // of our menu bar, base wxWindow class already handles the rest | |
878 | if ( !control && (cmd == 0 /* menu */ || cmd == 1 /* accel */) ) | |
42e69d6b | 879 | { |
1e6feb95 | 880 | #if wxUSE_MENUS_NATIVE |
a6ac49b1 | 881 | if ( !wxCurrentPopupMenu ) |
1e6feb95 | 882 | #endif // wxUSE_MENUS_NATIVE |
fb8a56b7 | 883 | { |
79f9ea05 | 884 | wxMenuItem * const mitem = FindItemInMenuBar((signed short)id); |
1483e5db VZ |
885 | if ( mitem ) |
886 | return ProcessCommand(mitem); | |
42e69d6b VZ |
887 | } |
888 | } | |
1483e5db | 889 | #endif // wxUSE_MENUS |
42e69d6b | 890 | |
1483e5db | 891 | return wxFrameBase::HandleCommand(id, cmd, control);; |
42e69d6b VZ |
892 | } |
893 | ||
a8ff046b VZ |
894 | #if wxUSE_MENUS |
895 | ||
3e603cb7 VZ |
896 | bool |
897 | wxFrame::HandleMenuSelect(WXWORD nItem, WXWORD flags, WXHMENU WXUNUSED(hMenu)) | |
a23fd0e1 | 898 | { |
f6a86aff VZ |
899 | // sign extend to int from unsigned short we get from Windows |
900 | int item = (signed short)nItem; | |
901 | ||
46743ff8 VZ |
902 | // WM_MENUSELECT is generated for both normal items and menus, including |
903 | // the top level menus of the menu bar, which can't be represented using | |
f6a86aff VZ |
904 | // any valid identifier in wxMenuEvent so use an otherwise unused value for |
905 | // them | |
906 | if ( flags & (MF_POPUP | MF_SEPARATOR) ) | |
29c7962a | 907 | item = wxID_NONE; |
a23fd0e1 VZ |
908 | |
909 | wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item); | |
ccef86c7 VZ |
910 | event.SetEventObject(this); |
911 | ||
46743ff8 VZ |
912 | if ( HandleWindowEvent(event) ) |
913 | return true; | |
914 | ||
915 | // by default, i.e. if the event wasn't handled above, clear the status bar | |
916 | // text when an item which can't have any associated help string in wx API | |
917 | // is selected | |
29c7962a | 918 | if ( item == wxID_NONE ) |
46743ff8 VZ |
919 | DoGiveHelp(wxEmptyString, true); |
920 | ||
921 | return false; | |
ccef86c7 VZ |
922 | } |
923 | ||
924 | bool wxFrame::HandleMenuLoop(const wxEventType& evtType, WXWORD isPopup) | |
925 | { | |
926 | // we don't have the menu id here, so we use the id to specify if the event | |
927 | // was from a popup menu or a normal one | |
928 | wxMenuEvent event(evtType, isPopup ? -1 : 0); | |
929 | event.SetEventObject(this); | |
a23fd0e1 | 930 | |
937013e0 | 931 | return HandleWindowEvent(event); |
a23fd0e1 VZ |
932 | } |
933 | ||
a8ff046b VZ |
934 | bool wxFrame::HandleInitMenuPopup(WXHMENU hMenu) |
935 | { | |
936 | wxMenu* menu = NULL; | |
937 | if (GetMenuBar()) | |
938 | { | |
939 | int nCount = GetMenuBar()->GetMenuCount(); | |
940 | for (int n = 0; n < nCount; n++) | |
941 | { | |
942 | if (GetMenuBar()->GetMenu(n)->GetHMenu() == hMenu) | |
943 | { | |
944 | menu = GetMenuBar()->GetMenu(n); | |
945 | break; | |
946 | } | |
947 | } | |
948 | } | |
949 | ||
950 | wxMenuEvent event(wxEVT_MENU_OPEN, 0, menu); | |
951 | event.SetEventObject(this); | |
952 | ||
937013e0 | 953 | return HandleWindowEvent(event); |
a8ff046b VZ |
954 | } |
955 | ||
956 | #endif // wxUSE_MENUS | |
957 | ||
a23fd0e1 | 958 | // --------------------------------------------------------------------------- |
0d53fc34 | 959 | // the window proc for wxFrame |
a23fd0e1 VZ |
960 | // --------------------------------------------------------------------------- |
961 | ||
c140b7e7 | 962 | WXLRESULT wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) |
a23fd0e1 | 963 | { |
c140b7e7 | 964 | WXLRESULT rc = 0; |
cbe874bd | 965 | bool processed = false; |
a23fd0e1 VZ |
966 | |
967 | switch ( message ) | |
968 | { | |
42e69d6b VZ |
969 | case WM_CLOSE: |
970 | // if we can't close, tell the system that we processed the | |
971 | // message - otherwise it would close us | |
972 | processed = !Close(); | |
973 | break; | |
974 | ||
ccef86c7 VZ |
975 | case WM_SIZE: |
976 | processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam); | |
977 | break; | |
978 | ||
42e69d6b VZ |
979 | case WM_COMMAND: |
980 | { | |
981 | WORD id, cmd; | |
982 | WXHWND hwnd; | |
983 | UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam, | |
984 | &id, &hwnd, &cmd); | |
985 | ||
a6ac49b1 VZ |
986 | HandleCommand(id, cmd, (WXHWND)hwnd); |
987 | ||
988 | // don't pass WM_COMMAND to the base class whether we processed | |
989 | // it or not because we did generate an event for it (our | |
990 | // HandleCommand() calls the base class version) and we must | |
991 | // not do it again or the handlers which skip the event would | |
992 | // be called twice | |
993 | processed = true; | |
42e69d6b VZ |
994 | } |
995 | break; | |
996 | ||
a8ff046b VZ |
997 | #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__) |
998 | #if wxUSE_MENUS | |
92f1a59c JS |
999 | case WM_INITMENUPOPUP: |
1000 | processed = HandleInitMenuPopup((WXHMENU) wParam); | |
1001 | break; | |
1002 | ||
a23fd0e1 VZ |
1003 | case WM_MENUSELECT: |
1004 | { | |
42e69d6b VZ |
1005 | WXWORD item, flags; |
1006 | WXHMENU hmenu; | |
1007 | UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu); | |
1008 | ||
1009 | processed = HandleMenuSelect(item, flags, hmenu); | |
a23fd0e1 VZ |
1010 | } |
1011 | break; | |
bc92cdf9 | 1012 | |
ccef86c7 | 1013 | case WM_EXITMENULOOP: |
373a5fb3 | 1014 | processed = HandleMenuLoop(wxEVT_MENU_CLOSE, (WXWORD)wParam); |
ccef86c7 | 1015 | break; |
a8ff046b | 1016 | #endif // wxUSE_MENUS |
ccef86c7 | 1017 | |
42e69d6b VZ |
1018 | case WM_QUERYDRAGICON: |
1019 | { | |
f618020a MB |
1020 | const wxIcon& icon = GetIcon(); |
1021 | HICON hIcon = icon.Ok() ? GetHiconOf(icon) | |
1022 | : (HICON)GetDefaultIcon(); | |
dca0f651 | 1023 | rc = (WXLRESULT)hIcon; |
42e69d6b VZ |
1024 | processed = rc != 0; |
1025 | } | |
1026 | break; | |
ccef86c7 | 1027 | #endif // !__WXMICROWIN__ |
a23fd0e1 VZ |
1028 | } |
1029 | ||
1030 | if ( !processed ) | |
7e25f59e | 1031 | rc = wxFrameBase::MSWWindowProc(message, wParam, lParam); |
a23fd0e1 VZ |
1032 | |
1033 | return rc; | |
1034 | } | |
21802234 | 1035 | |
a9928e9d JS |
1036 | // ---------------------------------------------------------------------------- |
1037 | // wxFrame size management: we exclude the areas taken by menu/status/toolbars | |
1038 | // from the client area, so the client area is what's really available for the | |
1039 | // frame contents | |
1040 | // ---------------------------------------------------------------------------- | |
1041 | ||
1042 | // get the origin of the client area in the client coordinates | |
1043 | wxPoint wxFrame::GetClientAreaOrigin() const | |
1044 | { | |
1045 | wxPoint pt = wxTopLevelWindow::GetClientAreaOrigin(); | |
1046 | ||
1047 | #if wxUSE_TOOLBAR && !defined(__WXUNIVERSAL__) && \ | |
1048 | (!defined(__WXWINCE__) || (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__))) | |
3882e746 | 1049 | wxToolBar * const toolbar = GetToolBar(); |
a9928e9d JS |
1050 | if ( toolbar && toolbar->IsShown() ) |
1051 | { | |
3882e746 | 1052 | const wxSize sizeTB = toolbar->GetSize(); |
a9928e9d | 1053 | |
3882e746 | 1054 | if ( toolbar->HasFlag(wxTB_TOP) ) |
a9928e9d | 1055 | { |
3882e746 | 1056 | pt.y += sizeTB.y; |
a9928e9d | 1057 | } |
3882e746 | 1058 | else if ( toolbar->HasFlag(wxTB_LEFT) ) |
a9928e9d | 1059 | { |
3882e746 | 1060 | pt.x += sizeTB.x; |
a9928e9d JS |
1061 | } |
1062 | } | |
1063 | #endif // wxUSE_TOOLBAR | |
1064 | ||
3d487566 | 1065 | #if defined(WINCE_WITH_COMMANDBAR) |
fb8a56b7 WS |
1066 | if (GetMenuBar() && GetMenuBar()->GetCommandBar()) |
1067 | { | |
1068 | RECT rect; | |
1069 | ::GetWindowRect((HWND) GetMenuBar()->GetCommandBar(), &rect); | |
1070 | pt.y += (rect.bottom - rect.top); | |
1071 | } | |
a9928e9d JS |
1072 | #endif |
1073 | ||
1074 | return pt; | |
1075 | } |