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"
36 #include "wx/containr.h" // wxSetFocusToChild()
37 #include "wx/module.h"
40 #include "wx/dynlib.h"
42 #include "wx/msw/private.h"
43 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
46 // Standard SDK doesn't have aygshell.dll: see include/wx/msw/wince/libraries.h
47 #if _WIN32_WCE < 400 || !defined(__WINCE_STANDARDSDK__)
52 #include "wx/msw/winundef.h"
53 #include "wx/msw/missing.h"
55 #include "wx/display.h"
65 // ----------------------------------------------------------------------------
66 // stubs for missing functions under MicroWindows
67 // ----------------------------------------------------------------------------
71 // static inline bool IsIconic(HWND WXUNUSED(hwnd)) { return false; }
72 static inline bool IsZoomed(HWND
WXUNUSED(hwnd
)) { return false; }
74 #endif // __WXMICROWIN__
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
79 wxDlgProc(HWND hDlg
, UINT message
, WPARAM wParam
, LPARAM lParam
);
81 // ----------------------------------------------------------------------------
82 // wxTLWHiddenParentModule: used to manage the hidden parent window (we need a
83 // module to ensure that the window is always deleted)
84 // ----------------------------------------------------------------------------
86 class wxTLWHiddenParentModule
: public wxModule
89 // module init/finalize
90 virtual bool OnInit();
91 virtual void OnExit();
93 // get the hidden window (creates on demand)
94 static HWND
GetHWND();
97 // the HWND of the hidden parent
100 // the class used to create it
101 static const wxChar
*ms_className
;
103 DECLARE_DYNAMIC_CLASS(wxTLWHiddenParentModule
)
106 IMPLEMENT_DYNAMIC_CLASS(wxTLWHiddenParentModule
, wxModule
)
108 // ============================================================================
109 // wxTopLevelWindowMSW implementation
110 // ============================================================================
112 BEGIN_EVENT_TABLE(wxTopLevelWindowMSW
, wxTopLevelWindowBase
)
113 EVT_ACTIVATE(wxTopLevelWindowMSW::OnActivate
)
116 // ----------------------------------------------------------------------------
117 // wxTopLevelWindowMSW creation
118 // ----------------------------------------------------------------------------
120 void wxTopLevelWindowMSW::Init()
123 m_maximizeOnShow
= false;
125 // Data to save/restore when calling ShowFullScreen
127 m_fsOldWindowStyle
= 0;
128 m_fsIsMaximized
= false;
129 m_fsIsShowing
= false;
131 m_winLastFocused
= NULL
;
133 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
137 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
138 SHACTIVATEINFO
* info
= new SHACTIVATEINFO
;
140 info
->cbSize
= sizeof(SHACTIVATEINFO
);
142 m_activateInfo
= (void*) info
;
148 WXDWORD
wxTopLevelWindowMSW::MSWGetStyle(long style
, WXDWORD
*exflags
) const
150 // let the base class deal with the common styles but fix the ones which
151 // don't make sense for us (we also deal with the borders ourselves)
152 WXDWORD msflags
= wxWindow::MSWGetStyle
154 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
, exflags
155 ) & ~WS_CHILD
& ~WS_VISIBLE
;
157 // For some reason, WS_VISIBLE needs to be defined on creation for
158 // SmartPhone 2003. The title can fail to be displayed otherwise.
159 #if defined(__SMARTPHONE__) || (defined(__WXWINCE__) && _WIN32_WCE < 400)
160 msflags
|= WS_VISIBLE
;
161 ((wxTopLevelWindowMSW
*)this)->wxWindowBase::Show(true);
164 // first select the kind of window being created
166 // note that if we don't set WS_POPUP, Windows assumes WS_OVERLAPPED and
167 // creates a window with both caption and border, hence we need to use
168 // WS_POPUP in a few cases just to avoid having caption/border which we
171 // border and caption styles
172 if ( ( style
& wxRESIZE_BORDER
) && !IsAlwaysMaximized())
173 msflags
|= WS_THICKFRAME
;
174 else if ( exflags
&& ((style
& wxBORDER_DOUBLE
) || (style
& wxBORDER_RAISED
)) )
175 *exflags
|= WS_EX_DLGMODALFRAME
;
176 else if ( !(style
& wxBORDER_NONE
) )
177 msflags
|= WS_BORDER
;
183 // normally we consider that all windows without a caption must be popups,
184 // but CE is an exception: there windows normally do not have the caption
185 // but shouldn't be made popups as popups can't have menus and don't look
186 // like normal windows anyhow
188 // TODO: Smartphone appears to like wxCAPTION, but we should check that
190 #if defined(__SMARTPHONE__) || !defined(__WXWINCE__)
191 if ( style
& wxCAPTION
)
192 msflags
|= WS_CAPTION
;
196 #endif // !__WXWINCE__
199 // next translate the individual flags
201 // WS_EX_CONTEXTHELP is incompatible with WS_MINIMIZEBOX and WS_MAXIMIZEBOX
202 // and is ignored if we specify both of them, but chances are that if we
203 // use wxWS_EX_CONTEXTHELP, we really do want to have the context help
204 // button while wxMINIMIZE/wxMAXIMIZE are included by default, so the help
206 if ( !(GetExtraStyle() & wxWS_EX_CONTEXTHELP
) )
208 if ( style
& wxMINIMIZE_BOX
)
209 msflags
|= WS_MINIMIZEBOX
;
210 if ( style
& wxMAXIMIZE_BOX
)
211 msflags
|= WS_MAXIMIZEBOX
;
215 // notice that if wxCLOSE_BOX is specified we need to use WS_SYSMENU too as
216 // otherwise the close box doesn't appear
217 if ( style
& (wxSYSTEM_MENU
| wxCLOSE_BOX
) )
218 msflags
|= WS_SYSMENU
;
219 #endif // !__WXWINCE__
221 // NB: under CE these 2 styles are not supported currently, we should
222 // call Minimize()/Maximize() "manually" if we want to support them
223 if ( style
& wxMINIMIZE
)
224 msflags
|= WS_MINIMIZE
;
226 if ( style
& wxMAXIMIZE
)
227 msflags
|= WS_MAXIMIZE
;
229 // Keep this here because it saves recoding this function in wxTinyFrame
230 if ( style
& wxTINY_CAPTION
)
231 msflags
|= WS_CAPTION
;
235 // there is no taskbar under CE, so omit all this
236 #if !defined(__WXWINCE__)
237 if ( !(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) )
239 if ( style
& wxFRAME_TOOL_WINDOW
)
241 // create the palette-like window
242 *exflags
|= WS_EX_TOOLWINDOW
;
244 // tool windows shouldn't appear on the taskbar (as documented)
245 style
|= wxFRAME_NO_TASKBAR
;
248 // We have to solve 2 different problems here:
250 // 1. frames with wxFRAME_NO_TASKBAR flag shouldn't appear in the
251 // taskbar even if they don't have a parent
253 // 2. frames without this style should appear in the taskbar even
254 // if they're owned (Windows only puts non owned windows into
255 // the taskbar normally)
257 // The second one is solved here by using WS_EX_APPWINDOW flag, the
258 // first one is dealt with in our MSWGetParent() method
260 if ( !(style
& wxFRAME_NO_TASKBAR
) && GetParent() )
262 // need to force the frame to appear in the taskbar
263 *exflags
|= WS_EX_APPWINDOW
;
265 //else: nothing to do [here]
268 if ( GetExtraStyle() & wxWS_EX_CONTEXTHELP
)
269 *exflags
|= WS_EX_CONTEXTHELP
;
270 #endif // !__WXWINCE__
272 if ( style
& wxSTAY_ON_TOP
)
273 *exflags
|= WS_EX_TOPMOST
;
279 WXHWND
wxTopLevelWindowMSW::MSWGetParent() const
281 // for the frames without wxFRAME_FLOAT_ON_PARENT style we should use NULL
282 // parent HWND or it would be always on top of its parent which is not what
283 // we usually want (in fact, we only want it for frames with the
284 // wxFRAME_FLOAT_ON_PARENT flag)
285 HWND hwndParent
= NULL
;
286 if ( HasFlag(wxFRAME_FLOAT_ON_PARENT
) )
288 const wxWindow
*parent
= GetParent();
292 // this flag doesn't make sense then and will be ignored
293 wxFAIL_MSG( wxT("wxFRAME_FLOAT_ON_PARENT but no parent?") );
297 hwndParent
= GetHwndOf(parent
);
300 //else: don't float on parent, must not be owned
302 // now deal with the 2nd taskbar-related problem (see comments above in
304 if ( HasFlag(wxFRAME_NO_TASKBAR
) && !hwndParent
)
307 hwndParent
= wxTLWHiddenParentModule::GetHWND();
310 return (WXHWND
)hwndParent
;
313 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
314 bool wxTopLevelWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
316 SHACTIVATEINFO
*info
= (SHACTIVATEINFO
*) m_activateInfo
;
319 SHHandleWMSettingChange(GetHwnd(), wParam
, lParam
, info
);
322 return wxWindowMSW::HandleSettingChange(wParam
, lParam
);
326 WXLRESULT
wxTopLevelWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
329 bool processed
= false;
333 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
336 SHACTIVATEINFO
* info
= (SHACTIVATEINFO
*) m_activateInfo
;
340 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
) flags
= SHA_INPUTDIALOG
;
341 SHHandleWMActivate(GetHwnd(), wParam
, lParam
, info
, flags
);
344 // This implicitly sends a wxEVT_ACTIVATE_APP event
346 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
354 wxActivateEvent
event(wxEVT_HIBERNATE
, true, wxID_ANY
);
355 event
.SetEventObject(wxTheApp
);
356 processed
= wxTheApp
->ProcessEvent(event
);
360 #endif // __SMARTPHONE__ || __POCKETPC__
363 // We may need to generate events for the items added to the system
364 // menu if it had been created (and presumably modified).
369 // ... the four low-order bits of the wParam parameter are
370 // used internally by the system. To obtain the correct
371 // result when testing the value of wParam, an application
372 // must combine the value 0xFFF0 with the wParam value by
373 // using the bitwise AND operator.
374 unsigned id
= wParam
& 0xfff0;
376 // SC_SIZE is the first of the system-defined commands and we
377 // leave those to DefWindowProc().
380 if ( m_menuSystem
->MSWCommand(0 /* unused anyhow */, id
) )
388 rc
= wxTopLevelWindowBase::MSWWindowProc(message
, wParam
, lParam
);
393 bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate
,
394 const wxString
& title
,
398 #ifdef __WXMICROWIN__
399 // no dialogs support under MicroWin yet
400 return CreateFrame(title
, pos
, size
);
401 #else // !__WXMICROWIN__
402 // static cast is valid as we're only ever called for dialogs
404 parent
= static_cast<wxDialog
*>(this)->GetParentForModalDialog();
406 m_hWnd
= (WXHWND
)::CreateDialogIndirect
409 (DLGTEMPLATE
*)dlgTemplate
,
410 parent
? GetHwndOf(parent
) : NULL
,
416 wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?"));
418 wxLogSysError(wxT("Can't create dialog using memory template"));
423 #if !defined(__WXWINCE__)
424 // For some reason, the system menu is activated when we use the
425 // WS_EX_CONTEXTHELP style, so let's set a reasonable icon
426 if ( HasExtraStyle(wxWS_EX_CONTEXTHELP
) )
428 wxFrame
*winTop
= wxDynamicCast(wxTheApp
->GetTopWindow(), wxFrame
);
431 wxIcon icon
= winTop
->GetIcon();
434 ::SendMessage(GetHwnd(), WM_SETICON
,
436 (LPARAM
)GetHiconOf(icon
));
440 #endif // !__WXWINCE__
442 #if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
443 // move the dialog to its initial position without forcing repainting
445 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
447 if ( x
== (int)CW_USEDEFAULT
)
449 // Let the system position the window, just set its size.
450 ::SetWindowPos(GetHwnd(), 0,
452 SWP_NOMOVE
| SWP_NOZORDER
);
454 else // Move the window to the desired location and set its size too.
456 if ( !::MoveWindow(GetHwnd(), x
, y
, w
, h
, FALSE
) )
458 wxLogLastError(wxT("MoveWindow"));
461 #endif // !__WXWINCE__
463 if ( !title
.empty() )
465 ::SetWindowText(GetHwnd(), title
.wx_str());
470 #ifdef __SMARTPHONE__
471 // Work around title non-display glitch
476 #endif // __WXMICROWIN__/!__WXMICROWIN__
479 bool wxTopLevelWindowMSW::CreateFrame(const wxString
& title
,
484 WXDWORD flags
= MSWGetCreateWindowFlags(&exflags
);
486 const wxSize sz
= IsAlwaysMaximized() ? wxDefaultSize
: size
;
489 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
490 exflags
|= WS_EX_LAYOUTRTL
;
493 return MSWCreate(MSWGetRegisteredClassName(),
494 title
.wx_str(), pos
, sz
, flags
, exflags
);
497 bool wxTopLevelWindowMSW::Create(wxWindow
*parent
,
499 const wxString
& title
,
503 const wxString
& name
)
505 wxSize sizeReal
= size
;
506 if ( !sizeReal
.IsFullySpecified() )
508 sizeReal
.SetDefaults(GetDefaultSize());
511 // notice that we should append this window to wxTopLevelWindows list
512 // before calling CreateBase() as it behaves differently for TLW and
514 wxTopLevelWindows
.Append(this);
516 bool ret
= CreateBase(parent
, id
, pos
, sizeReal
, style
, name
);
521 parent
->AddChild(this);
523 if ( GetExtraStyle() & wxTOPLEVEL_EX_DIALOG
)
525 // we have different dialog templates to allows creation of dialogs
526 // with & without captions under MSWindows, resizable or not (but a
527 // resizable dialog always has caption - otherwise it would look too
530 // we need 3 additional WORDs for dialog menu, class and title (as we
531 // don't use DS_SETFONT we don't need the fourth WORD for the font)
532 static const int dlgsize
= sizeof(DLGTEMPLATE
) + (sizeof(WORD
) * 3);
533 DLGTEMPLATE
*dlgTemplate
= (DLGTEMPLATE
*)malloc(dlgsize
);
534 memset(dlgTemplate
, 0, dlgsize
);
536 // these values are arbitrary, they won't be used normally anyhow
539 dlgTemplate
->cx
= 144;
540 dlgTemplate
->cy
= 75;
542 // reuse the code in MSWGetStyle() but correct the results slightly for
545 // NB: we need a temporary variable as we can't pass pointer to
546 // dwExtendedStyle directly, it's not aligned correctly for 64 bit
548 WXDWORD dwExtendedStyle
;
549 dlgTemplate
->style
= MSWGetStyle(style
, &dwExtendedStyle
);
550 dlgTemplate
->dwExtendedStyle
= dwExtendedStyle
;
552 // all dialogs are popups
553 dlgTemplate
->style
|= WS_POPUP
;
556 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
558 dlgTemplate
->dwExtendedStyle
|= WS_EX_LAYOUTRTL
;
561 // force 3D-look if necessary, it looks impossibly ugly otherwise
562 if ( style
& (wxRESIZE_BORDER
| wxCAPTION
) )
563 dlgTemplate
->style
|= DS_MODALFRAME
;
566 ret
= CreateDialog(dlgTemplate
, title
, pos
, sizeReal
);
571 ret
= CreateFrame(title
, pos
, sizeReal
);
575 if ( ret
&& !(GetWindowStyleFlag() & wxCLOSE_BOX
) )
577 EnableCloseButton(false);
581 // for standard dialogs the dialog manager generates WM_CHANGEUISTATE
582 // itself but for custom windows we have to do it ourselves in order to
583 // make the keyboard indicators (such as underlines for accelerators and
584 // focus rectangles) work under Win2k+
587 MSWUpdateUIState(UIS_INITIALIZE
);
590 // Note: if we include PocketPC in this test, dialogs can fail to show up,
591 // for example the text entry dialog in the dialogs sample. Problem with Maximise()?
592 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__WINCE_STANDARDSDK__))
593 if ( ( style
& wxMAXIMIZE
) || IsAlwaysMaximized() )
599 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
600 SetRightMenu(); // to nothing for initialization
606 wxTopLevelWindowMSW::~wxTopLevelWindowMSW()
612 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
613 SHACTIVATEINFO
* info
= (SHACTIVATEINFO
*) m_activateInfo
;
615 m_activateInfo
= NULL
;
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
) )
624 wxWindow
*parent
= GetParent();
627 ::BringWindowToTop(GetHwndOf(parent
));
632 // ----------------------------------------------------------------------------
633 // wxTopLevelWindowMSW showing
634 // ----------------------------------------------------------------------------
636 void wxTopLevelWindowMSW::DoShowWindow(int nShowCmd
)
638 ::ShowWindow(GetHwnd(), nShowCmd
);
640 m_iconized
= nShowCmd
== SW_MINIMIZE
;
643 void wxTopLevelWindowMSW::ShowWithoutActivating()
645 if ( !wxWindowBase::Show(true) )
648 DoShowWindow(SW_SHOWNA
);
651 bool wxTopLevelWindowMSW::Show(bool show
)
653 // don't use wxWindow version as we want to call DoShowWindow() ourselves
654 if ( !wxWindowBase::Show(show
) )
660 if ( m_maximizeOnShow
)
663 nShowCmd
= SW_MAXIMIZE
;
665 // This is necessary, or no window appears
666 #if defined( __WINCE_STANDARDSDK__) || defined(__SMARTPHONE__)
667 DoShowWindow(SW_SHOW
);
670 m_maximizeOnShow
= false;
672 else if ( m_iconized
)
675 nShowCmd
= SW_MINIMIZE
;
679 // we shouldn't use SW_SHOW which also activates the window for
680 // tool frames (as they shouldn't steal focus from the main window)
681 // nor for the currently disabled windows as they would be enabled
683 if ( HasFlag(wxFRAME_TOOL_WINDOW
) || !IsEnabled() )
684 nShowCmd
= SW_SHOWNA
;
694 #if wxUSE_DEFERRED_SIZING
695 // we only set pending size if we're maximized before being shown, now that
696 // we're shown we don't need it any more (it is reset in size event handler
697 // for child windows but we have to do it ourselves for this parent window)
699 // make sure to reset it before actually showing the window as this will
700 // generate WM_SIZE events and we want to use the correct client size from
701 // them, not the size returned by WM_NCCALCSIZE in DoGetClientSize() which
702 // turns out to be wrong for maximized windows (see #11762)
703 m_pendingSize
= wxDefaultSize
;
704 #endif // wxUSE_DEFERRED_SIZING
706 DoShowWindow(nShowCmd
);
708 #if defined(__WXWINCE__) && (_WIN32_WCE >= 400 && !defined(__POCKETPC__) && !defined(__SMARTPHONE__))
709 // Addornments have to be added when the frame is the correct size
710 wxFrame
* frame
= wxDynamicCast(this, wxFrame
);
711 if (frame
&& frame
->GetMenuBar())
712 frame
->GetMenuBar()->AddAdornments(GetWindowStyleFlag());
718 // ----------------------------------------------------------------------------
719 // wxTopLevelWindowMSW maximize/minimize
720 // ----------------------------------------------------------------------------
722 void wxTopLevelWindowMSW::Maximize(bool maximize
)
726 // just maximize it directly
727 DoShowWindow(maximize
? SW_MAXIMIZE
: SW_RESTORE
);
731 // we can't maximize the hidden frame because it shows it as well,
732 // so just remember that we should do it later in this case
733 m_maximizeOnShow
= maximize
;
735 #if wxUSE_DEFERRED_SIZING
736 // after calling Maximize() the client code expects to get the frame
737 // "real" size and doesn't want to know that, because of implementation
738 // details, the frame isn't really maximized yet but will be only once
739 // it's shown, so return our size as it will be then in this case
742 // we must only change pending size here, and not call SetSize()
743 // because otherwise Windows would think that this (full screen)
744 // size is the natural size for the frame and so would use it when
745 // the user clicks on "restore" title bar button instead of the
746 // correct initial frame size
748 // NB: unfortunately we don't know which display we're on yet so we
749 // have to use the default one
750 m_pendingSize
= wxGetClientDisplayRect().GetSize();
752 //else: can't do anything in this case, we don't have the old size
753 #endif // wxUSE_DEFERRED_SIZING
757 bool wxTopLevelWindowMSW::IsMaximized() const
759 return IsAlwaysMaximized() ||
760 #if !defined(__SMARTPHONE__) && !defined(__POCKETPC__) && !defined(__WINCE_STANDARDSDK__)
762 (::IsZoomed(GetHwnd()) != 0) ||
767 void wxTopLevelWindowMSW::Iconize(bool iconize
)
769 if ( iconize
== m_iconized
)
771 // Do nothing, in particular don't restore non-iconized windows when
772 // Iconize(false) is called as this would wrongly un-maximize them.
778 // change the window state immediately
779 DoShowWindow(iconize
? SW_MINIMIZE
: SW_RESTORE
);
783 // iconizing the window shouldn't show it so just remember that we need
784 // to become iconized when shown later
789 bool wxTopLevelWindowMSW::IsIconized() const
797 // don't use m_iconized, it may be briefly out of sync with the real state
798 // as it's only modified when we receive a WM_SIZE and we could be called
799 // from an event handler from one of the messages we receive before it,
801 return ::IsIconic(GetHwnd()) != 0;
805 void wxTopLevelWindowMSW::Restore()
807 DoShowWindow(SW_RESTORE
);
810 void wxTopLevelWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
812 if ( dir
== wxLayout_Default
)
813 dir
= wxTheApp
->GetLayoutDirection();
815 if ( dir
!= wxLayout_Default
)
816 wxTopLevelWindowBase::SetLayoutDirection(dir
);
819 // ----------------------------------------------------------------------------
820 // wxTopLevelWindowMSW geometry
821 // ----------------------------------------------------------------------------
825 void wxTopLevelWindowMSW::DoGetPosition(int *x
, int *y
) const
830 wp
.length
= sizeof(WINDOWPLACEMENT
);
831 if ( ::GetWindowPlacement(GetHwnd(), &wp
) )
833 RECT
& rc
= wp
.rcNormalPosition
;
835 // the position returned by GetWindowPlacement() is in workspace
836 // coordinates except for windows with WS_EX_TOOLWINDOW style
837 if ( !HasFlag(wxFRAME_TOOL_WINDOW
) )
839 // we must use the correct display for the translation as the
840 // task bar might be shown on one display but not the other one
841 int n
= wxDisplay::GetFromWindow(this);
842 wxDisplay
dpy(n
== wxNOT_FOUND
? 0 : n
);
843 const wxPoint ptOfs
= dpy
.GetClientArea().GetPosition() -
844 dpy
.GetGeometry().GetPosition();
858 wxLogLastError(wxT("GetWindowPlacement"));
862 wxTopLevelWindowBase::DoGetPosition(x
, y
);
865 void wxTopLevelWindowMSW::DoGetSize(int *width
, int *height
) const
870 wp
.length
= sizeof(WINDOWPLACEMENT
);
871 if ( ::GetWindowPlacement(GetHwnd(), &wp
) )
873 const RECT
& rc
= wp
.rcNormalPosition
;
876 *width
= rc
.right
- rc
.left
;
878 *height
= rc
.bottom
- rc
.top
;
883 wxLogLastError(wxT("GetWindowPlacement"));
887 wxTopLevelWindowBase::DoGetSize(width
, height
);
890 #endif // __WXWINCE__
893 wxTopLevelWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
896 int& w
, int& h
) const
898 // let the system position the window if no explicit position was specified
899 if ( pos
.x
== wxDefaultCoord
)
901 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
902 // can just as well set it to CW_USEDEFAULT as well
908 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
909 // neither because it is not handled as a special value by Windows then
910 // and so we have to choose some default value for it, even if a
911 // completely arbitrary one
912 static const int DEFAULT_Y
= 200;
915 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
918 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
920 // We don't use CW_USEDEFAULT here for several reasons:
922 // 1. It results in huge frames on modern screens (1000*800 is not
923 // uncommon on my 1280*1024 screen) which is way too big for a half
924 // empty frame of most of wxWidgets samples for example)
926 // 2. It is buggy for frames with wxFRAME_TOOL_WINDOW style for which
927 // the default is for whatever reason 8*8 which breaks client <->
928 // window size calculations (it would be nice if it didn't, but it
929 // does and the simplest way to fix it seemed to change the broken
930 // default size anyhow)
932 // 3. There is just no advantage in doing it: with x and y it is
933 // possible that [future versions of] Windows position the new top
934 // level window in some smart way which we can't do, but we can
935 // guess a reasonably good size for a new window just as well
938 // The only exception is for the Windows CE platform where the system
939 // does know better than we how should the windows be sized
944 wxSize sizeReal
= size
;
945 sizeReal
.SetDefaults(GetDefaultSize());
949 #endif // _WIN32_WCE/!_WIN32_WCE
958 // ----------------------------------------------------------------------------
959 // wxTopLevelWindowMSW fullscreen
960 // ----------------------------------------------------------------------------
962 bool wxTopLevelWindowMSW::ShowFullScreen(bool show
, long style
)
964 if ( show
== IsFullScreen() )
970 m_fsIsShowing
= show
;
976 // zap the frame borders
978 // save the 'normal' window style
979 m_fsOldWindowStyle
= GetWindowLong(GetHwnd(), GWL_STYLE
);
981 // save the old position, width & height, maximize state
982 m_fsOldSize
= GetRect();
983 m_fsIsMaximized
= IsMaximized();
985 // decide which window style flags to turn off
986 LONG newStyle
= m_fsOldWindowStyle
;
989 if (style
& wxFULLSCREEN_NOBORDER
)
991 offFlags
|= WS_BORDER
;
993 offFlags
|= WS_THICKFRAME
;
996 if (style
& wxFULLSCREEN_NOCAPTION
)
997 offFlags
|= WS_CAPTION
| WS_SYSMENU
;
999 newStyle
&= ~offFlags
;
1001 // change our window style to be compatible with full-screen mode
1002 ::SetWindowLong(GetHwnd(), GWL_STYLE
, newStyle
);
1006 // resize to the size of the display containing us
1007 int dpy
= wxDisplay::GetFromWindow(this);
1008 if ( dpy
!= wxNOT_FOUND
)
1010 rect
= wxDisplay(dpy
).GetGeometry();
1012 else // fall back to the main desktop
1013 #endif // wxUSE_DISPLAY
1015 // resize to the size of the desktop
1016 wxCopyRECTToRect(wxGetWindowRect(::GetDesktopWindow()), rect
);
1018 // FIXME: size of the bottom menu (toolbar)
1019 // should be taken in account
1020 rect
.height
+= rect
.y
;
1027 // now flush the window style cache and actually go full-screen
1028 long flags
= SWP_FRAMECHANGED
;
1030 // showing the frame full screen should also show it if it's still
1034 // don't call wxWindow version to avoid flicker from calling
1035 // ::ShowWindow() -- we're going to show the window at the correct
1036 // location directly below -- but do call the wxWindowBase version
1037 // to sync the internal m_isShown flag
1038 wxWindowBase::Show();
1040 flags
|= SWP_SHOWWINDOW
;
1043 SetWindowPos(GetHwnd(), HWND_TOP
,
1044 rect
.x
, rect
.y
, rect
.width
, rect
.height
,
1047 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
1048 ::SHFullScreen(GetHwnd(), SHFS_HIDETASKBAR
| SHFS_HIDESIPBUTTON
);
1051 // finally send an event allowing the window to relayout itself &c
1052 wxSizeEvent
event(rect
.GetSize(), GetId());
1053 event
.SetEventObject(this);
1054 HandleWindowEvent(event
);
1056 else // stop showing full screen
1058 #if !defined(__HANDHELDPC__) && (defined(__WXWINCE__) && (_WIN32_WCE < 400))
1059 ::SHFullScreen(GetHwnd(), SHFS_SHOWTASKBAR
| SHFS_SHOWSIPBUTTON
);
1061 Maximize(m_fsIsMaximized
);
1062 SetWindowLong(GetHwnd(),GWL_STYLE
, m_fsOldWindowStyle
);
1063 SetWindowPos(GetHwnd(),HWND_TOP
,m_fsOldSize
.x
, m_fsOldSize
.y
,
1064 m_fsOldSize
.width
, m_fsOldSize
.height
, SWP_FRAMECHANGED
);
1070 // ----------------------------------------------------------------------------
1071 // wxTopLevelWindowMSW misc
1072 // ----------------------------------------------------------------------------
1074 void wxTopLevelWindowMSW::SetTitle( const wxString
& title
)
1079 wxString
wxTopLevelWindowMSW::GetTitle() const
1084 bool wxTopLevelWindowMSW::DoSelectAndSetIcon(const wxIconBundle
& icons
,
1089 const wxSize
size(::GetSystemMetrics(smX
), ::GetSystemMetrics(smY
));
1091 // Try the exact size first.
1092 wxIcon icon
= icons
.GetIconOfExactSize(size
);
1096 // If we didn't find any, set at least some icon: it will look scaled
1097 // and ugly but in practice it's impossible to prevent this because not
1098 // everyone can provide the icons in all sizes used by all versions of
1099 // Windows in all DPIs (this would include creating them in at least
1100 // 14, 16, 22, 32, 48, 64 and 128 pixel sizes).
1101 icon
= icons
.GetIcon(size
);
1107 ::SendMessage(GetHwnd(), WM_SETICON
, i
, (LPARAM
)GetHiconOf(icon
));
1111 void wxTopLevelWindowMSW::SetIcons(const wxIconBundle
& icons
)
1113 wxTopLevelWindowBase::SetIcons(icons
);
1115 if ( icons
.IsEmpty() )
1117 // FIXME: SetIcons(wxNullIconBundle) should unset existing icons,
1118 // but we currently don't do that
1119 wxASSERT_MSG( m_icons
.IsEmpty(), "unsetting icons doesn't work" );
1123 DoSelectAndSetIcon(icons
, SM_CXSMICON
, SM_CYSMICON
, ICON_SMALL
);
1124 DoSelectAndSetIcon(icons
, SM_CXICON
, SM_CYICON
, ICON_BIG
);
1127 bool wxTopLevelWindowMSW::EnableCloseButton(bool enable
)
1129 #if !defined(__WXMICROWIN__)
1130 // get system (a.k.a. window) menu
1131 HMENU hmenu
= GetSystemMenu(GetHwnd(), FALSE
/* get it */);
1134 // no system menu at all -- ok if we want to remove the close button
1135 // anyhow, but bad if we want to show it
1139 // enabling/disabling the close item from it also automatically
1140 // disables/enables the close title bar button
1141 if ( ::EnableMenuItem(hmenu
, SC_CLOSE
,
1143 (enable
? MF_ENABLED
: MF_GRAYED
)) == -1 )
1145 wxLogLastError(wxT("EnableMenuItem(SC_CLOSE)"));
1150 // update appearance immediately
1151 if ( !::DrawMenuBar(GetHwnd()) )
1153 wxLogLastError(wxT("DrawMenuBar"));
1156 #endif // !__WXMICROWIN__
1163 bool wxTopLevelWindowMSW::SetShape(const wxRegion
& region
)
1165 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED
), false,
1166 wxT("Shaped windows must be created with the wxFRAME_SHAPED style."));
1168 // The empty region signifies that the shape should be removed from the
1170 if ( region
.IsEmpty() )
1172 if (::SetWindowRgn(GetHwnd(), NULL
, TRUE
) == 0)
1174 wxLogLastError(wxT("SetWindowRgn"));
1180 // Windows takes ownership of the region, so
1181 // we'll have to make a copy of the region to give to it.
1182 DWORD noBytes
= ::GetRegionData(GetHrgnOf(region
), 0, NULL
);
1183 RGNDATA
*rgnData
= (RGNDATA
*) new char[noBytes
];
1184 ::GetRegionData(GetHrgnOf(region
), noBytes
, rgnData
);
1185 HRGN hrgn
= ::ExtCreateRegion(NULL
, noBytes
, rgnData
);
1186 delete[] (char*) rgnData
;
1188 // SetWindowRgn expects the region to be in coordinants
1189 // relative to the window, not the client area. Figure
1190 // out the offset, if any.
1192 DWORD dwStyle
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1193 DWORD dwExStyle
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1194 ::GetClientRect(GetHwnd(), &rect
);
1195 ::AdjustWindowRectEx(&rect
, dwStyle
, ::GetMenu(GetHwnd()) != NULL
, dwExStyle
);
1196 ::OffsetRgn(hrgn
, -rect
.left
, -rect
.top
);
1198 // Now call the shape API with the new region.
1199 if (::SetWindowRgn(GetHwnd(), hrgn
, TRUE
) == 0)
1201 wxLogLastError(wxT("SetWindowRgn"));
1207 #endif // !__WXWINCE__
1209 void wxTopLevelWindowMSW::RequestUserAttention(int flags
)
1211 // check if we can use FlashWindowEx(): unfortunately a simple test for
1212 // FLASHW_STOP doesn't work because MSVC6 headers do #define it but don't
1213 // provide FlashWindowEx() declaration, so try to detect whether we have
1214 // real headers for WINVER 0x0500 by checking for existence of a symbol not
1215 // declated in MSVC6 header
1216 #if defined(FLASHW_STOP) && defined(VK_XBUTTON1) && wxUSE_DYNLIB_CLASS
1217 // available in the headers, check if it is supported by the system
1218 typedef BOOL (WINAPI
*FlashWindowEx_t
)(FLASHWINFO
*pfwi
);
1219 static FlashWindowEx_t s_pfnFlashWindowEx
= NULL
;
1220 if ( !s_pfnFlashWindowEx
)
1222 wxDynamicLibrary
dllUser32(wxT("user32.dll"));
1223 s_pfnFlashWindowEx
= (FlashWindowEx_t
)
1224 dllUser32
.GetSymbol(wxT("FlashWindowEx"));
1226 // we can safely unload user32.dll here, it's going to remain loaded as
1227 // long as the program is running anyhow
1230 if ( s_pfnFlashWindowEx
)
1232 WinStruct
<FLASHWINFO
> fwi
;
1233 fwi
.hwnd
= GetHwnd();
1234 fwi
.dwFlags
= FLASHW_ALL
;
1235 if ( flags
& wxUSER_ATTENTION_INFO
)
1237 // just flash a few times
1240 else // wxUSER_ATTENTION_ERROR
1242 // flash until the user notices it
1243 fwi
.dwFlags
|= FLASHW_TIMERNOFG
;
1246 s_pfnFlashWindowEx(&fwi
);
1248 else // FlashWindowEx() not available
1249 #endif // FlashWindowEx() defined
1253 ::FlashWindow(GetHwnd(), TRUE
);
1254 #endif // __WXWINCE__
1258 wxMenu
*wxTopLevelWindowMSW::MSWGetSystemMenu() const
1260 if ( !m_menuSystem
)
1262 HMENU hmenu
= ::GetSystemMenu(GetHwnd(), FALSE
);
1265 wxLogLastError(wxT("GetSystemMenu()"));
1269 wxTopLevelWindowMSW
* const
1270 self
= const_cast<wxTopLevelWindowMSW
*>(this);
1272 self
->m_menuSystem
= wxMenu::MSWNewFromHMENU(hmenu
);
1274 // We need to somehow associate this menu with this window to ensure
1275 // that we get events from it. A natural idea would be to pretend that
1276 // it's attached to our menu bar but this wouldn't work if we don't
1277 // have any menu bar which is a common case for applications using
1278 // custom items in the system menu (they mostly do it exactly because
1279 // they don't have any other menus).
1281 // So reuse the invoking window pointer instead, this is not exactly
1282 // correct but doesn't seem to have any serious drawbacks.
1283 m_menuSystem
->SetInvokingWindow(self
);
1286 return m_menuSystem
;
1289 // ----------------------------------------------------------------------------
1290 // Transparency support
1291 // ---------------------------------------------------------------------------
1293 bool wxTopLevelWindowMSW::SetTransparent(wxByte alpha
)
1295 #if wxUSE_DYNLIB_CLASS
1296 typedef DWORD (WINAPI
*PSETLAYEREDWINDOWATTR
)(HWND
, DWORD
, BYTE
, DWORD
);
1297 static PSETLAYEREDWINDOWATTR
1298 pSetLayeredWindowAttributes
= (PSETLAYEREDWINDOWATTR
)-1;
1300 if ( pSetLayeredWindowAttributes
== (PSETLAYEREDWINDOWATTR
)-1 )
1302 wxDynamicLibrary
dllUser32(wxT("user32.dll"));
1304 // use RawGetSymbol() and not GetSymbol() to avoid error messages under
1305 // Windows 95: there is nothing the user can do about this anyhow
1306 pSetLayeredWindowAttributes
= (PSETLAYEREDWINDOWATTR
)
1307 dllUser32
.RawGetSymbol(wxT("SetLayeredWindowAttributes"));
1309 // it's ok to destroy dllUser32 here, we link statically to user32.dll
1310 // anyhow so it won't be unloaded
1313 if ( !pSetLayeredWindowAttributes
)
1315 #endif // wxUSE_DYNLIB_CLASS
1317 LONG exstyle
= GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1319 // if setting alpha to fully opaque then turn off the layered style
1322 SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyle
& ~WS_EX_LAYERED
);
1327 #if wxUSE_DYNLIB_CLASS
1328 // Otherwise, set the layered style if needed and set the alpha value
1329 if ((exstyle
& WS_EX_LAYERED
) == 0 )
1330 SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyle
| WS_EX_LAYERED
);
1332 if ( pSetLayeredWindowAttributes(GetHwnd(), 0, (BYTE
)alpha
, LWA_ALPHA
) )
1334 #endif // wxUSE_DYNLIB_CLASS
1339 bool wxTopLevelWindowMSW::CanSetTransparent()
1341 // The API is available on win2k and above
1343 static int os_type
= -1;
1344 static int ver_major
= -1;
1347 os_type
= ::wxGetOsVersion(&ver_major
);
1349 return (os_type
== wxOS_WINDOWS_NT
&& ver_major
>= 5);
1352 void wxTopLevelWindowMSW::DoEnable(bool enable
)
1354 wxTopLevelWindowBase::DoEnable(enable
);
1356 // Enabling or disabling a window may change its appearance. Unfortunately,
1357 // in at least some situation, toplevel windows don't repaint themselves,
1358 // so we have to issue explicit refresh to avoid rendering artifacts.
1360 // TODO: find out just what exactly is wrong here
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 // Default activation behaviour - set the focus for the first child
1383 void wxTopLevelWindowMSW::OnActivate(wxActivateEvent
& event
)
1385 if ( event
.GetActive() )
1387 // restore focus to the child which was last focused unless we already
1389 wxLogTrace(wxT("focus"), wxT("wxTLW %p activated."), m_hWnd
);
1391 wxWindow
*winFocus
= FindFocus();
1392 if ( !winFocus
|| wxGetTopLevelParent(winFocus
) != this )
1394 wxWindow
*parent
= m_winLastFocused
? m_winLastFocused
->GetParent()
1401 wxSetFocusToChild(parent
, &m_winLastFocused
);
1404 else // deactivating
1406 // remember the last focused child if it is our child
1407 m_winLastFocused
= FindFocus();
1409 if ( m_winLastFocused
)
1411 // let it know that it doesn't have focus any more
1412 // But this will already be done via WM_KILLFOCUS, so we'll get two kill
1413 // focus events if we call it explicitly.
1414 // m_winLastFocused->HandleKillFocus((WXHWND)NULL);
1416 // and don't remember it if it's a child from some other frame
1417 if ( wxGetTopLevelParent(m_winLastFocused
) != this )
1419 m_winLastFocused
= NULL
;
1423 wxLogTrace(wxT("focus"),
1424 wxT("wxTLW %p deactivated, last focused: %p."),
1426 m_winLastFocused
? GetHwndOf(m_winLastFocused
) : NULL
);
1432 // the DialogProc for all wxWidgets dialogs
1433 LONG APIENTRY _EXPORT
1434 wxDlgProc(HWND hDlg
,
1436 WPARAM
WXUNUSED(wParam
),
1437 LPARAM
WXUNUSED(lParam
))
1443 // under CE, add a "Ok" button in the dialog title bar and make it full
1446 // TODO: find the window for this HWND, and take into account
1447 // wxMAXIMIZE and wxCLOSE_BOX. For now, assume both are present.
1449 // Standard SDK doesn't have aygshell.dll: see
1450 // include/wx/msw/wince/libraries.h
1451 #if defined(__WXWINCE__) && !defined(__WINCE_STANDARDSDK__) && !defined(__HANDHELDPC__)
1452 SHINITDLGINFO shidi
;
1453 shidi
.dwMask
= SHIDIM_FLAGS
;
1454 shidi
.dwFlags
= SHIDIF_SIZEDLG
// take account of the SIP or menubar
1455 #ifndef __SMARTPHONE__
1460 SHInitDialog( &shidi
);
1461 #else // no SHInitDialog()
1464 // for WM_INITDIALOG, returning TRUE tells system to set focus to
1465 // the first control in the dialog box, but as we set the focus
1466 // ourselves, we return FALSE for it as well
1471 // for almost all messages, returning FALSE means that we didn't process
1476 // ============================================================================
1477 // wxTLWHiddenParentModule implementation
1478 // ============================================================================
1480 HWND
wxTLWHiddenParentModule::ms_hwnd
= NULL
;
1482 const wxChar
*wxTLWHiddenParentModule::ms_className
= NULL
;
1484 bool wxTLWHiddenParentModule::OnInit()
1487 ms_className
= NULL
;
1492 void wxTLWHiddenParentModule::OnExit()
1496 if ( !::DestroyWindow(ms_hwnd
) )
1498 wxLogLastError(wxT("DestroyWindow(hidden TLW parent)"));
1506 if ( !::UnregisterClass(ms_className
, wxGetInstance()) )
1508 wxLogLastError(wxT("UnregisterClass(\"wxTLWHiddenParent\")"));
1511 ms_className
= NULL
;
1516 HWND
wxTLWHiddenParentModule::GetHWND()
1520 if ( !ms_className
)
1522 static const wxChar
*HIDDEN_PARENT_CLASS
= wxT("wxTLWHiddenParent");
1525 wxZeroMemory(wndclass
);
1527 wndclass
.lpfnWndProc
= DefWindowProc
;
1528 wndclass
.hInstance
= wxGetInstance();
1529 wndclass
.lpszClassName
= HIDDEN_PARENT_CLASS
;
1531 if ( !::RegisterClass(&wndclass
) )
1533 wxLogLastError(wxT("RegisterClass(\"wxTLWHiddenParent\")"));
1537 ms_className
= HIDDEN_PARENT_CLASS
;
1541 ms_hwnd
= ::CreateWindow(ms_className
, wxEmptyString
, 0, 0, 0, 0, 0, NULL
,
1542 (HMENU
)NULL
, wxGetInstance(), NULL
);
1545 wxLogLastError(wxT("CreateWindow(hidden TLW parent)"));