1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/toplevel.cpp
3 // Purpose: implements wxTopLevelWindow for MSW
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/toplevel.h"
31 #include "wx/dialog.h"
32 #include "wx/string.h"
37 #include "wx/containr.h" // wxSetFocusToChild()
38 #include "wx/module.h"
41 #include "wx/dynlib.h"
43 #include "wx/msw/private.h"
44 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
47 // Standard SDK doesn't have aygshell.dll: see include/wx/msw/wince/libraries.h
48 #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__)
53 #include "wx/msw/winundef.h"
54 #include "wx/msw/missing.h"
56 #include "wx/display.h"
66 // ----------------------------------------------------------------------------
67 // stubs for missing functions under MicroWindows
68 // ----------------------------------------------------------------------------
72 // static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return false; }
73 static inline bool IsZoomed(HWND
WXUNUSED(hwnd
)) { return false; }
75 #endif // __WXMICROWIN__
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
80 wxDlgProc(HWND hDlg
, UINT message
, WPARAM wParam
, LPARAM lParam
);
82 // ----------------------------------------------------------------------------
83 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
84 // module to ensure that the window is always deleted)
85 // ----------------------------------------------------------------------------
87 class wxTLWHiddenParentModule
: public wxModule
90 // module init/finalize
91 virtual bool OnInit();
92 virtual void OnExit();
94 // get the hidden window (creates on demand)
95 static HWND
GetHWND();
98 // the HWND of the hidden parent
101 // the class used to create it
102 static const wxChar
*ms_className
;
104 DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule
)
107 IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule
, wxModule
)
109 // ============================================================================
110 // wxTopLevelWindowMSW implementation
111 // ============================================================================
113 BEGIN_EVENT_TABLE(wxTopLevelWindowMSW
, wxTopLevelWindowBase
)
114 EVT_ACTIVATE(wxTopLevelWindowMSW::OnActivate
)
117 // ----------------------------------------------------------------------------
118 // wxTopLevelWindowMSW creation
119 // ----------------------------------------------------------------------------
121 void wxTopLevelWindowMSW::Init()
124 m_maximizeOnShow
= false;
126 // Data to save/restore when calling ShowFullScreen
128 m_fsOldWindowStyle
= 0;
129 m_fsIsMaximized
= false;
130 m_fsIsShowing
= false;
132 m_winLastFocused
= NULL
;
134 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
138 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
139 SHACTIVATEINFO
* info
= new SHACTIVATEINFO
;
141 info
->cbSize
= sizeof(SHACTIVATEINFO
);
143 m_activateInfo
= (void*) info
;
149 WXDWORD
wxTopLevelWindowMSW::MSWGetStyle(long style
, WXDWORD
*exflags
) const
151 // let the base class deal with the common styles but fix the ones which
152 // don't make sense for us (we also deal with the borders ourselves)
153 WXDWORD msflags
= wxWindow::MSWGetStyle
155 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
, exflags
156 ) & ~WS_CHILD
& ~WS_VISIBLE
;
158 // For some reason, WS_VISIBLE needs to be defined on creation for
159 // SmartPhone 2003. The title can fail to be displayed otherwise.
160 #if defined(__SMARTPHONE__) || (defined(__WXWINCE__) && _WIN32_WCE < 400)
161 msflags
|= WS_VISIBLE
;
162 ((wxTopLevelWindowMSW
*)this)->wxWindowBase::Show(true);
165 // first select the kind of window being created
167 // note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and
168 // creates a window with both caption and border, hence we need to use
169 // WS_POPUP in a few cases just to avoid having caption/border which we
172 // border and caption styles
173 if ( ( style
& wxRESIZE_BORDER
) && !IsAlwaysMaximized())
174 msflags
|= WS_THICKFRAME
;
175 else if ( exflags
&& ((style
& wxBORDER_DOUBLE
) || (style
& wxBORDER_RAISED
)) )
176 *exflags
|= WS_EX_DLGMODALFRAME
;
177 else if ( !(style
& wxBORDER_NONE
) )
178 msflags
|= WS_BORDER
;
184 // normally we consider that all windows without a caption must be popups,
185 // but CE is an exception: there windows normally do not have the caption
186 // but shouldn't be made popups as popups can't have menus and don't look
187 // like normal windows anyhow
189 // TODO: Smartphone appears to like wxCAPTION, but we should check that
191 #if defined(__SMARTPHONE__) || !defined(__WXWINCE__)
192 if ( style
& wxCAPTION
)
193 msflags
|= WS_CAPTION
;
197 #endif // !__WXWINCE__
200 // next translate the individual flags
202 // WS_EX_CONTEXTHELP is incompatible with WS_MINIMIZEBOX and WS_MAXIMIZEBOX
203 // and is ignored if we specify both of them, but chances are that if we
204 // use wxWS_EX_CONTEXTHELP, we really do want to have the context help
205 // button while wxMINIMIZE/wxMAXIMIZE are included by default, so the help
207 if ( !(GetExtraStyle() & wxWS_EX_CONTEXTHELP
) )
209 if ( style
& wxMINIMIZE_BOX
)
210 msflags
|= WS_MINIMIZEBOX
;
211 if ( style
& wxMAXIMIZE_BOX
)
212 msflags
|= WS_MAXIMIZEBOX
;
216 // notice that if wxCLOSE_BOX is specified we need to use WS_SYSMENU too as
217 // otherwise the close box doesn't appear
218 if ( style
& (wxSYSTEM_MENU
| wxCLOSE_BOX
) )
219 msflags
|= WS_SYSMENU
;
220 #endif // !__WXWINCE__
222 // NB: under CE these 2 styles are not supported currently, we should
223 // call Minimize()/Maximize() "manually" if we want to support them
224 if ( style
& wxMINIMIZE
)
225 msflags
|= WS_MINIMIZE
;
227 if ( style
& wxMAXIMIZE
)
228 msflags
|= WS_MAXIMIZE
;
230 // Keep this here because it saves recoding this function in wxTinyFrame
231 if ( style
& wxTINY_CAPTION
)
232 msflags
|= WS_CAPTION
;
236 // there is no taskbar under CE, so omit all this
237 #if !defined(__WXWINCE__)
238 if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) )
240 if ( style
& wxFRAME_TOOL_WINDOW
)
242 // create the palette-like window
243 *exflags
|= WS_EX_TOOLWINDOW
;
245 // tool windows shouldn't appear on the taskbar (as documented)
246 style
|= wxFRAME_NO_TASKBAR
;
249 // We have to solve 2 different problems here:
251 // 1. frames with wxFRAME_NO_TASKBAR flag shouldn't appear in the
252 // taskbar even if they don't have a parent
254 // 2. frames without this style should appear in the taskbar even
255 // if they're owned (Windows only puts non owned windows into
256 // the taskbar normally)
258 // The second one is solved here by using WS_EX_APPWINDOW flag, the
259 // first one is dealt with in our MSWGetParent() method
261 if ( !(style
& wxFRAME_NO_TASKBAR
) && GetParent() )
263 // need to force the frame to appear in the taskbar
264 *exflags
|= WS_EX_APPWINDOW
;
266 //else: nothing to do [here]
269 if ( GetExtraStyle() & wxWS_EX_CONTEXTHELP
)
270 *exflags
|= WS_EX_CONTEXTHELP
;
271 #endif // !__WXWINCE__
273 if ( style
& wxSTAY_ON_TOP
)
274 *exflags
|= WS_EX_TOPMOST
;
280 WXHWND
wxTopLevelWindowMSW::MSWGetParent() const
282 // for the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
283 // parent HWND or it would be always on top of its parent which is not what
284 // we usually want (in fact, we only want it for frames with the
285 // wxFRAME_FLOAT_ON_PARENT flag)
286 HWND hwndParent
= NULL
;
287 if ( HasFlag(wxFRAME_FLOAT_ON_PARENT
) )
289 const wxWindow
*parent
= GetParent();
293 // this flag doesn't make sense then and will be ignored
294 wxFAIL_MSG( wxT("wxFRAME_FLOAT_ON_PARENT but no parent?") );
298 hwndParent
= GetHwndOf(parent
);
301 //else: don't float on parent, must not be owned
303 // now deal with the 2nd taskbar-related problem (see comments above in
305 if ( HasFlag(wxFRAME_NO_TASKBAR
) && !hwndParent
)
308 hwndParent
= wxTLWHiddenParentModule::GetHWND();
311 return (WXHWND
)hwndParent
;
314 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
315 bool wxTopLevelWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
317 SHACTIVATEINFO
*info
= (SHACTIVATEINFO
*) m_activateInfo
;
320 SHHandleWMSettingChange(GetHwnd(), wParam
, lParam
, info
);
323 return wxWindowMSW::HandleSettingChange(wParam
, lParam
);
327 WXLRESULT
wxTopLevelWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
330 bool processed
= false;
334 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
337 SHACTIVATEINFO
* info
= (SHACTIVATEINFO
*) m_activateInfo
;
341 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) flags
= SHA_INPUTDIALOG
;
342 SHHandleWMActivate(GetHwnd(), wParam
, lParam
, info
, flags
);
345 // This implicitly sends a wxEVT_ACTIVATE_APP event
347 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
355 wxActivateEvent
event(wxEVT_HIBERNATE
, true, wxID_ANY
);
356 event
.SetEventObject(wxTheApp
);
357 processed
= wxTheApp
->ProcessEvent(event
);
361 #endif // __SMARTPHONE__ || __POCKETPC__
367 // ... the four low-order bits of the wParam parameter are
368 // used internally by the system. To obtain the correct
369 // result when testing the value of wParam, an application
370 // must combine the value 0xFFF0 with the wParam value by
371 // using the bitwise AND operator.
372 unsigned id
= wParam
& 0xfff0;
374 // Preserve the focus when minimizing/restoring the window: we
375 // need to do it manually as DefWindowProc() doesn't appear to
376 // do this for us for some reason (perhaps because we don't use
377 // WM_NEXTDLGCTL for setting focus?). Moreover, our code in
378 // OnActivate() doesn't work in this case as we receive the
379 // deactivation event too late when the window is being
380 // minimized and the focus is already NULL by then. Similarly,
381 // we receive the activation event too early and restoring
382 // focus in it fails because the window is still minimized. So
383 // we need to do it here.
384 if ( id
== SC_MINIMIZE
)
386 // For minimization, it's simple enough: just save the
387 // focus as usual. The important thing is that we're not
388 // minimized yet, so this works correctly.
391 else if ( id
== SC_RESTORE
)
393 // For restoring, it's trickier as DefWindowProc() sets
394 // focus to the window itself. So run it first and restore
395 // our saved focus only afterwards.
397 rc
= wxTopLevelWindowBase::MSWWindowProc(message
,
400 DoRestoreLastFocus();
403 #ifndef __WXUNIVERSAL__
404 // We need to generate events for the custom items added to the
405 // system menu if it had been created (and presumably modified).
406 // As SC_SIZE is the first of the system-defined commands, we
407 // only do this for the custom commands before it and leave
408 // SC_SIZE and everything after it to DefWindowProc().
409 if ( m_menuSystem
&& id
< SC_SIZE
)
411 if ( m_menuSystem
->MSWCommand(0 /* unused anyhow */, id
) )
414 #endif // #ifndef __WXUNIVERSAL__
420 rc
= wxTopLevelWindowBase::MSWWindowProc(message
, wParam
, lParam
);
425 bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate
,
426 const wxString
& title
,
430 #ifdef __WXMICROWIN__
431 // no dialogs support under MicroWin yet
432 return CreateFrame(title
, pos
, size
);
433 #else // !__WXMICROWIN__
434 // static cast is valid as we're only ever called for dialogs
436 parent
= static_cast<wxDialog
*>(this)->GetParentForModalDialog();
438 m_hWnd
= (WXHWND
)::CreateDialogIndirect
441 (DLGTEMPLATE
*)dlgTemplate
,
442 parent
? GetHwndOf(parent
) : NULL
,
448 wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?"));
450 wxLogSysError(wxT("Can't create dialog using memory template"));
455 #if !defined(__WXWINCE__)
456 // For some reason, the system menu is activated when we use the
457 // WS_EX_CONTEXTHELP style, so let's set a reasonable icon
458 if ( HasExtraStyle(wxWS_EX_CONTEXTHELP
) )
460 wxFrame
*winTop
= wxDynamicCast(wxTheApp
->GetTopWindow(), wxFrame
);
463 wxIcon icon
= winTop
->GetIcon();
466 ::SendMessage(GetHwnd(), WM_SETICON
,
468 (LPARAM
)GetHiconOf(icon
));
472 #endif // !__WXWINCE__
474 if ( !title
.empty() )
476 ::SetWindowText(GetHwnd(), title
.wx_str());
481 #if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
482 // move the dialog to its initial position without forcing repainting
484 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
486 if ( x
== (int)CW_USEDEFAULT
)
488 // Let the system position the window, just set its size.
489 ::SetWindowPos(GetHwnd(), 0,
491 SWP_NOMOVE
| SWP_NOZORDER
| SWP_NOACTIVATE
);
493 else // Move the window to the desired location and set its size too.
495 if ( !::MoveWindow(GetHwnd(), x
, y
, w
, h
, FALSE
) )
497 wxLogLastError(wxT("MoveWindow"));
500 #endif // !__WXWINCE__
502 #ifdef __SMARTPHONE__
503 // Work around title non-display glitch
508 #endif // __WXMICROWIN__/!__WXMICROWIN__
511 bool wxTopLevelWindowMSW::CreateFrame(const wxString
& title
,
516 WXDWORD flags
= MSWGetCreateWindowFlags(&exflags
);
518 const wxSize sz
= IsAlwaysMaximized() ? wxDefaultSize
: size
;
521 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
522 exflags
|= WS_EX_LAYOUTRTL
;
525 return MSWCreate(MSWGetRegisteredClassName(),
526 title
.wx_str(), pos
, sz
, flags
, exflags
);
529 bool wxTopLevelWindowMSW::Create(wxWindow
*parent
,
531 const wxString
& title
,
535 const wxString
& name
)
537 wxSize sizeReal
= size
;
538 if ( !sizeReal
.IsFullySpecified() )
540 sizeReal
.SetDefaults(GetDefaultSize());
543 // notice that we should append this window to wxTopLevelWindows list
544 // before calling CreateBase() as it behaves differently for TLW and
546 wxTopLevelWindows
.Append(this);
548 bool ret
= CreateBase(parent
, id
, pos
, sizeReal
, style
, name
);
553 parent
->AddChild(this);
555 if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
557 // we have different dialog templates to allows creation of dialogs
558 // with & without captions under MSWindows, resizable or not (but a
559 // resizable dialog always has caption - otherwise it would look too
562 // we need 3 additional WORDs for dialog menu, class and title (as we
563 // don't use DS_SETFONT we don't need the fourth WORD for the font)
564 static const int dlgsize
= sizeof(DLGTEMPLATE
) + (sizeof(WORD
) * 3);
565 DLGTEMPLATE
*dlgTemplate
= (DLGTEMPLATE
*)malloc(dlgsize
);
566 memset(dlgTemplate
, 0, dlgsize
);
568 // these values are arbitrary, they won't be used normally anyhow
571 dlgTemplate
->cx
= 144;
572 dlgTemplate
->cy
= 75;
574 // reuse the code in MSWGetStyle() but correct the results slightly for
577 // NB: we need a temporary variable as we can't pass pointer to
578 // dwExtendedStyle directly, it's not aligned correctly for 64 bit
580 WXDWORD dwExtendedStyle
;
581 dlgTemplate
->style
= MSWGetStyle(style
, &dwExtendedStyle
);
582 dlgTemplate
->dwExtendedStyle
= dwExtendedStyle
;
584 // all dialogs are popups
585 dlgTemplate
->style
|= WS_POPUP
;
588 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
590 dlgTemplate
->dwExtendedStyle
|= WS_EX_LAYOUTRTL
;
593 // force 3D-look if necessary, it looks impossibly ugly otherwise
594 if ( style
& (wxRESIZE_BORDER
| wxCAPTION
) )
595 dlgTemplate
->style
|= DS_MODALFRAME
;
598 ret
= CreateDialog(dlgTemplate
, title
, pos
, sizeReal
);
603 ret
= CreateFrame(title
, pos
, sizeReal
);
607 if ( ret
&& !(GetWindowStyleFlag() & wxCLOSE_BOX
) )
609 EnableCloseButton(false);
613 // for standard dialogs the dialog manager generates WM_CHANGEUISTATE
614 // itself but for custom windows we have to do it ourselves in order to
615 // make the keyboard indicators (such as underlines for accelerators and
616 // focus rectangles) work under Win2k+
619 MSWUpdateUIState(UIS_INITIALIZE
);
622 // Note: if we include PocketPC in this test, dialogs can fail to show up,
623 // for example the text entry dialog in the dialogs sample. Problem with Maximise()?
624 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__))
625 if ( ( style
& wxMAXIMIZE
) || IsAlwaysMaximized() )
631 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
632 SetRightMenu(); // to nothing for initialization
638 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
644 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
645 SHACTIVATEINFO
* info
= (SHACTIVATEINFO
*) m_activateInfo
;
647 m_activateInfo
= NULL
;
650 // after destroying an owned window, Windows activates the next top level
651 // window in Z order but it may be different from our owner (to reproduce
652 // this simply Alt-TAB to another application and back before closing the
653 // owned frame) whereas we always want to yield activation to our parent
654 if ( HasFlag(wxFRAME_FLOAT_ON_PARENT
) )
656 wxWindow
*parent
= GetParent();
659 ::BringWindowToTop(GetHwndOf(parent
));
664 // ----------------------------------------------------------------------------
665 // wxTopLevelWindowMSW showing
666 // ----------------------------------------------------------------------------
668 void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd
)
670 ::ShowWindow(GetHwnd(), nShowCmd
);
672 // Hiding the window doesn't change its iconized state.
673 if ( nShowCmd
!= SW_HIDE
)
675 // Otherwise restoring, maximizing or showing the window normally also
676 // makes it not iconized and only minimizing it does make it iconized.
677 m_iconized
= nShowCmd
== SW_MINIMIZE
;
681 void wxTopLevelWindowMSW::ShowWithoutActivating()
683 if ( !wxWindowBase::Show(true) )
686 DoShowWindow(SW_SHOWNA
);
689 bool wxTopLevelWindowMSW::Show(bool show
)
691 // don't use wxWindow version as we want to call DoShowWindow() ourselves
692 if ( !wxWindowBase::Show(show
) )
698 if ( m_maximizeOnShow
)
701 nShowCmd
= SW_MAXIMIZE
;
703 // This is necessary, or no window appears
704 #if defined( __WINCE_STANDARDSDK__) || defined(__SMARTPHONE__)
705 DoShowWindow(SW_SHOW
);
708 m_maximizeOnShow
= false;
710 else if ( m_iconized
)
713 nShowCmd
= SW_MINIMIZE
;
717 // we shouldn't use SW_SHOW which also activates the window for
718 // tool frames (as they shouldn't steal focus from the main window)
719 // nor for the currently disabled windows as they would be enabled
721 if ( HasFlag(wxFRAME_TOOL_WINDOW
) || !IsEnabled() )
722 nShowCmd
= SW_SHOWNA
;
732 #if wxUSE_DEFERRED_SIZING
733 // we only set pending size if we're maximized before being shown, now that
734 // we're shown we don't need it any more (it is reset in size event handler
735 // for child windows but we have to do it ourselves for this parent window)
737 // make sure to reset it before actually showing the window as this will
738 // generate WM_SIZE events and we want to use the correct client size from
739 // them, not the size returned by WM_NCCALCSIZE in DoGetClientSize() which
740 // turns out to be wrong for maximized windows (see #11762)
741 m_pendingSize
= wxDefaultSize
;
742 #endif // wxUSE_DEFERRED_SIZING
744 DoShowWindow(nShowCmd
);
746 #if defined(__WXWINCE__) && (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__))
747 // Addornments have to be added when the frame is the correct size
748 wxFrame
* frame
= wxDynamicCast(this, wxFrame
);
749 if (frame
&& frame
->GetMenuBar())
750 frame
->GetMenuBar()->AddAdornments(GetWindowStyleFlag());
756 void wxTopLevelWindowMSW::Raise()
758 ::SetForegroundWindow(GetHwnd());
761 // ----------------------------------------------------------------------------
762 // wxTopLevelWindowMSW maximize/minimize
763 // ----------------------------------------------------------------------------
765 void wxTopLevelWindowMSW::Maximize(bool maximize
)
769 // just maximize it directly
770 DoShowWindow(maximize
? SW_MAXIMIZE
: SW_RESTORE
);
774 // we can't maximize the hidden frame because it shows it as well,
775 // so just remember that we should do it later in this case
776 m_maximizeOnShow
= maximize
;
778 #if wxUSE_DEFERRED_SIZING
779 // after calling Maximize() the client code expects to get the frame
780 // "real" size and doesn't want to know that, because of implementation
781 // details, the frame isn't really maximized yet but will be only once
782 // it's shown, so return our size as it will be then in this case
785 // we must only change pending size here, and not call SetSize()
786 // because otherwise Windows would think that this (full screen)
787 // size is the natural size for the frame and so would use it when
788 // the user clicks on "restore" title bar button instead of the
789 // correct initial frame size
791 // NB: unfortunately we don't know which display we're on yet so we
792 // have to use the default one
793 m_pendingSize
= wxGetClientDisplayRect().GetSize();
795 //else: can't do anything in this case, we don't have the old size
796 #endif // wxUSE_DEFERRED_SIZING
800 bool wxTopLevelWindowMSW::IsMaximized() const
802 return IsAlwaysMaximized() ||
803 #if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) && !defined(__WINCE_STANDARDSDK__)
805 (::IsZoomed(GetHwnd()) != 0) ||
810 void wxTopLevelWindowMSW::Iconize(bool iconize
)
812 if ( iconize
== m_iconized
)
814 // Do nothing, in particular don't restore non-iconized windows when
815 // Iconize(false) is called as this would wrongly un-maximize them.
821 // change the window state immediately
822 DoShowWindow(iconize
? SW_MINIMIZE
: SW_RESTORE
);
826 // iconizing the window shouldn't show it so just remember that we need
827 // to become iconized when shown later
832 bool wxTopLevelWindowMSW::IsIconized() const
840 // don't use m_iconized, it may be briefly out of sync with the real state
841 // as it's only modified when we receive a WM_SIZE and we could be called
842 // from an event handler from one of the messages we receive before it,
844 return ::IsIconic(GetHwnd()) != 0;
848 void wxTopLevelWindowMSW::Restore()
850 DoShowWindow(SW_RESTORE
);
853 void wxTopLevelWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
855 if ( dir
== wxLayout_Default
)
856 dir
= wxTheApp
->GetLayoutDirection();
858 if ( dir
!= wxLayout_Default
)
859 wxTopLevelWindowBase::SetLayoutDirection(dir
);
862 // ----------------------------------------------------------------------------
863 // wxTopLevelWindowMSW geometry
864 // ----------------------------------------------------------------------------
868 void wxTopLevelWindowMSW::DoGetPosition(int *x
, int *y
) const
873 wp
.length
= sizeof(WINDOWPLACEMENT
);
874 if ( ::GetWindowPlacement(GetHwnd(), &wp
) )
876 RECT
& rc
= wp
.rcNormalPosition
;
878 // the position returned by GetWindowPlacement() is in workspace
879 // coordinates except for windows with WS_EX_TOOLWINDOW style
880 if ( !HasFlag(wxFRAME_TOOL_WINDOW
) )
882 // we must use the correct display for the translation as the
883 // task bar might be shown on one display but not the other one
884 int n
= wxDisplay::GetFromWindow(this);
885 wxDisplay
dpy(n
== wxNOT_FOUND
? 0 : n
);
886 const wxPoint ptOfs
= dpy
.GetClientArea().GetPosition() -
887 dpy
.GetGeometry().GetPosition();
901 wxLogLastError(wxT("GetWindowPlacement"));
905 wxTopLevelWindowBase::DoGetPosition(x
, y
);
908 void wxTopLevelWindowMSW::DoGetSize(int *width
, int *height
) const
913 wp
.length
= sizeof(WINDOWPLACEMENT
);
914 if ( ::GetWindowPlacement(GetHwnd(), &wp
) )
916 const RECT
& rc
= wp
.rcNormalPosition
;
919 *width
= rc
.right
- rc
.left
;
921 *height
= rc
.bottom
- rc
.top
;
926 wxLogLastError(wxT("GetWindowPlacement"));
930 wxTopLevelWindowBase::DoGetSize(width
, height
);
933 #endif // __WXWINCE__
936 wxTopLevelWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
939 int& w
, int& h
) const
941 // let the system position the window if no explicit position was specified
942 if ( pos
.x
== wxDefaultCoord
)
944 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
945 // can just as well set it to CW_USEDEFAULT as well
951 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
952 // neither because it is not handled as a special value by Windows then
953 // and so we have to choose some default value for it, even if a
954 // completely arbitrary one
955 static const int DEFAULT_Y
= 200;
958 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
961 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
963 // We don't use CW_USEDEFAULT here for several reasons:
965 // 1. It results in huge frames on modern screens (1000*800 is not
966 // uncommon on my 1280*1024 screen) which is way too big for a half
967 // empty frame of most of wxWidgets samples for example)
969 // 2. It is buggy for frames with wxFRAME_TOOL_WINDOW style for which
970 // the default is for whatever reason 8*8 which breaks client <->
971 // window size calculations (it would be nice if it didn't, but it
972 // does and the simplest way to fix it seemed to change the broken
973 // default size anyhow)
975 // 3. There is just no advantage in doing it: with x and y it is
976 // possible that [future versions of] Windows position the new top
977 // level window in some smart way which we can't do, but we can
978 // guess a reasonably good size for a new window just as well
981 // The only exception is for the Windows CE platform where the system
982 // does know better than we how should the windows be sized
987 wxSize sizeReal
= size
;
988 sizeReal
.SetDefaults(GetDefaultSize());
992 #endif // _WIN32_WCE/!_WIN32_WCE
1001 // ----------------------------------------------------------------------------
1002 // wxTopLevelWindowMSW fullscreen
1003 // ----------------------------------------------------------------------------
1005 bool wxTopLevelWindowMSW::ShowFullScreen(bool show
, long style
)
1007 if ( show
== IsFullScreen() )
1013 m_fsIsShowing
= show
;
1019 // zap the frame borders
1021 // save the 'normal' window style
1022 m_fsOldWindowStyle
= GetWindowLong(GetHwnd(), GWL_STYLE
);
1024 // save the old position, width & height, maximize state
1025 m_fsOldSize
= GetRect();
1026 m_fsIsMaximized
= IsMaximized();
1028 // decide which window style flags to turn off
1029 LONG newStyle
= m_fsOldWindowStyle
;
1032 if (style
& wxFULLSCREEN_NOBORDER
)
1034 offFlags
|= WS_BORDER
;
1036 offFlags
|= WS_THICKFRAME
;
1039 if (style
& wxFULLSCREEN_NOCAPTION
)
1040 offFlags
|= WS_CAPTION
| WS_SYSMENU
;
1042 newStyle
&= ~offFlags
;
1044 // change our window style to be compatible with full-screen mode
1045 ::SetWindowLong(GetHwnd(), GWL_STYLE
, newStyle
);
1049 // resize to the size of the display containing us
1050 int dpy
= wxDisplay::GetFromWindow(this);
1051 if ( dpy
!= wxNOT_FOUND
)
1053 rect
= wxDisplay(dpy
).GetGeometry();
1055 else // fall back to the main desktop
1056 #endif // wxUSE_DISPLAY
1058 // resize to the size of the desktop
1059 wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect
);
1061 // FIXME: size of the bottom menu (toolbar)
1062 // should be taken in account
1063 rect
.height
+= rect
.y
;
1070 // now flush the window style cache and actually go full-screen
1071 long flags
= SWP_FRAMECHANGED
;
1073 // showing the frame full screen should also show it if it's still
1077 // don't call wxWindow version to avoid flicker from calling
1078 // ::ShowWindow() -- we're going to show the window at the correct
1079 // location directly below -- but do call the wxWindowBase version
1080 // to sync the internal m_isShown flag
1081 wxWindowBase::Show();
1083 flags
|= SWP_SHOWWINDOW
;
1086 SetWindowPos(GetHwnd(), HWND_TOP
,
1087 rect
.x
, rect
.y
, rect
.width
, rect
.height
,
1090 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
1091 ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR
| SHFS_HIDESIPBUTTON
);
1094 // finally send an event allowing the window to relayout itself &c
1095 wxSizeEvent
event(rect
.GetSize(), GetId());
1096 event
.SetEventObject(this);
1097 HandleWindowEvent(event
);
1099 else // stop showing full screen
1101 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
1102 ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR
| SHFS_SHOWSIPBUTTON
);
1104 Maximize(m_fsIsMaximized
);
1105 SetWindowLong(GetHwnd(),GWL_STYLE
, m_fsOldWindowStyle
);
1106 SetWindowPos(GetHwnd(),HWND_TOP
,m_fsOldSize
.x
, m_fsOldSize
.y
,
1107 m_fsOldSize
.width
, m_fsOldSize
.height
, SWP_FRAMECHANGED
);
1113 // ----------------------------------------------------------------------------
1114 // wxTopLevelWindowMSW misc
1115 // ----------------------------------------------------------------------------
1117 void wxTopLevelWindowMSW::SetTitle( const wxString
& title
)
1122 wxString
wxTopLevelWindowMSW::GetTitle() const
1127 bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle
& icons
,
1132 const wxSize
size(::GetSystemMetrics(smX
), ::GetSystemMetrics(smY
));
1134 wxIcon icon
= icons
.GetIcon(size
, wxIconBundle::FALLBACK_NEAREST_LARGER
);
1139 ::SendMessage(GetHwnd(), WM_SETICON
, i
, (LPARAM
)GetHiconOf(icon
));
1143 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle
& icons
)
1145 wxTopLevelWindowBase::SetIcons(icons
);
1147 if ( icons
.IsEmpty() )
1149 // FIXME: SetIcons(wxNullIconBundle) should unset existing icons,
1150 // but we currently don't do that
1151 wxASSERT_MSG( m_icons
.IsEmpty(), "unsetting icons doesn't work" );
1155 DoSelectAndSetIcon(icons
, SM_CXSMICON
, SM_CYSMICON
, ICON_SMALL
);
1156 DoSelectAndSetIcon(icons
, SM_CXICON
, SM_CYICON
, ICON_BIG
);
1159 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable
)
1161 #if !defined(__WXMICROWIN__)
1162 // get system (a.k.a. window) menu
1163 HMENU hmenu
= GetSystemMenu(GetHwnd(), FALSE
/* get it */);
1166 // no system menu at all -- ok if we want to remove the close button
1167 // anyhow, but bad if we want to show it
1171 // enabling/disabling the close item from it also automatically
1172 // disables/enables the close title bar button
1173 if ( ::EnableMenuItem(hmenu
, SC_CLOSE
,
1175 (enable
? MF_ENABLED
: MF_GRAYED
)) == -1 )
1177 wxLogLastError(wxT("EnableMenuItem(SC_CLOSE)"));
1182 // update appearance immediately
1183 if ( !::DrawMenuBar(GetHwnd()) )
1185 wxLogLastError(wxT("DrawMenuBar"));
1188 #endif // !__WXMICROWIN__
1193 void wxTopLevelWindowMSW::RequestUserAttention(int flags
)
1195 // check if we can use FlashWindowEx(): unfortunately a simple test for
1196 // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't
1197 // provide FlashWindowEx() declaration, so try to detect whether we have
1198 // real headers for WINVER 0x0500 by checking for existence of a symbol not
1199 // declated in MSVC6 header
1200 #if defined(FLASHW_STOP) && defined(VK_XBUTTON1) && wxUSE_DYNLIB_CLASS
1201 // available in the headers, check if it is supported by the system
1202 typedef BOOL (WINAPI
*FlashWindowEx_t
)(FLASHWINFO
*pfwi
);
1203 static FlashWindowEx_t s_pfnFlashWindowEx
= NULL
;
1204 if ( !s_pfnFlashWindowEx
)
1206 wxDynamicLibrary
dllUser32(wxT("user32.dll"));
1207 s_pfnFlashWindowEx
= (FlashWindowEx_t
)
1208 dllUser32
.GetSymbol(wxT("FlashWindowEx"));
1210 // we can safely unload user32.dll here, it's going to remain loaded as
1211 // long as the program is running anyhow
1214 if ( s_pfnFlashWindowEx
)
1216 WinStruct
<FLASHWINFO
> fwi
;
1217 fwi
.hwnd
= GetHwnd();
1218 fwi
.dwFlags
= FLASHW_ALL
;
1219 if ( flags
& wxUSER_ATTENTION_INFO
)
1221 // just flash a few times
1224 else // wxUSER_ATTENTION_ERROR
1226 // flash until the user notices it
1227 fwi
.dwFlags
|= FLASHW_TIMERNOFG
;
1230 s_pfnFlashWindowEx(&fwi
);
1232 else // FlashWindowEx() not available
1233 #endif // FlashWindowEx() defined
1237 ::FlashWindow(GetHwnd(), TRUE
);
1238 #endif // __WXWINCE__
1242 wxMenu
*wxTopLevelWindowMSW::MSWGetSystemMenu() const
1244 #ifndef __WXUNIVERSAL__
1245 if ( !m_menuSystem
)
1247 HMENU hmenu
= ::GetSystemMenu(GetHwnd(), FALSE
);
1250 wxLogLastError(wxT("GetSystemMenu()"));
1254 wxTopLevelWindowMSW
* const
1255 self
= const_cast<wxTopLevelWindowMSW
*>(this);
1257 self
->m_menuSystem
= wxMenu::MSWNewFromHMENU(hmenu
);
1259 // We need to somehow associate this menu with this window to ensure
1260 // that we get events from it. A natural idea would be to pretend that
1261 // it's attached to our menu bar but this wouldn't work if we don't
1262 // have any menu bar which is a common case for applications using
1263 // custom items in the system menu (they mostly do it exactly because
1264 // they don't have any other menus).
1266 // So reuse the invoking window pointer instead, this is not exactly
1267 // correct but doesn't seem to have any serious drawbacks.
1268 m_menuSystem
->SetInvokingWindow(self
);
1270 #endif // #ifndef __WXUNIVERSAL__
1272 return m_menuSystem
;
1275 // ----------------------------------------------------------------------------
1276 // Transparency support
1277 // ---------------------------------------------------------------------------
1279 bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha
)
1281 #if wxUSE_DYNLIB_CLASS
1282 typedef DWORD (WINAPI
*PSETLAYEREDWINDOWATTR
)(HWND
, DWORD
, BYTE
, DWORD
);
1283 static PSETLAYEREDWINDOWATTR
1284 pSetLayeredWindowAttributes
= (PSETLAYEREDWINDOWATTR
)-1;
1286 if ( pSetLayeredWindowAttributes
== (PSETLAYEREDWINDOWATTR
)-1 )
1288 wxDynamicLibrary
dllUser32(wxT("user32.dll"));
1290 // use RawGetSymbol() and not GetSymbol() to avoid error messages under
1291 // Windows 95: there is nothing the user can do about this anyhow
1292 pSetLayeredWindowAttributes
= (PSETLAYEREDWINDOWATTR
)
1293 dllUser32
.RawGetSymbol(wxT("SetLayeredWindowAttributes"));
1295 // it's ok to destroy dllUser32 here, we link statically to user32.dll
1296 // anyhow so it won't be unloaded
1299 if ( !pSetLayeredWindowAttributes
)
1301 #endif // wxUSE_DYNLIB_CLASS
1303 LONG exstyle
= GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1305 // if setting alpha to fully opaque then turn off the layered style
1308 SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyle
& ~WS_EX_LAYERED
);
1313 #if wxUSE_DYNLIB_CLASS
1314 // Otherwise, set the layered style if needed and set the alpha value
1315 if ((exstyle
& WS_EX_LAYERED
) == 0 )
1316 SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyle
| WS_EX_LAYERED
);
1318 if ( pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE
)alpha
, LWA_ALPHA
) )
1320 #endif // wxUSE_DYNLIB_CLASS
1325 bool wxTopLevelWindowMSW::CanSetTransparent()
1327 // The API is available on win2k and above
1329 static int os_type
= -1;
1330 static int ver_major
= -1;
1333 os_type
= ::wxGetOsVersion(&ver_major
);
1335 return (os_type
== wxOS_WINDOWS_NT
&& ver_major
>= 5);
1338 void wxTopLevelWindowMSW::DoEnable(bool enable
)
1340 wxTopLevelWindowBase::DoEnable(enable
);
1342 // Enabling or disabling a window may change its appearance. Unfortunately,
1343 // in at least some situation, toplevel windows don't repaint themselves,
1344 // so we have to issue explicit refresh to avoid rendering artifacts.
1346 // TODO: find out just what exactly is wrong here
1349 // JS: From observing other application behaviour, such as VS 2010, controls such
1350 // as text fields and comboboxes do not indicate a disabled state when the parent
1351 // is disabled due to a modal dialog being shown. Therefore I have changed these
1352 // controls' behaviour to only indicate a disabled state when IsThisEnabled returns false,
1353 // i.e. the application has specifically disabled each control. Since the colour
1354 // no longer changes when the top-level window is disabled, this means we can avoid
1355 // doing a refresh that causes a distracting flicker in some controls.
1356 // Windows should probably be sending a paint event to each child control just in
1357 // case the state change requires a refresh, but this would cause flicker so perhaps
1358 // it's as well that it doesn't.
1359 // The result of this change is to remove the flicker and also remove the distraction
1360 // of individual controls greying-out due to a dialog being shown, which I think was
1361 // the wrong behaviour.
1364 void wxTopLevelWindowMSW::DoFreeze()
1366 // do nothing: freezing toplevel window causes paint and mouse events
1367 // to go through it any TLWs under it, so the best we can do is to freeze
1368 // all children -- and wxWindowBase::Freeze() does that
1371 void wxTopLevelWindowMSW::DoThaw()
1373 // intentionally empty -- see DoFreeze()
1377 // ----------------------------------------------------------------------------
1378 // wxTopLevelWindow event handling
1379 // ----------------------------------------------------------------------------
1381 void wxTopLevelWindowMSW::DoSaveLastFocus()
1386 // remember the last focused child if it is our child
1387 m_winLastFocused
= FindFocus();
1389 if ( m_winLastFocused
)
1391 // and don't remember it if it's a child from some other frame
1392 if ( wxGetTopLevelParent(m_winLastFocused
) != this )
1394 m_winLastFocused
= NULL
;
1399 void wxTopLevelWindowMSW::DoRestoreLastFocus()
1401 wxWindow
*parent
= m_winLastFocused
? m_winLastFocused
->GetParent()
1408 wxSetFocusToChild(parent
, &m_winLastFocused
);
1411 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent
& event
)
1413 if ( event
.GetActive() )
1415 // We get WM_ACTIVATE before being restored from iconized state, so we
1416 // can be still iconized here. In this case, avoid restoring the focus
1417 // as it doesn't work anyhow and we will do when we're really restored.
1424 // restore focus to the child which was last focused unless we already
1426 wxLogTrace(wxT("focus"), wxT("wxTLW %p activated."), m_hWnd
);
1428 wxWindow
*winFocus
= FindFocus();
1429 if ( !winFocus
|| wxGetTopLevelParent(winFocus
) != this )
1430 DoRestoreLastFocus();
1432 else // deactivating
1436 wxLogTrace(wxT("focus"),
1437 wxT("wxTLW %p deactivated, last focused: %p."),
1439 m_winLastFocused
? GetHwndOf(m_winLastFocused
) : NULL
);
1445 // the DialogProc for all wxWidgets dialogs
1446 LONG APIENTRY _EXPORT
1447 wxDlgProc(HWND hDlg
,
1449 WPARAM
WXUNUSED(wParam
),
1450 LPARAM
WXUNUSED(lParam
))
1456 // under CE, add a "Ok" button in the dialog title bar and make it full
1459 // TODO: find the window for this HWND, and take into account
1460 // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present.
1462 // Standard SDK doesn't have aygshell.dll: see
1463 // include/wx/msw/wince/libraries.h
1464 #if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__)
1465 SHINITDLGINFO shidi
;
1466 shidi
.dwMask
= SHIDIM_FLAGS
;
1467 shidi
.dwFlags
= SHIDIF_SIZEDLG
// take account of the SIP or menubar
1468 #ifndef __SMARTPHONE__
1473 SHInitDialog( &shidi
);
1474 #else // no SHInitDialog()
1477 // for WM_INITDIALOG, returning TRUE tells system to set focus to
1478 // the first control in the dialog box, but as we set the focus
1479 // ourselves, we return FALSE for it as well
1484 // for almost all messages, returning FALSE means that we didn't process
1489 // ============================================================================
1490 // wxTLWHiddenParentModule implementation
1491 // ============================================================================
1493 HWND
wxTLWHiddenParentModule::ms_hwnd
= NULL
;
1495 const wxChar
*wxTLWHiddenParentModule::ms_className
= NULL
;
1497 bool wxTLWHiddenParentModule::OnInit()
1500 ms_className
= NULL
;
1505 void wxTLWHiddenParentModule::OnExit()
1509 if ( !::DestroyWindow(ms_hwnd
) )
1511 wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
1519 if ( !::UnregisterClass(ms_className
, wxGetInstance()) )
1521 wxLogLastError(wxT("UnregisterClass(\"wxTLWHiddenParent\")"));
1524 ms_className
= NULL
;
1529 HWND
wxTLWHiddenParentModule::GetHWND()
1533 if ( !ms_className
)
1535 static const wxChar
*HIDDEN_PARENT_CLASS
= wxT("wxTLWHiddenParent");
1538 wxZeroMemory(wndclass
);
1540 wndclass
.lpfnWndProc
= DefWindowProc
;
1541 wndclass
.hInstance
= wxGetInstance();
1542 wndclass
.lpszClassName
= HIDDEN_PARENT_CLASS
;
1544 if ( !::RegisterClass(&wndclass
) )
1546 wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
1550 ms_className
= HIDDEN_PARENT_CLASS
;
1554 ms_hwnd
= ::CreateWindow(ms_className
, wxEmptyString
, 0, 0, 0, 0, 0, NULL
,
1555 (HMENU
)NULL
, wxGetInstance(), NULL
);
1558 wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));