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