]>
Commit | Line | Data |
---|---|---|
82c9f85c | 1 | /////////////////////////////////////////////////////////////////////////////// |
faa49bfd | 2 | // Name: src/msw/toplevel.cpp |
82c9f85c VZ |
3 | // Purpose: implements wxTopLevelWindow for MSW |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 24.09.01 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com) | |
65571936 | 9 | // License: wxWindows licence |
82c9f85c VZ |
10 | /////////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
82c9f85c VZ |
20 | // For compilers that support precompilation, includes "wx.h". |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
1832043f WS |
27 | #include "wx/toplevel.h" |
28 | ||
82c9f85c | 29 | #ifndef WX_PRECOMP |
3a922bb4 | 30 | #include "wx/app.h" |
28b68852 | 31 | #include "wx/dialog.h" |
82c9f85c VZ |
32 | #include "wx/string.h" |
33 | #include "wx/log.h" | |
34 | #include "wx/intl.h" | |
14dd645e | 35 | #include "wx/frame.h" |
706d74ab | 36 | #include "wx/containr.h" // wxSetFocusToChild() |
82c9f85c VZ |
37 | #endif //WX_PRECOMP |
38 | ||
2b5f62a0 | 39 | #include "wx/module.h" |
dc92adaf | 40 | #include "wx/dynlib.h" |
2b5f62a0 | 41 | |
82c9f85c | 42 | #include "wx/msw/private.h" |
3d487566 | 43 | #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) |
80a81a12 JS |
44 | #include <ole2.h> |
45 | #include <shellapi.h> | |
3874e500 | 46 | // Standard SDK doesn't have aygshell.dll: see include/wx/msw/wince/libraries.h |
a9928e9d | 47 | #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__) |
2d36b3d8 JS |
48 | #include <aygshell.h> |
49 | #endif | |
50 | #include "wx/msw/wince/missing.h" | |
80a81a12 JS |
51 | #endif |
52 | ||
d61c1a6f | 53 | #include "wx/msw/missing.h" |
4676948b JS |
54 | #include "wx/msw/winundef.h" |
55 | ||
716645d3 | 56 | #include "wx/display.h" |
7e25f59e | 57 | |
e121a72a MB |
58 | #ifndef ICON_BIG |
59 | #define ICON_BIG 1 | |
60 | #endif | |
61 | ||
62 | #ifndef ICON_SMALL | |
63 | #define ICON_SMALL 0 | |
64 | #endif | |
65 | ||
82c9f85c VZ |
66 | // ---------------------------------------------------------------------------- |
67 | // stubs for missing functions under MicroWindows | |
68 | // ---------------------------------------------------------------------------- | |
69 | ||
70 | #ifdef __WXMICROWIN__ | |
71 | ||
bfbb0b4c WS |
72 | // static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return false; } |
73 | static inline bool IsZoomed(HWND WXUNUSED(hwnd)) { return false; } | |
82c9f85c VZ |
74 | |
75 | #endif // __WXMICROWIN__ | |
76 | ||
12447831 VZ |
77 | // NB: wxDlgProc must be defined here and not in dialog.cpp because the latter |
78 | // is not included by wxUniv build which does need wxDlgProc | |
61179e28 VZ |
79 | LONG APIENTRY _EXPORT |
80 | wxDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam); | |
81 | ||
82c9f85c VZ |
82 | // ---------------------------------------------------------------------------- |
83 | // globals | |
84 | // ---------------------------------------------------------------------------- | |
85 | ||
77ffb593 | 86 | // the name of the default wxWidgets class |
46fa338b RR |
87 | #ifdef __WXWINCE__ |
88 | extern wxChar *wxCanvasClassName; | |
89 | #else | |
b225f659 | 90 | extern const wxChar *wxCanvasClassName; |
46fa338b | 91 | #endif |
b225f659 | 92 | |
2b5f62a0 VZ |
93 | // ---------------------------------------------------------------------------- |
94 | // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a | |
95 | // module to ensure that the window is always deleted) | |
96 | // ---------------------------------------------------------------------------- | |
97 | ||
98 | class wxTLWHiddenParentModule : public wxModule | |
99 | { | |
100 | public: | |
101 | // module init/finalize | |
102 | virtual bool OnInit(); | |
103 | virtual void OnExit(); | |
104 | ||
105 | // get the hidden window (creates on demand) | |
106 | static HWND GetHWND(); | |
107 | ||
108 | private: | |
109 | // the HWND of the hidden parent | |
110 | static HWND ms_hwnd; | |
111 | ||
112 | // the class used to create it | |
113 | static const wxChar *ms_className; | |
114 | ||
115 | DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule) | |
116 | }; | |
117 | ||
118 | IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule, wxModule) | |
9dfef5ac | 119 | |
82c9f85c VZ |
120 | // ============================================================================ |
121 | // wxTopLevelWindowMSW implementation | |
122 | // ============================================================================ | |
123 | ||
085ad686 VZ |
124 | BEGIN_EVENT_TABLE(wxTopLevelWindowMSW, wxTopLevelWindowBase) |
125 | EVT_ACTIVATE(wxTopLevelWindowMSW::OnActivate) | |
126 | END_EVENT_TABLE() | |
127 | ||
82c9f85c VZ |
128 | // ---------------------------------------------------------------------------- |
129 | // wxTopLevelWindowMSW creation | |
130 | // ---------------------------------------------------------------------------- | |
131 | ||
132 | void wxTopLevelWindowMSW::Init() | |
133 | { | |
134 | m_iconized = | |
bfbb0b4c | 135 | m_maximizeOnShow = false; |
b225f659 | 136 | |
c641b1d2 VS |
137 | // Data to save/restore when calling ShowFullScreen |
138 | m_fsStyle = 0; | |
139 | m_fsOldWindowStyle = 0; | |
bfbb0b4c WS |
140 | m_fsIsMaximized = false; |
141 | m_fsIsShowing = false; | |
085ad686 VZ |
142 | |
143 | m_winLastFocused = (wxWindow *)NULL; | |
fb8a56b7 | 144 | |
3180bc0e | 145 | #if defined(__SMARTPHONE__) && defined(__WXWINCE__) |
fb8a56b7 WS |
146 | m_MenuBarHWND = 0; |
147 | #endif | |
08b97268 WS |
148 | |
149 | #if defined(__SMARTPHONE__) || defined(__POCKETPC__) | |
150 | SHACTIVATEINFO* info = new SHACTIVATEINFO; | |
151 | wxZeroMemory(*info); | |
152 | info->cbSize = sizeof(SHACTIVATEINFO); | |
153 | ||
154 | m_activateInfo = (void*) info; | |
155 | #endif | |
b225f659 VZ |
156 | } |
157 | ||
b2d5a7ee | 158 | WXDWORD wxTopLevelWindowMSW::MSWGetStyle(long style, WXDWORD *exflags) const |
b225f659 | 159 | { |
b2d5a7ee VZ |
160 | // let the base class deal with the common styles but fix the ones which |
161 | // don't make sense for us (we also deal with the borders ourselves) | |
162 | WXDWORD msflags = wxWindow::MSWGetStyle | |
163 | ( | |
164 | (style & ~wxBORDER_MASK) | wxBORDER_NONE, exflags | |
31e7e89f | 165 | ) & ~WS_CHILD & ~WS_VISIBLE; |
b225f659 | 166 | |
aa29eefa JS |
167 | // For some reason, WS_VISIBLE needs to be defined on creation for |
168 | // SmartPhone 2003. The title can fail to be displayed otherwise. | |
169 | #if defined(__SMARTPHONE__) || (defined(__WXWINCE__) && _WIN32_WCE < 400) | |
c1855476 | 170 | msflags |= WS_VISIBLE; |
aa29eefa | 171 | ((wxTopLevelWindowMSW*)this)->wxWindowBase::Show(true); |
c1855476 RR |
172 | #endif |
173 | ||
b225f659 | 174 | // first select the kind of window being created |
dfb06c62 VZ |
175 | // |
176 | // note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and | |
0fcd3b92 VZ |
177 | // creates a window with both caption and border, hence we need to use |
178 | // WS_POPUP in a few cases just to avoid having caption/border which we | |
179 | // don't want | |
0e082993 VZ |
180 | |
181 | // border and caption styles | |
6f26f98e | 182 | if ( ( style & wxRESIZE_BORDER ) && !IsAlwaysMaximized()) |
0e082993 | 183 | msflags |= WS_THICKFRAME; |
f8d56830 JS |
184 | else if ( exflags && ((style & wxBORDER_DOUBLE) || (style & wxBORDER_RAISED)) ) |
185 | *exflags |= WS_EX_DLGMODALFRAME; | |
0e082993 VZ |
186 | else if ( !(style & wxBORDER_NONE) ) |
187 | msflags |= WS_BORDER; | |
9cce2fe2 | 188 | #ifndef __POCKETPC__ |
dfb06c62 VZ |
189 | else |
190 | msflags |= WS_POPUP; | |
82eda5ec | 191 | #endif |
0e082993 | 192 | |
9ceeecb9 | 193 | // normally we consider that all windows without a caption must be popups, |
f76858d8 VZ |
194 | // but CE is an exception: there windows normally do not have the caption |
195 | // but shouldn't be made popups as popups can't have menus and don't look | |
196 | // like normal windows anyhow | |
9ceeecb9 JS |
197 | |
198 | // TODO: Smartphone appears to like wxCAPTION, but we should check that | |
199 | // we need it. | |
200 | #if defined(__SMARTPHONE__) || !defined(__WXWINCE__) | |
0e082993 VZ |
201 | if ( style & wxCAPTION ) |
202 | msflags |= WS_CAPTION; | |
f76858d8 | 203 | #ifndef __WXWINCE__ |
dfb06c62 | 204 | else |
b225f659 | 205 | msflags |= WS_POPUP; |
f76858d8 | 206 | #endif // !__WXWINCE__ |
9ceeecb9 | 207 | #endif |
e5aa8b81 | 208 | |
b225f659 | 209 | // next translate the individual flags |
dc134969 VZ |
210 | |
211 | // WS_EX_CONTEXTHELP is incompatible with WS_MINIMIZEBOX and WS_MAXIMIZEBOX | |
212 | // and is ignored if we specify both of them, but chances are that if we | |
7ce6cc9b | 213 | // use wxWS_EX_CONTEXTHELP, we really do want to have the context help |
dc134969 VZ |
214 | // button while wxMINIMIZE/wxMAXIMIZE are included by default, so the help |
215 | // takes precedence | |
7ce6cc9b | 216 | if ( !(GetExtraStyle() & wxWS_EX_CONTEXTHELP) ) |
dc134969 VZ |
217 | { |
218 | if ( style & wxMINIMIZE_BOX ) | |
219 | msflags |= WS_MINIMIZEBOX; | |
220 | if ( style & wxMAXIMIZE_BOX ) | |
221 | msflags |= WS_MAXIMIZEBOX; | |
222 | } | |
9ceeecb9 | 223 | |
faa49bfd | 224 | #ifndef __WXWINCE__ |
b225f659 VZ |
225 | if ( style & wxSYSTEM_MENU ) |
226 | msflags |= WS_SYSMENU; | |
9ceeecb9 | 227 | #endif |
2a47cb1b | 228 | |
f76858d8 VZ |
229 | // NB: under CE these 2 styles are not supported currently, we should |
230 | // call Minimize()/Maximize() "manually" if we want to support them | |
b225f659 VZ |
231 | if ( style & wxMINIMIZE ) |
232 | msflags |= WS_MINIMIZE; | |
9ceeecb9 | 233 | |
b225f659 VZ |
234 | if ( style & wxMAXIMIZE ) |
235 | msflags |= WS_MAXIMIZE; | |
0e082993 | 236 | |
b225f659 | 237 | // Keep this here because it saves recoding this function in wxTinyFrame |
b225f659 VZ |
238 | if ( style & (wxTINY_CAPTION_VERT | wxTINY_CAPTION_HORIZ) ) |
239 | msflags |= WS_CAPTION; | |
82eda5ec | 240 | |
b225f659 VZ |
241 | if ( exflags ) |
242 | { | |
f76858d8 | 243 | // there is no taskbar under CE, so omit all this |
45f27284 | 244 | #if !defined(__WXWINCE__) |
35bf863b VZ |
245 | if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ) |
246 | { | |
9dfef5ac VZ |
247 | if ( style & wxFRAME_TOOL_WINDOW ) |
248 | { | |
249 | // create the palette-like window | |
35bf863b | 250 | *exflags |= WS_EX_TOOLWINDOW; |
404a4d93 VZ |
251 | |
252 | // tool windows shouldn't appear on the taskbar (as documented) | |
253 | style |= wxFRAME_NO_TASKBAR; | |
9dfef5ac VZ |
254 | } |
255 | ||
256 | // We have to solve 2 different problems here: | |
257 | // | |
258 | // 1. frames with wxFRAME_NO_TASKBAR flag shouldn't appear in the | |
259 | // taskbar even if they don't have a parent | |
260 | // | |
261 | // 2. frames without this style should appear in the taskbar even | |
262 | // if they're owned (Windows only puts non owned windows into | |
263 | // the taskbar normally) | |
264 | // | |
265 | // The second one is solved here by using WS_EX_APPWINDOW flag, the | |
266 | // first one is dealt with in our MSWGetParent() method | |
267 | // implementation | |
268 | if ( !(style & wxFRAME_NO_TASKBAR) && GetParent() ) | |
269 | { | |
270 | // need to force the frame to appear in the taskbar | |
35bf863b | 271 | *exflags |= WS_EX_APPWINDOW; |
9dfef5ac VZ |
272 | } |
273 | //else: nothing to do [here] | |
35bf863b | 274 | } |
b554cf63 | 275 | |
7ce6cc9b | 276 | if ( GetExtraStyle() & wxWS_EX_CONTEXTHELP ) |
b554cf63 | 277 | *exflags |= WS_EX_CONTEXTHELP; |
f76858d8 | 278 | #endif // !__WXWINCE__ |
b225f659 VZ |
279 | |
280 | if ( style & wxSTAY_ON_TOP ) | |
281 | *exflags |= WS_EX_TOPMOST; | |
b225f659 VZ |
282 | } |
283 | ||
284 | return msflags; | |
285 | } | |
286 | ||
9dfef5ac VZ |
287 | WXHWND wxTopLevelWindowMSW::MSWGetParent() const |
288 | { | |
289 | // for the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL | |
290 | // parent HWND or it would be always on top of its parent which is not what | |
291 | // we usually want (in fact, we only want it for frames with the | |
292 | // wxFRAME_FLOAT_ON_PARENT flag) | |
2b5f62a0 | 293 | HWND hwndParent = NULL; |
9dfef5ac VZ |
294 | if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) ) |
295 | { | |
2b5f62a0 | 296 | const wxWindow *parent = GetParent(); |
9dfef5ac | 297 | |
2b5f62a0 VZ |
298 | if ( !parent ) |
299 | { | |
300 | // this flag doesn't make sense then and will be ignored | |
301 | wxFAIL_MSG( _T("wxFRAME_FLOAT_ON_PARENT but no parent?") ); | |
302 | } | |
303 | else | |
304 | { | |
305 | hwndParent = GetHwndOf(parent); | |
306 | } | |
9dfef5ac | 307 | } |
2b5f62a0 | 308 | //else: don't float on parent, must not be owned |
9dfef5ac VZ |
309 | |
310 | // now deal with the 2nd taskbar-related problem (see comments above in | |
311 | // MSWGetStyle()) | |
2b5f62a0 | 312 | if ( HasFlag(wxFRAME_NO_TASKBAR) && !hwndParent ) |
9dfef5ac | 313 | { |
2b5f62a0 VZ |
314 | // use hidden parent |
315 | hwndParent = wxTLWHiddenParentModule::GetHWND(); | |
9dfef5ac VZ |
316 | } |
317 | ||
2b5f62a0 | 318 | return (WXHWND)hwndParent; |
9dfef5ac VZ |
319 | } |
320 | ||
b7e5ba8f JG |
321 | #if defined(__SMARTPHONE__) || defined(__POCKETPC__) |
322 | bool wxTopLevelWindowMSW::HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam) | |
323 | { | |
324 | SHACTIVATEINFO *info = (SHACTIVATEINFO*) m_activateInfo; | |
325 | if ( info ) | |
326 | { | |
1272e71b | 327 | SHHandleWMSettingChange(GetHwnd(), wParam, lParam, info); |
b7e5ba8f JG |
328 | } |
329 | ||
1272e71b | 330 | return wxWindowMSW::HandleSettingChange(wParam, lParam); |
b7e5ba8f JG |
331 | } |
332 | #endif | |
333 | ||
08b97268 WS |
334 | WXLRESULT wxTopLevelWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam) |
335 | { | |
336 | WXLRESULT rc = 0; | |
337 | bool processed = false; | |
338 | ||
8b0df0e1 | 339 | #if defined(__SMARTPHONE__) || defined(__POCKETPC__) |
08b97268 WS |
340 | switch ( message ) |
341 | { | |
08b97268 WS |
342 | case WM_ACTIVATE: |
343 | { | |
344 | SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo; | |
345 | if (info) | |
346 | { | |
347 | DWORD flags = 0; | |
348 | if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) flags = SHA_INPUTDIALOG; | |
349 | SHHandleWMActivate(GetHwnd(), wParam, lParam, info, flags); | |
350 | } | |
351 | ||
352 | // This implicitly sends a wxEVT_ACTIVATE_APP event | |
353 | if (wxTheApp) | |
354 | wxTheApp->SetActive(wParam != 0, FindFocus()); | |
355 | ||
356 | break; | |
357 | } | |
08b97268 WS |
358 | case WM_HIBERNATE: |
359 | { | |
360 | if (wxTheApp) | |
361 | { | |
362 | wxActivateEvent event(wxEVT_HIBERNATE, true, wxID_ANY); | |
363 | event.SetEventObject(wxTheApp); | |
364 | processed = wxTheApp->ProcessEvent(event); | |
365 | } | |
366 | break; | |
367 | } | |
08b97268 | 368 | } |
8b0df0e1 | 369 | #endif |
08b97268 WS |
370 | |
371 | if ( !processed ) | |
372 | rc = wxTopLevelWindowBase::MSWWindowProc(message, wParam, lParam); | |
373 | ||
374 | return rc; | |
375 | } | |
376 | ||
6e8515a3 | 377 | bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate, |
b225f659 VZ |
378 | const wxString& title, |
379 | const wxPoint& pos, | |
380 | const wxSize& size) | |
381 | { | |
382 | #ifdef __WXMICROWIN__ | |
383 | // no dialogs support under MicroWin yet | |
384 | return CreateFrame(title, pos, size); | |
385 | #else // !__WXMICROWIN__ | |
386 | wxWindow *parent = GetParent(); | |
387 | ||
388 | // for the dialogs without wxDIALOG_NO_PARENT style, use the top level | |
389 | // app window as parent - this avoids creating modal dialogs without | |
390 | // parent | |
391 | if ( !parent && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT) ) | |
392 | { | |
393 | parent = wxTheApp->GetTopWindow(); | |
e058b98d | 394 | |
39cc7a0b | 395 | if ( parent ) |
e058b98d | 396 | { |
39cc7a0b VZ |
397 | // don't use transient windows as parents, this is dangerous as it |
398 | // can lead to a crash if the parent is destroyed before the child | |
399 | // | |
400 | // also don't use the window which is currently hidden as then the | |
401 | // dialog would be hidden as well | |
402 | if ( (parent->GetExtraStyle() & wxWS_EX_TRANSIENT) || | |
403 | !parent->IsShown() ) | |
404 | { | |
405 | parent = NULL; | |
406 | } | |
e058b98d | 407 | } |
b225f659 VZ |
408 | } |
409 | ||
434005ca VZ |
410 | m_hWnd = (WXHWND)::CreateDialogIndirect |
411 | ( | |
412 | wxGetInstance(), | |
413 | (DLGTEMPLATE*)dlgTemplate, | |
414 | parent ? GetHwndOf(parent) : NULL, | |
415 | (DLGPROC)wxDlgProc | |
416 | ); | |
b225f659 VZ |
417 | |
418 | if ( !m_hWnd ) | |
419 | { | |
7e99eddf | 420 | wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?")); |
b225f659 | 421 | |
7e99eddf | 422 | wxLogSysError(wxT("Can't create dialog using memory template")); |
b225f659 | 423 | |
bfbb0b4c | 424 | return false; |
b225f659 VZ |
425 | } |
426 | ||
b2d5a7ee | 427 | WXDWORD exflags; |
b225f659 VZ |
428 | (void)MSWGetCreateWindowFlags(&exflags); |
429 | ||
430 | if ( exflags ) | |
431 | { | |
432 | ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exflags); | |
cef338d3 VZ |
433 | ::SetWindowPos(GetHwnd(), |
434 | exflags & WS_EX_TOPMOST ? HWND_TOPMOST : 0, | |
435 | 0, 0, 0, 0, | |
b225f659 VZ |
436 | SWP_NOSIZE | |
437 | SWP_NOMOVE | | |
cef338d3 | 438 | (exflags & WS_EX_TOPMOST ? 0 : SWP_NOZORDER) | |
b225f659 VZ |
439 | SWP_NOACTIVATE); |
440 | } | |
441 | ||
b554cf63 | 442 | #if !defined(__WXWINCE__) |
b225f659 VZ |
443 | // For some reason, the system menu is activated when we use the |
444 | // WS_EX_CONTEXTHELP style, so let's set a reasonable icon | |
445 | if ( exflags & WS_EX_CONTEXTHELP ) | |
446 | { | |
447 | wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame); | |
448 | if ( winTop ) | |
449 | { | |
450 | wxIcon icon = winTop->GetIcon(); | |
451 | if ( icon.Ok() ) | |
452 | { | |
453 | ::SendMessage(GetHwnd(), WM_SETICON, | |
454 | (WPARAM)TRUE, | |
455 | (LPARAM)GetHiconOf(icon)); | |
456 | } | |
457 | } | |
458 | } | |
b554cf63 | 459 | #endif |
b225f659 VZ |
460 | |
461 | // move the dialog to its initial position without forcing repainting | |
462 | int x, y, w, h; | |
72a11184 | 463 | (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h); |
4c53c743 | 464 | |
26268100 RD |
465 | if ( x == (int)CW_USEDEFAULT ) |
466 | { | |
467 | // centre it on the screen - what else can we do? | |
468 | wxSize sizeDpy = wxGetDisplaySize(); | |
469 | ||
470 | x = (sizeDpy.x - w) / 2; | |
471 | y = (sizeDpy.y - h) / 2; | |
472 | } | |
473 | ||
a9928e9d | 474 | #if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__) |
4c53c743 VZ |
475 | if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) ) |
476 | { | |
477 | wxLogLastError(wxT("MoveWindow")); | |
b225f659 | 478 | } |
28c191aa | 479 | #endif |
b225f659 VZ |
480 | |
481 | if ( !title.empty() ) | |
482 | { | |
483 | ::SetWindowText(GetHwnd(), title); | |
484 | } | |
485 | ||
486 | SubclassWin(m_hWnd); | |
faa49bfd | 487 | |
aa29eefa JS |
488 | #ifdef __SMARTPHONE__ |
489 | // Work around title non-display glitch | |
490 | Show(false); | |
faa49bfd | 491 | #endif |
b225f659 | 492 | |
bfbb0b4c | 493 | return true; |
b225f659 VZ |
494 | #endif // __WXMICROWIN__/!__WXMICROWIN__ |
495 | } | |
496 | ||
497 | bool wxTopLevelWindowMSW::CreateFrame(const wxString& title, | |
498 | const wxPoint& pos, | |
499 | const wxSize& size) | |
500 | { | |
b2d5a7ee VZ |
501 | WXDWORD exflags; |
502 | WXDWORD flags = MSWGetCreateWindowFlags(&exflags); | |
b225f659 | 503 | |
6fd54d58 | 504 | const wxSize sz = IsAlwaysMaximized() ? wxDefaultSize : size; |
6f26f98e | 505 | |
6fd54d58 | 506 | return MSWCreate(wxCanvasClassName, title, pos, sz, flags, exflags); |
82c9f85c VZ |
507 | } |
508 | ||
509 | bool wxTopLevelWindowMSW::Create(wxWindow *parent, | |
510 | wxWindowID id, | |
511 | const wxString& title, | |
512 | const wxPoint& pos, | |
513 | const wxSize& size, | |
514 | long style, | |
515 | const wxString& name) | |
516 | { | |
999836aa | 517 | bool ret wxDUMMY_INITIALIZE(false); |
2a47cb1b | 518 | |
82c9f85c VZ |
519 | // init our fields |
520 | Init(); | |
2a47cb1b VZ |
521 | |
522 | wxSize sizeReal = size; | |
523 | if ( !sizeReal.IsFullySpecified() ) | |
524 | { | |
525 | sizeReal.SetDefaults(GetDefaultSize()); | |
526 | } | |
82c9f85c VZ |
527 | |
528 | m_windowStyle = style; | |
529 | ||
530 | SetName(name); | |
531 | ||
bfbb0b4c | 532 | m_windowId = id == wxID_ANY ? NewControlId() : id; |
82c9f85c VZ |
533 | |
534 | wxTopLevelWindows.Append(this); | |
535 | ||
536 | if ( parent ) | |
537 | parent->AddChild(this); | |
538 | ||
b225f659 VZ |
539 | if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG ) |
540 | { | |
b225f659 VZ |
541 | // we have different dialog templates to allows creation of dialogs |
542 | // with & without captions under MSWindows, resizeable or not (but a | |
543 | // resizeable dialog always has caption - otherwise it would look too | |
544 | // strange) | |
434005ca VZ |
545 | |
546 | // we need 3 additional WORDs for dialog menu, class and title (as we | |
547 | // don't use DS_SETFONT we don't need the fourth WORD for the font) | |
548 | static const int dlgsize = sizeof(DLGTEMPLATE) + (sizeof(WORD) * 3); | |
549 | DLGTEMPLATE *dlgTemplate = (DLGTEMPLATE *)malloc(dlgsize); | |
550 | memset(dlgTemplate, 0, dlgsize); | |
551 | ||
552 | // these values are arbitrary, they won't be used normally anyhow | |
6e8515a3 JS |
553 | dlgTemplate->x = 34; |
554 | dlgTemplate->y = 22; | |
555 | dlgTemplate->cx = 144; | |
556 | dlgTemplate->cy = 75; | |
557 | ||
434005ca VZ |
558 | // reuse the code in MSWGetStyle() but correct the results slightly for |
559 | // the dialog | |
560 | dlgTemplate->style = MSWGetStyle(style, NULL); | |
561 | ||
562 | // all dialogs are popups | |
563 | dlgTemplate->style |= WS_POPUP; | |
564 | ||
9cce2fe2 | 565 | #ifndef __WXWINCE__ |
434005ca VZ |
566 | // force 3D-look if necessary, it looks impossibly ugly otherwise |
567 | if ( style & (wxRESIZE_BORDER | wxCAPTION) ) | |
568 | dlgTemplate->style |= DS_MODALFRAME; | |
9cce2fe2 | 569 | #endif |
b225f659 | 570 | |
2a47cb1b | 571 | ret = CreateDialog(dlgTemplate, title, pos, sizeReal); |
6e8515a3 | 572 | free(dlgTemplate); |
b225f659 VZ |
573 | } |
574 | else // !dialog | |
575 | { | |
2a47cb1b | 576 | ret = CreateFrame(title, pos, sizeReal); |
9ca4dd06 VS |
577 | } |
578 | ||
9ceeecb9 | 579 | #ifndef __WXWINCE__ |
9ca4dd06 VS |
580 | if ( ret && !(GetWindowStyleFlag() & wxCLOSE_BOX) ) |
581 | { | |
582 | EnableCloseButton(false); | |
b225f659 | 583 | } |
9ceeecb9 | 584 | #endif |
9ca4dd06 | 585 | |
d7e0024b VZ |
586 | // for standard dialogs the dialog manager generates WM_CHANGEUISTATE |
587 | // itself but for custom windows we have to do it ourselves in order to | |
588 | // make the keyboard indicators (such as underlines for accelerators and | |
589 | // focus rectangles) work under Win2k+ | |
bb655ead VZ |
590 | if ( ret ) |
591 | { | |
3ef092d6 | 592 | MSWUpdateUIState(UIS_INITIALIZE); |
bb655ead VZ |
593 | } |
594 | ||
f43255e8 WS |
595 | // Note: if we include PocketPC in this test, dialogs can fail to show up, |
596 | // for example the text entry dialog in the dialogs sample. Problem with Maximise()? | |
597 | #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__)) | |
6f26f98e | 598 | if ( ( style & wxMAXIMIZE ) || IsAlwaysMaximized() ) |
991420e6 WS |
599 | { |
600 | this->Maximize(); | |
601 | } | |
f43255e8 | 602 | #endif |
82eda5ec | 603 | |
3180bc0e | 604 | #if defined(__SMARTPHONE__) && defined(__WXWINCE__) |
fb8a56b7 WS |
605 | SetRightMenu(); // to nothing for initialization |
606 | #endif | |
607 | ||
9ca4dd06 | 608 | return ret; |
82c9f85c VZ |
609 | } |
610 | ||
611 | wxTopLevelWindowMSW::~wxTopLevelWindowMSW() | |
612 | { | |
08b97268 WS |
613 | #if defined(__SMARTPHONE__) || defined(__POCKETPC__) |
614 | SHACTIVATEINFO* info = (SHACTIVATEINFO*) m_activateInfo; | |
615 | delete info; | |
616 | m_activateInfo = NULL; | |
617 | #endif | |
618 | ||
d6fb86a8 VZ |
619 | // after destroying an owned window, Windows activates the next top level |
620 | // window in Z order but it may be different from our owner (to reproduce | |
621 | // this simply Alt-TAB to another application and back before closing the | |
622 | // owned frame) whereas we always want to yield activation to our parent | |
623 | if ( HasFlag(wxFRAME_FLOAT_ON_PARENT) ) | |
624 | { | |
625 | wxWindow *parent = GetParent(); | |
626 | if ( parent ) | |
627 | { | |
628 | ::BringWindowToTop(GetHwndOf(parent)); | |
629 | } | |
630 | } | |
82c9f85c VZ |
631 | } |
632 | ||
82c9f85c VZ |
633 | // ---------------------------------------------------------------------------- |
634 | // wxTopLevelWindowMSW showing | |
635 | // ---------------------------------------------------------------------------- | |
636 | ||
637 | void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd) | |
638 | { | |
639 | ::ShowWindow(GetHwnd(), nShowCmd); | |
640 | ||
641 | m_iconized = nShowCmd == SW_MINIMIZE; | |
642 | } | |
643 | ||
644 | bool wxTopLevelWindowMSW::Show(bool show) | |
645 | { | |
646 | // don't use wxWindow version as we want to call DoShowWindow() ourselves | |
647 | if ( !wxWindowBase::Show(show) ) | |
bfbb0b4c | 648 | return false; |
82c9f85c VZ |
649 | |
650 | int nShowCmd; | |
651 | if ( show ) | |
652 | { | |
653 | if ( m_maximizeOnShow ) | |
654 | { | |
655 | // show and maximize | |
656 | nShowCmd = SW_MAXIMIZE; | |
657 | ||
991420e6 | 658 | // This is necessary, or no window appears |
aa29eefa | 659 | #if defined( __WINCE_STANDARDSDK__) || defined(__SMARTPHONE__) |
991420e6 | 660 | DoShowWindow(SW_SHOW); |
a9928e9d JS |
661 | #endif |
662 | ||
bfbb0b4c | 663 | m_maximizeOnShow = false; |
82c9f85c VZ |
664 | } |
665 | else // just show | |
666 | { | |
84cff965 JS |
667 | if ( GetWindowStyle() & wxFRAME_TOOL_WINDOW ) |
668 | nShowCmd = SW_SHOWNA; | |
669 | else | |
670 | nShowCmd = SW_SHOW; | |
82c9f85c VZ |
671 | } |
672 | } | |
673 | else // hide | |
674 | { | |
675 | nShowCmd = SW_HIDE; | |
676 | } | |
677 | ||
678 | DoShowWindow(nShowCmd); | |
679 | ||
a9928e9d JS |
680 | #if defined(__WXWINCE__) && (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__)) |
681 | // Addornments have to be added when the frame is the correct size | |
682 | wxFrame* frame = wxDynamicCast(this, wxFrame); | |
683 | if (frame && frame->GetMenuBar()) | |
684 | frame->GetMenuBar()->AddAdornments(GetWindowStyleFlag()); | |
685 | #endif | |
0567fdfc | 686 | |
6fd54d58 VZ |
687 | // we only set pending size if we're maximized before being shown, now that |
688 | // we're shown we don't need it any more (it is reset in size event handler | |
689 | // for child windows but we have to do it ourselves for this parent window) | |
690 | m_pendingSize = wxDefaultSize; | |
691 | ||
0567fdfc | 692 | return true; |
82c9f85c VZ |
693 | } |
694 | ||
695 | // ---------------------------------------------------------------------------- | |
696 | // wxTopLevelWindowMSW maximize/minimize | |
697 | // ---------------------------------------------------------------------------- | |
698 | ||
699 | void wxTopLevelWindowMSW::Maximize(bool maximize) | |
700 | { | |
701 | if ( IsShown() ) | |
702 | { | |
703 | // just maximize it directly | |
704 | DoShowWindow(maximize ? SW_MAXIMIZE : SW_RESTORE); | |
705 | } | |
706 | else // hidden | |
707 | { | |
73c902d6 DS |
708 | // we can't maximize the hidden frame because it shows it as well, |
709 | // so just remember that we should do it later in this case | |
a0be434e | 710 | m_maximizeOnShow = maximize; |
ac2de323 VZ |
711 | |
712 | // after calling Maximize() the client code expects to get the frame | |
713 | // "real" size and doesn't want to know that, because of implementation | |
714 | // details, the frame isn't really maximized yet but will be only once | |
715 | // it's shown, so return our size as it will be then in this case | |
7889b795 VZ |
716 | if ( maximize ) |
717 | { | |
6fd54d58 VZ |
718 | // we must only change pending size here, and not call SetSize() |
719 | // because otherwise Windows would think that this (full screen) | |
720 | // size is the natural size for the frame and so would use it when | |
721 | // the user clicks on "restore" title bar button instead of the | |
722 | // correct initial frame size | |
723 | // | |
724 | // NB: unfortunately we don't know which display we're on yet so we | |
725 | // have to use the default one | |
726 | m_pendingSize = wxGetClientDisplayRect().GetSize(); | |
7889b795 VZ |
727 | } |
728 | //else: can't do anything in this case, we don't have the old size | |
82c9f85c VZ |
729 | } |
730 | } | |
731 | ||
732 | bool wxTopLevelWindowMSW::IsMaximized() const | |
733 | { | |
979a0320 WS |
734 | return IsAlwaysMaximized() || |
735 | #if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) | |
736 | (::IsZoomed(GetHwnd()) != 0) || | |
4676948b | 737 | #endif |
979a0320 | 738 | m_maximizeOnShow; |
82c9f85c VZ |
739 | } |
740 | ||
741 | void wxTopLevelWindowMSW::Iconize(bool iconize) | |
742 | { | |
743 | DoShowWindow(iconize ? SW_MINIMIZE : SW_RESTORE); | |
744 | } | |
745 | ||
746 | bool wxTopLevelWindowMSW::IsIconized() const | |
747 | { | |
4676948b | 748 | #ifdef __WXWINCE__ |
bfbb0b4c | 749 | return false; |
4676948b | 750 | #else |
9f01395e VZ |
751 | // don't use m_iconized, it may be briefly out of sync with the real state |
752 | // as it's only modified when we receive a WM_SIZE and we could be called | |
753 | // from an event handler from one of the messages we receive before it, | |
754 | // such as WM_MOVE | |
755 | return ::IsIconic(GetHwnd()) != 0; | |
4676948b | 756 | #endif |
82c9f85c VZ |
757 | } |
758 | ||
759 | void wxTopLevelWindowMSW::Restore() | |
760 | { | |
761 | DoShowWindow(SW_RESTORE); | |
762 | } | |
763 | ||
c641b1d2 VS |
764 | // ---------------------------------------------------------------------------- |
765 | // wxTopLevelWindowMSW fullscreen | |
766 | // ---------------------------------------------------------------------------- | |
767 | ||
768 | bool wxTopLevelWindowMSW::ShowFullScreen(bool show, long style) | |
769 | { | |
716645d3 | 770 | if ( show == IsFullScreen() ) |
c641b1d2 | 771 | { |
716645d3 | 772 | // nothing to do |
bfbb0b4c | 773 | return true; |
716645d3 VZ |
774 | } |
775 | ||
776 | m_fsIsShowing = show; | |
c641b1d2 | 777 | |
716645d3 VZ |
778 | if ( show ) |
779 | { | |
c641b1d2 VS |
780 | m_fsStyle = style; |
781 | ||
782 | // zap the frame borders | |
783 | ||
784 | // save the 'normal' window style | |
716645d3 | 785 | m_fsOldWindowStyle = GetWindowLong(GetHwnd(), GWL_STYLE); |
c641b1d2 VS |
786 | |
787 | // save the old position, width & height, maximize state | |
788 | m_fsOldSize = GetRect(); | |
789 | m_fsIsMaximized = IsMaximized(); | |
790 | ||
791 | // decide which window style flags to turn off | |
792 | LONG newStyle = m_fsOldWindowStyle; | |
793 | LONG offFlags = 0; | |
794 | ||
795 | if (style & wxFULLSCREEN_NOBORDER) | |
4676948b JS |
796 | { |
797 | offFlags |= WS_BORDER; | |
798 | #ifndef __WXWINCE__ | |
799 | offFlags |= WS_THICKFRAME; | |
800 | #endif | |
801 | } | |
c641b1d2 | 802 | if (style & wxFULLSCREEN_NOCAPTION) |
716645d3 | 803 | offFlags |= WS_CAPTION | WS_SYSMENU; |
c641b1d2 | 804 | |
716645d3 | 805 | newStyle &= ~offFlags; |
c641b1d2 VS |
806 | |
807 | // change our window style to be compatible with full-screen mode | |
716645d3 | 808 | ::SetWindowLong(GetHwnd(), GWL_STYLE, newStyle); |
c641b1d2 | 809 | |
716645d3 VZ |
810 | wxRect rect; |
811 | #if wxUSE_DISPLAY | |
812 | // resize to the size of the display containing us | |
813 | int dpy = wxDisplay::GetFromWindow(this); | |
814 | if ( dpy != wxNOT_FOUND ) | |
815 | { | |
816 | rect = wxDisplay(dpy).GetGeometry(); | |
817 | } | |
818 | else // fall back to the main desktop | |
86828e0f | 819 | #endif // wxUSE_DISPLAY |
716645d3 VZ |
820 | { |
821 | // resize to the size of the desktop | |
822 | wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect); | |
80a81a12 JS |
823 | #ifdef __WXWINCE__ |
824 | // FIXME: size of the bottom menu (toolbar) | |
825 | // should be taken in account | |
826 | rect.height += rect.y; | |
827 | rect.y = 0; | |
4676948b | 828 | #endif |
716645d3 | 829 | } |
c641b1d2 | 830 | |
716645d3 | 831 | SetSize(rect); |
c641b1d2 VS |
832 | |
833 | // now flush the window style cache and actually go full-screen | |
716645d3 | 834 | long flags = SWP_FRAMECHANGED; |
c641b1d2 | 835 | |
716645d3 VZ |
836 | // showing the frame full screen should also show it if it's still |
837 | // hidden | |
838 | if ( !IsShown() ) | |
839 | { | |
840 | // don't call wxWindow version to avoid flicker from calling | |
841 | // ::ShowWindow() -- we're going to show the window at the correct | |
842 | // location directly below -- but do call the wxWindowBase version | |
843 | // to sync the internal m_isShown flag | |
844 | wxWindowBase::Show(); | |
c641b1d2 | 845 | |
716645d3 VZ |
846 | flags |= SWP_SHOWWINDOW; |
847 | } | |
c641b1d2 | 848 | |
716645d3 VZ |
849 | SetWindowPos(GetHwnd(), HWND_TOP, |
850 | rect.x, rect.y, rect.width, rect.height, | |
851 | flags); | |
c641b1d2 | 852 | |
3d487566 | 853 | #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400)) |
80a81a12 JS |
854 | ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON); |
855 | #endif | |
856 | ||
716645d3 VZ |
857 | // finally send an event allowing the window to relayout itself &c |
858 | wxSizeEvent event(rect.GetSize(), GetId()); | |
859 | GetEventHandler()->ProcessEvent(event); | |
860 | } | |
861 | else // stop showing full screen | |
862 | { | |
3d487566 | 863 | #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400)) |
80a81a12 JS |
864 | ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON); |
865 | #endif | |
c641b1d2 | 866 | Maximize(m_fsIsMaximized); |
716645d3 VZ |
867 | SetWindowLong(GetHwnd(),GWL_STYLE, m_fsOldWindowStyle); |
868 | SetWindowPos(GetHwnd(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y, | |
c641b1d2 | 869 | m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED); |
c641b1d2 | 870 | } |
716645d3 | 871 | |
bfbb0b4c | 872 | return true; |
c641b1d2 VS |
873 | } |
874 | ||
82c9f85c VZ |
875 | // ---------------------------------------------------------------------------- |
876 | // wxTopLevelWindowMSW misc | |
877 | // ---------------------------------------------------------------------------- | |
878 | ||
faa49bfd WS |
879 | void wxTopLevelWindowMSW::SetTitle( const wxString& title) |
880 | { | |
881 | SetLabel(title); | |
882 | } | |
883 | ||
884 | wxString wxTopLevelWindowMSW::GetTitle() const | |
885 | { | |
886 | return GetLabel(); | |
887 | } | |
888 | ||
82c9f85c VZ |
889 | void wxTopLevelWindowMSW::SetIcon(const wxIcon& icon) |
890 | { | |
f618020a MB |
891 | SetIcons( wxIconBundle( icon ) ); |
892 | } | |
893 | ||
894 | void wxTopLevelWindowMSW::SetIcons(const wxIconBundle& icons) | |
895 | { | |
896 | wxTopLevelWindowBase::SetIcons(icons); | |
82c9f85c | 897 | |
a71d815b | 898 | #if !defined(__WXMICROWIN__) |
f618020a MB |
899 | const wxIcon& sml = icons.GetIcon( wxSize( 16, 16 ) ); |
900 | if( sml.Ok() && sml.GetWidth() == 16 && sml.GetHeight() == 16 ) | |
901 | { | |
902 | ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_SMALL, | |
903 | (LPARAM)GetHiconOf(sml) ); | |
904 | } | |
905 | ||
906 | const wxIcon& big = icons.GetIcon( wxSize( 32, 32 ) ); | |
907 | if( big.Ok() && big.GetWidth() == 32 && big.GetHeight() == 32 ) | |
82c9f85c | 908 | { |
f618020a MB |
909 | ::SendMessage( GetHwndOf( this ), WM_SETICON, ICON_BIG, |
910 | (LPARAM)GetHiconOf(big) ); | |
82c9f85c | 911 | } |
a71d815b | 912 | #endif // !__WXMICROWIN__ |
82c9f85c | 913 | } |
a91cf80c VZ |
914 | |
915 | bool wxTopLevelWindowMSW::EnableCloseButton(bool enable) | |
916 | { | |
4676948b | 917 | #if !defined(__WXMICROWIN__) |
a91cf80c | 918 | // get system (a.k.a. window) menu |
068959b9 | 919 | HMENU hmenu = GetSystemMenu(GetHwnd(), FALSE /* get it */); |
a91cf80c VZ |
920 | if ( !hmenu ) |
921 | { | |
660b1906 VZ |
922 | // no system menu at all -- ok if we want to remove the close button |
923 | // anyhow, but bad if we want to show it | |
924 | return !enable; | |
a91cf80c VZ |
925 | } |
926 | ||
927 | // enabling/disabling the close item from it also automatically | |
928 | // disables/enables the close title bar button | |
aaf765a5 VZ |
929 | if ( ::EnableMenuItem(hmenu, SC_CLOSE, |
930 | MF_BYCOMMAND | | |
931 | (enable ? MF_ENABLED : MF_GRAYED)) == -1 ) | |
a91cf80c VZ |
932 | { |
933 | wxLogLastError(_T("EnableMenuItem(SC_CLOSE)")); | |
934 | ||
bfbb0b4c | 935 | return false; |
a91cf80c | 936 | } |
960b193e | 937 | #ifndef __WXWINCE__ |
a91cf80c VZ |
938 | // update appearance immediately |
939 | if ( !::DrawMenuBar(GetHwnd()) ) | |
940 | { | |
941 | wxLogLastError(_T("DrawMenuBar")); | |
942 | } | |
960b193e | 943 | #endif |
a91cf80c VZ |
944 | #endif // !__WXMICROWIN__ |
945 | ||
bfbb0b4c | 946 | return true; |
a91cf80c VZ |
947 | } |
948 | ||
2a47cb1b VZ |
949 | #ifndef __WXWINCE__ |
950 | ||
1542ea39 RD |
951 | bool wxTopLevelWindowMSW::SetShape(const wxRegion& region) |
952 | { | |
bfbb0b4c | 953 | wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false, |
6a7e6411 RD |
954 | _T("Shaped windows must be created with the wxFRAME_SHAPED style.")); |
955 | ||
1542ea39 RD |
956 | // The empty region signifies that the shape should be removed from the |
957 | // window. | |
958 | if ( region.IsEmpty() ) | |
959 | { | |
960 | if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0) | |
961 | { | |
962 | wxLogLastError(_T("SetWindowRgn")); | |
bfbb0b4c | 963 | return false; |
1542ea39 | 964 | } |
bfbb0b4c | 965 | return true; |
1542ea39 RD |
966 | } |
967 | ||
968 | // Windows takes ownership of the region, so | |
969 | // we'll have to make a copy of the region to give to it. | |
970 | DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL); | |
971 | RGNDATA *rgnData = (RGNDATA*) new char[noBytes]; | |
972 | ::GetRegionData(GetHrgnOf(region), noBytes, rgnData); | |
973 | HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData); | |
974 | delete[] (char*) rgnData; | |
975 | ||
976 | // SetWindowRgn expects the region to be in coordinants | |
977 | // relative to the window, not the client area. Figure | |
978 | // out the offset, if any. | |
979 | RECT rect; | |
980 | DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE); | |
981 | DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE); | |
982 | ::GetClientRect(GetHwnd(), &rect); | |
983 | ::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle); | |
984 | ::OffsetRgn(hrgn, -rect.left, -rect.top); | |
985 | ||
986 | // Now call the shape API with the new region. | |
987 | if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0) | |
988 | { | |
989 | wxLogLastError(_T("SetWindowRgn")); | |
bfbb0b4c | 990 | return false; |
1542ea39 | 991 | } |
bfbb0b4c | 992 | return true; |
1542ea39 RD |
993 | } |
994 | ||
2a47cb1b VZ |
995 | #endif // !__WXWINCE__ |
996 | ||
dc92adaf VZ |
997 | void wxTopLevelWindowMSW::RequestUserAttention(int flags) |
998 | { | |
3a6b0a3e VZ |
999 | // check if we can use FlashWindowEx(): unfortunately a simple test for |
1000 | // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't | |
1001 | // provide FlashWindowEx() declaration, so try to detect whether we have | |
1002 | // real headers for WINVER 0x0500 by checking for existence of a symbol not | |
1003 | // declated in MSVC6 header | |
1004 | #if defined(FLASHW_STOP) && defined(VK_XBUTTON1) | |
dc92adaf VZ |
1005 | // available in the headers, check if it is supported by the system |
1006 | typedef BOOL (WINAPI *FlashWindowEx_t)(FLASHWINFO *pfwi); | |
1007 | FlashWindowEx_t s_pfnFlashWindowEx = NULL; | |
1008 | if ( !s_pfnFlashWindowEx ) | |
1009 | { | |
1010 | wxDynamicLibrary dllUser32(_T("user32.dll")); | |
1011 | s_pfnFlashWindowEx = (FlashWindowEx_t) | |
1012 | dllUser32.GetSymbol(_T("FlashWindowEx")); | |
1013 | ||
3103e8a9 | 1014 | // we can safely unload user32.dll here, it's going to remain loaded as |
dc92adaf VZ |
1015 | // long as the program is running anyhow |
1016 | } | |
1017 | ||
1018 | if ( s_pfnFlashWindowEx ) | |
1019 | { | |
1020 | WinStruct<FLASHWINFO> fwi; | |
1021 | fwi.hwnd = GetHwnd(); | |
1022 | fwi.dwFlags = FLASHW_ALL; | |
1023 | if ( flags & wxUSER_ATTENTION_INFO ) | |
1024 | { | |
1025 | // just flash a few times | |
1026 | fwi.uCount = 3; | |
1027 | } | |
1028 | else // wxUSER_ATTENTION_ERROR | |
1029 | { | |
1030 | // flash until the user notices it | |
1031 | fwi.dwFlags |= FLASHW_TIMERNOFG; | |
1032 | } | |
1033 | ||
1034 | s_pfnFlashWindowEx(&fwi); | |
1035 | } | |
1036 | else // FlashWindowEx() not available | |
4f79eb79 | 1037 | #endif // FlashWindowEx() defined |
dc92adaf VZ |
1038 | { |
1039 | wxUnusedVar(flags); | |
068959b9 | 1040 | #ifndef __WXWINCE__ |
dc92adaf | 1041 | ::FlashWindow(GetHwnd(), TRUE); |
068959b9 | 1042 | #endif // __WXWINCE__ |
dc92adaf VZ |
1043 | } |
1044 | } | |
1045 | ||
50f3c41d RD |
1046 | // --------------------------------------------------------------------------- |
1047 | ||
07880314 | 1048 | bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha) |
50f3c41d RD |
1049 | { |
1050 | typedef DWORD (WINAPI *PSETLAYEREDWINDOWATTR)(HWND, DWORD, BYTE, DWORD); | |
1051 | static PSETLAYEREDWINDOWATTR pSetLayeredWindowAttributes = NULL; | |
1052 | ||
50f3c41d RD |
1053 | if ( pSetLayeredWindowAttributes == NULL ) |
1054 | { | |
1055 | wxDynamicLibrary dllUser32(_T("user32.dll")); | |
1056 | pSetLayeredWindowAttributes = (PSETLAYEREDWINDOWATTR) | |
1057 | dllUser32.GetSymbol(wxT("SetLayeredWindowAttributes")); | |
1058 | } | |
1059 | if ( pSetLayeredWindowAttributes == NULL ) | |
1060 | return false; | |
1061 | ||
1062 | LONG exstyle = GetWindowLong(GetHwnd(), GWL_EXSTYLE); | |
1063 | ||
1064 | // if setting alpha to fully opaque then turn off the layered style | |
1065 | if (alpha == 255) | |
1066 | { | |
1067 | SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle & ~WS_EX_LAYERED); | |
1068 | Refresh(); | |
1069 | return true; | |
1070 | } | |
1071 | ||
1072 | // Otherwise, set the layered style if needed and set the alpha value | |
1073 | if ((exstyle & WS_EX_LAYERED) == 0 ) | |
1074 | SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyle | WS_EX_LAYERED); | |
1075 | ||
1076 | return pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE)alpha, LWA_ALPHA) != 0; | |
1077 | } | |
1078 | ||
07880314 | 1079 | bool wxTopLevelWindowMSW::CanSetTransparent() |
50f3c41d RD |
1080 | { |
1081 | // The API is available on win2k and above | |
1082 | ||
1083 | static int os_type = -1; | |
1084 | static int ver_major = -1; | |
1085 | ||
1086 | if (os_type == -1) | |
1087 | os_type = ::wxGetOsVersion(&ver_major); | |
1088 | ||
406d283a | 1089 | return (os_type == wxOS_WINDOWS_NT && ver_major >= 5); |
50f3c41d RD |
1090 | } |
1091 | ||
085ad686 VZ |
1092 | // ---------------------------------------------------------------------------- |
1093 | // wxTopLevelWindow event handling | |
1094 | // ---------------------------------------------------------------------------- | |
1095 | ||
1096 | // Default activation behaviour - set the focus for the first child | |
1097 | // subwindow found. | |
1098 | void wxTopLevelWindowMSW::OnActivate(wxActivateEvent& event) | |
1099 | { | |
1100 | if ( event.GetActive() ) | |
1101 | { | |
2736a5de VZ |
1102 | // restore focus to the child which was last focused unless we already |
1103 | // have it | |
1104 | wxLogTrace(_T("focus"), _T("wxTLW %08x activated."), (int) m_hWnd); | |
085ad686 | 1105 | |
2736a5de VZ |
1106 | wxWindow *winFocus = FindFocus(); |
1107 | if ( !winFocus || wxGetTopLevelParent(winFocus) != this ) | |
085ad686 | 1108 | { |
2736a5de VZ |
1109 | wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent() |
1110 | : NULL; | |
1111 | if ( !parent ) | |
1112 | { | |
1113 | parent = this; | |
1114 | } | |
085ad686 | 1115 | |
2736a5de VZ |
1116 | wxSetFocusToChild(parent, &m_winLastFocused); |
1117 | } | |
085ad686 VZ |
1118 | } |
1119 | else // deactivating | |
1120 | { | |
1121 | // remember the last focused child if it is our child | |
1122 | m_winLastFocused = FindFocus(); | |
1123 | ||
13834828 VZ |
1124 | if ( m_winLastFocused ) |
1125 | { | |
1126 | // let it know that it doesn't have focus any more | |
77e00fe9 | 1127 | m_winLastFocused->HandleKillFocus((WXHWND)NULL); |
13834828 | 1128 | |
2736a5de VZ |
1129 | // and don't remember it if it's a child from some other frame |
1130 | if ( wxGetTopLevelParent(m_winLastFocused) != this ) | |
085ad686 | 1131 | { |
2736a5de | 1132 | m_winLastFocused = NULL; |
085ad686 | 1133 | } |
085ad686 VZ |
1134 | } |
1135 | ||
1136 | wxLogTrace(_T("focus"), | |
1137 | _T("wxTLW %08x deactivated, last focused: %08x."), | |
9b601c24 GRG |
1138 | (int) m_hWnd, |
1139 | (int) (m_winLastFocused ? GetHwndOf(m_winLastFocused) | |
1140 | : NULL)); | |
085ad686 VZ |
1141 | |
1142 | event.Skip(); | |
1143 | } | |
1144 | } | |
1145 | ||
77ffb593 | 1146 | // the DialogProc for all wxWidgets dialogs |
12447831 | 1147 | LONG APIENTRY _EXPORT |
0fc58b86 | 1148 | wxDlgProc(HWND hDlg, |
2eb10e2a | 1149 | UINT message, |
3c96418b JG |
1150 | WPARAM WXUNUSED(wParam), |
1151 | LPARAM WXUNUSED(lParam)) | |
12447831 | 1152 | { |
08b97268 | 1153 | switch ( message ) |
12447831 | 1154 | { |
08b97268 WS |
1155 | case WM_INITDIALOG: |
1156 | { | |
1157 | // under CE, add a "Ok" button in the dialog title bar and make it full | |
1158 | // screen | |
1159 | // | |
1160 | // TODO: find the window for this HWND, and take into account | |
1161 | // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present. | |
1162 | // | |
1163 | // Standard SDK doesn't have aygshell.dll: see | |
1164 | // include/wx/msw/wince/libraries.h | |
3d487566 | 1165 | #if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__) |
08b97268 WS |
1166 | SHINITDLGINFO shidi; |
1167 | shidi.dwMask = SHIDIM_FLAGS; | |
1168 | shidi.dwFlags = SHIDIF_SIZEDLG // take account of the SIP or menubar | |
ef6d716b | 1169 | #ifndef __SMARTPHONE__ |
08b97268 | 1170 | | SHIDIF_DONEBUTTON |
ef6d716b WS |
1171 | #endif |
1172 | ; | |
08b97268 WS |
1173 | shidi.hDlg = hDlg; |
1174 | SHInitDialog( &shidi ); | |
a48e51ce | 1175 | #else // no SHInitDialog() |
08b97268 WS |
1176 | wxUnusedVar(hDlg); |
1177 | #endif | |
1178 | // for WM_INITDIALOG, returning TRUE tells system to set focus to | |
1179 | // the first control in the dialog box, but as we set the focus | |
1180 | // ourselves, we return FALSE for it as well | |
1181 | return FALSE; | |
1182 | } | |
12447831 | 1183 | } |
a48e51ce VZ |
1184 | |
1185 | // for almost all messages, returning FALSE means that we didn't process | |
1186 | // the message | |
a48e51ce | 1187 | return FALSE; |
12447831 VZ |
1188 | } |
1189 | ||
2b5f62a0 VZ |
1190 | // ============================================================================ |
1191 | // wxTLWHiddenParentModule implementation | |
1192 | // ============================================================================ | |
1193 | ||
1194 | HWND wxTLWHiddenParentModule::ms_hwnd = NULL; | |
1195 | ||
1196 | const wxChar *wxTLWHiddenParentModule::ms_className = NULL; | |
1197 | ||
1198 | bool wxTLWHiddenParentModule::OnInit() | |
1199 | { | |
1200 | ms_hwnd = NULL; | |
1201 | ms_className = NULL; | |
1202 | ||
bfbb0b4c | 1203 | return true; |
2b5f62a0 VZ |
1204 | } |
1205 | ||
1206 | void wxTLWHiddenParentModule::OnExit() | |
1207 | { | |
1208 | if ( ms_hwnd ) | |
1209 | { | |
1210 | if ( !::DestroyWindow(ms_hwnd) ) | |
1211 | { | |
1212 | wxLogLastError(_T("DestroyWindow(hidden TLW parent)")); | |
1213 | } | |
1214 | ||
1215 | ms_hwnd = NULL; | |
1216 | } | |
1217 | ||
1218 | if ( ms_className ) | |
1219 | { | |
1220 | if ( !::UnregisterClass(ms_className, wxGetInstance()) ) | |
1221 | { | |
1222 | wxLogLastError(_T("UnregisterClass(\"wxTLWHiddenParent\")")); | |
1223 | } | |
1224 | ||
1225 | ms_className = NULL; | |
1226 | } | |
1227 | } | |
1228 | ||
1229 | /* static */ | |
1230 | HWND wxTLWHiddenParentModule::GetHWND() | |
1231 | { | |
1232 | if ( !ms_hwnd ) | |
1233 | { | |
1234 | if ( !ms_className ) | |
1235 | { | |
1236 | static const wxChar *HIDDEN_PARENT_CLASS = _T("wxTLWHiddenParent"); | |
1237 | ||
1238 | WNDCLASS wndclass; | |
1239 | wxZeroMemory(wndclass); | |
1240 | ||
1241 | wndclass.lpfnWndProc = DefWindowProc; | |
1242 | wndclass.hInstance = wxGetInstance(); | |
1243 | wndclass.lpszClassName = HIDDEN_PARENT_CLASS; | |
1244 | ||
1245 | if ( !::RegisterClass(&wndclass) ) | |
1246 | { | |
1247 | wxLogLastError(_T("RegisterClass(\"wxTLWHiddenParent\")")); | |
1248 | } | |
1249 | else | |
1250 | { | |
1251 | ms_className = HIDDEN_PARENT_CLASS; | |
1252 | } | |
1253 | } | |
1254 | ||
fda7962d | 1255 | ms_hwnd = ::CreateWindow(ms_className, wxEmptyString, 0, 0, 0, 0, 0, NULL, |
2b5f62a0 VZ |
1256 | (HMENU)NULL, wxGetInstance(), NULL); |
1257 | if ( !ms_hwnd ) | |
1258 | { | |
1259 | wxLogLastError(_T("CreateWindow(hidden TLW parent)")); | |
1260 | } | |
1261 | } | |
1262 | ||
1263 | return ms_hwnd; | |
1264 | } |