1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/window.cpp
3 // Purpose: wxWindowMSW
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
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/window.h"
30 #include "wx/msw/wrapwin.h"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
56 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
60 #include "wx/hashmap.h"
61 #include "wx/evtloop.h"
63 #include "wx/sysopt.h"
65 #if wxUSE_DRAG_AND_DROP
69 #if wxUSE_ACCESSIBILITY
70 #include "wx/access.h"
74 #define WM_GETOBJECT 0x003D
77 #define OBJID_CLIENT 0xFFFFFFFC
81 #include "wx/msw/private.h"
82 #include "wx/msw/private/keyboard.h"
83 #include "wx/msw/dcclient.h"
86 #include "wx/tooltip.h"
94 #include "wx/radiobox.h"
95 #endif // wxUSE_RADIOBOX
98 #include "wx/spinctrl.h"
99 #endif // wxUSE_SPINCTRL
101 #include "wx/notebook.h"
102 #include "wx/listctrl.h"
103 #include "wx/dynlib.h"
107 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
108 #include <shellapi.h>
109 #include <mmsystem.h>
113 #include <windowsx.h>
116 #if !defined __WXWINCE__ && !defined NEED_PBT_H
120 #if defined(__WXWINCE__)
121 #include "wx/msw/wince/missing.h"
124 #include <shellapi.h>
126 #include <aygshell.h>
131 #include "wx/msw/uxtheme.h"
132 #define EP_EDITTEXT 1
135 #define ETS_SELECTED 3
136 #define ETS_DISABLED 4
137 #define ETS_FOCUSED 5
138 #define ETS_READONLY 6
142 // define the constants used by AnimateWindow() if our SDK doesn't have them
144 #define AW_HOR_POSITIVE 0x00000001
145 #define AW_HOR_NEGATIVE 0x00000002
146 #define AW_VER_POSITIVE 0x00000004
147 #define AW_VER_NEGATIVE 0x00000008
148 #define AW_CENTER 0x00000010
149 #define AW_HIDE 0x00010000
150 #define AW_ACTIVATE 0x00020000
151 #define AW_SLIDE 0x00040000
152 #define AW_BLEND 0x00080000
155 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
156 #define HAVE_TRACKMOUSEEVENT
157 #endif // everything needed for TrackMouseEvent()
159 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
160 // when mouse position didnd't change
162 #define wxUSE_MOUSEEVENT_HACK 0
164 #define wxUSE_MOUSEEVENT_HACK 1
167 // not all compilers/platforms have X button related declarations (notably
168 // Windows CE doesn't, and probably some old SDKs don't neither)
169 #ifdef WM_XBUTTONDOWN
170 #define wxHAS_XBUTTON
173 #ifndef MAPVK_VK_TO_CHAR
174 #define MAPVK_VK_TO_CHAR 2
177 // ---------------------------------------------------------------------------
179 // ---------------------------------------------------------------------------
181 #if wxUSE_MENUS_NATIVE
182 extern wxMenu
*wxCurrentPopupMenu
;
186 // This is a hack used by the owner-drawn wxButton implementation to ensure
187 // that the brush used for erasing its background is correctly aligned with the
189 wxWindowMSW
*wxWindowBeingErased
= NULL
;
190 #endif // wxUSE_UXTHEME
195 // true if we had already created the std colour map, used by
196 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
197 bool gs_hasStdCmap
= false;
199 // last mouse event information we need to filter out the duplicates
200 #if wxUSE_MOUSEEVENT_HACK
201 struct MouseEventInfoDummy
203 // mouse position (in screen coordinates)
206 // last mouse event type
209 #endif // wxUSE_MOUSEEVENT_HACK
211 // hash containing the registered handlers for the custom messages
212 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
213 wxIntegerHash
, wxIntegerEqual
,
216 MSWMessageHandlers gs_messageHandlers
;
218 // hash containing all our windows, it uses HWND keys and wxWindow* values
219 WX_DECLARE_HASH_MAP(HWND
, wxWindow
*,
220 wxPointerHash
, wxPointerEqual
,
223 WindowHandles gs_windowHandles
;
225 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
227 // temporary override for WM_ERASEBKGND processing: we don't store this in
228 // wxWindow itself as we don't need it during most of the time so don't
229 // increase the size of all window objects unnecessarily
230 WX_DECLARE_HASH_MAP(wxWindow
*, wxWindow
*,
231 wxPointerHash
, wxPointerEqual
,
234 EraseBgHooks gs_eraseBgHooks
;
236 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
238 // If this variable is strictly positive, EVT_CHAR_HOOK is not generated for
239 // Escape key presses as it can't be intercepted because it's needed by some
240 // currently shown window, e.g. IME entry.
242 // This is currently global as we allow using UI from the main thread only
243 // anyhow but could be replaced with a thread-specific value in the future if
245 int gs_modalEntryWindowCount
= 0;
247 } // anonymous namespace
249 // ---------------------------------------------------------------------------
251 // ---------------------------------------------------------------------------
253 // the window proc for all our windows
254 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
255 WPARAM wParam
, LPARAM lParam
);
258 #if wxDEBUG_LEVEL >= 2
259 const wxChar
*wxGetMessageName(int message
);
260 #endif // wxDEBUG_LEVEL >= 2
262 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
263 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
265 // get the text metrics for the current font
266 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
269 // find the window for the mouse event at the specified position
270 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
271 #endif // __WXWINCE__
273 // wrapper around BringWindowToTop() API
274 static inline void wxBringWindowToTop(HWND hwnd
)
276 #ifdef __WXMICROWIN__
277 // It seems that MicroWindows brings the _parent_ of the window to the top,
278 // which can be the wrong one.
280 // activate (set focus to) specified window
284 // raise top level parent to top of z order
285 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
287 wxLogLastError(wxT("SetWindowPos"));
293 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
294 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
297 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
298 parent as well as otherwise several Win32 functions using
299 GetNextDlgTabItem() to iterate over all controls such as
300 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
301 all of them iterate over all the controls starting from the currently
302 focused one and stop iterating when they get back to the focus but
303 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
304 get back to the initial (focused) window: as we do have this style,
305 GetNextDlgTabItem() will leave this window and continue in its parent,
306 but if the parent doesn't have it, it wouldn't recurse inside it later
307 on and so wouldn't have a chance of getting back to this window either.
309 while ( parent
&& !parent
->IsTopLevel() )
311 LONG exStyle
= wxGetWindowExStyle(parent
);
312 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
314 // force the parent to have this style
315 wxSetWindowExStyle(parent
, exStyle
| WS_EX_CONTROLPARENT
);
318 parent
= parent
->GetParent();
322 #endif // !__WXWINCE__
325 // On Windows CE, GetCursorPos can return an error, so use this function
327 bool GetCursorPosWinCE(POINT
* pt
)
329 if (!GetCursorPos(pt
))
331 DWORD pos
= GetMessagePos();
339 // ---------------------------------------------------------------------------
341 // ---------------------------------------------------------------------------
343 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
345 #ifdef __WXUNIVERSAL__
346 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
347 #endif // __WXUNIVERSAL__
349 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
350 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
352 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
356 // ===========================================================================
358 // ===========================================================================
360 // ---------------------------------------------------------------------------
361 // wxWindow utility functions
362 // ---------------------------------------------------------------------------
364 // Find an item given the MS Windows id
365 wxWindow
*wxWindowMSW::FindItem(long id
) const
368 wxControl
*item
= wxDynamicCastThis(wxControl
);
371 // is it us or one of our "internal" children?
372 if ( item
->GetId() == id
373 #ifndef __WXUNIVERSAL__
374 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
375 #endif // __WXUNIVERSAL__
381 #endif // wxUSE_CONTROLS
383 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
386 wxWindow
*childWin
= current
->GetData();
388 wxWindow
*wnd
= childWin
->FindItem(id
);
392 current
= current
->GetNext();
398 // Find an item given the MS Windows handle
399 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
401 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
404 wxWindow
*parent
= current
->GetData();
406 // Do a recursive search.
407 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
413 || parent
->IsKindOf(CLASSINFO(wxControl
))
414 #endif // wxUSE_CONTROLS
417 wxWindow
*item
= current
->GetData();
418 if ( item
->GetHWND() == hWnd
)
422 if ( item
->ContainsHWND(hWnd
) )
427 current
= current
->GetNext();
432 // Default command handler
433 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
438 // ----------------------------------------------------------------------------
439 // constructors and such
440 // ----------------------------------------------------------------------------
442 void wxWindowMSW::Init()
446 m_mouseInWindow
= false;
447 m_lastKeydownProcessed
= false;
454 #if wxUSE_DEFERRED_SIZING
456 m_pendingPosition
= wxDefaultPosition
;
457 m_pendingSize
= wxDefaultSize
;
458 #endif // wxUSE_DEFERRED_SIZING
461 m_contextMenuEnabled
= false;
466 wxWindowMSW::~wxWindowMSW()
470 #ifndef __WXUNIVERSAL__
471 // VS: make sure there's no wxFrame with last focus set to us:
472 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
474 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
477 if ( frame
->GetLastFocus() == this )
479 frame
->SetLastFocus(NULL
);
482 // apparently sometimes we can end up with our grand parent
483 // pointing to us as well: this is surely a bug in focus handling
484 // code but it's not clear where it happens so for now just try to
485 // fix it here by not breaking out of the loop
489 #endif // __WXUNIVERSAL__
491 // VS: destroy children first and _then_ detach *this from its parent.
492 // If we did it the other way around, children wouldn't be able
493 // find their parent frame (see above).
498 // VZ: test temp removed to understand what really happens here
499 //if (::IsWindow(GetHwnd()))
501 if ( !::DestroyWindow(GetHwnd()) )
503 wxLogLastError(wxT("DestroyWindow"));
507 // remove hWnd <-> wxWindow association
508 wxRemoveHandleAssociation(this);
514 const wxChar
*wxWindowMSW::MSWGetRegisteredClassName()
516 return wxApp::GetRegisteredClassName(wxT("wxWindow"), COLOR_BTNFACE
);
519 // real construction (Init() must have been called before!)
520 bool wxWindowMSW::Create(wxWindow
*parent
,
525 const wxString
& name
)
527 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
529 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
532 parent
->AddChild(this);
535 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
537 #ifdef __WXUNIVERSAL__
538 // no borders, we draw them ourselves
539 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
543 msflags
&= ~WS_BORDER
;
544 #endif // wxUniversal
548 msflags
|= WS_VISIBLE
;
551 if ( !MSWCreate(MSWGetRegisteredClassName(),
552 NULL
, pos
, size
, msflags
, exstyle
) )
560 // ---------------------------------------------------------------------------
562 // ---------------------------------------------------------------------------
564 void wxWindowMSW::SetFocus()
566 HWND hWnd
= GetHwnd();
567 wxCHECK_RET( hWnd
, wxT("can't set focus to invalid window") );
569 #if !defined(__WXWINCE__)
573 if ( !::SetFocus(hWnd
) )
575 // was there really an error?
576 DWORD dwRes
= ::GetLastError();
579 HWND hwndFocus
= ::GetFocus();
580 if ( hwndFocus
!= hWnd
)
582 wxLogApiError(wxT("SetFocus"), dwRes
);
588 void wxWindowMSW::SetFocusFromKbd()
590 // when the focus is given to the control with DLGC_HASSETSEL style from
591 // keyboard its contents should be entirely selected: this is what
592 // ::IsDialogMessage() does and so we should do it as well to provide the
593 // same LNF as the native programs
594 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
596 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
599 // do this after (maybe) setting the selection as like this when
600 // wxEVT_SET_FOCUS handler is called, the selection would have been already
601 // set correctly -- this may be important
602 wxWindowBase::SetFocusFromKbd();
605 // Get the window with the focus
606 wxWindow
*wxWindowBase::DoFindFocus()
608 HWND hWnd
= ::GetFocus();
611 return wxGetWindowFromHWND((WXHWND
)hWnd
);
617 void wxWindowMSW::DoEnable( bool enable
)
619 MSWEnableHWND(GetHwnd(), enable
);
622 bool wxWindowMSW::MSWEnableHWND(WXHWND hWnd
, bool enable
)
627 // If disabling focused control, we move focus to the next one, as if the
628 // user pressed Tab. That's because we can't keep focus on a disabled
629 // control, Tab-navigation would stop working then.
630 if ( !enable
&& ::GetFocus() == hWnd
)
633 return ::EnableWindow(hWnd
, (BOOL
)enable
) != 0;
636 bool wxWindowMSW::Show(bool show
)
638 if ( !wxWindowBase::Show(show
) )
641 HWND hWnd
= GetHwnd();
643 // we could be called before the underlying window is created (this is
644 // actually useful to prevent it from being initially shown), e.g.
646 // wxFoo *foo = new wxFoo;
648 // foo->Create(parent, ...);
650 // should work without errors
653 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
658 // DoFreeze/DoThaw don't do anything if the window is not shown, so
659 // we have to call them from here now
670 wxWindowMSW::MSWShowWithEffect(bool show
,
674 if ( effect
== wxSHOW_EFFECT_NONE
)
677 if ( !wxWindowBase::Show(show
) )
680 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
682 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
683 static bool s_initDone
= false;
686 wxDynamicLibrary
dllUser32(wxT("user32.dll"), wxDL_VERBATIM
| wxDL_QUIET
);
687 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
691 // notice that it's ok to unload user32.dll here as it won't be really
692 // unloaded, being still in use because we link to it statically too
695 if ( !s_pfnAnimateWindow
)
698 // Show() has a side effect of sending a WM_SIZE to the window, which helps
699 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
700 // this so send the event ourselves
703 // prepare to use AnimateWindow()
706 timeout
= 200; // this is the default animation timeout, per MSDN
708 DWORD dwFlags
= show
? 0 : AW_HIDE
;
712 case wxSHOW_EFFECT_ROLL_TO_LEFT
:
713 dwFlags
|= AW_HOR_NEGATIVE
;
716 case wxSHOW_EFFECT_ROLL_TO_RIGHT
:
717 dwFlags
|= AW_HOR_POSITIVE
;
720 case wxSHOW_EFFECT_ROLL_TO_TOP
:
721 dwFlags
|= AW_VER_NEGATIVE
;
724 case wxSHOW_EFFECT_ROLL_TO_BOTTOM
:
725 dwFlags
|= AW_VER_POSITIVE
;
728 case wxSHOW_EFFECT_SLIDE_TO_LEFT
:
729 dwFlags
|= AW_SLIDE
| AW_HOR_NEGATIVE
;
732 case wxSHOW_EFFECT_SLIDE_TO_RIGHT
:
733 dwFlags
|= AW_SLIDE
| AW_HOR_POSITIVE
;
736 case wxSHOW_EFFECT_SLIDE_TO_TOP
:
737 dwFlags
|= AW_SLIDE
| AW_VER_NEGATIVE
;
740 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM
:
741 dwFlags
|= AW_SLIDE
| AW_VER_POSITIVE
;
744 case wxSHOW_EFFECT_BLEND
:
748 case wxSHOW_EFFECT_EXPAND
:
749 dwFlags
|= AW_CENTER
;
753 case wxSHOW_EFFECT_MAX
:
754 wxFAIL_MSG( wxT("invalid window show effect") );
758 wxFAIL_MSG( wxT("unknown window show effect") );
762 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
764 wxLogLastError(wxT("AnimateWindow"));
772 // Raise the window to the top of the Z order
773 void wxWindowMSW::Raise()
775 wxBringWindowToTop(GetHwnd());
778 // Lower the window to the bottom of the Z order
779 void wxWindowMSW::Lower()
781 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
782 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
785 void wxWindowMSW::DoCaptureMouse()
787 HWND hWnd
= GetHwnd();
794 void wxWindowMSW::DoReleaseMouse()
796 if ( !::ReleaseCapture() )
798 wxLogLastError(wxT("ReleaseCapture"));
802 /* static */ wxWindow
*wxWindowBase::GetCapture()
804 HWND hwnd
= ::GetCapture();
805 return hwnd
? wxFindWinFromHandle(hwnd
) : NULL
;
808 bool wxWindowMSW::SetFont(const wxFont
& font
)
810 if ( !wxWindowBase::SetFont(font
) )
816 HWND hWnd
= GetHwnd();
819 // note the use of GetFont() instead of m_font: our own font could have
820 // just been reset and in this case we need to change the font used by
821 // the native window to the default for this class, i.e. exactly what
823 WXHANDLE hFont
= GetFont().GetResourceHandle();
825 wxASSERT_MSG( hFont
, wxT("should have valid font") );
827 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
833 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
835 if ( !wxWindowBase::SetCursor(cursor
) )
841 // don't "overwrite" busy cursor
845 if ( m_cursor
.IsOk() )
847 // normally we should change the cursor only if it's over this window
848 // but we should do it always if we capture the mouse currently
849 bool set
= HasCapture();
852 HWND hWnd
= GetHwnd();
856 ::GetCursorPosWinCE(&point
);
858 ::GetCursorPos(&point
);
861 RECT rect
= wxGetWindowRect(hWnd
);
863 set
= ::PtInRect(&rect
, point
) != 0;
868 ::SetCursor(GetHcursorOf(m_cursor
));
870 //else: will be set later when the mouse enters this window
872 else // Invalid cursor: this means reset to the default one.
874 // To revert to the correct cursor we need to find the window currently
875 // under the cursor and ask it to set its cursor itself as only it
878 if ( !::GetCursorPos(&pt
) )
880 wxLogLastError(wxT("GetCursorPos"));
884 const wxWindowMSW
* win
= wxFindWindowAtPoint(wxPoint(pt
.x
, pt
.y
));
888 ::SendMessage(GetHwndOf(win
), WM_SETCURSOR
,
889 (WPARAM
)GetHwndOf(win
),
890 MAKELPARAM(HTCLIENT
, WM_MOUSEMOVE
));
896 void wxWindowMSW::WarpPointer(int x
, int y
)
898 ClientToScreen(&x
, &y
);
900 if ( !::SetCursorPos(x
, y
) )
902 wxLogLastError(wxT("SetCursorPos"));
906 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
908 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
909 // to use it on older systems -- and could possibly do some harm
910 static int s_needToUpdate
= -1;
911 if ( s_needToUpdate
== -1 )
914 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
918 if ( s_needToUpdate
)
920 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
921 // won't send WM_UPDATEUISTATE
922 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
926 // ---------------------------------------------------------------------------
928 // ---------------------------------------------------------------------------
933 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
935 #ifdef __WXMICROWIN__
936 return ::GetScrollPosWX(hWnd
, wOrient
);
938 WinStruct
<SCROLLINFO
> scrollInfo
;
939 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
940 scrollInfo
.fMask
= SIF_POS
;
941 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
943 return scrollInfo
.nPos
;
948 inline UINT
WXOrientToSB(int orient
)
950 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
953 } // anonymous namespace
955 int wxWindowMSW::GetScrollPos(int orient
) const
957 HWND hWnd
= GetHwnd();
958 wxCHECK_MSG( hWnd
, 0, wxT("no HWND in GetScrollPos") );
960 return GetScrollPosition(hWnd
, WXOrientToSB(orient
));
963 // This now returns the whole range, not just the number
964 // of positions that we can scroll.
965 int wxWindowMSW::GetScrollRange(int orient
) const
968 HWND hWnd
= GetHwnd();
971 WinStruct
<SCROLLINFO
> scrollInfo
;
972 scrollInfo
.fMask
= SIF_RANGE
;
973 if ( !::GetScrollInfo(hWnd
, WXOrientToSB(orient
), &scrollInfo
) )
975 // Most of the time this is not really an error, since the return
976 // value can also be zero when there is no scrollbar yet.
977 // wxLogLastError(wxT("GetScrollInfo"));
979 maxPos
= scrollInfo
.nMax
;
981 // undo "range - 1" done in SetScrollbar()
985 int wxWindowMSW::GetScrollThumb(int orient
) const
987 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
990 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
992 HWND hWnd
= GetHwnd();
993 wxCHECK_RET( hWnd
, wxT("SetScrollPos: no HWND") );
995 WinStruct
<SCROLLINFO
> info
;
999 info
.fMask
= SIF_POS
;
1000 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1002 // disable scrollbar instead of removing it then
1003 info
.fMask
|= SIF_DISABLENOSCROLL
;
1006 ::SetScrollInfo(hWnd
, WXOrientToSB(orient
), &info
, refresh
);
1009 // New function that will replace some of the above.
1010 void wxWindowMSW::SetScrollbar(int orient
,
1016 // We have to set the variables here to make them valid in events
1017 // triggered by ::SetScrollInfo()
1018 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1020 HWND hwnd
= GetHwnd();
1024 WinStruct
<SCROLLINFO
> info
;
1027 info
.nPage
= pageSize
;
1028 info
.nMin
= 0; // range is nMax - nMin + 1
1029 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1032 // We normally also reenable scrollbar in case it had been previously
1033 // disabled by specifying SIF_DISABLENOSCROLL below but we should only
1034 // do this if it has valid range, otherwise it would be enabled but not
1036 if ( range
>= pageSize
)
1038 ::EnableScrollBar(hwnd
, WXOrientToSB(orient
), ESB_ENABLE_BOTH
);
1041 //else: leave all the fields to be 0
1043 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1044 if ( HasFlag(wxALWAYS_SHOW_SB
) || range
== -1 )
1046 // disable scrollbar instead of removing it then
1047 info
.fMask
|= SIF_DISABLENOSCROLL
;
1050 ::SetScrollInfo(hwnd
, WXOrientToSB(orient
), &info
, refresh
);
1053 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1059 wxCopyRectToRECT(*prect
, rect
);
1069 // FIXME: is this the exact equivalent of the line below?
1070 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1072 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1076 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1078 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1081 for ( int n
= 0; n
< count
; n
++ )
1083 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1085 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1086 if ( posNew
== pos
)
1088 // don't bother to continue, we're already at top/bottom
1095 return pos
!= posStart
;
1098 bool wxWindowMSW::ScrollLines(int lines
)
1100 bool down
= lines
> 0;
1102 return ScrollVertically(GetHwnd(),
1103 down
? SB_LINEDOWN
: SB_LINEUP
,
1104 down
? lines
: -lines
);
1107 bool wxWindowMSW::ScrollPages(int pages
)
1109 bool down
= pages
> 0;
1111 return ScrollVertically(GetHwnd(),
1112 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1113 down
? pages
: -pages
);
1116 // ----------------------------------------------------------------------------
1118 // ----------------------------------------------------------------------------
1120 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1125 wxCHECK_RET( GetHwnd(),
1126 wxT("layout direction must be set after window creation") );
1128 LONG styleOld
= wxGetWindowExStyle(this);
1130 LONG styleNew
= styleOld
;
1133 case wxLayout_LeftToRight
:
1134 styleNew
&= ~WS_EX_LAYOUTRTL
;
1137 case wxLayout_RightToLeft
:
1138 styleNew
|= WS_EX_LAYOUTRTL
;
1142 wxFAIL_MSG(wxT("unsupported layout direction"));
1146 if ( styleNew
!= styleOld
)
1148 wxSetWindowExStyle(this, styleNew
);
1153 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1156 return wxLayout_Default
;
1158 wxCHECK_MSG( GetHwnd(), wxLayout_Default
, wxT("invalid window") );
1160 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL
) ? wxLayout_RightToLeft
1161 : wxLayout_LeftToRight
;
1166 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1167 wxCoord
WXUNUSED(width
),
1168 wxCoord
WXUNUSED(widthTotal
)) const
1170 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1171 // redo it ourselves
1175 // ---------------------------------------------------------------------------
1177 // ---------------------------------------------------------------------------
1179 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1181 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1183 HWND hwnd
= (HWND
)hWnd
;
1184 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1188 wxAssociateWinWithHandle(hwnd
, this);
1190 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1192 // we don't need to subclass the window of our own class (in the Windows
1193 // sense of the word)
1194 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1196 wxSetWindowProc(hwnd
, wxWndProc
);
1200 // don't bother restoring it either: this also makes it easy to
1201 // implement IsOfStandardClass() method which returns true for the
1202 // standard controls and false for the wxWidgets own windows as it can
1203 // simply check m_oldWndProc
1204 m_oldWndProc
= NULL
;
1207 // we're officially created now, send the event
1208 wxWindowCreateEvent
event((wxWindow
*)this);
1209 (void)HandleWindowEvent(event
);
1212 void wxWindowMSW::UnsubclassWin()
1214 wxRemoveHandleAssociation(this);
1216 // Restore old Window proc
1217 HWND hwnd
= GetHwnd();
1222 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1226 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1228 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1231 m_oldWndProc
= NULL
;
1236 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1240 if ( !::DestroyWindow(GetHwnd()) )
1242 wxLogLastError(wxT("DestroyWindow"));
1246 WXHWND wxhwnd
= (WXHWND
)handle
;
1248 // this also calls SetHWND(wxhwnd)
1249 SubclassWin(wxhwnd
);
1252 void wxWindowMSW::DissociateHandle()
1254 // this also calls SetHWND(0) for us
1259 bool wxCheckWindowWndProc(WXHWND hWnd
,
1260 WXFARPROC
WXUNUSED(wndProc
))
1262 const wxString
str(wxGetWindowClass(hWnd
));
1264 // TODO: get rid of wxTLWHiddenParent special case (currently it's not
1265 // registered by wxApp but using ad hoc code in msw/toplevel.cpp);
1266 // there is also a hidden window class used by sockets &c
1267 return wxApp::IsRegisteredClassName(str
) || str
== wxT("wxTLWHiddenParent");
1270 // ----------------------------------------------------------------------------
1272 // ----------------------------------------------------------------------------
1274 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1276 long flagsOld
= GetWindowStyleFlag();
1277 if ( flags
== flagsOld
)
1280 // update the internal variable
1281 wxWindowBase::SetWindowStyleFlag(flags
);
1283 // and the real window flags
1284 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1287 void wxWindowMSW::SetExtraStyle(long exflags
)
1289 long exflagsOld
= GetExtraStyle();
1290 if ( exflags
== exflagsOld
)
1293 // update the internal variable
1294 wxWindowBase::SetExtraStyle(exflags
);
1296 // and the real window flags
1297 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1300 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1302 // now update the Windows style as well if needed - and if the window had
1303 // been already created
1307 // we may need to call SetWindowPos() when we change some styles
1308 bool callSWP
= false;
1311 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1313 // this is quite a horrible hack but we need it because MSWGetStyle()
1314 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1315 // and so we have to modify the window exflags temporarily to get the
1316 // correct exstyleOld
1317 long exflagsNew
= GetExtraStyle();
1318 wxWindowBase::SetExtraStyle(exflagsOld
);
1321 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1323 wxWindowBase::SetExtraStyle(exflagsNew
);
1326 if ( style
!= styleOld
)
1328 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1329 // this function so instead of simply setting the style to the new
1330 // value we clear the bits which were set in styleOld but are set in
1331 // the new one and set the ones which were not set before
1332 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1333 styleReal
&= ~styleOld
;
1336 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1338 // we need to call SetWindowPos() if any of the styles affecting the
1339 // frame appearance have changed
1340 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1349 // and the extended style
1350 long exstyleReal
= wxGetWindowExStyle(this);
1352 if ( exstyle
!= exstyleOld
)
1354 exstyleReal
&= ~exstyleOld
;
1355 exstyleReal
|= exstyle
;
1357 wxSetWindowExStyle(this, exstyleReal
);
1359 // ex style changes don't take effect without calling SetWindowPos
1365 // we must call SetWindowPos() to flush the cached extended style and
1366 // also to make the change to wxSTAY_ON_TOP style take effect: just
1367 // setting the style simply doesn't work
1368 if ( !::SetWindowPos(GetHwnd(),
1369 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1372 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
|
1375 wxLogLastError(wxT("SetWindowPos"));
1380 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1382 return wxBORDER_THEME
;
1385 wxBorder
wxWindowMSW::GetDefaultBorder() const
1387 return wxWindowBase::GetDefaultBorder();
1390 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1391 // that makes most sense for this Windows environment
1392 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1394 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1395 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1396 return wxBORDER_SIMPLE
;
1398 return wxBORDER_NONE
;
1401 if (border
== wxBORDER_THEME
)
1403 if (CanApplyThemeBorder())
1405 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1407 return wxBORDER_THEME
;
1409 return wxBORDER_SUNKEN
;
1417 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1419 // translate common wxWidgets styles to Windows ones
1421 // most of windows are child ones, those which are not (such as
1422 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1423 WXDWORD style
= WS_CHILD
;
1425 // using this flag results in very significant reduction in flicker,
1426 // especially with controls inside the static boxes (as the interior of the
1427 // box is not redrawn twice), but sometimes results in redraw problems, so
1428 // optionally allow the old code to continue to use it provided a special
1429 // system option is turned on
1430 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1431 || (flags
& wxCLIP_CHILDREN
) )
1432 style
|= WS_CLIPCHILDREN
;
1434 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1435 // don't support overlapping windows and it only makes sense for them and,
1436 // presumably, gives the system some extra work (to manage more clipping
1437 // regions), so avoid it alltogether
1440 if ( flags
& wxVSCROLL
)
1441 style
|= WS_VSCROLL
;
1443 if ( flags
& wxHSCROLL
)
1444 style
|= WS_HSCROLL
;
1446 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1448 // After translation, border is now optimized for the specific version of Windows
1449 // and theme engine presence.
1451 // WS_BORDER is only required for wxBORDER_SIMPLE
1452 if ( border
== wxBORDER_SIMPLE
)
1455 // now deal with ext style if the caller wants it
1461 if ( flags
& wxTRANSPARENT_WINDOW
)
1462 *exstyle
|= WS_EX_TRANSPARENT
;
1468 case wxBORDER_DEFAULT
:
1469 wxFAIL_MSG( wxT("unknown border style") );
1473 case wxBORDER_SIMPLE
:
1474 case wxBORDER_THEME
:
1477 case wxBORDER_STATIC
:
1478 *exstyle
|= WS_EX_STATICEDGE
;
1481 case wxBORDER_RAISED
:
1482 *exstyle
|= WS_EX_DLGMODALFRAME
;
1485 case wxBORDER_SUNKEN
:
1486 *exstyle
|= WS_EX_CLIENTEDGE
;
1487 style
&= ~WS_BORDER
;
1490 // case wxBORDER_DOUBLE:
1491 // *exstyle |= WS_EX_DLGMODALFRAME;
1495 // wxUniv doesn't use Windows dialog navigation functions at all
1496 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1497 // to make the dialog navigation work with the nested panels we must
1498 // use this style (top level windows such as dialogs don't need it)
1499 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1501 *exstyle
|= WS_EX_CONTROLPARENT
;
1503 #endif // __WXUNIVERSAL__
1509 // Setup background and foreground colours correctly
1510 void wxWindowMSW::SetupColours()
1513 SetBackgroundColour(GetParent()->GetBackgroundColour());
1516 bool wxWindowMSW::IsMouseInWindow() const
1518 // get the mouse position
1521 ::GetCursorPosWinCE(&pt
);
1523 ::GetCursorPos(&pt
);
1526 // find the window which currently has the cursor and go up the window
1527 // chain until we find this window - or exhaust it
1528 HWND hwnd
= ::WindowFromPoint(pt
);
1529 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1530 hwnd
= ::GetParent(hwnd
);
1532 return hwnd
!= NULL
;
1535 void wxWindowMSW::OnInternalIdle()
1537 #ifndef HAVE_TRACKMOUSEEVENT
1538 // Check if we need to send a LEAVE event
1539 if ( m_mouseInWindow
)
1541 // note that we should generate the leave event whether the window has
1542 // or doesn't have mouse capture
1543 if ( !IsMouseInWindow() )
1545 GenerateMouseLeave();
1548 #endif // !HAVE_TRACKMOUSEEVENT
1550 wxWindowBase::OnInternalIdle();
1553 // Set this window to be the child of 'parent'.
1554 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1556 if ( !wxWindowBase::Reparent(parent
) )
1559 HWND hWndChild
= GetHwnd();
1560 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1562 ::SetParent(hWndChild
, hWndParent
);
1565 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT
) )
1567 EnsureParentHasControlParentStyle(GetParent());
1569 #endif // !__WXWINCE__
1574 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1576 #ifndef __WXMICROWIN__
1577 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1581 void wxWindowMSW::DoFreeze()
1584 return; // no point in freezing hidden window
1586 SendSetRedraw(GetHwnd(), false);
1589 void wxWindowMSW::DoThaw()
1592 return; // hidden windows aren't frozen by DoFreeze
1594 SendSetRedraw(GetHwnd(), true);
1596 // we need to refresh everything or otherwise the invalidated area
1597 // is not going to be repainted
1601 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1603 HWND hWnd
= GetHwnd();
1610 wxCopyRectToRECT(*rect
, mswRect
);
1618 // RedrawWindow not available on SmartPhone or eVC++ 3
1619 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1620 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1624 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1626 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1631 void wxWindowMSW::Update()
1633 if ( !::UpdateWindow(GetHwnd()) )
1635 wxLogLastError(wxT("UpdateWindow"));
1638 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1639 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1640 // handler needs to be really drawn right now
1645 // ---------------------------------------------------------------------------
1647 // ---------------------------------------------------------------------------
1649 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1653 // we need to lower the sibling static boxes so controls contained within can be
1655 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1657 // no sibling static boxes if we have no parent (ie TLW)
1661 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1663 node
= node
->GetNext() )
1665 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1668 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1669 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1674 #else // !wxUSE_STATBOX
1676 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1680 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1682 #endif // drag and drop is used
1684 #if wxUSE_DRAG_AND_DROP
1685 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1687 if ( m_dropTarget
!= 0 ) {
1688 m_dropTarget
->Revoke(m_hWnd
);
1689 delete m_dropTarget
;
1692 m_dropTarget
= pDropTarget
;
1693 if ( m_dropTarget
!= 0 )
1695 AdjustStaticBoxZOrder(GetParent());
1696 m_dropTarget
->Register(m_hWnd
);
1699 #endif // wxUSE_DRAG_AND_DROP
1701 // old-style file manager drag&drop support: we retain the old-style
1702 // DragAcceptFiles in parallel with SetDropTarget.
1703 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1706 HWND hWnd
= GetHwnd();
1709 AdjustStaticBoxZOrder(GetParent());
1710 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1715 // ----------------------------------------------------------------------------
1717 // ----------------------------------------------------------------------------
1721 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1723 wxWindowBase::DoSetToolTip(tooltip
);
1726 m_tooltip
->SetWindow((wxWindow
*)this);
1729 #endif // wxUSE_TOOLTIPS
1731 // ---------------------------------------------------------------------------
1732 // moving and resizing
1733 // ---------------------------------------------------------------------------
1735 bool wxWindowMSW::IsSizeDeferred() const
1737 #if wxUSE_DEFERRED_SIZING
1738 if ( m_pendingPosition
!= wxDefaultPosition
||
1739 m_pendingSize
!= wxDefaultSize
)
1741 #endif // wxUSE_DEFERRED_SIZING
1747 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1749 #if wxUSE_DEFERRED_SIZING
1750 // if SetSize() had been called at wx level but not realized at Windows
1751 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1752 // the new and not the old position to the other wx code
1753 if ( m_pendingSize
!= wxDefaultSize
)
1756 *x
= m_pendingSize
.x
;
1758 *y
= m_pendingSize
.y
;
1760 else // use current size
1761 #endif // wxUSE_DEFERRED_SIZING
1763 RECT rect
= wxGetWindowRect(GetHwnd());
1766 *x
= rect
.right
- rect
.left
;
1768 *y
= rect
.bottom
- rect
.top
;
1772 // Get size *available for subwindows* i.e. excluding menu bar etc.
1773 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1775 #if wxUSE_DEFERRED_SIZING
1776 if ( m_pendingSize
!= wxDefaultSize
)
1778 // we need to calculate the client size corresponding to pending size
1780 // FIXME: Unfortunately this doesn't work correctly for the maximized
1781 // top level windows, the returned values are too small (e.g.
1782 // under Windows 7 on a 1600*1200 screen with task bar on the
1783 // right the pending size for a maximized window is 1538*1200
1784 // and WM_NCCALCSIZE returns 1528*1172 even though the correct
1785 // client size of such window is 1538*1182). No idea how to fix
1786 // it though, setting WS_MAXIMIZE in GWL_STYLE before calling
1787 // WM_NCCALCSIZE doesn't help and AdjustWindowRectEx() doesn't
1788 // work in this direction neither. So we just have to live with
1789 // the slightly wrong results and relayout the window when it
1790 // gets finally shown in its maximized state (see #11762).
1792 rect
.left
= m_pendingPosition
.x
;
1793 rect
.top
= m_pendingPosition
.y
;
1794 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1795 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1797 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1800 *x
= rect
.right
- rect
.left
;
1802 *y
= rect
.bottom
- rect
.top
;
1805 #endif // wxUSE_DEFERRED_SIZING
1807 RECT rect
= wxGetClientRect(GetHwnd());
1815 // The size of the client window can't be negative but ::GetClientRect()
1816 // can return negative size for an extremely small (1x1) window with
1817 // borders so ensure that we correct it here as having negative sizes is
1818 // completely unexpected.
1825 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1827 wxWindow
* const parent
= GetParent();
1830 #if wxUSE_DEFERRED_SIZING
1831 if ( m_pendingPosition
!= wxDefaultPosition
)
1833 pos
= m_pendingPosition
;
1835 else // use current position
1836 #endif // wxUSE_DEFERRED_SIZING
1838 RECT rect
= wxGetWindowRect(GetHwnd());
1841 point
.x
= rect
.left
;
1844 // we do the adjustments with respect to the parent only for the "real"
1845 // children, not for the dialogs/frames
1846 if ( !IsTopLevel() )
1848 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1850 // In RTL mode, we want the logical left x-coordinate,
1851 // which would be the physical right x-coordinate.
1852 point
.x
= rect
.right
;
1855 // Since we now have the absolute screen coords, if there's a
1856 // parent we must subtract its top left corner
1859 ::ScreenToClient(GetHwndOf(parent
), &point
);
1867 // we also must adjust by the client area offset: a control which is just
1868 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1869 if ( parent
&& !IsTopLevel() )
1871 const wxPoint
pt(parent
->GetClientAreaOrigin());
1882 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1890 ::ScreenToClient(GetHwnd(), &pt
);
1898 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1906 ::ClientToScreen(GetHwnd(), &pt
);
1915 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1917 #if wxUSE_DEFERRED_SIZING
1918 // if our parent had prepared a defer window handle for us, use it (unless
1919 // we are a top level window)
1920 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1922 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1925 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1926 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1929 wxLogLastError(wxT("DeferWindowPos"));
1935 // hdwp must be updated as it may have been changed
1936 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1941 // did deferred move, remember new coordinates of the window as they're
1942 // different from what Windows would return for it
1946 // otherwise (or if deferring failed) move the window in place immediately
1947 #endif // wxUSE_DEFERRED_SIZING
1948 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1950 wxLogLastError(wxT("MoveWindow"));
1953 // if wxUSE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1954 // ignored otherwise
1958 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1960 // TODO: is this consistent with other platforms?
1961 // Still, negative width or height shouldn't be allowed
1967 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1969 #if wxUSE_DEFERRED_SIZING
1970 m_pendingPosition
= wxPoint(x
, y
);
1971 m_pendingSize
= wxSize(width
, height
);
1973 else // window was moved immediately, without deferring it
1975 m_pendingPosition
= wxDefaultPosition
;
1976 m_pendingSize
= wxDefaultSize
;
1977 #endif // wxUSE_DEFERRED_SIZING
1981 // set the size of the window: if the dimensions are positive, just use them,
1982 // but if any of them is equal to -1, it means that we must find the value for
1983 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1984 // which case -1 is a valid value for x and y)
1986 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1987 // the width/height to best suit our contents, otherwise we reuse the current
1989 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1991 // get the current size and position...
1992 int currentX
, currentY
;
1993 int currentW
, currentH
;
1995 GetPosition(¤tX
, ¤tY
);
1996 GetSize(¤tW
, ¤tH
);
1998 // ... and don't do anything (avoiding flicker) if it's already ok unless
1999 // we're forced to resize the window
2000 if ( x
== currentX
&& y
== currentY
&&
2001 width
== currentW
&& height
== currentH
&&
2002 !(sizeFlags
& wxSIZE_FORCE
) )
2004 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2006 wxSizeEvent
event( wxSize(width
,height
), GetId() );
2007 event
.SetEventObject( this );
2008 HandleWindowEvent( event
);
2013 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2015 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2018 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2020 wxSize size
= wxDefaultSize
;
2021 if ( width
== wxDefaultCoord
)
2023 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2025 size
= GetBestSize();
2030 // just take the current one
2035 if ( height
== wxDefaultCoord
)
2037 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2039 if ( size
.x
== wxDefaultCoord
)
2041 size
= GetBestSize();
2043 //else: already called GetBestSize() above
2049 // just take the current one
2054 DoMoveWindow(x
, y
, width
, height
);
2057 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2059 // setting the client size is less obvious than it could have been
2060 // because in the result of changing the total size the window scrollbar
2061 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2062 // doesn't take neither into account) and so the client size will not be
2063 // correct as the difference between the total and client size changes --
2064 // so we keep changing it until we get it right
2066 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2067 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2068 // may become 3 if the window had 0 size originally and so we didn't
2069 // calculate the scrollbar correction correctly during the first iteration)
2070 // but just to be on the safe side we check for it instead of making it an
2071 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2072 for ( int i
= 0; i
< 4; i
++ )
2075 ::GetClientRect(GetHwnd(), &rectClient
);
2077 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2078 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2079 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2084 // Find the difference between the entire window (title bar and all)
2085 // and the client area; add this to the new client size to move the
2088 ::GetWindowRect(GetHwnd(), &rectWin
);
2090 const int widthWin
= rectWin
.right
- rectWin
.left
,
2091 heightWin
= rectWin
.bottom
- rectWin
.top
;
2093 // MoveWindow positions the child windows relative to the parent, so
2094 // adjust if necessary
2095 if ( !IsTopLevel() )
2097 wxWindow
*parent
= GetParent();
2100 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2104 // don't call DoMoveWindow() because we want to move window immediately
2105 // and not defer it here as otherwise the value returned by
2106 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2108 if ( !::MoveWindow(GetHwnd(),
2111 width
+ widthWin
- rectClient
.right
,
2112 height
+ heightWin
- rectClient
.bottom
,
2115 wxLogLastError(wxT("MoveWindow"));
2120 wxSize
wxWindowMSW::DoGetBorderSize() const
2123 switch ( GetBorder() )
2125 case wxBORDER_STATIC
:
2126 case wxBORDER_SIMPLE
:
2130 case wxBORDER_SUNKEN
:
2134 case wxBORDER_RAISED
:
2135 case wxBORDER_DOUBLE
:
2140 wxFAIL_MSG( wxT("unknown border style") );
2147 return 2*wxSize(border
, border
);
2150 // ---------------------------------------------------------------------------
2152 // ---------------------------------------------------------------------------
2154 int wxWindowMSW::GetCharHeight() const
2156 return wxGetTextMetrics(this).tmHeight
;
2159 int wxWindowMSW::GetCharWidth() const
2161 // +1 is needed because Windows apparently adds it when calculating the
2162 // dialog units size in pixels
2163 #if wxDIALOG_UNIT_COMPATIBILITY
2164 return wxGetTextMetrics(this).tmAveCharWidth
;
2166 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2170 void wxWindowMSW::DoGetTextExtent(const wxString
& string
,
2173 int *externalLeading
,
2174 const wxFont
*fontToUse
) const
2176 wxASSERT_MSG( !fontToUse
|| fontToUse
->IsOk(),
2177 wxT("invalid font in GetTextExtent()") );
2181 hfontToUse
= GetHfontOf(*fontToUse
);
2183 hfontToUse
= GetHfontOf(GetFont());
2185 WindowHDC
hdc(GetHwnd());
2186 SelectInHDC
selectFont(hdc
, hfontToUse
);
2190 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2191 GetTextMetrics(hdc
, &tm
);
2198 *descent
= tm
.tmDescent
;
2199 if ( externalLeading
)
2200 *externalLeading
= tm
.tmExternalLeading
;
2203 // ---------------------------------------------------------------------------
2205 // ---------------------------------------------------------------------------
2207 #if wxUSE_MENUS_NATIVE
2209 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2210 // immediately, without waiting for the next event loop iteration
2212 // NB: this function should probably be made public later as it can almost
2213 // surely replace wxYield() elsewhere as well
2214 static void wxYieldForCommandsOnly()
2216 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2217 // want to process it here)
2219 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2221 if ( msg
.message
== WM_QUIT
)
2223 // if we retrieved a WM_QUIT, insert back into the message queue.
2224 ::PostQuitMessage(0);
2228 // luckily (as we don't have access to wxEventLoopImpl method from here
2229 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2231 ::TranslateMessage(&msg
);
2232 ::DispatchMessage(&msg
);
2236 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2241 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2243 pt
= wxGetMousePosition();
2247 pt
= ClientToScreen(wxPoint(x
, y
));
2250 #if defined(__WXWINCE__)
2251 static const UINT flags
= 0;
2252 #else // !__WXWINCE__
2253 UINT flags
= TPM_RIGHTBUTTON
;
2254 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2255 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2256 // side and not to use it there neither -- modify the test if it does work
2258 if ( wxGetWinVersion() >= wxWinVersion_5
)
2260 // using TPM_RECURSE allows us to show a popup menu while another menu
2261 // is opened which can be useful and is supported by the other
2262 // platforms, so allow it under Windows too
2263 flags
|= TPM_RECURSE
;
2265 #endif // __WXWINCE__/!__WXWINCE__
2267 ::TrackPopupMenu(GetHmenuOf(menu
), flags
, pt
.x
, pt
.y
, 0, GetHwnd(), NULL
);
2269 // we need to do it right now as otherwise the events are never going to be
2270 // sent to wxCurrentPopupMenu from HandleCommand()
2272 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2273 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2274 // destroyed as soon as we return (it can be a local variable in the caller
2275 // for example) and so we do need to process the event immediately
2276 wxYieldForCommandsOnly();
2281 #endif // wxUSE_MENUS_NATIVE
2283 // ===========================================================================
2284 // pre/post message processing
2285 // ===========================================================================
2287 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2291 rc
= ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2293 rc
= ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2295 // Special hack used by wxTextEntry auto-completion only: this event is
2296 // sent after the normal keyboard processing so that its handler could use
2297 // the updated contents of the text control, after taking the key that was
2298 // pressed into account.
2299 if ( nMsg
== WM_CHAR
)
2301 wxKeyEvent
event(CreateCharEvent(wxEVT_AFTER_CHAR
, wParam
, lParam
));
2302 HandleWindowEvent(event
);
2308 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2310 // wxUniversal implements tab traversal itself
2311 #ifndef __WXUNIVERSAL__
2312 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2314 // intercept dialog navigation keys
2315 MSG
*msg
= (MSG
*)pMsg
;
2317 // here we try to do all the job which ::IsDialogMessage() usually does
2319 if ( msg
->message
== WM_KEYDOWN
)
2321 bool bCtrlDown
= wxIsCtrlDown();
2322 bool bShiftDown
= wxIsShiftDown();
2324 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2325 // don't process it if it's the case (except for Ctrl-Tab/Enter
2326 // combinations which are always processed)
2327 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2329 // surprisingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2330 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2331 // it, of course, implies them
2332 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2334 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2337 bool bForward
= true,
2338 bWindowChange
= false,
2341 // should we process this message specially?
2342 bool bProcess
= true;
2343 switch ( msg
->wParam
)
2346 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2348 // let the control have the TAB
2351 else // use it for navigation
2353 // Ctrl-Tab cycles thru notebook pages
2354 bWindowChange
= bCtrlDown
;
2355 bForward
= !bShiftDown
;
2362 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2370 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2379 // we treat PageUp/Dn as arrows because chances are that
2380 // a control which needs arrows also needs them for
2381 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2382 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2384 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2385 bWindowChange
= true;
2391 // currently active button should get enter press even
2392 // if there is a default button elsewhere so check if
2393 // this window is a button first
2394 wxWindow
*btn
= NULL
;
2395 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2397 // let IsDialogMessage() handle this for all
2398 // buttons except the owner-drawn ones which it
2399 // just seems to ignore
2400 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2401 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2403 // emulate the button click
2404 btn
= wxFindWinFromHandle(msg
->hwnd
);
2407 else // not a button itself, do we have default button?
2409 // check if this window or any of its ancestors
2410 // wants the message for itself (we always reserve
2411 // Ctrl-Enter for dialog navigation though)
2412 wxWindow
*win
= this;
2415 // this will contain the dialog code of this
2416 // window and all of its parent windows in turn
2417 LONG lDlgCode2
= lDlgCode
;
2421 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2423 // as it wants to process Enter itself,
2424 // don't call IsDialogMessage() which
2429 // don't propagate keyboard messages beyond
2430 // the first top level window parent
2431 if ( win
->IsTopLevel() )
2434 win
= win
->GetParent();
2436 lDlgCode2
= ::SendMessage
2447 win
= wxGetTopLevelParent(win
);
2450 wxTopLevelWindow
* const
2451 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2454 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2459 if ( btn
&& btn
->IsEnabled() )
2461 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2465 // This "Return" key press won't be actually used for
2466 // navigation so don't generate wxNavigationKeyEvent
2467 // for it but still pass it to IsDialogMessage() as it
2468 // may handle it in some other way (e.g. by playing the
2469 // default error sound).
2472 #endif // wxUSE_BUTTON
2475 // map Enter presses into button presses on PDAs
2476 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2477 event
.SetEventObject(this);
2478 if ( HandleWindowEvent(event
) )
2480 #endif // __WXWINCE__
2490 wxNavigationKeyEvent event
;
2491 event
.SetDirection(bForward
);
2492 event
.SetWindowChange(bWindowChange
);
2493 event
.SetFromTab(bFromTab
);
2494 event
.SetEventObject(this);
2496 if ( HandleWindowEvent(event
) )
2498 // as we don't call IsDialogMessage(), which would take of
2499 // this by default, we need to manually send this message
2500 // so that controls can change their UI state if needed
2501 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2508 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2510 // IsDialogMessage() did something...
2514 #endif // __WXUNIVERSAL__
2519 // relay mouse move events to the tooltip control
2520 MSG
*msg
= (MSG
*)pMsg
;
2521 if ( msg
->message
== WM_MOUSEMOVE
)
2522 wxToolTip::RelayEvent(pMsg
);
2524 #endif // wxUSE_TOOLTIPS
2529 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2531 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2532 return m_acceleratorTable
.Translate(this, pMsg
);
2536 #endif // wxUSE_ACCEL
2539 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2541 // all tests below have to deal with various bugs/misfeatures of
2542 // IsDialogMessage(): we have to prevent it from being called from our
2543 // MSWProcessMessage() in some situations
2545 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2546 // message even when there is no cancel button and when the message is
2547 // needed by the control itself: in particular, it prevents the tree in
2548 // place edit control from being closed with Escape in a dialog
2549 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2554 // ::IsDialogMessage() is broken and may sometimes hang the application by
2555 // going into an infinite loop when it tries to find the control to give
2556 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2557 // situations when this may happen and not call it then
2558 if ( msg
->message
!= WM_SYSCHAR
)
2561 // assume we can call it by default
2562 bool canSafelyCallIsDlgMsg
= true;
2564 HWND hwndFocus
= ::GetFocus();
2566 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2567 // ::IsDialogMessage() will also enter an infinite loop, because it will
2568 // recursively check the child windows but not the window itself and so if
2569 // none of the children accepts focus it loops forever (as it only stops
2570 // when it gets back to the window it started from)
2572 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2573 // style has the focus, it can happen. One such possibility is if
2574 // all windows are either toplevel, wxDialog, wxPanel or static
2575 // controls and no window can actually accept keyboard input.
2576 #if !defined(__WXWINCE__)
2577 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2579 // pessimistic by default
2580 canSafelyCallIsDlgMsg
= false;
2581 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2583 node
= node
->GetNext() )
2585 wxWindow
* const win
= node
->GetData();
2586 if ( win
->CanAcceptFocus() &&
2587 !wxHasWindowExStyle(win
, WS_EX_CONTROLPARENT
) )
2589 // it shouldn't hang...
2590 canSafelyCallIsDlgMsg
= true;
2596 #endif // !__WXWINCE__
2598 if ( canSafelyCallIsDlgMsg
)
2600 // ::IsDialogMessage() can enter in an infinite loop when the
2601 // currently focused window is disabled or hidden and its
2602 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2606 if ( !::IsWindowEnabled(hwndFocus
) ||
2607 !::IsWindowVisible(hwndFocus
) )
2609 // it would enter an infinite loop if we do this!
2610 canSafelyCallIsDlgMsg
= false;
2615 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2617 // it's a top level window, don't go further -- e.g. even
2618 // if the parent of a dialog is disabled, this doesn't
2619 // break navigation inside the dialog
2623 hwndFocus
= ::GetParent(hwndFocus
);
2627 return canSafelyCallIsDlgMsg
;
2630 // ---------------------------------------------------------------------------
2631 // message params unpackers
2632 // ---------------------------------------------------------------------------
2634 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2635 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2637 *id
= LOWORD(wParam
);
2638 *hwnd
= (WXHWND
)lParam
;
2639 *cmd
= HIWORD(wParam
);
2642 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2643 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2645 *state
= LOWORD(wParam
);
2646 *minimized
= HIWORD(wParam
);
2647 *hwnd
= (WXHWND
)lParam
;
2650 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2651 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2653 *code
= LOWORD(wParam
);
2654 *pos
= HIWORD(wParam
);
2655 *hwnd
= (WXHWND
)lParam
;
2658 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2659 WXHDC
*hdc
, WXHWND
*hwnd
)
2661 *hwnd
= (WXHWND
)lParam
;
2662 *hdc
= (WXHDC
)wParam
;
2665 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2666 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2668 *item
= (WXWORD
)wParam
;
2669 *flags
= HIWORD(wParam
);
2670 *hmenu
= (WXHMENU
)lParam
;
2673 // ---------------------------------------------------------------------------
2674 // Main wxWidgets window proc and the window proc for wxWindow
2675 // ---------------------------------------------------------------------------
2677 // Hook for new window just as it's being created, when the window isn't yet
2678 // associated with the handle
2679 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2681 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2682 // window being created and insures that it's always unset back later
2683 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2685 gs_winBeingCreated
= winBeingCreated
;
2688 wxWindowCreationHook::~wxWindowCreationHook()
2690 gs_winBeingCreated
= NULL
;
2694 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2696 // trace all messages: useful for the debugging but noticeably slows down
2697 // the code so don't do it by default
2698 #if wxDEBUG_LEVEL >= 2
2699 // notice that we cast wParam and lParam to long to avoid mismatch with
2700 // format specifiers in 64 bit builds where they are both int64 quantities
2702 // casting like this loses information, of course, but it shouldn't matter
2703 // much for this diagnostic code and it keeps the code simple
2704 wxLogTrace("winmsg",
2705 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2706 wxGetMessageName(message
), hWnd
, (long)wParam
, (long)lParam
);
2707 #endif // wxDEBUG_LEVEL >= 2
2709 wxWindowMSW
*wnd
= wxFindWinFromHandle(hWnd
);
2711 // when we get the first message for the HWND we just created, we associate
2712 // it with wxWindow stored in gs_winBeingCreated
2713 if ( !wnd
&& gs_winBeingCreated
)
2715 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2716 wnd
= gs_winBeingCreated
;
2717 gs_winBeingCreated
= NULL
;
2718 wnd
->SetHWND((WXHWND
)hWnd
);
2723 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2724 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2726 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2732 wxWindowMSW::MSWHandleMessage(WXLRESULT
*result
,
2737 // did we process the message?
2738 bool processed
= false;
2748 // for most messages we should return 0 when we do process the message
2756 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2759 // return 0 to allow window creation
2760 rc
.result
= mayCreate
? 0 : -1;
2766 // never set processed to true and *always* pass WM_DESTROY to
2767 // DefWindowProc() as Windows may do some internal cleanup when
2768 // processing it and failing to pass the message along may cause
2769 // memory and resource leaks!
2770 (void)HandleDestroy();
2774 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2778 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2781 #if !defined(__WXWINCE__)
2784 LPRECT pRect
= (LPRECT
)lParam
;
2786 rc
.SetLeft(pRect
->left
);
2787 rc
.SetTop(pRect
->top
);
2788 rc
.SetRight(pRect
->right
);
2789 rc
.SetBottom(pRect
->bottom
);
2790 processed
= HandleMoving(rc
);
2792 pRect
->left
= rc
.GetLeft();
2793 pRect
->top
= rc
.GetTop();
2794 pRect
->right
= rc
.GetRight();
2795 pRect
->bottom
= rc
.GetBottom();
2800 case WM_ENTERSIZEMOVE
:
2802 processed
= HandleEnterSizeMove();
2806 case WM_EXITSIZEMOVE
:
2808 processed
= HandleExitSizeMove();
2814 LPRECT pRect
= (LPRECT
)lParam
;
2816 rc
.SetLeft(pRect
->left
);
2817 rc
.SetTop(pRect
->top
);
2818 rc
.SetRight(pRect
->right
);
2819 rc
.SetBottom(pRect
->bottom
);
2820 processed
= HandleSizing(rc
);
2822 pRect
->left
= rc
.GetLeft();
2823 pRect
->top
= rc
.GetTop();
2824 pRect
->right
= rc
.GetRight();
2825 pRect
->bottom
= rc
.GetBottom();
2829 #endif // !__WXWINCE__
2831 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2832 case WM_ACTIVATEAPP
:
2833 // This implicitly sends a wxEVT_ACTIVATE_APP event
2834 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2840 WXWORD state
, minimized
;
2842 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2844 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2849 processed
= HandleSetFocus((WXHWND
)wParam
);
2853 processed
= HandleKillFocus((WXHWND
)wParam
);
2856 case WM_PRINTCLIENT
:
2857 processed
= HandlePrintClient((WXHDC
)wParam
);
2863 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2865 processed
= HandlePaint();
2869 processed
= HandlePaint();
2874 #ifdef __WXUNIVERSAL__
2875 // Universal uses its own wxFrame/wxDialog, so we don't receive
2876 // close events unless we have this.
2878 #endif // __WXUNIVERSAL__
2880 // don't let the DefWindowProc() destroy our window - we'll do it
2881 // ourselves in ~wxWindow
2887 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2891 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2892 GET_Y_LPARAM(lParam
),
2896 #ifdef HAVE_TRACKMOUSEEVENT
2898 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2900 if ( m_mouseInWindow
)
2902 GenerateMouseLeave();
2905 // always pass processed back as false, this allows the window
2906 // manager to process the message too. This is needed to
2907 // ensure windows XP themes work properly as the mouse moves
2908 // over widgets like buttons. So don't set processed to true here.
2910 #endif // HAVE_TRACKMOUSEEVENT
2912 #if wxUSE_MOUSEWHEEL
2914 processed
= HandleMouseWheel(wParam
, lParam
);
2918 case WM_LBUTTONDOWN
:
2920 case WM_LBUTTONDBLCLK
:
2921 case WM_RBUTTONDOWN
:
2923 case WM_RBUTTONDBLCLK
:
2924 case WM_MBUTTONDOWN
:
2926 case WM_MBUTTONDBLCLK
:
2927 #ifdef wxHAS_XBUTTON
2928 case WM_XBUTTONDOWN
:
2930 case WM_XBUTTONDBLCLK
:
2931 #endif // wxHAS_XBUTTON
2933 #ifdef __WXMICROWIN__
2934 // MicroWindows seems to ignore the fact that a window is
2935 // disabled. So catch mouse events and throw them away if
2937 wxWindowMSW
* win
= this;
2940 if (!win
->IsEnabled())
2946 win
= win
->GetParent();
2947 if ( !win
|| win
->IsTopLevel() )
2954 #endif // __WXMICROWIN__
2955 int x
= GET_X_LPARAM(lParam
),
2956 y
= GET_Y_LPARAM(lParam
);
2959 // redirect the event to a static control if necessary by
2960 // finding one under mouse because under CE the static controls
2961 // don't generate mouse events (even with SS_NOTIFY)
2963 if ( GetCapture() == this )
2965 // but don't do it if the mouse is captured by this window
2966 // because then it should really get this event itself
2971 win
= FindWindowForMouseEvent(this, &x
, &y
);
2973 // this should never happen
2974 wxCHECK_MSG( win
, 0,
2975 wxT("FindWindowForMouseEvent() returned NULL") );
2978 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2980 SHRGINFO shrgi
= {0};
2982 shrgi
.cbSize
= sizeof(SHRGINFO
);
2983 shrgi
.hwndClient
= (HWND
) GetHWND();
2987 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2988 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2990 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2993 pt
= ClientToScreen(pt
);
2995 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2997 evtCtx
.SetEventObject(this);
2998 if (HandleWindowEvent(evtCtx
))
3007 #else // !__WXWINCE__
3008 wxWindowMSW
*win
= this;
3009 #endif // __WXWINCE__/!__WXWINCE__
3011 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
3013 // if the app didn't eat the event, handle it in the default
3014 // way, that is by giving this window the focus
3017 // for the standard classes their WndProc sets the focus to
3018 // them anyhow and doing it from here results in some weird
3019 // problems, so don't do it for them (unnecessary anyhow)
3020 if ( !win
->IsOfStandardClass() )
3022 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
3034 case MM_JOY1BUTTONDOWN
:
3035 case MM_JOY2BUTTONDOWN
:
3036 case MM_JOY1BUTTONUP
:
3037 case MM_JOY2BUTTONUP
:
3038 processed
= HandleJoystickEvent(message
,
3039 GET_X_LPARAM(lParam
),
3040 GET_Y_LPARAM(lParam
),
3043 #endif // __WXMICROWIN__
3049 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
3051 processed
= HandleCommand(id
, cmd
, hwnd
);
3056 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
3059 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3060 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3061 // apparently doesn't always behave properly and needs some help
3062 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3063 case WM_NOTIFYFORMAT
:
3064 if ( lParam
== NF_QUERY
)
3067 rc
.result
= NFR_UNICODE
;
3070 #endif // wxUSE_UNICODE_MSLU
3072 // for these messages we must return true if process the message
3075 processed
= MSWOnDrawItem(wParam
, (WXDRAWITEMSTRUCT
*)lParam
);
3080 case WM_MEASUREITEM
:
3081 processed
= MSWOnMeasureItem(wParam
, (WXMEASUREITEMSTRUCT
*)lParam
);
3085 #endif // defined(WM_DRAWITEM)
3088 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3090 // we always want to get the char events
3091 rc
.result
= DLGC_WANTCHARS
;
3093 if ( HasFlag(wxWANTS_CHARS
) )
3095 // in fact, we want everything
3096 rc
.result
|= DLGC_WANTARROWS
|
3103 else if (IsOfStandardClass() && IsKindOf(CLASSINFO(wxTextCtrl
)) && ((wxTextCtrl
*)this)->IsMultiLine())
3105 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3106 // Clear the DLGC_HASSETSEL bit from the return value
3107 rc
.result
&= ~DLGC_HASSETSEL
;
3110 //else: get the dlg code from the DefWindowProc()
3115 // Generate the key down event in any case.
3116 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3117 if ( m_lastKeydownProcessed
)
3119 // If it was processed by an event handler, we stop here,
3120 // notably we intentionally don't generate char event then.
3123 else // key down event not handled
3125 // Examine the event to decide whether we need to generate a
3126 // char event for it ourselves or let Windows do it. Window
3127 // mostly only does it for the keys which produce printable
3128 // characters (although there are exceptions, e.g. VK_ESCAPE or
3129 // VK_BACK (but not VK_DELETE)) while we do it for all keys
3130 // except the modifier ones (the wisdom of this is debatable
3131 // but by now this decision is enshrined forever due to
3132 // backwards compatibility).
3135 // No wxEVT_CHAR events are generated for these keys at all.
3143 // Windows will send us WM_CHAR for these ones so we'll
3144 // generate wxEVT_CHAR for them later when we get it.
3179 // special case of VK_APPS: treat it the same as right mouse
3180 // click because both usually pop up a context menu
3182 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3187 if ( (wParam
>= '0' && wParam
<= '9') ||
3188 (wParam
>= 'A' && wParam
<= 'Z') )
3190 // We'll get WM_CHAR for those later too.
3194 // But for the rest we won't get WM_CHAR later so we do
3195 // need to generate the event right now.
3196 wxKeyEvent
event(wxEVT_CHAR
);
3197 InitAnyKeyEvent(event
, wParam
, lParam
);
3199 // Set the "extended" bit in lParam because we want to
3200 // generate CHAR events with WXK_HOME and not
3201 // WXK_NUMPAD_HOME even if the "Home" key on numpad was
3203 event
.m_keyCode
= wxMSWKeyboard::VKToWX
3206 lParam
| (KF_EXTENDED
<< 16)
3209 // Don't produce events without any valid character
3210 // code (even if this shouldn't normally happen...).
3211 if ( event
.m_keyCode
!= WXK_NONE
)
3212 processed
= HandleWindowEvent(event
);
3215 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3222 // special case of VK_APPS: treat it the same as right mouse button
3223 if ( wParam
== VK_APPS
)
3225 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3230 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3235 case WM_CHAR
: // Always an ASCII character
3236 if ( m_lastKeydownProcessed
)
3238 // The key was handled in the EVT_KEY_DOWN and handling
3239 // a key in an EVT_KEY_DOWN handler is meant, by
3240 // design, to prevent EVT_CHARs from happening
3241 m_lastKeydownProcessed
= false;
3246 processed
= HandleChar((WORD
)wParam
, lParam
);
3250 case WM_IME_STARTCOMPOSITION
:
3251 // IME popup needs Escape as it should undo the changes in its
3252 // entry window instead of e.g. closing the dialog for which the
3253 // IME is used (and losing all the changes in the IME window).
3254 gs_modalEntryWindowCount
++;
3257 case WM_IME_ENDCOMPOSITION
:
3258 gs_modalEntryWindowCount
--;
3263 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3265 #endif // wxUSE_HOTKEY
3270 processed
= HandleClipboardEvent(message
);
3278 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3280 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3286 // CTLCOLOR messages are sent by children to query the parent for their
3288 #ifndef __WXMICROWIN__
3289 case WM_CTLCOLORMSGBOX
:
3290 case WM_CTLCOLOREDIT
:
3291 case WM_CTLCOLORLISTBOX
:
3292 case WM_CTLCOLORBTN
:
3293 case WM_CTLCOLORDLG
:
3294 case WM_CTLCOLORSCROLLBAR
:
3295 case WM_CTLCOLORSTATIC
:
3299 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3301 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3304 #endif // !__WXMICROWIN__
3306 case WM_SYSCOLORCHANGE
:
3307 // the return value for this message is ignored
3308 processed
= HandleSysColorChange();
3311 #if !defined(__WXWINCE__)
3312 case WM_DISPLAYCHANGE
:
3313 processed
= HandleDisplayChange();
3317 case WM_PALETTECHANGED
:
3318 processed
= HandlePaletteChanged((WXHWND
)wParam
);
3321 case WM_CAPTURECHANGED
:
3322 processed
= HandleCaptureChanged((WXHWND
)lParam
);
3325 case WM_SETTINGCHANGE
:
3326 processed
= HandleSettingChange(wParam
, lParam
);
3329 case WM_QUERYNEWPALETTE
:
3330 processed
= HandleQueryNewPalette();
3335 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
3336 // check if an override was configured for this window
3337 EraseBgHooks::const_iterator it
= gs_eraseBgHooks
.find(this);
3338 if ( it
!= gs_eraseBgHooks
.end() )
3339 processed
= it
->second
->MSWEraseBgHook((WXHDC
)wParam
);
3341 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
3342 processed
= HandleEraseBkgnd((WXHDC
)wParam
);
3347 // we processed the message, i.e. erased the background
3352 #if !defined(__WXWINCE__)
3354 processed
= HandleDropFiles(wParam
);
3359 processed
= HandleInitDialog((WXHWND
)wParam
);
3363 // we never set focus from here
3368 #if !defined(__WXWINCE__)
3369 case WM_QUERYENDSESSION
:
3370 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3374 processed
= HandleEndSession(wParam
!= 0, lParam
);
3377 case WM_GETMINMAXINFO
:
3378 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3383 processed
= HandleSetCursor((WXHWND
)wParam
,
3384 LOWORD(lParam
), // hit test
3385 HIWORD(lParam
)); // mouse msg
3389 // returning TRUE stops the DefWindowProc() from further
3390 // processing this message - exactly what we need because we've
3391 // just set the cursor.
3396 #if wxUSE_ACCESSIBILITY
3399 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3400 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3402 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3404 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3410 #if defined(WM_HELP)
3413 // by default, WM_HELP is propagated by DefWindowProc() upwards
3414 // to the window parent but as we do it ourselves already
3415 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3416 // to get the other events if we process this message at all
3419 // WM_HELP doesn't use lParam under CE
3421 HELPINFO
* info
= (HELPINFO
*) lParam
;
3422 if ( info
->iContextType
== HELPINFO_WINDOW
)
3424 #endif // !__WXWINCE__
3425 wxHelpEvent helpEvent
3430 wxGetMousePosition() // what else?
3432 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3436 helpEvent
.SetEventObject(this);
3437 HandleWindowEvent(helpEvent
);
3440 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3442 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3443 helpEvent
.SetEventObject(this);
3444 HandleWindowEvent(helpEvent
);
3447 else // unknown help event?
3451 #endif // !__WXWINCE__
3456 #if !defined(__WXWINCE__)
3457 case WM_CONTEXTMENU
:
3459 // we don't convert from screen to client coordinates as
3460 // the event may be handled by a parent window
3461 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3463 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3465 // we could have got an event from our child, reflect it back
3466 // to it if this is the case
3467 wxWindowMSW
*win
= NULL
;
3468 WXHWND hWnd
= (WXHWND
)wParam
;
3469 if ( hWnd
!= m_hWnd
)
3471 win
= FindItemByHWND(hWnd
);
3477 evtCtx
.SetEventObject(win
);
3478 processed
= win
->HandleWindowEvent(evtCtx
);
3485 // we're only interested in our own menus, not MF_SYSMENU
3486 if ( HIWORD(wParam
) == MF_POPUP
)
3488 // handle menu chars for ownerdrawn menu items
3489 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3490 if ( i
!= wxNOT_FOUND
)
3492 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3497 #endif // wxUSE_MENUS
3500 case WM_POWERBROADCAST
:
3503 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3504 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3507 #endif // __WXWINCE__
3510 // If we want the default themed border then we need to draw it ourselves
3513 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3514 const wxBorder border
= TranslateBorder(GetBorder());
3515 if (theme
&& border
== wxBORDER_THEME
)
3517 // first ask the widget to calculate the border size
3518 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3521 // now alter the client size making room for drawing a
3524 NCCALCSIZE_PARAMS
*csparam
= NULL
;
3527 csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3528 rect
= &csparam
->rgrc
[0];
3532 rect
= (RECT
*)lParam
;
3535 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3536 RECT rcClient
= { 0, 0, 0, 0 };
3537 wxClientDC
dc((wxWindow
*)this);
3538 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3540 if ( theme
->GetThemeBackgroundContentRect
3547 &rcClient
) == S_OK
)
3549 InflateRect(&rcClient
, -1, -1);
3551 csparam
->rgrc
[0] = rcClient
;
3553 *((RECT
*)lParam
) = rcClient
;
3555 // WVR_REDRAW triggers a bug whereby child windows are moved up and left,
3557 // rc.result = WVR_REDRAW;
3565 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3566 const wxBorder border
= TranslateBorder(GetBorder());
3567 if (theme
&& border
== wxBORDER_THEME
)
3569 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3570 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3573 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3574 wxWindowDC
dc((wxWindow
*)this);
3575 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3577 // Clip the DC so that you only draw on the non-client area
3579 wxCopyRectToRECT(GetSize(), rcBorder
);
3582 theme
->GetThemeBackgroundContentRect(
3583 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3584 InflateRect(&rcClient
, -1, -1);
3586 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3587 rcClient
.right
, rcClient
.bottom
);
3589 // Make sure the background is in a proper state
3590 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3592 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3598 nState
= ETS_DISABLED
;
3599 // should we check this?
3600 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3601 // nState = ETS_READONLY;
3603 nState
= ETS_NORMAL
;
3604 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3609 #endif // wxUSE_UXTHEME
3612 // try a custom message handler
3613 const MSWMessageHandlers::const_iterator
3614 i
= gs_messageHandlers
.find(message
);
3615 if ( i
!= gs_messageHandlers
.end() )
3617 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3624 *result
= rc
.result
;
3629 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
3632 if ( !MSWHandleMessage(&result
, message
, wParam
, lParam
) )
3634 #if wxDEBUG_LEVEL >= 2
3635 wxLogTrace("winmsg", wxT("Forwarding %s to DefWindowProc."),
3636 wxGetMessageName(message
));
3637 #endif // wxDEBUG_LEVEL >= 2
3638 result
= MSWDefWindowProc(message
, wParam
, lParam
);
3644 // ----------------------------------------------------------------------------
3645 // wxWindow <-> HWND map
3646 // ----------------------------------------------------------------------------
3648 wxWindow
*wxFindWinFromHandle(HWND hwnd
)
3650 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3651 return i
== gs_windowHandles
.end() ? NULL
: i
->second
;
3654 void wxAssociateWinWithHandle(HWND hwnd
, wxWindowMSW
*win
)
3656 // adding NULL hwnd is (first) surely a result of an error and
3657 // (secondly) breaks menu command processing
3658 wxCHECK_RET( hwnd
!= (HWND
)NULL
,
3659 wxT("attempt to add a NULL hwnd to window list ignored") );
3662 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3663 if ( i
!= gs_windowHandles
.end() )
3665 if ( i
->second
!= win
)
3669 wxT("HWND %p already associated with another window (%s)"),
3670 hwnd
, win
->GetClassInfo()->GetClassName()
3674 //else: this actually happens currently because we associate the window
3675 // with its HWND during creation (if we create it) and also when
3676 // SubclassWin() is called later, this is ok
3678 #endif // wxDEBUG_LEVEL
3680 gs_windowHandles
[hwnd
] = (wxWindow
*)win
;
3683 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3685 gs_windowHandles
.erase(GetHwndOf(win
));
3688 // ----------------------------------------------------------------------------
3689 // various MSW speciic class dependent functions
3690 // ----------------------------------------------------------------------------
3692 // Default destroyer - override if you destroy it in some other way
3693 // (e.g. with MDI child windows)
3694 void wxWindowMSW::MSWDestroyWindow()
3698 void wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3701 int& w
, int& h
) const
3703 // CW_USEDEFAULT can't be used for child windows so just position them at
3704 // the origin by default
3705 x
= pos
.x
== wxDefaultCoord
? 0 : pos
.x
;
3706 y
= pos
.y
== wxDefaultCoord
? 0 : pos
.y
;
3708 AdjustForParentClientOrigin(x
, y
);
3710 // We don't have any clearly good choice for the size by default neither
3711 // but we must use something non-zero.
3712 w
= WidthDefault(size
.x
);
3713 h
= HeightDefault(size
.y
);
3716 NB: there used to be some code here which set the initial size of the
3717 window to the client size of the parent if no explicit size was
3718 specified. This was wrong because wxWidgets programs often assume
3719 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3720 it. To see why, you should understand that Windows sends WM_SIZE from
3721 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3722 from some base class ctor and so this WM_SIZE is not processed in the
3723 real class' OnSize() (because it's not fully constructed yet and the
3724 event goes to some base class OnSize() instead). So the WM_SIZE we
3725 rely on is the one sent when the parent frame resizes its children
3726 but here is the problem: if the child already has just the right
3727 size, nothing will happen as both wxWidgets and Windows check for
3728 this and ignore any attempts to change the window size to the size it
3729 already has - so no WM_SIZE would be sent.
3733 WXHWND
wxWindowMSW::MSWGetParent() const
3735 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3738 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3739 const wxChar
*title
,
3743 WXDWORD extendedStyle
)
3745 // check a common bug in the user code: if the window is created with a
3746 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3747 // single wxWindow object and this results in all sorts of trouble,
3748 // especially for wxTLWs
3749 wxCHECK_MSG( !m_hWnd
, true, "window can't be recreated" );
3751 // this can happen if this function is called using the return value of
3752 // wxApp::GetRegisteredClassName() which failed
3753 wxCHECK_MSG( wclass
, false, "failed to register window class?" );
3756 // choose the position/size for the new window
3758 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3760 // controlId is menu handle for the top level windows, so set it to 0
3761 // unless we're creating a child window
3762 int controlId
= style
& WS_CHILD
? GetId() : 0;
3764 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3765 // which is the same but without CS_[HV]REDRAW class styles so using it
3766 // ensures that the window is not fully repainted on each resize
3767 wxString
className(wclass
);
3768 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3770 className
+= wxApp::GetNoRedrawClassSuffix();
3773 // do create the window
3774 wxWindowCreationHook
hook(this);
3776 m_hWnd
= (WXHWND
)::CreateWindowEx
3780 title
? title
: m_windowName
.wx_str(),
3783 (HWND
)MSWGetParent(),
3784 (HMENU
)wxUIntToPtr(controlId
),
3786 NULL
// no extra data
3791 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3796 SubclassWin(m_hWnd
);
3801 // ===========================================================================
3802 // MSW message handlers
3803 // ===========================================================================
3805 // ---------------------------------------------------------------------------
3807 // ---------------------------------------------------------------------------
3809 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3811 #ifndef __WXMICROWIN__
3812 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3813 HWND hWnd
= hdr
->hwndFrom
;
3814 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
3816 // if the control is one of our windows, let it handle the message itself
3819 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3822 // VZ: why did we do it? normally this is unnecessary and, besides, it
3823 // breaks the message processing for the toolbars because the tooltip
3824 // notifications were being forwarded to the toolbar child controls
3825 // (if it had any) before being passed to the toolbar itself, so in my
3826 // example the tooltip for the combobox was always shown instead of the
3827 // correct button tooltips
3829 // try all our children
3830 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3833 wxWindow
*child
= node
->GetData();
3834 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3839 node
= node
->GetNext();
3843 // by default, handle it ourselves
3844 return MSWOnNotify(idCtrl
, lParam
, result
);
3845 #else // __WXMICROWIN__
3852 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3854 const wxString
& ttip
)
3856 // I don't know why it happens, but the versions of comctl32.dll starting
3857 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3858 // this message is supposed to be sent to Unicode programs only) -- hence
3859 // we need to handle it as well, otherwise no tooltips will be shown in
3862 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3865 // not a tooltip message or no tooltip to show anyhow
3870 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3872 // We don't want to use the szText buffer because it has a limit of 80
3873 // bytes and this is not enough, especially for Unicode build where it
3874 // limits the tooltip string length to only 40 characters
3876 // The best would be, of course, to not impose any length limitations at
3877 // all but then the buffer would have to be dynamic and someone would have
3878 // to free it and we don't have the tooltip owner object here any more, so
3879 // for now use our own static buffer with a higher fixed max length.
3881 // Note that using a static buffer should not be a problem as only a single
3882 // tooltip can be shown at the same time anyhow.
3884 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3886 // We need to convert tooltip from multi byte to Unicode on the fly.
3887 static wchar_t buf
[513];
3889 // Truncate tooltip length if needed as otherwise we might not have
3890 // enough space for it in the buffer and MultiByteToWideChar() would
3892 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3894 // Convert to WideChar without adding the NULL character. The NULL
3895 // character is added afterwards (this is more efficient).
3896 int len
= ::MultiByteToWideChar
3908 wxLogLastError(wxT("MultiByteToWideChar()"));
3912 ttText
->lpszText
= (LPSTR
) buf
;
3914 else // TTN_NEEDTEXTA
3915 #endif // !wxUSE_UNICODE
3917 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3918 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3919 // to copy the string we have into the buffer
3920 static wxChar buf
[513];
3921 wxStrlcpy(buf
, ttip
.c_str(), WXSIZEOF(buf
));
3922 ttText
->lpszText
= buf
;
3928 #endif // wxUSE_TOOLTIPS
3930 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3932 WXLPARAM
* WXUNUSED(result
))
3937 NMHDR
* hdr
= (NMHDR
*)lParam
;
3938 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3945 wxUnusedVar(lParam
);
3946 #endif // wxUSE_TOOLTIPS
3951 // ---------------------------------------------------------------------------
3952 // end session messages
3953 // ---------------------------------------------------------------------------
3955 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3957 #ifdef ENDSESSION_LOGOFF
3958 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3959 event
.SetEventObject(wxTheApp
);
3960 event
.SetCanVeto(true);
3961 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3963 bool rc
= wxTheApp
->ProcessEvent(event
);
3967 // we may end only if the app didn't veto session closing (double
3969 *mayEnd
= !event
.GetVeto();
3974 wxUnusedVar(logOff
);
3975 wxUnusedVar(mayEnd
);
3980 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3982 #ifdef ENDSESSION_LOGOFF
3983 // do nothing if the session isn't ending
3988 if ( (this != wxTheApp
->GetTopWindow()) )
3991 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3992 event
.SetEventObject(wxTheApp
);
3993 event
.SetCanVeto(false);
3994 event
.SetLoggingOff((logOff
& ENDSESSION_LOGOFF
) != 0);
3996 return wxTheApp
->ProcessEvent(event
);
3998 wxUnusedVar(endSession
);
3999 wxUnusedVar(logOff
);
4004 // ---------------------------------------------------------------------------
4005 // window creation/destruction
4006 // ---------------------------------------------------------------------------
4008 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
4011 // VZ: why is this commented out for WinCE? If it doesn't support
4012 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
4013 // not with multiple #ifdef's!
4015 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
4016 EnsureParentHasControlParentStyle(GetParent());
4017 #endif // !__WXWINCE__
4024 bool wxWindowMSW::HandleDestroy()
4026 // delete our drop target if we've got one
4027 #if wxUSE_DRAG_AND_DROP
4028 if ( m_dropTarget
!= NULL
)
4030 m_dropTarget
->Revoke(m_hWnd
);
4032 wxDELETE(m_dropTarget
);
4034 #endif // wxUSE_DRAG_AND_DROP
4036 // WM_DESTROY handled
4040 // ---------------------------------------------------------------------------
4042 // ---------------------------------------------------------------------------
4044 bool wxWindowMSW::HandleActivate(int state
,
4045 bool WXUNUSED(minimized
),
4046 WXHWND
WXUNUSED(activate
))
4048 wxActivateEvent
event(wxEVT_ACTIVATE
,
4049 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
4051 event
.SetEventObject(this);
4053 return HandleWindowEvent(event
);
4056 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
4058 // Strangly enough, some controls get set focus events when they are being
4059 // deleted, even if they already had focus before.
4060 if ( m_isBeingDeleted
)
4065 // notify the parent keeping track of focus for the kbd navigation
4066 // purposes that we got it
4067 wxChildFocusEvent
eventFocus((wxWindow
*)this);
4068 (void)HandleWindowEvent(eventFocus
);
4074 m_caret
->OnSetFocus();
4076 #endif // wxUSE_CARET
4078 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
4079 event
.SetEventObject(this);
4081 // wxFindWinFromHandle() may return NULL, it is ok
4082 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4084 return HandleWindowEvent(event
);
4087 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4093 m_caret
->OnKillFocus();
4095 #endif // wxUSE_CARET
4097 // Don't send the event when in the process of being deleted. This can
4098 // only cause problems if the event handler tries to access the object.
4099 if ( m_isBeingDeleted
)
4104 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4105 event
.SetEventObject(this);
4107 // wxFindWinFromHandle() may return NULL, it is ok
4108 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4110 return HandleWindowEvent(event
);
4113 // ---------------------------------------------------------------------------
4115 // ---------------------------------------------------------------------------
4117 void wxWindowMSW::SetLabel( const wxString
& label
)
4119 SetWindowText(GetHwnd(), label
.c_str());
4122 wxString
wxWindowMSW::GetLabel() const
4124 return wxGetWindowText(GetHWND());
4127 // ---------------------------------------------------------------------------
4129 // ---------------------------------------------------------------------------
4131 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4133 wxShowEvent
event(GetId(), show
);
4134 event
.SetEventObject(this);
4136 return HandleWindowEvent(event
);
4139 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4141 wxInitDialogEvent
event(GetId());
4142 event
.SetEventObject(this);
4144 return HandleWindowEvent(event
);
4147 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4149 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4150 wxUnusedVar(wParam
);
4152 #else // __WXMICROWIN__
4153 HDROP hFilesInfo
= (HDROP
) wParam
;
4155 // Get the total number of files dropped
4156 UINT gwFilesDropped
= ::DragQueryFile
4164 wxString
*files
= new wxString
[gwFilesDropped
];
4165 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4167 // first get the needed buffer length (+1 for terminating NUL)
4168 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4170 // and now get the file name
4171 ::DragQueryFile(hFilesInfo
, wIndex
,
4172 wxStringBuffer(files
[wIndex
], len
), len
);
4175 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4176 event
.SetEventObject(this);
4179 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4180 event
.m_pos
.x
= dropPoint
.x
;
4181 event
.m_pos
.y
= dropPoint
.y
;
4183 DragFinish(hFilesInfo
);
4185 return HandleWindowEvent(event
);
4190 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4192 int WXUNUSED(mouseMsg
))
4194 #ifndef __WXMICROWIN__
4195 // the logic is as follows:
4196 // 0. if we're busy, set the busy cursor (even for non client elements)
4197 // 1. don't set custom cursor for non client area of enabled windows
4198 // 2. ask user EVT_SET_CURSOR handler for the cursor
4199 // 3. if still no cursor but we're in a TLW, set the global cursor
4201 HCURSOR hcursor
= 0;
4204 hcursor
= wxGetCurrentBusyCursor();
4208 if ( nHitTest
!= HTCLIENT
)
4211 // first ask the user code - it may wish to set the cursor in some very
4212 // specific way (for example, depending on the current position)
4215 if ( !::GetCursorPosWinCE(&pt
))
4217 if ( !::GetCursorPos(&pt
) )
4220 wxLogLastError(wxT("GetCursorPos"));
4225 ScreenToClient(&x
, &y
);
4226 wxSetCursorEvent
event(x
, y
);
4227 event
.SetId(GetId());
4228 event
.SetEventObject(this);
4230 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4231 if ( processedEvtSetCursor
&& event
.HasCursor() )
4233 hcursor
= GetHcursorOf(event
.GetCursor());
4238 // the test for processedEvtSetCursor is here to prevent using
4239 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4240 // nothing from it - this is a way to say that our cursor shouldn't
4241 // be used for this point
4242 if ( !processedEvtSetCursor
&& m_cursor
.IsOk() )
4244 hcursor
= GetHcursorOf(m_cursor
);
4247 if ( !hcursor
&& !GetParent() )
4249 const wxCursor
*cursor
= wxGetGlobalCursor();
4250 if ( cursor
&& cursor
->IsOk() )
4252 hcursor
= GetHcursorOf(*cursor
);
4261 ::SetCursor(hcursor
);
4263 // cursor set, stop here
4266 #endif // __WXMICROWIN__
4268 // pass up the window chain
4272 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4273 WXLPARAM
WXUNUSED(lParam
),
4274 bool *WXUNUSED_IN_WINCE(vetoed
))
4280 wxEventType evtType
;
4283 case PBT_APMQUERYSUSPEND
:
4284 evtType
= wxEVT_POWER_SUSPENDING
;
4287 case PBT_APMQUERYSUSPENDFAILED
:
4288 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4291 case PBT_APMSUSPEND
:
4292 evtType
= wxEVT_POWER_SUSPENDED
;
4295 case PBT_APMRESUMESUSPEND
:
4296 evtType
= wxEVT_POWER_RESUME
;
4300 wxLogDebug(wxT("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4303 // these messages are currently not mapped to wx events
4304 case PBT_APMQUERYSTANDBY
:
4305 case PBT_APMQUERYSTANDBYFAILED
:
4306 case PBT_APMSTANDBY
:
4307 case PBT_APMRESUMESTANDBY
:
4308 case PBT_APMBATTERYLOW
:
4309 case PBT_APMPOWERSTATUSCHANGE
:
4310 case PBT_APMOEMEVENT
:
4311 case PBT_APMRESUMECRITICAL
:
4312 #ifdef PBT_APMRESUMEAUTOMATIC
4313 case PBT_APMRESUMEAUTOMATIC
:
4315 evtType
= wxEVT_NULL
;
4319 // don't handle unknown messages
4320 if ( evtType
== wxEVT_NULL
)
4323 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4325 wxPowerEvent
event(evtType
);
4326 if ( !HandleWindowEvent(event
) )
4329 *vetoed
= event
.IsVetoed();
4335 bool wxWindowMSW::IsDoubleBuffered() const
4337 for ( const wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4339 if ( wxHasWindowExStyle(win
, WS_EX_COMPOSITED
) )
4342 if ( win
->IsTopLevel() )
4349 void wxWindowMSW::SetDoubleBuffered(bool on
)
4351 // Get the current extended style bits
4352 long exstyle
= wxGetWindowExStyle(this);
4354 // Twiddle the bit as needed
4356 exstyle
|= WS_EX_COMPOSITED
;
4358 exstyle
&= ~WS_EX_COMPOSITED
;
4361 wxSetWindowExStyle(this, exstyle
);
4364 // ---------------------------------------------------------------------------
4365 // owner drawn stuff
4366 // ---------------------------------------------------------------------------
4368 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4369 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4370 #define WXUNUSED_UNLESS_ODRAWN(param) param
4372 #define WXUNUSED_UNLESS_ODRAWN(param)
4376 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4377 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4379 #if wxUSE_OWNER_DRAWN
4381 #if wxUSE_MENUS_NATIVE
4382 // is it a menu item?
4383 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4384 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4386 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4388 // see comment before the same test in MSWOnMeasureItem() below
4392 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4393 false, wxT("MSWOnDrawItem: bad wxMenuItem pointer") );
4395 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4396 // the DC from being released
4397 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4398 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4399 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4400 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4402 return pMenuItem
->OnDrawItem
4406 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4407 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4410 #endif // wxUSE_MENUS_NATIVE
4412 #endif // USE_OWNER_DRAWN
4414 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4416 #if wxUSE_OWNER_DRAWN
4417 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4418 #else // !wxUSE_OWNER_DRAWN
4419 // we may still have owner-drawn buttons internally because we have to make
4420 // them owner-drawn to support colour change
4423 wxDynamicCast(FindItem(id
), wxButton
)
4428 #endif // USE_OWNER_DRAWN
4432 return item
->MSWOnDraw(itemStruct
);
4435 #endif // wxUSE_CONTROLS
4441 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4443 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4444 // is it a menu item?
4445 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4446 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4448 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4450 // according to Carsten Fuchs the pointer may be NULL under XP if an
4451 // MDI child frame is initially maximized, see this for more info:
4452 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4454 // so silently ignore it instead of asserting
4458 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4459 false, wxT("MSWOnMeasureItem: bad wxMenuItem pointer") );
4462 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4464 pMeasureStruct
->itemWidth
= w
;
4465 pMeasureStruct
->itemHeight
= h
;
4470 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4473 return item
->MSWOnMeasure(itemStruct
);
4477 wxUnusedVar(itemStruct
);
4478 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4483 // ---------------------------------------------------------------------------
4484 // colours and palettes
4485 // ---------------------------------------------------------------------------
4487 bool wxWindowMSW::HandleSysColorChange()
4489 wxSysColourChangedEvent event
;
4490 event
.SetEventObject(this);
4492 (void)HandleWindowEvent(event
);
4494 // always let the system carry on the default processing to allow the
4495 // native controls to react to the colours update
4499 bool wxWindowMSW::HandleDisplayChange()
4501 wxDisplayChangedEvent event
;
4502 event
.SetEventObject(this);
4504 return HandleWindowEvent(event
);
4507 #ifndef __WXMICROWIN__
4509 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4511 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4515 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4518 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4520 #endif // wxUSE_CONTROLS
4523 return *brush
!= NULL
;
4526 #endif // __WXMICROWIN__
4528 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4531 // same as below except we don't respond to our own messages
4532 if ( hWndPalChange
!= GetHWND() )
4534 // check to see if we our our parents have a custom palette
4535 wxWindowMSW
*win
= this;
4536 while ( win
&& !win
->HasCustomPalette() )
4538 win
= win
->GetParent();
4541 if ( win
&& win
->HasCustomPalette() )
4543 // realize the palette to see whether redrawing is needed
4544 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4545 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4546 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4548 int result
= ::RealizePalette(hdc
);
4550 // restore the palette (before releasing the DC)
4551 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4552 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4553 ::RealizePalette(hdc
);
4554 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4556 // now check for the need to redraw
4558 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4562 #endif // wxUSE_PALETTE
4564 wxPaletteChangedEvent
event(GetId());
4565 event
.SetEventObject(this);
4566 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4568 return HandleWindowEvent(event
);
4571 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4573 // notify windows on the capture stack about lost capture
4574 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4575 wxWindowBase::NotifyCaptureLost();
4577 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4578 wxMouseCaptureChangedEvent
event(GetId(), win
);
4579 event
.SetEventObject(this);
4580 return HandleWindowEvent(event
);
4583 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4585 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4586 // we need to send this to child windows (it is only sent to top-level
4587 // windows) so {list,tree}ctrls can adjust their font size if necessary
4588 // this is exactly how explorer does it to enable the font size changes
4590 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4593 // top-level windows already get this message from the system
4594 wxWindow
*win
= node
->GetData();
4595 if ( !win
->IsTopLevel() )
4597 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4600 node
= node
->GetNext();
4603 // let the system handle it
4607 bool wxWindowMSW::HandleQueryNewPalette()
4611 // check to see if we our our parents have a custom palette
4612 wxWindowMSW
*win
= this;
4613 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4614 if (win
->HasCustomPalette()) {
4615 /* realize the palette to see whether redrawing is needed */
4616 HDC hdc
= ::GetDC((HWND
) GetHWND());
4617 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4618 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4620 int result
= ::RealizePalette(hdc
);
4621 /* restore the palette (before releasing the DC) */
4622 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4623 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4624 ::RealizePalette(hdc
);
4625 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4626 /* now check for the need to redraw */
4628 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4630 #endif // wxUSE_PALETTE
4632 wxQueryNewPaletteEvent
event(GetId());
4633 event
.SetEventObject(this);
4635 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4638 // Responds to colour changes: passes event on to children.
4639 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4641 // the top level window also reset the standard colour map as it might have
4642 // changed (there is no need to do it for the non top level windows as we
4643 // only have to do it once)
4647 gs_hasStdCmap
= false;
4649 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4652 // Only propagate to non-top-level windows because Windows already
4653 // sends this event to all top-level ones
4654 wxWindow
*win
= node
->GetData();
4655 if ( !win
->IsTopLevel() )
4657 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4658 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4659 // the standard controls
4660 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4663 node
= node
->GetNext();
4667 extern wxCOLORMAP
*wxGetStdColourMap()
4669 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4670 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4672 if ( !gs_hasStdCmap
)
4674 static bool s_coloursInit
= false;
4676 if ( !s_coloursInit
)
4678 // When a bitmap is loaded, the RGB values can change (apparently
4679 // because Windows adjusts them to care for the old programs always
4680 // using 0xc0c0c0 while the transparent colour for the new Windows
4681 // versions is different). But we do this adjustment ourselves so
4682 // we want to avoid Windows' "help" and for this we need to have a
4683 // reference bitmap which can tell us what the RGB values change
4685 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4686 wxBitmap
stdColourBitmap(wxT("wxBITMAP_STD_COLOURS"));
4687 if ( stdColourBitmap
.IsOk() )
4689 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4690 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4691 wxT("forgot to update wxBITMAP_STD_COLOURS!") );
4694 memDC
.SelectObject(stdColourBitmap
);
4697 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4699 memDC
.GetPixel(i
, 0, &colour
);
4700 s_stdColours
[i
] = wxColourToRGB(colour
);
4703 else // wxBITMAP_STD_COLOURS couldn't be loaded
4705 s_stdColours
[0] = RGB(000,000,000); // black
4706 s_stdColours
[1] = RGB(128,128,128); // dark grey
4707 s_stdColours
[2] = RGB(192,192,192); // light grey
4708 s_stdColours
[3] = RGB(255,255,255); // white
4709 //s_stdColours[4] = RGB(000,000,255); // blue
4710 //s_stdColours[5] = RGB(255,000,255); // magenta
4713 s_coloursInit
= true;
4716 gs_hasStdCmap
= true;
4718 // create the colour map
4719 #define INIT_CMAP_ENTRY(col) \
4720 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4721 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4723 INIT_CMAP_ENTRY(BTNTEXT
);
4724 INIT_CMAP_ENTRY(BTNSHADOW
);
4725 INIT_CMAP_ENTRY(BTNFACE
);
4726 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4728 #undef INIT_CMAP_ENTRY
4734 #if wxUSE_UXTHEME && !defined(TMT_FILLCOLOR)
4735 #define TMT_FILLCOLOR 3802
4736 #define TMT_TEXTCOLOR 3803
4737 #define TMT_BORDERCOLOR 3801
4740 wxColour
wxWindowMSW::MSWGetThemeColour(const wchar_t *themeName
,
4743 MSWThemeColour themeColour
,
4744 wxSystemColour fallback
) const
4747 const wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
4750 int themeProperty
= 0;
4752 // TODO: Convert this into a table? Sure would be faster.
4753 switch ( themeColour
)
4755 case ThemeColourBackground
:
4756 themeProperty
= TMT_FILLCOLOR
;
4758 case ThemeColourText
:
4759 themeProperty
= TMT_TEXTCOLOR
;
4761 case ThemeColourBorder
:
4762 themeProperty
= TMT_BORDERCOLOR
;
4765 wxFAIL_MSG(wxT("unsupported theme colour"));
4768 wxUxThemeHandle
hTheme((const wxWindow
*)this, themeName
);
4770 HRESULT hr
= theme
->GetThemeColor
4779 if ( SUCCEEDED(hr
) )
4780 return wxRGBToColour(col
);
4784 "GetThemeColor(%s, %i, %i, %i)",
4785 themeName
, themePart
, themeState
, themeProperty
),
4789 wxUnusedVar(themeName
);
4790 wxUnusedVar(themePart
);
4791 wxUnusedVar(themeState
);
4792 wxUnusedVar(themeColour
);
4794 return wxSystemSettings::GetColour(fallback
);
4797 // ---------------------------------------------------------------------------
4799 // ---------------------------------------------------------------------------
4801 // this variable is used to check that a paint event handler which processed
4802 // the event did create a wxPaintDC inside its code and called BeginPaint() to
4803 // validate the invalidated window area as otherwise we'd keep getting an
4804 // endless stream of WM_PAINT messages for this window resulting in a lot of
4805 // difficult to debug problems (e.g. impossibility to repaint other windows,
4806 // lack of timer and idle events and so on)
4807 extern bool wxDidCreatePaintDC
;
4808 bool wxDidCreatePaintDC
= false;
4810 bool wxWindowMSW::HandlePaint()
4812 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4815 wxLogLastError(wxT("CreateRectRgn"));
4817 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4819 wxLogLastError(wxT("GetUpdateRgn"));
4822 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4824 wxDidCreatePaintDC
= false;
4826 wxPaintEvent
event(m_windowId
);
4827 event
.SetEventObject(this);
4829 bool processed
= HandleWindowEvent(event
);
4831 if ( processed
&& !wxDidCreatePaintDC
)
4833 // do call MSWDefWindowProc() to validate the update region to avoid
4834 // the problems mentioned above
4838 // note that we must generate NC event after the normal one as otherwise
4839 // BeginPaint() will happily overwrite our decorations with the background
4841 wxNcPaintEvent
eventNc(m_windowId
);
4842 eventNc
.SetEventObject(this);
4843 HandleWindowEvent(eventNc
);
4845 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4846 // be called from inside the event handlers called above)
4847 m_updateRegion
.Clear();
4852 // Can be called from an application's OnPaint handler
4853 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4855 #ifdef __WXUNIVERSAL__
4858 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4861 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4866 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4868 switch ( GetBackgroundStyle() )
4870 case wxBG_STYLE_ERASE
:
4871 case wxBG_STYLE_COLOUR
:
4872 // we need to generate an erase background event
4874 wxDCTemp
dc(hdc
, GetClientSize());
4875 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4878 impl
->SetWindow((wxWindow
*)this);
4880 wxEraseEvent
event(m_windowId
, &dc
);
4881 event
.SetEventObject(this);
4882 bool rc
= HandleWindowEvent(event
);
4884 // must be called manually as ~wxDC doesn't do anything for
4886 impl
->SelectOldObjects(hdc
);
4890 // background erased by the user-defined handler
4896 case wxBG_STYLE_SYSTEM
:
4897 if ( !DoEraseBackground(hdc
) )
4899 // let the default processing to take place if we didn't erase
4900 // the background ourselves
4905 case wxBG_STYLE_PAINT
:
4906 case wxBG_STYLE_TRANSPARENT
:
4907 // no need to do anything here at all, background will be entirely
4908 // redrawn in WM_PAINT handler
4912 wxFAIL_MSG( "unknown background style" );
4918 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
4920 bool wxWindowMSW::MSWHasEraseBgHook() const
4922 return gs_eraseBgHooks
.find(const_cast<wxWindowMSW
*>(this))
4923 != gs_eraseBgHooks
.end();
4926 void wxWindowMSW::MSWSetEraseBgHook(wxWindow
*child
)
4930 if ( !gs_eraseBgHooks
.insert(
4931 EraseBgHooks::value_type(this, child
)).second
)
4933 wxFAIL_MSG( wxT("Setting erase background hook twice?") );
4936 else // reset the hook
4938 if ( gs_eraseBgHooks
.erase(this) != 1 )
4940 wxFAIL_MSG( wxT("Resetting erase background which was not set?") );
4945 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
4947 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4949 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4953 // erase just the client area of the window, this is important for the
4954 // frames to avoid drawing over the toolbar part of the window (you might
4955 // think using WS_CLIPCHILDREN would prevent this from happening, but it
4958 wxCopyRectToRECT(GetClientRect(), rc
);
4959 ::FillRect((HDC
)hDC
, &rc
, hbr
);
4965 wxWindowMSW::MSWGetBgBrushForChild(WXHDC hDC
, wxWindowMSW
*child
)
4967 // Test for the custom background brush first.
4968 WXHBRUSH hbrush
= MSWGetCustomBgBrush();
4971 // We assume that this is either a stipple or hatched brush and not a
4972 // solid one as otherwise it would have been enough to set the
4973 // background colour and such brushes need to be positioned correctly
4974 // in order to align when different windows are painted, so do it here.
4976 ::GetWindowRect(GetHwndOf(child
), &rc
);
4978 ::MapWindowPoints(NULL
, GetHwnd(), (POINT
*)&rc
, 1);
4980 if ( !::SetBrushOrgEx((HDC
)hDC
, -rc
.left
, -rc
.top
, NULL
) )
4982 wxLogLastError(wxT("SetBrushOrgEx(bg brush)"));
4988 // Otherwise see if we have a custom background colour.
4992 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4994 return (WXHBRUSH
)GetHbrushOf(*brush
);
5000 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
)
5002 // Use the special wxWindowBeingErased variable if it is set as the child
5004 wxWindowMSW
* const child
=
5006 wxWindowBeingErased
? wxWindowBeingErased
:
5010 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
5012 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, child
);
5016 // don't use the parent background if we're not transparent
5017 if ( !win
->HasTransparentBackground() )
5020 // background is not inherited beyond top level windows
5021 if ( win
->IsTopLevel() )
5028 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
5030 // we receive this message when DrawThemeParentBackground() is
5031 // called from def window proc of several controls under XP and we
5032 // must draw properly themed background here
5034 // note that naively I'd expect filling the client rect with the
5035 // brush returned by MSWGetBgBrush() work -- but for some reason it
5036 // doesn't and we have to call parents MSWPrintChild() which is
5037 // supposed to call DrawThemeBackground() with appropriate params
5039 // also note that in this case lParam == PRF_CLIENT but we're
5040 // clearly expected to paint the background and nothing else!
5042 if ( IsTopLevel() || InheritsBackgroundColour() )
5045 // sometimes we don't want the parent to handle it at all, instead
5046 // return whatever value this window wants
5047 if ( !MSWShouldPropagatePrintChild() )
5048 return MSWPrintChild(hDC
, (wxWindow
*)this);
5050 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
5052 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
5055 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
5062 // ---------------------------------------------------------------------------
5063 // moving and resizing
5064 // ---------------------------------------------------------------------------
5066 bool wxWindowMSW::HandleMinimize()
5068 wxIconizeEvent
event(m_windowId
);
5069 event
.SetEventObject(this);
5071 return HandleWindowEvent(event
);
5074 bool wxWindowMSW::HandleMaximize()
5076 wxMaximizeEvent
event(m_windowId
);
5077 event
.SetEventObject(this);
5079 return HandleWindowEvent(event
);
5082 bool wxWindowMSW::HandleMove(int x
, int y
)
5085 wxMoveEvent
event(point
, m_windowId
);
5086 event
.SetEventObject(this);
5088 return HandleWindowEvent(event
);
5091 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
5093 wxMoveEvent
event(rect
, m_windowId
);
5094 event
.SetEventObject(this);
5096 bool rc
= HandleWindowEvent(event
);
5098 rect
= event
.GetRect();
5102 bool wxWindowMSW::HandleEnterSizeMove()
5104 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
5105 event
.SetEventType(wxEVT_MOVE_START
);
5106 event
.SetEventObject(this);
5108 return HandleWindowEvent(event
);
5111 bool wxWindowMSW::HandleExitSizeMove()
5113 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
5114 event
.SetEventType(wxEVT_MOVE_END
);
5115 event
.SetEventObject(this);
5117 return HandleWindowEvent(event
);
5120 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
5122 #if wxUSE_DEFERRED_SIZING
5123 // when we resize this window, its children are probably going to be
5124 // repositioned as well, prepare to use DeferWindowPos() for them
5125 int numChildren
= 0;
5126 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
5128 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
5133 // Protect against valid m_hDWP being overwritten
5134 bool useDefer
= false;
5136 if ( numChildren
> 1 )
5140 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
5143 wxLogLastError(wxT("BeginDeferWindowPos"));
5149 #endif // wxUSE_DEFERRED_SIZING
5151 // update this window size
5152 bool processed
= false;
5156 wxFAIL_MSG( wxT("unexpected WM_SIZE parameter") );
5157 // fall through nevertheless
5161 // we're not interested in these messages at all
5164 case SIZE_MINIMIZED
:
5165 processed
= HandleMinimize();
5168 case SIZE_MAXIMIZED
:
5169 /* processed = */ HandleMaximize();
5170 // fall through to send a normal size event as well
5173 // don't use w and h parameters as they specify the client size
5174 // while according to the docs EVT_SIZE handler is supposed to
5175 // receive the total size
5176 wxSizeEvent
event(GetSize(), m_windowId
);
5177 event
.SetEventObject(this);
5179 processed
= HandleWindowEvent(event
);
5182 #if wxUSE_DEFERRED_SIZING
5183 // and finally change the positions of all child windows at once
5184 if ( useDefer
&& m_hDWP
)
5186 // reset m_hDWP to NULL so that child windows don't try to use our
5187 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
5188 // happen anyhow normally but who knows what weird flow of control we
5189 // may have depending on what the users EVT_SIZE handler does...)
5190 HDWP hDWP
= (HDWP
)m_hDWP
;
5193 // do put all child controls in place at once
5194 if ( !::EndDeferWindowPos(hDWP
) )
5196 wxLogLastError(wxT("EndDeferWindowPos"));
5199 // Reset our children's pending pos/size values.
5200 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
5202 node
= node
->GetNext() )
5204 wxWindowMSW
* const child
= node
->GetData();
5205 child
->MSWEndDeferWindowPos();
5208 #endif // wxUSE_DEFERRED_SIZING
5213 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
5215 wxSizeEvent
event(rect
, m_windowId
);
5216 event
.SetEventObject(this);
5218 bool rc
= HandleWindowEvent(event
);
5220 rect
= event
.GetRect();
5224 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5229 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5233 int minWidth
= GetMinWidth(),
5234 minHeight
= GetMinHeight(),
5235 maxWidth
= GetMaxWidth(),
5236 maxHeight
= GetMaxHeight();
5238 if ( minWidth
!= wxDefaultCoord
)
5240 info
->ptMinTrackSize
.x
= minWidth
;
5244 if ( minHeight
!= wxDefaultCoord
)
5246 info
->ptMinTrackSize
.y
= minHeight
;
5250 if ( maxWidth
!= wxDefaultCoord
)
5252 info
->ptMaxTrackSize
.x
= maxWidth
;
5256 if ( maxHeight
!= wxDefaultCoord
)
5258 info
->ptMaxTrackSize
.y
= maxHeight
;
5266 // ---------------------------------------------------------------------------
5268 // ---------------------------------------------------------------------------
5270 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5272 // sign extend to int from short before comparing with the other int ids
5273 int id
= (signed short)id_
;
5275 #if wxUSE_MENUS_NATIVE
5276 if ( !cmd
&& wxCurrentPopupMenu
)
5278 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5279 wxCurrentPopupMenu
= NULL
;
5281 return popupMenu
->MSWCommand(cmd
, id
);
5283 #endif // wxUSE_MENUS_NATIVE
5285 wxWindow
*win
= NULL
;
5287 // first try to find it from HWND - this works even with the broken
5288 // programs using the same ids for different controls
5291 win
= wxFindWinFromHandle(control
);
5302 return win
->MSWCommand(cmd
, id
);
5305 // the messages sent from the in-place edit control used by the treectrl
5306 // for label editing have id == 0, but they should _not_ be treated as menu
5307 // messages (they are EN_XXX ones, in fact) so don't translate anything
5308 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5311 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, id
);
5312 event
.SetEventObject(this);
5315 return HandleWindowEvent(event
);
5319 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5320 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5321 // notifications to its parent which we want to reflect back to
5323 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5324 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5326 #endif // wxUSE_SPINCTRL
5328 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5329 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5330 // notifications to its parent which we want to reflect back to
5332 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5333 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5341 // ---------------------------------------------------------------------------
5343 // ---------------------------------------------------------------------------
5345 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5349 // our client coords are not quite the same as Windows ones
5350 wxPoint pt
= GetClientAreaOrigin();
5351 event
.m_x
= x
- pt
.x
;
5352 event
.m_y
= y
- pt
.y
;
5354 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5355 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5356 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5357 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5358 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5359 #ifdef wxHAS_XBUTTON
5360 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5361 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5362 #endif // wxHAS_XBUTTON
5363 event
.m_altDown
= ::wxIsAltDown();
5366 event
.SetTimestamp(::GetMessageTime());
5369 event
.SetEventObject(this);
5370 event
.SetId(GetId());
5372 #if wxUSE_MOUSEEVENT_HACK
5373 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5374 gs_lastMouseEvent
.type
= event
.GetEventType();
5375 #endif // wxUSE_MOUSEEVENT_HACK
5379 // Windows doesn't send the mouse events to the static controls (which are
5380 // transparent in the sense that their WM_NCHITTEST handler returns
5381 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5382 // and so we manually check if we don't have a child window under mouse and if
5383 // we do, send the event to it instead of the window Windows had sent WM_XXX
5386 // Notice that this is not done for the mouse move events because this could
5387 // (would?) be too slow, but only for clicks which means that the static texts
5388 // still don't get move, enter nor leave events.
5389 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5391 wxCHECK_MSG( x
&& y
, win
, wxT("NULL pointer in FindWindowForMouseEvent") );
5393 // first try to find a non transparent child: this allows us to send events
5394 // to a static text which is inside a static box, for example
5395 POINT pt
= { *x
, *y
};
5396 HWND hwnd
= GetHwndOf(win
),
5400 hwndUnderMouse
= ::ChildWindowFromPoint
5406 hwndUnderMouse
= ::ChildWindowFromPointEx
5416 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5418 // now try any child window at all
5419 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5422 // check that we have a child window which is susceptible to receive mouse
5423 // events: for this it must be shown and enabled
5424 if ( hwndUnderMouse
&&
5425 hwndUnderMouse
!= hwnd
&&
5426 ::IsWindowVisible(hwndUnderMouse
) &&
5427 ::IsWindowEnabled(hwndUnderMouse
) )
5429 wxWindow
*winUnderMouse
= wxFindWinFromHandle(hwndUnderMouse
);
5430 if ( winUnderMouse
)
5432 // translate the mouse coords to the other window coords
5433 win
->ClientToScreen(x
, y
);
5434 winUnderMouse
->ScreenToClient(x
, y
);
5436 win
= winUnderMouse
;
5442 #endif // __WXWINCE__
5444 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5446 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5447 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5448 // from the message id and take the value in the table to get wxWin event
5450 static const wxEventType eventsMouse
[] =
5461 wxEVT_MIDDLE_DCLICK
,
5462 0, // this one is for wxEVT_MOTION which is not used here
5471 #ifdef wxHAS_XBUTTON
5472 // the same messages are used for both auxillary mouse buttons so we need
5473 // to adjust the index manually
5476 case WM_XBUTTONDOWN
:
5478 case WM_XBUTTONDBLCLK
:
5479 if ( flags
& MK_XBUTTON2
)
5480 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5482 #endif // wxHAS_XBUTTON
5484 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5485 InitMouseEvent(event
, x
, y
, flags
);
5487 return HandleWindowEvent(event
);
5490 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5492 if ( !m_mouseInWindow
)
5494 // it would be wrong to assume that just because we get a mouse move
5495 // event that the mouse is inside the window: although this is usually
5496 // true, it is not if we had captured the mouse, so we need to check
5497 // the mouse coordinates here
5498 if ( !HasCapture() || IsMouseInWindow() )
5500 // Generate an ENTER event
5501 m_mouseInWindow
= true;
5503 #ifdef HAVE_TRACKMOUSEEVENT
5504 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5506 static const _TrackMouseEvent_t
5507 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5508 #else // !__WXWINCE__
5509 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5510 static bool s_initDone
= false;
5513 // see comment in wxApp::GetComCtl32Version() explaining the
5514 // use of wxLoadedDLL
5515 wxLoadedDLL
dllComCtl32(wxT("comctl32.dll"));
5516 if ( dllComCtl32
.IsLoaded() )
5518 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5519 dllComCtl32
.RawGetSymbol(wxT("_TrackMouseEvent"));
5525 if ( s_pfn_TrackMouseEvent
)
5526 #endif // __WXWINCE__/!__WXWINCE__
5528 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5530 trackinfo
.dwFlags
= TME_LEAVE
;
5531 trackinfo
.hwndTrack
= GetHwnd();
5533 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5535 #endif // HAVE_TRACKMOUSEEVENT
5537 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5538 InitMouseEvent(event
, x
, y
, flags
);
5540 (void)HandleWindowEvent(event
);
5543 #ifdef HAVE_TRACKMOUSEEVENT
5544 else // mouse not in window
5546 // Check if we need to send a LEAVE event
5547 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5548 // send it here if we are using native mouse leave tracking
5549 if ( HasCapture() && !IsMouseInWindow() )
5551 GenerateMouseLeave();
5554 #endif // HAVE_TRACKMOUSEEVENT
5556 #if wxUSE_MOUSEEVENT_HACK
5557 // Windows often generates mouse events even if mouse position hasn't
5558 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5560 // Filter this out as it can result in unexpected behaviour compared to
5562 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5563 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5564 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5565 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5567 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5569 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5574 #endif // wxUSE_MOUSEEVENT_HACK
5576 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5580 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5582 #if wxUSE_MOUSEWHEEL
5583 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5584 // forwarded up to the parent by DefWindowProc()) and not in the client
5585 // ones as all the other messages, translate them to the client coords for
5588 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5589 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5590 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5591 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5592 event
.m_wheelDelta
= WHEEL_DELTA
;
5594 static int s_linesPerRotation
= -1;
5595 if ( s_linesPerRotation
== -1 )
5597 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5598 &s_linesPerRotation
, 0))
5600 // this is not supposed to happen
5601 wxLogLastError(wxT("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5603 // the default is 3, so use it if SystemParametersInfo() failed
5604 s_linesPerRotation
= 3;
5608 event
.m_linesPerAction
= s_linesPerRotation
;
5609 return HandleWindowEvent(event
);
5611 #else // !wxUSE_MOUSEWHEEL
5612 wxUnusedVar(wParam
);
5613 wxUnusedVar(lParam
);
5616 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5619 void wxWindowMSW::GenerateMouseLeave()
5621 m_mouseInWindow
= false;
5624 if ( wxIsShiftDown() )
5626 if ( wxIsCtrlDown() )
5627 state
|= MK_CONTROL
;
5629 // Only the high-order bit should be tested
5630 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5631 state
|= MK_LBUTTON
;
5632 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5633 state
|= MK_MBUTTON
;
5634 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5635 state
|= MK_RBUTTON
;
5639 if ( !::GetCursorPosWinCE(&pt
) )
5641 if ( !::GetCursorPos(&pt
) )
5644 wxLogLastError(wxT("GetCursorPos"));
5647 // we need to have client coordinates here for symmetry with
5648 // wxEVT_ENTER_WINDOW
5649 RECT rect
= wxGetWindowRect(GetHwnd());
5653 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5654 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5656 (void)HandleWindowEvent(event
);
5659 // ---------------------------------------------------------------------------
5660 // keyboard handling
5661 // ---------------------------------------------------------------------------
5666 // Implementation of InitAnyKeyEvent() which can also be used when there is no
5667 // associated window: this can happen for the wxEVT_CHAR_HOOK events created by
5668 // the global keyboard hook (e.g. the event might have happened in a non-wx
5671 MSWInitAnyKeyEvent(wxKeyEvent
& event
,
5674 const wxWindowBase
*win
/* may be NULL */)
5678 event
.SetId(win
->GetId());
5679 event
.SetEventObject(const_cast<wxWindowBase
*>(win
));
5681 else // No associated window.
5683 // Use wxID_ANY for compatibility with the old code even if wxID_NONE
5684 // would arguably make more sense.
5685 event
.SetId(wxID_ANY
);
5688 event
.m_shiftDown
= wxIsShiftDown();
5689 event
.m_controlDown
= wxIsCtrlDown();
5690 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5692 event
.m_rawCode
= (wxUint32
) wParam
;
5693 event
.m_rawFlags
= (wxUint32
) lParam
;
5695 event
.SetTimestamp(::GetMessageTime());
5698 // Event coordinates must be in window client coordinates system which
5699 // doesn't make sense if there is no window.
5701 // We could use screen coordinates for such events but this would make the
5702 // logic of the event handlers more complicated: you'd need to test for the
5703 // event object and interpret the coordinates differently according to
5704 // whether it's NULL or not so unless somebody really asks for this let's
5705 // just avoid the issue.
5708 const wxPoint mousePos
= win
->ScreenToClient(wxGetMousePosition());
5709 event
.m_x
= mousePos
.x
;
5710 event
.m_y
= mousePos
.y
;
5714 } // anonymous namespace
5717 wxWindowMSW::InitAnyKeyEvent(wxKeyEvent
& event
,
5719 WXLPARAM lParam
) const
5721 MSWInitAnyKeyEvent(event
, wParam
, lParam
, this);
5725 wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5727 WXLPARAM lParam
) const
5729 // Catch any attempts to use this with WM_CHAR, it wouldn't work because
5730 // wParam is supposed to be a virtual key and not a character here.
5731 wxASSERT_MSG( evType
!= wxEVT_CHAR
&& evType
!= wxEVT_CHAR_HOOK
,
5732 "CreateKeyEvent() can't be used for char events" );
5734 wxKeyEvent
event(evType
);
5735 InitAnyKeyEvent(event
, wParam
, lParam
);
5737 event
.m_keyCode
= wxMSWKeyboard::VKToWX
5743 #endif // wxUSE_UNICODE
5750 wxWindowMSW::CreateCharEvent(wxEventType evType
,
5752 WXLPARAM lParam
) const
5754 wxKeyEvent
event(evType
);
5755 InitAnyKeyEvent(event
, wParam
, lParam
);
5758 // TODO: wParam uses UTF-16 so this is incorrect for characters outside of
5759 // the BMP, we should use WM_UNICHAR to handle them.
5760 event
.m_uniChar
= wParam
;
5761 #endif // wxUSE_UNICODE
5763 // Set non-Unicode key code too for compatibility if possible.
5764 if ( wParam
< 0x80 )
5766 // It's an ASCII character, no need to translate it.
5767 event
.m_keyCode
= wParam
;
5771 // Check if this key can be represented (as a single character) in the
5773 const wchar_t wc
= wParam
;
5775 if ( wxConvLibc
.FromWChar(&ch
, 1, &wc
, 1) != wxCONV_FAILED
)
5777 // For compatibility continue to provide the key code in this field
5778 // even though using GetUnicodeKey() is recommended now.
5779 event
.m_keyCode
= static_cast<unsigned char>(ch
);
5781 //else: Key can't be represented in the current locale, leave m_keyCode
5782 // as WXK_NONE and use GetUnicodeKey() to access the character.
5785 // the alphanumeric keys produced by pressing AltGr+something on European
5786 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5787 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5788 // alphanumeric, so pretend that there are no modifiers at all (the
5789 // KEY_DOWN event would still have the correct modifiers if they're really
5791 if ( event
.m_controlDown
&& event
.m_altDown
&&
5792 (event
.m_keyCode
>= 32 && event
.m_keyCode
< 256) )
5794 event
.m_controlDown
=
5795 event
.m_altDown
= false;
5801 // isASCII is true only when we're called from WM_CHAR handler and not from
5803 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
)
5805 wxKeyEvent
event(CreateCharEvent(wxEVT_CHAR
, wParam
, lParam
));
5806 return HandleWindowEvent(event
);
5809 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5811 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, wParam
, lParam
));
5812 return HandleWindowEvent(event
);
5815 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5817 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, wParam
, lParam
));
5818 return HandleWindowEvent(event
);
5822 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5823 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5825 // FIXME: implement GetMenuItemCount for WinCE, possibly
5826 // in terms of GetMenuItemInfo
5828 const HMENU hmenu
= (HMENU
)lParam
;
5832 mii
.cbSize
= sizeof(MENUITEMINFO
);
5834 // we could use MIIM_FTYPE here as we only need to know if the item is
5835 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5836 // MIIM_FTYPE is not supported under Win95
5837 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5839 // find if we have this letter in any owner drawn item
5840 const int count
= ::GetMenuItemCount(hmenu
);
5841 for ( int i
= 0; i
< count
; i
++ )
5843 // previous loop iteration could modify it, reset it back before
5844 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5847 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5849 if ( mii
.fType
== MFT_OWNERDRAW
)
5851 // dwItemData member of the MENUITEMINFO is a
5852 // pointer to the associated wxMenuItem -- see the
5853 // menu creation code
5854 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5856 const wxString
label(item
->GetItemLabel());
5857 const wxChar
*p
= wxStrchr(label
.wx_str(), wxT('&'));
5860 if ( *p
== wxT('&') )
5862 // this is not the accel char, find the real one
5863 p
= wxStrchr(p
+ 1, wxT('&'));
5865 else // got the accel char
5867 // FIXME-UNICODE: this comparison doesn't risk to work
5868 // for non ASCII accelerator characters I'm afraid, but
5870 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5876 // this one doesn't match
5883 else // failed to get the menu text?
5885 // it's not fatal, so don't show error, but still log it
5886 wxLogLastError(wxT("GetMenuItemInfo"));
5893 #endif // wxUSE_MENUS
5895 bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg
)
5897 const wxEventType type
= nMsg
== WM_CUT
? wxEVT_COMMAND_TEXT_CUT
5898 : nMsg
== WM_COPY
? wxEVT_COMMAND_TEXT_COPY
5899 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE
;
5900 wxClipboardTextEvent
evt(type
, GetId());
5902 evt
.SetEventObject(this);
5904 return HandleWindowEvent(evt
);
5907 // ---------------------------------------------------------------------------
5909 // ---------------------------------------------------------------------------
5911 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5915 if ( flags
& JOY_BUTTON1CHG
)
5916 change
= wxJOY_BUTTON1
;
5917 if ( flags
& JOY_BUTTON2CHG
)
5918 change
= wxJOY_BUTTON2
;
5919 if ( flags
& JOY_BUTTON3CHG
)
5920 change
= wxJOY_BUTTON3
;
5921 if ( flags
& JOY_BUTTON4CHG
)
5922 change
= wxJOY_BUTTON4
;
5925 if ( flags
& JOY_BUTTON1
)
5926 buttons
|= wxJOY_BUTTON1
;
5927 if ( flags
& JOY_BUTTON2
)
5928 buttons
|= wxJOY_BUTTON2
;
5929 if ( flags
& JOY_BUTTON3
)
5930 buttons
|= wxJOY_BUTTON3
;
5931 if ( flags
& JOY_BUTTON4
)
5932 buttons
|= wxJOY_BUTTON4
;
5934 // the event ids aren't consecutive so we can't use table based lookup
5936 wxEventType eventType
;
5941 eventType
= wxEVT_JOY_MOVE
;
5946 eventType
= wxEVT_JOY_MOVE
;
5951 eventType
= wxEVT_JOY_ZMOVE
;
5956 eventType
= wxEVT_JOY_ZMOVE
;
5959 case MM_JOY1BUTTONDOWN
:
5961 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5964 case MM_JOY2BUTTONDOWN
:
5966 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5969 case MM_JOY1BUTTONUP
:
5971 eventType
= wxEVT_JOY_BUTTON_UP
;
5974 case MM_JOY2BUTTONUP
:
5976 eventType
= wxEVT_JOY_BUTTON_UP
;
5980 wxFAIL_MSG(wxT("no such joystick event"));
5985 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5986 event
.SetPosition(wxPoint(x
, y
));
5987 event
.SetEventObject(this);
5989 return HandleWindowEvent(event
);
5999 // ---------------------------------------------------------------------------
6001 // ---------------------------------------------------------------------------
6003 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
6004 WXWORD pos
, WXHWND control
)
6006 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
6008 wxWindow
*child
= wxFindWinFromHandle(control
);
6010 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
6013 wxScrollWinEvent event
;
6014 event
.SetPosition(pos
);
6015 event
.SetOrientation(orientation
);
6016 event
.SetEventObject(this);
6021 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
6025 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
6029 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
6033 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
6037 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
6041 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
6044 case SB_THUMBPOSITION
:
6046 // under Win32, the scrollbar range and position are 32 bit integers,
6047 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
6048 // explicitly query the scrollbar for the correct position (this must
6049 // be done only for these two SB_ events as they are the only one
6050 // carrying the scrollbar position)
6052 WinStruct
<SCROLLINFO
> scrollInfo
;
6053 scrollInfo
.fMask
= SIF_TRACKPOS
;
6055 if ( !::GetScrollInfo(GetHwnd(),
6056 WXOrientToSB(orientation
),
6059 // Not necessarily an error, if there are no scrollbars yet.
6060 // wxLogLastError(wxT("GetScrollInfo"));
6063 event
.SetPosition(scrollInfo
.nTrackPos
);
6066 event
.SetEventType( wParam
== SB_THUMBPOSITION
6067 ? wxEVT_SCROLLWIN_THUMBRELEASE
6068 : wxEVT_SCROLLWIN_THUMBTRACK
);
6075 return HandleWindowEvent(event
);
6078 // ----------------------------------------------------------------------------
6079 // custom message handlers
6080 // ----------------------------------------------------------------------------
6083 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
6085 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
6086 false, wxT("registering handler for the same message twice") );
6088 gs_messageHandlers
[msg
] = handler
;
6093 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
6095 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
6096 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
6097 wxT("unregistering non-registered handler?") );
6099 gs_messageHandlers
.erase(i
);
6102 // ===========================================================================
6104 // ===========================================================================
6106 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
6109 HDC dc
= ::GetDC((HWND
) wnd
);
6112 // the_font.UseResource();
6113 // the_font.RealizeResource();
6114 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
6116 was
= (HFONT
) SelectObject(dc
,fnt
);
6118 GetTextMetrics(dc
, &tm
);
6121 SelectObject(dc
,was
);
6123 ReleaseDC((HWND
)wnd
, dc
);
6126 *x
= tm
.tmAveCharWidth
;
6128 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
6130 // the_font.ReleaseResource();
6133 // ----------------------------------------------------------------------------
6135 // ----------------------------------------------------------------------------
6137 namespace wxMSWKeyboard
6143 // use the "extended" bit of lParam to distinguish extended keys from normal
6144 // keys as the same virtual key code is sent for both by Windows
6146 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
6148 // except that if lParam is 0, it means we don't have real lParam from
6149 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
6150 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
6151 // non-numpad (hence extended) key as this is a more common case
6152 return !lParam
|| (HIWORD(lParam
) & KF_EXTENDED
) ? keyExtended
: keyNormal
;
6155 // this array contains the Windows virtual key codes which map one to one to
6156 // WXK_xxx constants and is used in wxMSWKeyboard::VKToWX/WXToVK() below
6158 // note that keys having a normal and numpad version (e.g. WXK_HOME and
6159 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
6160 const struct wxKeyMapping
6164 } gs_specialKeys
[] =
6166 { VK_CANCEL
, WXK_CANCEL
},
6167 { VK_BACK
, WXK_BACK
},
6168 { VK_TAB
, WXK_TAB
},
6169 { VK_CLEAR
, WXK_CLEAR
},
6170 { VK_SHIFT
, WXK_SHIFT
},
6171 { VK_CONTROL
, WXK_CONTROL
},
6172 { VK_MENU
, WXK_ALT
},
6173 { VK_PAUSE
, WXK_PAUSE
},
6174 { VK_CAPITAL
, WXK_CAPITAL
},
6175 { VK_SPACE
, WXK_SPACE
},
6176 { VK_ESCAPE
, WXK_ESCAPE
},
6177 { VK_SELECT
, WXK_SELECT
},
6178 { VK_PRINT
, WXK_PRINT
},
6179 { VK_EXECUTE
, WXK_EXECUTE
},
6180 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
6181 { VK_HELP
, WXK_HELP
},
6183 { VK_NUMPAD0
, WXK_NUMPAD0
},
6184 { VK_NUMPAD1
, WXK_NUMPAD1
},
6185 { VK_NUMPAD2
, WXK_NUMPAD2
},
6186 { VK_NUMPAD3
, WXK_NUMPAD3
},
6187 { VK_NUMPAD4
, WXK_NUMPAD4
},
6188 { VK_NUMPAD5
, WXK_NUMPAD5
},
6189 { VK_NUMPAD6
, WXK_NUMPAD6
},
6190 { VK_NUMPAD7
, WXK_NUMPAD7
},
6191 { VK_NUMPAD8
, WXK_NUMPAD8
},
6192 { VK_NUMPAD9
, WXK_NUMPAD9
},
6193 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
6194 { VK_ADD
, WXK_NUMPAD_ADD
},
6195 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
6196 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
6197 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
6208 { VK_F10
, WXK_F10
},
6209 { VK_F11
, WXK_F11
},
6210 { VK_F12
, WXK_F12
},
6211 { VK_F13
, WXK_F13
},
6212 { VK_F14
, WXK_F14
},
6213 { VK_F15
, WXK_F15
},
6214 { VK_F16
, WXK_F16
},
6215 { VK_F17
, WXK_F17
},
6216 { VK_F18
, WXK_F18
},
6217 { VK_F19
, WXK_F19
},
6218 { VK_F20
, WXK_F20
},
6219 { VK_F21
, WXK_F21
},
6220 { VK_F22
, WXK_F22
},
6221 { VK_F23
, WXK_F23
},
6222 { VK_F24
, WXK_F24
},
6224 { VK_NUMLOCK
, WXK_NUMLOCK
},
6225 { VK_SCROLL
, WXK_SCROLL
},
6228 { VK_LWIN
, WXK_WINDOWS_LEFT
},
6229 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
6230 { VK_APPS
, WXK_WINDOWS_MENU
},
6231 #endif // VK_APPS defined
6234 } // anonymous namespace
6236 int VKToWX(WXWORD vk
, WXLPARAM lParam
, wchar_t *uc
)
6240 // check the table first
6241 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6243 if ( gs_specialKeys
[n
].vk
== vk
)
6245 wxk
= gs_specialKeys
[n
].wxk
;
6246 if ( wxk
< WXK_START
)
6248 // Unicode code for this key is the same as its ASCII code.
6257 // keys requiring special handling
6271 // MapVirtualKey() returns 0 if it fails to convert the virtual
6272 // key which nicely corresponds to our WXK_NONE.
6273 wxk
= ::MapVirtualKey(vk
, MAPVK_VK_TO_CHAR
);
6275 if ( HIWORD(wxk
) & 0x8000 )
6277 // It's a dead key and we don't return anything at all for them
6278 // as we simply don't have any way to indicate the difference
6279 // between e.g. a normal "'" and "'" as a dead key -- and
6280 // generating the same events for them just doesn't seem like a
6285 // In any case return this as a Unicode character value.
6289 // For compatibility with the old non-Unicode code we continue
6290 // returning key codes for Latin-1 characters directly
6291 // (normally it would really only make sense to do it for the
6292 // ASCII characters, not Latin-1 ones).
6295 // But for anything beyond this we can only return the key
6296 // value as a real Unicode character, not a wxKeyCode
6297 // because this enum values clash with Unicode characters
6298 // (e.g. WXK_LBUTTON also happens to be U+012C a.k.a.
6299 // "LATIN CAPITAL LETTER I WITH BREVE").
6304 // handle extended keys
6306 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
6310 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
6314 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6318 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6322 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6326 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6330 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6334 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6338 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6342 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6346 // don't use ChooseNormalOrExtended() here as the keys are reversed
6347 // here: numpad enter is the extended one
6348 wxk
= HIWORD(lParam
) & KF_EXTENDED
? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6352 if ( (vk
>= '0' && vk
<= '9') || (vk
>= 'A' && vk
<= 'Z') )
6354 // A simple alphanumeric key and the values of them coincide in
6355 // Windows and wx for both ASCII and Unicode codes.
6358 else // Something we simply don't know about at all.
6370 WXWORD
WXToVK(int wxk
, bool *isExtended
)
6372 // check the table first
6373 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6375 if ( gs_specialKeys
[n
].wxk
== wxk
)
6377 // All extended keys (i.e. non-numpad versions of the keys that
6378 // exist both in the numpad and outside of it) are dealt with
6381 *isExtended
= false;
6383 return gs_specialKeys
[n
].vk
;
6387 // and then check for special keys not included in the table
6388 bool extended
= false;
6394 case WXK_NUMPAD_PAGEUP
:
6400 case WXK_NUMPAD_PAGEDOWN
:
6406 case WXK_NUMPAD_END
:
6412 case WXK_NUMPAD_HOME
:
6418 case WXK_NUMPAD_LEFT
:
6430 case WXK_NUMPAD_RIGHT
:
6436 case WXK_NUMPAD_DOWN
:
6442 case WXK_NUMPAD_INSERT
:
6448 case WXK_NUMPAD_DELETE
:
6453 // no VkKeyScan() under CE unfortunately, we need to test how does
6454 // it handle OEM keys
6456 // check to see if its one of the OEM key codes.
6457 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6463 #endif // !__WXWINCE__
6470 *isExtended
= extended
;
6475 } // namespace wxMSWKeyboard
6477 // small helper for wxGetKeyState() and wxGetMouseState()
6478 static inline bool wxIsKeyDown(WXWORD vk
)
6480 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6481 #ifdef SM_SWAPBUTTON
6482 if ( vk
== VK_LBUTTON
|| vk
== VK_RBUTTON
)
6484 if ( ::GetSystemMetrics(SM_SWAPBUTTON
) )
6486 if ( vk
== VK_LBUTTON
)
6488 else // vk == VK_RBUTTON
6492 #endif // SM_SWAPBUTTON
6494 // the low order bit indicates whether the key was pressed since the last
6495 // call and the high order one indicates whether it is down right now and
6496 // we only want that one
6497 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6500 bool wxGetKeyState(wxKeyCode key
)
6502 // although this does work under Windows, it is not supported under other
6503 // platforms so don't allow it, you must use wxGetMouseState() instead
6504 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6505 key
!= VK_RBUTTON
&&
6507 wxT("can't use wxGetKeyState() for mouse buttons") );
6509 const WXWORD vk
= wxMSWKeyboard::WXToVK(key
);
6511 // if the requested key is a LED key, return true if the led is pressed
6512 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6514 // low order bit means LED is highlighted and high order one means the
6515 // key is down; for compatibility with the other ports return true if
6516 // either one is set
6517 return GetKeyState(vk
) != 0;
6522 return wxIsKeyDown(vk
);
6527 wxMouseState
wxGetMouseState()
6531 GetCursorPos( &pt
);
6535 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6536 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6537 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6538 #ifdef wxHAS_XBUTTON
6539 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6540 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6541 #endif // wxHAS_XBUTTON
6543 ms
.SetControlDown(wxIsCtrlDown ());
6544 ms
.SetShiftDown (wxIsShiftDown());
6545 ms
.SetAltDown (wxIsAltDown ());
6546 // ms.SetMetaDown();
6552 wxWindow
*wxGetActiveWindow()
6554 HWND hWnd
= GetActiveWindow();
6557 return wxFindWinFromHandle(hWnd
);
6562 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6564 HWND hwnd
= (HWND
)hWnd
;
6566 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6567 // by code in msw/radiobox.cpp), for all the others we just search up the
6569 wxWindow
*win
= NULL
;
6572 win
= wxFindWinFromHandle(hwnd
);
6575 #if wxUSE_RADIOBOX && !defined(__WXUNIVERSAL__)
6576 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6577 // wxWindow class which overrides WM_GETDLGCODE processing to
6578 // do it as well, win would be already non NULL
6579 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6581 win
= wxRadioBox::GetFromRadioButtonHWND(hwnd
);
6583 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6584 #endif // wxUSE_RADIOBOX
6586 // spin control text buddy window should be mapped to spin ctrl
6587 // itself so try it too
6588 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6591 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6593 #endif // wxUSE_SPINCTRL
6597 while ( hwnd
&& !win
)
6599 // this is a really ugly hack needed to avoid mistakenly returning the
6600 // parent frame wxWindow for the find/replace modeless dialog HWND -
6601 // this, in turn, is needed to call IsDialogMessage() from
6602 // wxApp::ProcessMessage() as for this we must return NULL from here
6604 // FIXME: this is clearly not the best way to do it but I think we'll
6605 // need to change HWND <-> wxWindow code more heavily than I can
6606 // do it now to fix it
6607 #ifndef __WXMICROWIN__
6608 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6610 // it's a dialog box, don't go upwards
6615 hwnd
= ::GetParent(hwnd
);
6616 win
= wxFindWinFromHandle(hwnd
);
6622 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6624 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6625 // in active frames and dialogs, regardless of where the focus is.
6626 static HHOOK wxTheKeyboardHook
= 0;
6629 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6631 DWORD hiWord
= HIWORD(lParam
);
6632 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6635 int id
= wxMSWKeyboard::VKToWX(wParam
, lParam
, &uc
);
6637 // Don't intercept keyboard entry (notably Escape) if a modal window
6638 // (not managed by wx, e.g. IME one) is currently opened as more often
6639 // than not it needs all the keys for itself.
6641 // Also don't catch it if a window currently captures the mouse as
6642 // Escape is normally used to release the mouse capture and if you
6643 // really need to catch all the keys in the window that has mouse
6644 // capture it can be easily done in its own EVT_CHAR handler as it is
6645 // certain to have focus while it has the capture.
6646 if ( !gs_modalEntryWindowCount
&& !::GetCapture() )
6650 || static_cast<int>(uc
) != WXK_NONE
6651 #endif // wxUSE_UNICODE
6654 const wxWindow
* const win
= wxGetActiveWindow();
6656 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6657 MSWInitAnyKeyEvent(event
, wParam
, lParam
, win
);
6659 event
.m_keyCode
= id
;
6661 event
.m_uniChar
= uc
;
6662 #endif // wxUSE_UNICODE
6664 wxEvtHandler
* const handler
= win
? win
->GetEventHandler()
6667 if ( handler
&& handler
->ProcessEvent(event
) )
6676 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6679 void wxSetKeyboardHook(bool doIt
)
6683 wxTheKeyboardHook
= ::SetWindowsHookEx
6686 (HOOKPROC
)wxKeyboardHook
,
6687 NULL
, // must be NULL for process hook
6688 ::GetCurrentThreadId()
6690 if ( !wxTheKeyboardHook
)
6692 wxLogLastError(wxT("SetWindowsHookEx(wxKeyboardHook)"));
6697 if ( wxTheKeyboardHook
)
6698 ::UnhookWindowsHookEx(wxTheKeyboardHook
);
6702 #endif // !__WXMICROWIN__
6704 #if wxDEBUG_LEVEL >= 2
6705 const wxChar
*wxGetMessageName(int message
)
6709 case 0x0000: return wxT("WM_NULL");
6710 case 0x0001: return wxT("WM_CREATE");
6711 case 0x0002: return wxT("WM_DESTROY");
6712 case 0x0003: return wxT("WM_MOVE");
6713 case 0x0005: return wxT("WM_SIZE");
6714 case 0x0006: return wxT("WM_ACTIVATE");
6715 case 0x0007: return wxT("WM_SETFOCUS");
6716 case 0x0008: return wxT("WM_KILLFOCUS");
6717 case 0x000A: return wxT("WM_ENABLE");
6718 case 0x000B: return wxT("WM_SETREDRAW");
6719 case 0x000C: return wxT("WM_SETTEXT");
6720 case 0x000D: return wxT("WM_GETTEXT");
6721 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6722 case 0x000F: return wxT("WM_PAINT");
6723 case 0x0010: return wxT("WM_CLOSE");
6724 case 0x0011: return wxT("WM_QUERYENDSESSION");
6725 case 0x0012: return wxT("WM_QUIT");
6726 case 0x0013: return wxT("WM_QUERYOPEN");
6727 case 0x0014: return wxT("WM_ERASEBKGND");
6728 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6729 case 0x0016: return wxT("WM_ENDSESSION");
6730 case 0x0017: return wxT("WM_SYSTEMERROR");
6731 case 0x0018: return wxT("WM_SHOWWINDOW");
6732 case 0x0019: return wxT("WM_CTLCOLOR");
6733 case 0x001A: return wxT("WM_WININICHANGE");
6734 case 0x001B: return wxT("WM_DEVMODECHANGE");
6735 case 0x001C: return wxT("WM_ACTIVATEAPP");
6736 case 0x001D: return wxT("WM_FONTCHANGE");
6737 case 0x001E: return wxT("WM_TIMECHANGE");
6738 case 0x001F: return wxT("WM_CANCELMODE");
6739 case 0x0020: return wxT("WM_SETCURSOR");
6740 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6741 case 0x0022: return wxT("WM_CHILDACTIVATE");
6742 case 0x0023: return wxT("WM_QUEUESYNC");
6743 case 0x0024: return wxT("WM_GETMINMAXINFO");
6744 case 0x0026: return wxT("WM_PAINTICON");
6745 case 0x0027: return wxT("WM_ICONERASEBKGND");
6746 case 0x0028: return wxT("WM_NEXTDLGCTL");
6747 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6748 case 0x002B: return wxT("WM_DRAWITEM");
6749 case 0x002C: return wxT("WM_MEASUREITEM");
6750 case 0x002D: return wxT("WM_DELETEITEM");
6751 case 0x002E: return wxT("WM_VKEYTOITEM");
6752 case 0x002F: return wxT("WM_CHARTOITEM");
6753 case 0x0030: return wxT("WM_SETFONT");
6754 case 0x0031: return wxT("WM_GETFONT");
6755 case 0x0037: return wxT("WM_QUERYDRAGICON");
6756 case 0x0039: return wxT("WM_COMPAREITEM");
6757 case 0x0041: return wxT("WM_COMPACTING");
6758 case 0x0044: return wxT("WM_COMMNOTIFY");
6759 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6760 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6761 case 0x0048: return wxT("WM_POWER");
6763 case 0x004A: return wxT("WM_COPYDATA");
6764 case 0x004B: return wxT("WM_CANCELJOURNAL");
6765 case 0x004E: return wxT("WM_NOTIFY");
6766 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6767 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6768 case 0x0052: return wxT("WM_TCARD");
6769 case 0x0053: return wxT("WM_HELP");
6770 case 0x0054: return wxT("WM_USERCHANGED");
6771 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6772 case 0x007B: return wxT("WM_CONTEXTMENU");
6773 case 0x007C: return wxT("WM_STYLECHANGING");
6774 case 0x007D: return wxT("WM_STYLECHANGED");
6775 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6776 case 0x007F: return wxT("WM_GETICON");
6777 case 0x0080: return wxT("WM_SETICON");
6779 case 0x0081: return wxT("WM_NCCREATE");
6780 case 0x0082: return wxT("WM_NCDESTROY");
6781 case 0x0083: return wxT("WM_NCCALCSIZE");
6782 case 0x0084: return wxT("WM_NCHITTEST");
6783 case 0x0085: return wxT("WM_NCPAINT");
6784 case 0x0086: return wxT("WM_NCACTIVATE");
6785 case 0x0087: return wxT("WM_GETDLGCODE");
6786 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6787 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6788 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6789 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6790 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6791 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6792 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6793 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6794 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6795 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6797 case 0x00B0: return wxT("EM_GETSEL");
6798 case 0x00B1: return wxT("EM_SETSEL");
6799 case 0x00B2: return wxT("EM_GETRECT");
6800 case 0x00B3: return wxT("EM_SETRECT");
6801 case 0x00B4: return wxT("EM_SETRECTNP");
6802 case 0x00B5: return wxT("EM_SCROLL");
6803 case 0x00B6: return wxT("EM_LINESCROLL");
6804 case 0x00B7: return wxT("EM_SCROLLCARET");
6805 case 0x00B8: return wxT("EM_GETMODIFY");
6806 case 0x00B9: return wxT("EM_SETMODIFY");
6807 case 0x00BA: return wxT("EM_GETLINECOUNT");
6808 case 0x00BB: return wxT("EM_LINEINDEX");
6809 case 0x00BC: return wxT("EM_SETHANDLE");
6810 case 0x00BD: return wxT("EM_GETHANDLE");
6811 case 0x00BE: return wxT("EM_GETTHUMB");
6812 case 0x00C1: return wxT("EM_LINELENGTH");
6813 case 0x00C2: return wxT("EM_REPLACESEL");
6814 case 0x00C4: return wxT("EM_GETLINE");
6815 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6816 case 0x00C6: return wxT("EM_CANUNDO");
6817 case 0x00C7: return wxT("EM_UNDO");
6818 case 0x00C8: return wxT("EM_FMTLINES");
6819 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6820 case 0x00CB: return wxT("EM_SETTABSTOPS");
6821 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6822 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6823 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6824 case 0x00CF: return wxT("EM_SETREADONLY");
6825 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6826 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6827 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6828 case 0x00D3: return wxT("EM_SETMARGINS");
6829 case 0x00D4: return wxT("EM_GETMARGINS");
6830 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6831 case 0x00D6: return wxT("EM_POSFROMCHAR");
6832 case 0x00D7: return wxT("EM_CHARFROMPOS");
6833 case 0x00D8: return wxT("EM_SETIMESTATUS");
6834 case 0x00D9: return wxT("EM_GETIMESTATUS");
6836 case 0x0100: return wxT("WM_KEYDOWN");
6837 case 0x0101: return wxT("WM_KEYUP");
6838 case 0x0102: return wxT("WM_CHAR");
6839 case 0x0103: return wxT("WM_DEADCHAR");
6840 case 0x0104: return wxT("WM_SYSKEYDOWN");
6841 case 0x0105: return wxT("WM_SYSKEYUP");
6842 case 0x0106: return wxT("WM_SYSCHAR");
6843 case 0x0107: return wxT("WM_SYSDEADCHAR");
6844 case 0x0108: return wxT("WM_KEYLAST");
6846 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6847 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6848 case 0x010F: return wxT("WM_IME_COMPOSITION");
6850 case 0x0110: return wxT("WM_INITDIALOG");
6851 case 0x0111: return wxT("WM_COMMAND");
6852 case 0x0112: return wxT("WM_SYSCOMMAND");
6853 case 0x0113: return wxT("WM_TIMER");
6854 case 0x0114: return wxT("WM_HSCROLL");
6855 case 0x0115: return wxT("WM_VSCROLL");
6856 case 0x0116: return wxT("WM_INITMENU");
6857 case 0x0117: return wxT("WM_INITMENUPOPUP");
6858 case 0x011F: return wxT("WM_MENUSELECT");
6859 case 0x0120: return wxT("WM_MENUCHAR");
6860 case 0x0121: return wxT("WM_ENTERIDLE");
6862 case 0x0127: return wxT("WM_CHANGEUISTATE");
6863 case 0x0128: return wxT("WM_UPDATEUISTATE");
6864 case 0x0129: return wxT("WM_QUERYUISTATE");
6866 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6867 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6868 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6869 case 0x0135: return wxT("WM_CTLCOLORBTN");
6870 case 0x0136: return wxT("WM_CTLCOLORDLG");
6871 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6872 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6873 case 0x01E1: return wxT("MN_GETHMENU");
6875 case 0x0200: return wxT("WM_MOUSEMOVE");
6876 case 0x0201: return wxT("WM_LBUTTONDOWN");
6877 case 0x0202: return wxT("WM_LBUTTONUP");
6878 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6879 case 0x0204: return wxT("WM_RBUTTONDOWN");
6880 case 0x0205: return wxT("WM_RBUTTONUP");
6881 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6882 case 0x0207: return wxT("WM_MBUTTONDOWN");
6883 case 0x0208: return wxT("WM_MBUTTONUP");
6884 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6885 case 0x020A: return wxT("WM_MOUSEWHEEL");
6886 case 0x020B: return wxT("WM_XBUTTONDOWN");
6887 case 0x020C: return wxT("WM_XBUTTONUP");
6888 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6889 case 0x0210: return wxT("WM_PARENTNOTIFY");
6890 case 0x0211: return wxT("WM_ENTERMENULOOP");
6891 case 0x0212: return wxT("WM_EXITMENULOOP");
6893 case 0x0213: return wxT("WM_NEXTMENU");
6894 case 0x0214: return wxT("WM_SIZING");
6895 case 0x0215: return wxT("WM_CAPTURECHANGED");
6896 case 0x0216: return wxT("WM_MOVING");
6897 case 0x0218: return wxT("WM_POWERBROADCAST");
6898 case 0x0219: return wxT("WM_DEVICECHANGE");
6900 case 0x0220: return wxT("WM_MDICREATE");
6901 case 0x0221: return wxT("WM_MDIDESTROY");
6902 case 0x0222: return wxT("WM_MDIACTIVATE");
6903 case 0x0223: return wxT("WM_MDIRESTORE");
6904 case 0x0224: return wxT("WM_MDINEXT");
6905 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6906 case 0x0226: return wxT("WM_MDITILE");
6907 case 0x0227: return wxT("WM_MDICASCADE");
6908 case 0x0228: return wxT("WM_MDIICONARRANGE");
6909 case 0x0229: return wxT("WM_MDIGETACTIVE");
6910 case 0x0230: return wxT("WM_MDISETMENU");
6911 case 0x0233: return wxT("WM_DROPFILES");
6913 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6914 case 0x0282: return wxT("WM_IME_NOTIFY");
6915 case 0x0283: return wxT("WM_IME_CONTROL");
6916 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6917 case 0x0285: return wxT("WM_IME_SELECT");
6918 case 0x0286: return wxT("WM_IME_CHAR");
6919 case 0x0290: return wxT("WM_IME_KEYDOWN");
6920 case 0x0291: return wxT("WM_IME_KEYUP");
6922 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6923 case 0x02A1: return wxT("WM_MOUSEHOVER");
6924 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6925 case 0x02A3: return wxT("WM_MOUSELEAVE");
6927 case 0x0300: return wxT("WM_CUT");
6928 case 0x0301: return wxT("WM_COPY");
6929 case 0x0302: return wxT("WM_PASTE");
6930 case 0x0303: return wxT("WM_CLEAR");
6931 case 0x0304: return wxT("WM_UNDO");
6932 case 0x0305: return wxT("WM_RENDERFORMAT");
6933 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6934 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6935 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6936 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6937 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6938 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6939 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6940 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6941 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6942 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6943 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6944 case 0x0311: return wxT("WM_PALETTECHANGED");
6945 case 0x0312: return wxT("WM_HOTKEY");
6947 case 0x0317: return wxT("WM_PRINT");
6948 case 0x0318: return wxT("WM_PRINTCLIENT");
6950 // common controls messages - although they're not strictly speaking
6951 // standard, it's nice to decode them nevertheless
6954 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6955 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6956 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6957 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6958 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6959 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6960 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6961 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6962 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6963 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6964 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6965 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6966 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6967 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6968 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6969 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6970 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6971 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6972 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6973 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6974 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6975 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6976 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6977 case 0x1000 + 18: return wxT("LVM_HITTEST");
6978 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6979 case 0x1000 + 20: return wxT("LVM_SCROLL");
6980 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6981 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6982 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6983 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6984 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6985 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6986 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6987 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6988 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6989 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6990 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6991 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6992 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6993 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6994 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6995 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6996 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6997 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6998 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6999 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
7000 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
7001 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
7002 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
7003 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
7004 case 0x1000 + 42: return wxT("LVM_UPDATE");
7005 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
7006 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
7007 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
7008 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
7009 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
7010 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
7011 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
7012 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
7013 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
7014 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
7015 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
7016 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
7017 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
7018 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
7019 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
7020 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
7021 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
7022 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
7023 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
7024 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
7025 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
7026 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
7027 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
7028 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
7029 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
7030 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
7033 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
7034 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
7035 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
7036 case 0x1100 + 2: return wxT("TVM_EXPAND");
7037 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
7038 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
7039 case 0x1100 + 6: return wxT("TVM_GETINDENT");
7040 case 0x1100 + 7: return wxT("TVM_SETINDENT");
7041 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
7042 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
7043 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
7044 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
7045 case 0x1100 + 12: return wxT("TVM_GETITEMA");
7046 case 0x1100 + 62: return wxT("TVM_GETITEMW");
7047 case 0x1100 + 13: return wxT("TVM_SETITEMA");
7048 case 0x1100 + 63: return wxT("TVM_SETITEMW");
7049 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
7050 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
7051 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
7052 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
7053 case 0x1100 + 17: return wxT("TVM_HITTEST");
7054 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
7055 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
7056 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
7057 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
7058 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
7059 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
7060 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
7061 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
7062 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
7065 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
7066 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
7067 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
7068 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
7069 case 0x1200 + 3: return wxT("HDM_GETITEMA");
7070 case 0x1200 + 11: return wxT("HDM_GETITEMW");
7071 case 0x1200 + 4: return wxT("HDM_SETITEMA");
7072 case 0x1200 + 12: return wxT("HDM_SETITEMW");
7073 case 0x1200 + 5: return wxT("HDM_LAYOUT");
7074 case 0x1200 + 6: return wxT("HDM_HITTEST");
7075 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
7076 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
7077 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
7078 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
7079 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
7080 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
7081 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
7082 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
7085 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
7086 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
7087 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
7088 case 0x1300 + 5: return wxT("TCM_GETITEMA");
7089 case 0x1300 + 60: return wxT("TCM_GETITEMW");
7090 case 0x1300 + 6: return wxT("TCM_SETITEMA");
7091 case 0x1300 + 61: return wxT("TCM_SETITEMW");
7092 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
7093 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
7094 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
7095 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
7096 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
7097 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
7098 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
7099 case 0x1300 + 13: return wxT("TCM_HITTEST");
7100 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
7101 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
7102 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
7103 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
7104 case 0x1300 + 43: return wxT("TCM_SETPADDING");
7105 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
7106 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
7107 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
7108 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
7109 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
7110 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
7111 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
7114 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
7115 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
7116 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
7117 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
7118 case WM_USER
+5: return wxT("TB_INDETERMINATE");
7119 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
7120 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
7121 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
7122 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
7123 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
7124 case WM_USER
+17: return wxT("TB_SETSTATE");
7125 case WM_USER
+18: return wxT("TB_GETSTATE");
7126 case WM_USER
+19: return wxT("TB_ADDBITMAP");
7127 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
7128 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
7129 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
7130 case WM_USER
+23: return wxT("TB_GETBUTTON");
7131 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
7132 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
7133 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
7134 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
7135 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
7136 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
7137 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
7138 case WM_USER
+29: return wxT("TB_GETITEMRECT");
7139 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
7140 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
7141 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
7142 case WM_USER
+33: return wxT("TB_AUTOSIZE");
7143 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
7144 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
7145 case WM_USER
+37: return wxT("TB_SETPARENT");
7146 case WM_USER
+39: return wxT("TB_SETROWS");
7147 case WM_USER
+40: return wxT("TB_GETROWS");
7148 case WM_USER
+42: return wxT("TB_SETCMDID");
7149 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
7150 case WM_USER
+44: return wxT("TB_GETBITMAP");
7151 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
7152 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
7153 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
7154 case WM_USER
+47: return wxT("TB_SETINDENT");
7155 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
7156 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
7157 case WM_USER
+50: return wxT("TB_LOADIMAGES");
7158 case WM_USER
+51: return wxT("TB_GETRECT");
7159 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
7160 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
7161 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
7162 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
7163 case WM_USER
+56: return wxT("TB_SETSTYLE");
7164 case WM_USER
+57: return wxT("TB_GETSTYLE");
7165 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
7166 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
7167 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
7168 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
7169 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
7172 static wxString s_szBuf
;
7173 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
7174 return s_szBuf
.c_str();
7177 #endif // wxDEBUG_LEVEL >= 2
7179 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
7183 HWND hwnd
= GetHwndOf(win
);
7184 HDC hdc
= ::GetDC(hwnd
);
7186 #if !wxDIALOG_UNIT_COMPATIBILITY
7187 // and select the current font into it
7188 HFONT hfont
= GetHfontOf(win
->GetFont());
7191 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
7195 // finally retrieve the text metrics from it
7196 GetTextMetrics(hdc
, &tm
);
7198 #if !wxDIALOG_UNIT_COMPATIBILITY
7202 (void)::SelectObject(hdc
, hfont
);
7206 ::ReleaseDC(hwnd
, hdc
);
7211 // Find the wxWindow at the current mouse position, returning the mouse
7213 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
7215 pt
= wxGetMousePosition();
7216 return wxFindWindowAtPoint(pt
);
7219 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
7225 HWND hWnd
= ::WindowFromPoint(pt2
);
7227 return wxGetWindowFromHWND((WXHWND
)hWnd
);
7230 // Get the current mouse position.
7231 wxPoint
wxGetMousePosition()
7235 GetCursorPosWinCE(&pt
);
7237 GetCursorPos( & pt
);
7240 return wxPoint(pt
.x
, pt
.y
);
7245 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7246 static void WinCEUnregisterHotKey(int modifiers
, int id
)
7248 // Register hotkeys for the hardware buttons
7250 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
7252 UnregisterFunc1Proc procUnregisterFunc
;
7253 hCoreDll
= LoadLibrary(wxT("coredll.dll"));
7256 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, wxT("UnregisterFunc1"));
7257 if (procUnregisterFunc
)
7258 procUnregisterFunc(modifiers
, id
);
7259 FreeLibrary(hCoreDll
);
7264 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
7266 UINT win_modifiers
=0;
7267 if ( modifiers
& wxMOD_ALT
)
7268 win_modifiers
|= MOD_ALT
;
7269 if ( modifiers
& wxMOD_SHIFT
)
7270 win_modifiers
|= MOD_SHIFT
;
7271 if ( modifiers
& wxMOD_CONTROL
)
7272 win_modifiers
|= MOD_CONTROL
;
7273 if ( modifiers
& wxMOD_WIN
)
7274 win_modifiers
|= MOD_WIN
;
7276 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7277 // Required for PPC and Smartphone hardware buttons
7278 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
7279 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
7282 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
7284 wxLogLastError(wxT("RegisterHotKey"));
7292 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
7294 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7295 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
7298 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
7300 wxLogLastError(wxT("UnregisterHotKey"));
7310 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
7312 int win_modifiers
= LOWORD(lParam
);
7314 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, HIWORD(lParam
)));
7315 event
.SetId(wParam
);
7316 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
7317 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
7318 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
7319 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
7321 return HandleWindowEvent(event
);
7324 #endif // wxUSE_ACCEL
7326 #endif // wxUSE_HOTKEY
7328 // Not tested under WinCE
7331 // this class installs a message hook which really wakes up our idle processing
7332 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
7333 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
7334 // being dragged or even inside ::MessageBox()) and so don't control message
7335 // dispatching otherwise
7336 class wxIdleWakeUpModule
: public wxModule
7339 virtual bool OnInit()
7341 ms_hMsgHookProc
= ::SetWindowsHookEx
7344 &wxIdleWakeUpModule::MsgHookProc
,
7346 GetCurrentThreadId()
7349 if ( !ms_hMsgHookProc
)
7351 wxLogLastError(wxT("SetWindowsHookEx(WH_GETMESSAGE)"));
7359 virtual void OnExit()
7361 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
7364 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
7366 MSG
*msg
= (MSG
*)lParam
;
7368 // only process the message if it is actually going to be removed from
7369 // the message queue, this prevents that the same event from being
7370 // processed multiple times if now someone just called PeekMessage()
7371 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7373 wxTheApp
->ProcessPendingEvents();
7376 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7380 static HHOOK ms_hMsgHookProc
;
7382 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7385 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7387 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7389 #endif // __WXWINCE__
7394 static void wxAdjustZOrder(wxWindow
* parent
)
7396 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7398 // Set the z-order correctly
7399 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7402 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7405 wxWindow
*childWin
= current
->GetData();
7406 wxAdjustZOrder(childWin
);
7407 current
= current
->GetNext();
7412 // We need to adjust the z-order of static boxes in WinCE, to
7413 // make 'contained' controls visible
7414 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7417 wxAdjustZOrder(this);