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"
84 #include "wx/private/textmeasure.h"
87 #include "wx/tooltip.h"
95 #include "wx/radiobox.h"
96 #endif // wxUSE_RADIOBOX
99 #include "wx/spinctrl.h"
100 #endif // wxUSE_SPINCTRL
102 #include "wx/notebook.h"
103 #include "wx/listctrl.h"
104 #include "wx/dynlib.h"
108 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
109 #include <shellapi.h>
110 #include <mmsystem.h>
114 #include <windowsx.h>
117 #if defined(__WXWINCE__)
118 #include "wx/msw/wince/missing.h"
121 #include <shellapi.h>
123 #include <aygshell.h>
128 #include "wx/msw/uxtheme.h"
129 #define EP_EDITTEXT 1
132 #define ETS_SELECTED 3
133 #define ETS_DISABLED 4
134 #define ETS_FOCUSED 5
135 #define ETS_READONLY 6
139 // define the constants used by AnimateWindow() if our SDK doesn't have them
141 #define AW_HOR_POSITIVE 0x00000001
142 #define AW_HOR_NEGATIVE 0x00000002
143 #define AW_VER_POSITIVE 0x00000004
144 #define AW_VER_NEGATIVE 0x00000008
145 #define AW_CENTER 0x00000010
146 #define AW_HIDE 0x00010000
147 #define AW_ACTIVATE 0x00020000
148 #define AW_SLIDE 0x00040000
149 #define AW_BLEND 0x00080000
152 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
153 #define HAVE_TRACKMOUSEEVENT
154 #endif // everything needed for TrackMouseEvent()
156 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
157 // when mouse position didnd't change
159 #define wxUSE_MOUSEEVENT_HACK 0
161 #define wxUSE_MOUSEEVENT_HACK 1
164 // not all compilers/platforms have X button related declarations (notably
165 // Windows CE doesn't, and probably some old SDKs don't neither)
166 #ifdef WM_XBUTTONDOWN
167 #define wxHAS_XBUTTON
170 #ifndef MAPVK_VK_TO_CHAR
171 #define MAPVK_VK_TO_CHAR 2
174 // ---------------------------------------------------------------------------
176 // ---------------------------------------------------------------------------
178 #if wxUSE_MENUS_NATIVE
179 extern wxMenu
*wxCurrentPopupMenu
;
183 // This is a hack used by the owner-drawn wxButton implementation to ensure
184 // that the brush used for erasing its background is correctly aligned with the
186 wxWindowMSW
*wxWindowBeingErased
= NULL
;
187 #endif // wxUSE_UXTHEME
192 // true if we had already created the std colour map, used by
193 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
194 bool gs_hasStdCmap
= false;
196 // last mouse event information we need to filter out the duplicates
197 #if wxUSE_MOUSEEVENT_HACK
198 struct MouseEventInfoDummy
200 // mouse position (in screen coordinates)
203 // last mouse event type
206 #endif // wxUSE_MOUSEEVENT_HACK
208 // hash containing the registered handlers for the custom messages
209 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
210 wxIntegerHash
, wxIntegerEqual
,
213 MSWMessageHandlers gs_messageHandlers
;
215 // hash containing all our windows, it uses HWND keys and wxWindow* values
216 WX_DECLARE_HASH_MAP(HWND
, wxWindow
*,
217 wxPointerHash
, wxPointerEqual
,
220 WindowHandles gs_windowHandles
;
222 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
224 // temporary override for WM_ERASEBKGND processing: we don't store this in
225 // wxWindow itself as we don't need it during most of the time so don't
226 // increase the size of all window objects unnecessarily
227 WX_DECLARE_HASH_MAP(wxWindow
*, wxWindow
*,
228 wxPointerHash
, wxPointerEqual
,
231 EraseBgHooks gs_eraseBgHooks
;
233 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
235 // If this variable is strictly positive, EVT_CHAR_HOOK is not generated for
236 // Escape key presses as it can't be intercepted because it's needed by some
237 // currently shown window, e.g. IME entry.
239 // This is currently global as we allow using UI from the main thread only
240 // anyhow but could be replaced with a thread-specific value in the future if
242 int gs_modalEntryWindowCount
= 0;
244 } // anonymous namespace
246 // ---------------------------------------------------------------------------
248 // ---------------------------------------------------------------------------
250 // the window proc for all our windows
251 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
252 WPARAM wParam
, LPARAM lParam
);
255 #if wxDEBUG_LEVEL >= 2
256 const wxChar
*wxGetMessageName(int message
);
257 #endif // wxDEBUG_LEVEL >= 2
259 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
260 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
262 // get the text metrics for the current font
263 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
266 // find the window for the mouse event at the specified position
267 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
268 #endif // __WXWINCE__
270 // wrapper around BringWindowToTop() API
271 static inline void wxBringWindowToTop(HWND hwnd
)
273 #ifdef __WXMICROWIN__
274 // It seems that MicroWindows brings the _parent_ of the window to the top,
275 // which can be the wrong one.
277 // activate (set focus to) specified window
281 // raise top level parent to top of z order
282 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
284 wxLogLastError(wxT("SetWindowPos"));
290 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
291 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
294 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
295 parent as well as otherwise several Win32 functions using
296 GetNextDlgTabItem() to iterate over all controls such as
297 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
298 all of them iterate over all the controls starting from the currently
299 focused one and stop iterating when they get back to the focus but
300 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
301 get back to the initial (focused) window: as we do have this style,
302 GetNextDlgTabItem() will leave this window and continue in its parent,
303 but if the parent doesn't have it, it wouldn't recurse inside it later
304 on and so wouldn't have a chance of getting back to this window either.
306 while ( parent
&& !parent
->IsTopLevel() )
308 LONG exStyle
= wxGetWindowExStyle(parent
);
309 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
311 // force the parent to have this style
312 wxSetWindowExStyle(parent
, exStyle
| WS_EX_CONTROLPARENT
);
315 parent
= parent
->GetParent();
319 #endif // !__WXWINCE__
321 // GetCursorPos can return an error, so use this function
323 // Error originally observed with WinCE, but later using Remote Desktop
325 void wxGetCursorPosMSW(POINT
* pt
)
327 if (!GetCursorPos(pt
))
330 wxLogLastError(wxT("GetCursorPos"));
332 DWORD pos
= GetMessagePos();
333 // the coordinates may be negative in multi-monitor systems
334 pt
->x
= GET_X_LPARAM(pos
);
335 pt
->y
= GET_Y_LPARAM(pos
);
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 || wxDynamicCast(parent
, 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 wxUSE_DYNLIB_CLASS
675 if ( effect
== wxSHOW_EFFECT_NONE
)
678 if ( !wxWindowBase::Show(show
) )
681 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
683 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
684 static bool s_initDone
= false;
687 wxDynamicLibrary
dllUser32(wxT("user32.dll"), wxDL_VERBATIM
| wxDL_QUIET
);
688 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
692 // notice that it's ok to unload user32.dll here as it won't be really
693 // unloaded, being still in use because we link to it statically too
696 if ( !s_pfnAnimateWindow
)
699 // Show() has a side effect of sending a WM_SIZE to the window, which helps
700 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
701 // this so send the event ourselves
704 // prepare to use AnimateWindow()
707 timeout
= 200; // this is the default animation timeout, per MSDN
709 DWORD dwFlags
= show
? 0 : AW_HIDE
;
713 case wxSHOW_EFFECT_ROLL_TO_LEFT
:
714 dwFlags
|= AW_HOR_NEGATIVE
;
717 case wxSHOW_EFFECT_ROLL_TO_RIGHT
:
718 dwFlags
|= AW_HOR_POSITIVE
;
721 case wxSHOW_EFFECT_ROLL_TO_TOP
:
722 dwFlags
|= AW_VER_NEGATIVE
;
725 case wxSHOW_EFFECT_ROLL_TO_BOTTOM
:
726 dwFlags
|= AW_VER_POSITIVE
;
729 case wxSHOW_EFFECT_SLIDE_TO_LEFT
:
730 dwFlags
|= AW_SLIDE
| AW_HOR_NEGATIVE
;
733 case wxSHOW_EFFECT_SLIDE_TO_RIGHT
:
734 dwFlags
|= AW_SLIDE
| AW_HOR_POSITIVE
;
737 case wxSHOW_EFFECT_SLIDE_TO_TOP
:
738 dwFlags
|= AW_SLIDE
| AW_VER_NEGATIVE
;
741 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM
:
742 dwFlags
|= AW_SLIDE
| AW_VER_POSITIVE
;
745 case wxSHOW_EFFECT_BLEND
:
749 case wxSHOW_EFFECT_EXPAND
:
750 dwFlags
|= AW_CENTER
;
754 case wxSHOW_EFFECT_MAX
:
755 wxFAIL_MSG( wxT("invalid window show effect") );
759 wxFAIL_MSG( wxT("unknown window show effect") );
763 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
765 wxLogLastError(wxT("AnimateWindow"));
771 #else // wxUSE_DYNLIB_CLASS
776 // Raise the window to the top of the Z order
777 void wxWindowMSW::Raise()
779 wxBringWindowToTop(GetHwnd());
782 // Lower the window to the bottom of the Z order
783 void wxWindowMSW::Lower()
785 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
786 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
789 void wxWindowMSW::DoCaptureMouse()
791 HWND hWnd
= GetHwnd();
798 void wxWindowMSW::DoReleaseMouse()
800 if ( !::ReleaseCapture() )
802 wxLogLastError(wxT("ReleaseCapture"));
806 /* static */ wxWindow
*wxWindowBase::GetCapture()
808 HWND hwnd
= ::GetCapture();
809 return hwnd
? wxFindWinFromHandle(hwnd
) : NULL
;
812 bool wxWindowMSW::SetFont(const wxFont
& font
)
814 if ( !wxWindowBase::SetFont(font
) )
820 HWND hWnd
= GetHwnd();
823 // note the use of GetFont() instead of m_font: our own font could have
824 // just been reset and in this case we need to change the font used by
825 // the native window to the default for this class, i.e. exactly what
827 WXHANDLE hFont
= GetFont().GetResourceHandle();
829 wxASSERT_MSG( hFont
, wxT("should have valid font") );
831 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
837 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
839 if ( !wxWindowBase::SetCursor(cursor
) )
845 // don't "overwrite" busy cursor
849 if ( m_cursor
.IsOk() )
851 // normally we should change the cursor only if it's over this window
852 // but we should do it always if we capture the mouse currently
853 bool set
= HasCapture();
856 HWND hWnd
= GetHwnd();
859 ::wxGetCursorPosMSW(&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 wxGetCursorPosMSW(&pt
);
880 const wxWindowMSW
* win
= wxFindWindowAtPoint(wxPoint(pt
.x
, pt
.y
));
884 ::SendMessage(GetHwndOf(win
), WM_SETCURSOR
,
885 (WPARAM
)GetHwndOf(win
),
886 MAKELPARAM(HTCLIENT
, WM_MOUSEMOVE
));
892 void wxWindowMSW::WarpPointer(int x
, int y
)
894 ClientToScreen(&x
, &y
);
896 if ( !::SetCursorPos(x
, y
) )
898 wxLogLastError(wxT("SetCursorPos"));
902 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
904 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
905 // to use it on older systems -- and could possibly do some harm
906 static int s_needToUpdate
= -1;
907 if ( s_needToUpdate
== -1 )
910 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
914 if ( s_needToUpdate
)
916 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
917 // won't send WM_UPDATEUISTATE
918 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
922 // ---------------------------------------------------------------------------
924 // ---------------------------------------------------------------------------
929 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
931 #ifdef __WXMICROWIN__
932 return ::GetScrollPosWX(hWnd
, wOrient
);
934 WinStruct
<SCROLLINFO
> scrollInfo
;
935 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
936 scrollInfo
.fMask
= SIF_POS
;
937 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
939 return scrollInfo
.nPos
;
944 inline UINT
WXOrientToSB(int orient
)
946 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
949 } // anonymous namespace
951 int wxWindowMSW::GetScrollPos(int orient
) const
953 HWND hWnd
= GetHwnd();
954 wxCHECK_MSG( hWnd
, 0, wxT("no HWND in GetScrollPos") );
956 return GetScrollPosition(hWnd
, WXOrientToSB(orient
));
959 // This now returns the whole range, not just the number
960 // of positions that we can scroll.
961 int wxWindowMSW::GetScrollRange(int orient
) const
964 HWND hWnd
= GetHwnd();
967 WinStruct
<SCROLLINFO
> scrollInfo
;
968 scrollInfo
.fMask
= SIF_RANGE
;
969 if ( !::GetScrollInfo(hWnd
, WXOrientToSB(orient
), &scrollInfo
) )
971 // Most of the time this is not really an error, since the return
972 // value can also be zero when there is no scrollbar yet.
973 // wxLogLastError(wxT("GetScrollInfo"));
975 maxPos
= scrollInfo
.nMax
;
977 // undo "range - 1" done in SetScrollbar()
981 int wxWindowMSW::GetScrollThumb(int orient
) const
983 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
986 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
988 HWND hWnd
= GetHwnd();
989 wxCHECK_RET( hWnd
, wxT("SetScrollPos: no HWND") );
991 WinStruct
<SCROLLINFO
> info
;
995 info
.fMask
= SIF_POS
;
996 if ( HasFlag(wxALWAYS_SHOW_SB
) )
998 // disable scrollbar instead of removing it then
999 info
.fMask
|= SIF_DISABLENOSCROLL
;
1002 ::SetScrollInfo(hWnd
, WXOrientToSB(orient
), &info
, refresh
);
1005 // New function that will replace some of the above.
1006 void wxWindowMSW::SetScrollbar(int orient
,
1012 // We have to set the variables here to make them valid in events
1013 // triggered by ::SetScrollInfo()
1014 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1016 HWND hwnd
= GetHwnd();
1020 WinStruct
<SCROLLINFO
> info
;
1023 info
.nPage
= pageSize
;
1024 info
.nMin
= 0; // range is nMax - nMin + 1
1025 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1028 // We normally also reenable scrollbar in case it had been previously
1029 // disabled by specifying SIF_DISABLENOSCROLL below but we should only
1030 // do this if it has valid range, otherwise it would be enabled but not
1032 if ( range
>= pageSize
)
1034 ::EnableScrollBar(hwnd
, WXOrientToSB(orient
), ESB_ENABLE_BOTH
);
1037 //else: leave all the fields to be 0
1039 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1040 if ( HasFlag(wxALWAYS_SHOW_SB
) || range
== -1 )
1042 // disable scrollbar instead of removing it then
1043 info
.fMask
|= SIF_DISABLENOSCROLL
;
1046 ::SetScrollInfo(hwnd
, WXOrientToSB(orient
), &info
, refresh
);
1049 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1055 wxCopyRectToRECT(*prect
, rect
);
1065 // FIXME: is this the exact equivalent of the line below?
1066 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1068 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1072 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1074 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1077 for ( int n
= 0; n
< count
; n
++ )
1079 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1081 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1082 if ( posNew
== pos
)
1084 // don't bother to continue, we're already at top/bottom
1091 return pos
!= posStart
;
1094 bool wxWindowMSW::ScrollLines(int lines
)
1096 bool down
= lines
> 0;
1098 return ScrollVertically(GetHwnd(),
1099 down
? SB_LINEDOWN
: SB_LINEUP
,
1100 down
? lines
: -lines
);
1103 bool wxWindowMSW::ScrollPages(int pages
)
1105 bool down
= pages
> 0;
1107 return ScrollVertically(GetHwnd(),
1108 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1109 down
? pages
: -pages
);
1112 // ----------------------------------------------------------------------------
1114 // ----------------------------------------------------------------------------
1116 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1121 wxCHECK_RET( GetHwnd(),
1122 wxT("layout direction must be set after window creation") );
1124 LONG styleOld
= wxGetWindowExStyle(this);
1126 LONG styleNew
= styleOld
;
1129 case wxLayout_LeftToRight
:
1130 styleNew
&= ~WS_EX_LAYOUTRTL
;
1133 case wxLayout_RightToLeft
:
1134 styleNew
|= WS_EX_LAYOUTRTL
;
1138 wxFAIL_MSG(wxT("unsupported layout direction"));
1142 if ( styleNew
!= styleOld
)
1144 wxSetWindowExStyle(this, styleNew
);
1149 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1152 return wxLayout_Default
;
1154 wxCHECK_MSG( GetHwnd(), wxLayout_Default
, wxT("invalid window") );
1156 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL
) ? wxLayout_RightToLeft
1157 : wxLayout_LeftToRight
;
1162 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1163 wxCoord
WXUNUSED(width
),
1164 wxCoord
WXUNUSED(widthTotal
)) const
1166 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1167 // redo it ourselves
1171 // ---------------------------------------------------------------------------
1173 // ---------------------------------------------------------------------------
1175 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1177 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1179 HWND hwnd
= (HWND
)hWnd
;
1180 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1184 wxAssociateWinWithHandle(hwnd
, this);
1186 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1188 // we don't need to subclass the window of our own class (in the Windows
1189 // sense of the word)
1190 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1192 wxSetWindowProc(hwnd
, wxWndProc
);
1196 // don't bother restoring it either: this also makes it easy to
1197 // implement IsOfStandardClass() method which returns true for the
1198 // standard controls and false for the wxWidgets own windows as it can
1199 // simply check m_oldWndProc
1200 m_oldWndProc
= NULL
;
1203 // we're officially created now, send the event
1204 wxWindowCreateEvent
event((wxWindow
*)this);
1205 (void)HandleWindowEvent(event
);
1208 void wxWindowMSW::UnsubclassWin()
1210 wxRemoveHandleAssociation(this);
1212 // Restore old Window proc
1213 HWND hwnd
= GetHwnd();
1218 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1222 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1224 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1227 m_oldWndProc
= NULL
;
1232 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1236 if ( !::DestroyWindow(GetHwnd()) )
1238 wxLogLastError(wxT("DestroyWindow"));
1242 WXHWND wxhwnd
= (WXHWND
)handle
;
1244 // this also calls SetHWND(wxhwnd)
1245 SubclassWin(wxhwnd
);
1248 void wxWindowMSW::DissociateHandle()
1250 // this also calls SetHWND(0) for us
1255 bool wxCheckWindowWndProc(WXHWND hWnd
,
1256 WXFARPROC
WXUNUSED(wndProc
))
1258 const wxString
str(wxGetWindowClass(hWnd
));
1260 // TODO: get rid of wxTLWHiddenParent special case (currently it's not
1261 // registered by wxApp but using ad hoc code in msw/toplevel.cpp);
1262 // there is also a hidden window class used by sockets &c
1263 return wxApp::IsRegisteredClassName(str
) || str
== wxT("wxTLWHiddenParent");
1266 // ----------------------------------------------------------------------------
1268 // ----------------------------------------------------------------------------
1270 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1272 long flagsOld
= GetWindowStyleFlag();
1273 if ( flags
== flagsOld
)
1276 // update the internal variable
1277 wxWindowBase::SetWindowStyleFlag(flags
);
1279 // and the real window flags
1280 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1283 void wxWindowMSW::SetExtraStyle(long exflags
)
1285 long exflagsOld
= GetExtraStyle();
1286 if ( exflags
== exflagsOld
)
1289 // update the internal variable
1290 wxWindowBase::SetExtraStyle(exflags
);
1292 // and the real window flags
1293 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1296 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1298 // now update the Windows style as well if needed - and if the window had
1299 // been already created
1303 // we may need to call SetWindowPos() when we change some styles
1304 bool callSWP
= false;
1307 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1309 // this is quite a horrible hack but we need it because MSWGetStyle()
1310 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1311 // and so we have to modify the window exflags temporarily to get the
1312 // correct exstyleOld
1313 long exflagsNew
= GetExtraStyle();
1314 wxWindowBase::SetExtraStyle(exflagsOld
);
1317 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1319 wxWindowBase::SetExtraStyle(exflagsNew
);
1322 if ( style
!= styleOld
)
1324 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1325 // this function so instead of simply setting the style to the new
1326 // value we clear the bits which were set in styleOld but are set in
1327 // the new one and set the ones which were not set before
1328 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1329 styleReal
&= ~styleOld
;
1332 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1334 // we need to call SetWindowPos() if any of the styles affecting the
1335 // frame appearance have changed
1336 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1345 // and the extended style
1346 long exstyleReal
= wxGetWindowExStyle(this);
1348 if ( exstyle
!= exstyleOld
)
1350 exstyleReal
&= ~exstyleOld
;
1351 exstyleReal
|= exstyle
;
1353 wxSetWindowExStyle(this, exstyleReal
);
1355 // ex style changes don't take effect without calling SetWindowPos
1361 // we must call SetWindowPos() to flush the cached extended style and
1362 // also to make the change to wxSTAY_ON_TOP style take effect: just
1363 // setting the style simply doesn't work
1364 if ( !::SetWindowPos(GetHwnd(),
1365 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1368 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
|
1371 wxLogLastError(wxT("SetWindowPos"));
1376 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1378 return wxBORDER_THEME
;
1381 wxBorder
wxWindowMSW::GetDefaultBorder() const
1383 return wxWindowBase::GetDefaultBorder();
1386 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1387 // that makes most sense for this Windows environment
1388 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1390 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1391 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1392 return wxBORDER_SIMPLE
;
1394 return wxBORDER_NONE
;
1397 if (border
== wxBORDER_THEME
)
1399 if (CanApplyThemeBorder())
1401 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1403 return wxBORDER_THEME
;
1405 return wxBORDER_SUNKEN
;
1413 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1415 // translate common wxWidgets styles to Windows ones
1417 // most of windows are child ones, those which are not (such as
1418 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1419 WXDWORD style
= WS_CHILD
;
1421 // using this flag results in very significant reduction in flicker,
1422 // especially with controls inside the static boxes (as the interior of the
1423 // box is not redrawn twice), but sometimes results in redraw problems, so
1424 // optionally allow the old code to continue to use it provided a special
1425 // system option is turned on
1426 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1427 || (flags
& wxCLIP_CHILDREN
) )
1428 style
|= WS_CLIPCHILDREN
;
1430 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1431 // don't support overlapping windows and it only makes sense for them and,
1432 // presumably, gives the system some extra work (to manage more clipping
1433 // regions), so avoid it alltogether
1436 if ( flags
& wxVSCROLL
)
1437 style
|= WS_VSCROLL
;
1439 if ( flags
& wxHSCROLL
)
1440 style
|= WS_HSCROLL
;
1442 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1444 // After translation, border is now optimized for the specific version of Windows
1445 // and theme engine presence.
1447 // WS_BORDER is only required for wxBORDER_SIMPLE
1448 if ( border
== wxBORDER_SIMPLE
)
1451 // now deal with ext style if the caller wants it
1457 if ( flags
& wxTRANSPARENT_WINDOW
)
1458 *exstyle
|= WS_EX_TRANSPARENT
;
1464 case wxBORDER_DEFAULT
:
1465 wxFAIL_MSG( wxT("unknown border style") );
1469 case wxBORDER_SIMPLE
:
1470 case wxBORDER_THEME
:
1473 case wxBORDER_STATIC
:
1474 *exstyle
|= WS_EX_STATICEDGE
;
1477 case wxBORDER_RAISED
:
1478 *exstyle
|= WS_EX_DLGMODALFRAME
;
1481 case wxBORDER_SUNKEN
:
1482 *exstyle
|= WS_EX_CLIENTEDGE
;
1483 style
&= ~WS_BORDER
;
1486 // case wxBORDER_DOUBLE:
1487 // *exstyle |= WS_EX_DLGMODALFRAME;
1491 // wxUniv doesn't use Windows dialog navigation functions at all
1492 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1493 // to make the dialog navigation work with the nested panels we must
1494 // use this style (top level windows such as dialogs don't need it)
1495 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1497 *exstyle
|= WS_EX_CONTROLPARENT
;
1499 #endif // __WXUNIVERSAL__
1505 // Setup background and foreground colours correctly
1506 void wxWindowMSW::SetupColours()
1509 SetBackgroundColour(GetParent()->GetBackgroundColour());
1512 bool wxWindowMSW::IsMouseInWindow() const
1514 // get the mouse position
1516 wxGetCursorPosMSW(&pt
);
1518 // find the window which currently has the cursor and go up the window
1519 // chain until we find this window - or exhaust it
1520 HWND hwnd
= ::WindowFromPoint(pt
);
1521 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1522 hwnd
= ::GetParent(hwnd
);
1524 return hwnd
!= NULL
;
1527 void wxWindowMSW::OnInternalIdle()
1529 #ifndef HAVE_TRACKMOUSEEVENT
1530 // Check if we need to send a LEAVE event
1531 if ( m_mouseInWindow
)
1533 // note that we should generate the leave event whether the window has
1534 // or doesn't have mouse capture
1535 if ( !IsMouseInWindow() )
1537 GenerateMouseLeave();
1540 #endif // !HAVE_TRACKMOUSEEVENT
1542 wxWindowBase::OnInternalIdle();
1545 // Set this window to be the child of 'parent'.
1546 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1548 if ( !wxWindowBase::Reparent(parent
) )
1551 HWND hWndChild
= GetHwnd();
1552 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1554 ::SetParent(hWndChild
, hWndParent
);
1557 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT
) )
1559 EnsureParentHasControlParentStyle(GetParent());
1561 #endif // !__WXWINCE__
1566 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1568 #ifndef __WXMICROWIN__
1569 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1573 void wxWindowMSW::DoFreeze()
1576 return; // no point in freezing hidden window
1578 SendSetRedraw(GetHwnd(), false);
1581 void wxWindowMSW::DoThaw()
1584 return; // hidden windows aren't frozen by DoFreeze
1586 SendSetRedraw(GetHwnd(), true);
1588 // we need to refresh everything or otherwise the invalidated area
1589 // is not going to be repainted
1593 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1595 HWND hWnd
= GetHwnd();
1602 wxCopyRectToRECT(*rect
, mswRect
);
1610 // RedrawWindow not available on SmartPhone or eVC++ 3
1611 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1612 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1616 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1618 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1623 void wxWindowMSW::Update()
1625 if ( !::UpdateWindow(GetHwnd()) )
1627 wxLogLastError(wxT("UpdateWindow"));
1630 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1631 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1632 // handler needs to be really drawn right now
1637 // ---------------------------------------------------------------------------
1639 // ---------------------------------------------------------------------------
1641 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1645 // we need to lower the sibling static boxes so controls contained within can be
1647 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1649 // no sibling static boxes if we have no parent (ie TLW)
1653 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1655 node
= node
->GetNext() )
1657 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1660 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1661 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1666 #else // !wxUSE_STATBOX
1668 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1672 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1674 #endif // drag and drop is used
1676 #if wxUSE_DRAG_AND_DROP
1677 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1679 if ( m_dropTarget
!= 0 ) {
1680 m_dropTarget
->Revoke(m_hWnd
);
1681 delete m_dropTarget
;
1684 m_dropTarget
= pDropTarget
;
1685 if ( m_dropTarget
!= 0 )
1687 AdjustStaticBoxZOrder(GetParent());
1688 m_dropTarget
->Register(m_hWnd
);
1691 #endif // wxUSE_DRAG_AND_DROP
1693 // old-style file manager drag&drop support: we retain the old-style
1694 // DragAcceptFiles in parallel with SetDropTarget.
1695 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1698 HWND hWnd
= GetHwnd();
1701 AdjustStaticBoxZOrder(GetParent());
1702 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1707 // ----------------------------------------------------------------------------
1709 // ----------------------------------------------------------------------------
1713 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1715 wxWindowBase::DoSetToolTip(tooltip
);
1718 m_tooltip
->SetWindow((wxWindow
*)this);
1721 #endif // wxUSE_TOOLTIPS
1723 // ---------------------------------------------------------------------------
1724 // moving and resizing
1725 // ---------------------------------------------------------------------------
1727 bool wxWindowMSW::IsSizeDeferred() const
1729 #if wxUSE_DEFERRED_SIZING
1730 if ( m_pendingPosition
!= wxDefaultPosition
||
1731 m_pendingSize
!= wxDefaultSize
)
1733 #endif // wxUSE_DEFERRED_SIZING
1739 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1741 #if wxUSE_DEFERRED_SIZING
1742 // if SetSize() had been called at wx level but not realized at Windows
1743 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1744 // the new and not the old position to the other wx code
1745 if ( m_pendingSize
!= wxDefaultSize
)
1748 *x
= m_pendingSize
.x
;
1750 *y
= m_pendingSize
.y
;
1752 else // use current size
1753 #endif // wxUSE_DEFERRED_SIZING
1755 RECT rect
= wxGetWindowRect(GetHwnd());
1758 *x
= rect
.right
- rect
.left
;
1760 *y
= rect
.bottom
- rect
.top
;
1764 // Get size *available for subwindows* i.e. excluding menu bar etc.
1765 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1767 #if wxUSE_DEFERRED_SIZING
1768 if ( m_pendingSize
!= wxDefaultSize
)
1770 // we need to calculate the client size corresponding to pending size
1772 // FIXME: Unfortunately this doesn't work correctly for the maximized
1773 // top level windows, the returned values are too small (e.g.
1774 // under Windows 7 on a 1600*1200 screen with task bar on the
1775 // right the pending size for a maximized window is 1538*1200
1776 // and WM_NCCALCSIZE returns 1528*1172 even though the correct
1777 // client size of such window is 1538*1182). No idea how to fix
1778 // it though, setting WS_MAXIMIZE in GWL_STYLE before calling
1779 // WM_NCCALCSIZE doesn't help and AdjustWindowRectEx() doesn't
1780 // work in this direction neither. So we just have to live with
1781 // the slightly wrong results and relayout the window when it
1782 // gets finally shown in its maximized state (see #11762).
1784 rect
.left
= m_pendingPosition
.x
;
1785 rect
.top
= m_pendingPosition
.y
;
1786 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1787 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1789 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1792 *x
= rect
.right
- rect
.left
;
1794 *y
= rect
.bottom
- rect
.top
;
1797 #endif // wxUSE_DEFERRED_SIZING
1799 RECT rect
= wxGetClientRect(GetHwnd());
1807 // The size of the client window can't be negative but ::GetClientRect()
1808 // can return negative size for an extremely small (1x1) window with
1809 // borders so ensure that we correct it here as having negative sizes is
1810 // completely unexpected.
1817 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1819 wxWindow
* const parent
= GetParent();
1822 #if wxUSE_DEFERRED_SIZING
1823 if ( m_pendingPosition
!= wxDefaultPosition
)
1825 pos
= m_pendingPosition
;
1827 else // use current position
1828 #endif // wxUSE_DEFERRED_SIZING
1830 RECT rect
= wxGetWindowRect(GetHwnd());
1833 point
.x
= rect
.left
;
1836 // we do the adjustments with respect to the parent only for the "real"
1837 // children, not for the dialogs/frames
1838 if ( !IsTopLevel() )
1840 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1842 // In RTL mode, we want the logical left x-coordinate,
1843 // which would be the physical right x-coordinate.
1844 point
.x
= rect
.right
;
1847 // Since we now have the absolute screen coords, if there's a
1848 // parent we must subtract its top left corner
1851 ::ScreenToClient(GetHwndOf(parent
), &point
);
1859 // we also must adjust by the client area offset: a control which is just
1860 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1861 if ( parent
&& !IsTopLevel() )
1863 const wxPoint
pt(parent
->GetClientAreaOrigin());
1874 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1882 ::ScreenToClient(GetHwnd(), &pt
);
1890 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1898 ::ClientToScreen(GetHwnd(), &pt
);
1907 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1909 #if wxUSE_DEFERRED_SIZING
1910 // if our parent had prepared a defer window handle for us, use it (unless
1911 // we are a top level window)
1912 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1914 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1917 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1918 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1921 wxLogLastError(wxT("DeferWindowPos"));
1927 // hdwp must be updated as it may have been changed
1928 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1933 // did deferred move, remember new coordinates of the window as they're
1934 // different from what Windows would return for it
1938 // otherwise (or if deferring failed) move the window in place immediately
1939 #endif // wxUSE_DEFERRED_SIZING
1940 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1942 wxLogLastError(wxT("MoveWindow"));
1945 // if wxUSE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1946 // ignored otherwise
1950 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1952 // TODO: is this consistent with other platforms?
1953 // Still, negative width or height shouldn't be allowed
1959 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1961 #if wxUSE_DEFERRED_SIZING
1962 m_pendingPosition
= wxPoint(x
, y
);
1963 m_pendingSize
= wxSize(width
, height
);
1965 else // window was moved immediately, without deferring it
1967 m_pendingPosition
= wxDefaultPosition
;
1968 m_pendingSize
= wxDefaultSize
;
1969 #endif // wxUSE_DEFERRED_SIZING
1973 // set the size of the window: if the dimensions are positive, just use them,
1974 // but if any of them is equal to -1, it means that we must find the value for
1975 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1976 // which case -1 is a valid value for x and y)
1978 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1979 // the width/height to best suit our contents, otherwise we reuse the current
1981 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1983 // get the current size and position...
1984 int currentX
, currentY
;
1985 int currentW
, currentH
;
1987 GetPosition(¤tX
, ¤tY
);
1988 GetSize(¤tW
, ¤tH
);
1990 // ... and don't do anything (avoiding flicker) if it's already ok unless
1991 // we're forced to resize the window
1992 if ( x
== currentX
&& y
== currentY
&&
1993 width
== currentW
&& height
== currentH
&&
1994 !(sizeFlags
& wxSIZE_FORCE
) )
1996 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
1998 wxSizeEvent
event( wxSize(width
,height
), GetId() );
1999 event
.SetEventObject( this );
2000 HandleWindowEvent( event
);
2005 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2007 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2010 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2012 wxSize size
= wxDefaultSize
;
2013 if ( width
== wxDefaultCoord
)
2015 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2017 size
= GetBestSize();
2022 // just take the current one
2027 if ( height
== wxDefaultCoord
)
2029 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2031 if ( size
.x
== wxDefaultCoord
)
2033 size
= GetBestSize();
2035 //else: already called GetBestSize() above
2041 // just take the current one
2046 DoMoveWindow(x
, y
, width
, height
);
2049 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2051 // setting the client size is less obvious than it could have been
2052 // because in the result of changing the total size the window scrollbar
2053 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2054 // doesn't take neither into account) and so the client size will not be
2055 // correct as the difference between the total and client size changes --
2056 // so we keep changing it until we get it right
2058 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2059 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2060 // may become 3 if the window had 0 size originally and so we didn't
2061 // calculate the scrollbar correction correctly during the first iteration)
2062 // but just to be on the safe side we check for it instead of making it an
2063 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2064 for ( int i
= 0; i
< 4; i
++ )
2067 ::GetClientRect(GetHwnd(), &rectClient
);
2069 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2070 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2071 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2076 // Find the difference between the entire window (title bar and all)
2077 // and the client area; add this to the new client size to move the
2080 ::GetWindowRect(GetHwnd(), &rectWin
);
2082 const int widthWin
= rectWin
.right
- rectWin
.left
,
2083 heightWin
= rectWin
.bottom
- rectWin
.top
;
2085 // MoveWindow positions the child windows relative to the parent, so
2086 // adjust if necessary
2087 if ( !IsTopLevel() )
2089 wxWindow
*parent
= GetParent();
2092 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2096 // don't call DoMoveWindow() because we want to move window immediately
2097 // and not defer it here as otherwise the value returned by
2098 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2100 if ( !::MoveWindow(GetHwnd(),
2103 width
+ widthWin
- rectClient
.right
,
2104 height
+ heightWin
- rectClient
.bottom
,
2107 wxLogLastError(wxT("MoveWindow"));
2112 wxSize
wxWindowMSW::DoGetBorderSize() const
2115 switch ( GetBorder() )
2117 case wxBORDER_STATIC
:
2118 case wxBORDER_SIMPLE
:
2122 case wxBORDER_SUNKEN
:
2126 case wxBORDER_RAISED
:
2127 case wxBORDER_DOUBLE
:
2132 wxFAIL_MSG( wxT("unknown border style") );
2139 return 2*wxSize(border
, border
);
2142 // ---------------------------------------------------------------------------
2144 // ---------------------------------------------------------------------------
2146 int wxWindowMSW::GetCharHeight() const
2148 return wxGetTextMetrics(this).tmHeight
;
2151 int wxWindowMSW::GetCharWidth() const
2153 // +1 is needed because Windows apparently adds it when calculating the
2154 // dialog units size in pixels
2155 #if wxDIALOG_UNIT_COMPATIBILITY
2156 return wxGetTextMetrics(this).tmAveCharWidth
;
2158 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2162 void wxWindowMSW::DoGetTextExtent(const wxString
& string
,
2165 int *externalLeading
,
2166 const wxFont
*fontToUse
) const
2168 // ensure we work with a valid font
2170 if ( !fontToUse
|| !fontToUse
->IsOk() )
2175 wxCHECK_RET( font
.IsOk(), wxT("invalid font in GetTextExtent()") );
2177 const wxWindow
* win
= static_cast<const wxWindow
*>(this);
2178 wxTextMeasure
txm(win
, &font
);
2179 txm
.GetTextExtent(string
, x
, y
, descent
, externalLeading
);
2182 // ---------------------------------------------------------------------------
2184 // ---------------------------------------------------------------------------
2186 #if wxUSE_MENUS_NATIVE
2188 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2189 // immediately, without waiting for the next event loop iteration
2191 // NB: this function should probably be made public later as it can almost
2192 // surely replace wxYield() elsewhere as well
2193 static void wxYieldForCommandsOnly()
2195 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2196 // want to process it here)
2198 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2200 if ( msg
.message
== WM_QUIT
)
2202 // if we retrieved a WM_QUIT, insert back into the message queue.
2203 ::PostQuitMessage(0);
2207 // luckily (as we don't have access to wxEventLoopImpl method from here
2208 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2210 ::TranslateMessage(&msg
);
2211 ::DispatchMessage(&msg
);
2215 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2220 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2222 pt
= wxGetMousePosition();
2226 pt
= ClientToScreen(wxPoint(x
, y
));
2229 #if defined(__WXWINCE__)
2230 static const UINT flags
= 0;
2231 #else // !__WXWINCE__
2232 UINT flags
= TPM_RIGHTBUTTON
;
2233 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2234 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2235 // side and not to use it there neither -- modify the test if it does work
2237 if ( wxGetWinVersion() >= wxWinVersion_5
)
2239 // using TPM_RECURSE allows us to show a popup menu while another menu
2240 // is opened which can be useful and is supported by the other
2241 // platforms, so allow it under Windows too
2242 flags
|= TPM_RECURSE
;
2244 #endif // __WXWINCE__/!__WXWINCE__
2246 ::TrackPopupMenu(GetHmenuOf(menu
), flags
, pt
.x
, pt
.y
, 0, GetHwnd(), NULL
);
2248 // we need to do it right now as otherwise the events are never going to be
2249 // sent to wxCurrentPopupMenu from HandleCommand()
2251 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2252 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2253 // destroyed as soon as we return (it can be a local variable in the caller
2254 // for example) and so we do need to process the event immediately
2255 wxYieldForCommandsOnly();
2260 #endif // wxUSE_MENUS_NATIVE
2262 // ===========================================================================
2263 // pre/post message processing
2264 // ===========================================================================
2266 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2270 rc
= ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2272 rc
= ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2274 // Special hack used by wxTextEntry auto-completion only: this event is
2275 // sent after the normal keyboard processing so that its handler could use
2276 // the updated contents of the text control, after taking the key that was
2277 // pressed into account.
2278 if ( nMsg
== WM_CHAR
)
2280 wxKeyEvent
event(CreateCharEvent(wxEVT_AFTER_CHAR
, wParam
, lParam
));
2281 HandleWindowEvent(event
);
2287 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2289 // wxUniversal implements tab traversal itself
2290 #ifndef __WXUNIVERSAL__
2291 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2293 // intercept dialog navigation keys
2294 MSG
*msg
= (MSG
*)pMsg
;
2296 // here we try to do all the job which ::IsDialogMessage() usually does
2298 if ( msg
->message
== WM_KEYDOWN
)
2300 bool bCtrlDown
= wxIsCtrlDown();
2301 bool bShiftDown
= wxIsShiftDown();
2303 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2304 // don't process it if it's the case (except for Ctrl-Tab/Enter
2305 // combinations which are always processed)
2306 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2308 // surprisingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2309 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2310 // it, of course, implies them
2311 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2313 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2316 bool bForward
= true,
2317 bWindowChange
= false,
2320 // should we process this message specially?
2321 bool bProcess
= true;
2322 switch ( msg
->wParam
)
2325 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2327 // let the control have the TAB
2330 else // use it for navigation
2332 // Ctrl-Tab cycles thru notebook pages
2333 bWindowChange
= bCtrlDown
;
2334 bForward
= !bShiftDown
;
2341 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2349 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2358 // we treat PageUp/Dn as arrows because chances are that
2359 // a control which needs arrows also needs them for
2360 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2361 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2363 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2364 bWindowChange
= true;
2370 // currently active button should get enter press even
2371 // if there is a default button elsewhere so check if
2372 // this window is a button first
2373 wxWindow
*btn
= NULL
;
2374 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2376 // let IsDialogMessage() handle this for all
2377 // buttons except the owner-drawn ones which it
2378 // just seems to ignore
2379 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2380 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2382 // emulate the button click
2383 btn
= wxFindWinFromHandle(msg
->hwnd
);
2386 else // not a button itself, do we have default button?
2388 // check if this window or any of its ancestors
2389 // wants the message for itself (we always reserve
2390 // Ctrl-Enter for dialog navigation though)
2391 wxWindow
*win
= this;
2394 // this will contain the dialog code of this
2395 // window and all of its parent windows in turn
2396 LONG lDlgCode2
= lDlgCode
;
2400 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2402 // as it wants to process Enter itself,
2403 // don't call IsDialogMessage() which
2408 // don't propagate keyboard messages beyond
2409 // the first top level window parent
2410 if ( win
->IsTopLevel() )
2413 win
= win
->GetParent();
2415 lDlgCode2
= ::SendMessage
2426 win
= wxGetTopLevelParent(win
);
2429 wxTopLevelWindow
* const
2430 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2433 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2438 if ( btn
&& btn
->IsEnabled() )
2440 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2444 // This "Return" key press won't be actually used for
2445 // navigation so don't generate wxNavigationKeyEvent
2446 // for it but still pass it to IsDialogMessage() as it
2447 // may handle it in some other way (e.g. by playing the
2448 // default error sound).
2451 #endif // wxUSE_BUTTON
2454 // map Enter presses into button presses on PDAs
2455 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2456 event
.SetEventObject(this);
2457 if ( HandleWindowEvent(event
) )
2459 #endif // __WXWINCE__
2469 wxNavigationKeyEvent event
;
2470 event
.SetDirection(bForward
);
2471 event
.SetWindowChange(bWindowChange
);
2472 event
.SetFromTab(bFromTab
);
2473 event
.SetEventObject(this);
2475 if ( HandleWindowEvent(event
) )
2477 // as we don't call IsDialogMessage(), which would take of
2478 // this by default, we need to manually send this message
2479 // so that controls can change their UI state if needed
2480 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2487 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2489 // IsDialogMessage() did something...
2493 #endif // __WXUNIVERSAL__
2498 // relay mouse move events to the tooltip control
2499 MSG
*msg
= (MSG
*)pMsg
;
2500 if ( msg
->message
== WM_MOUSEMOVE
)
2501 wxToolTip::RelayEvent(pMsg
);
2503 #endif // wxUSE_TOOLTIPS
2508 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2510 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2511 return m_acceleratorTable
.Translate(this, pMsg
);
2515 #endif // wxUSE_ACCEL
2518 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2520 // all tests below have to deal with various bugs/misfeatures of
2521 // IsDialogMessage(): we have to prevent it from being called from our
2522 // MSWProcessMessage() in some situations
2524 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2525 // message even when there is no cancel button and when the message is
2526 // needed by the control itself: in particular, it prevents the tree in
2527 // place edit control from being closed with Escape in a dialog
2528 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2533 // ::IsDialogMessage() is broken and may sometimes hang the application by
2534 // going into an infinite loop when it tries to find the control to give
2535 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2536 // situations when this may happen and not call it then
2537 if ( msg
->message
!= WM_SYSCHAR
)
2540 // assume we can call it by default
2541 bool canSafelyCallIsDlgMsg
= true;
2543 HWND hwndFocus
= ::GetFocus();
2545 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2546 // ::IsDialogMessage() will also enter an infinite loop, because it will
2547 // recursively check the child windows but not the window itself and so if
2548 // none of the children accepts focus it loops forever (as it only stops
2549 // when it gets back to the window it started from)
2551 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2552 // style has the focus, it can happen. One such possibility is if
2553 // all windows are either toplevel, wxDialog, wxPanel or static
2554 // controls and no window can actually accept keyboard input.
2555 #if !defined(__WXWINCE__)
2556 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2558 // pessimistic by default
2559 canSafelyCallIsDlgMsg
= false;
2560 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2562 node
= node
->GetNext() )
2564 wxWindow
* const win
= node
->GetData();
2565 if ( win
->CanAcceptFocus() &&
2566 !wxHasWindowExStyle(win
, WS_EX_CONTROLPARENT
) )
2568 // it shouldn't hang...
2569 canSafelyCallIsDlgMsg
= true;
2575 #endif // !__WXWINCE__
2577 if ( canSafelyCallIsDlgMsg
)
2579 // ::IsDialogMessage() can enter in an infinite loop when the
2580 // currently focused window is disabled or hidden and its
2581 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2585 if ( !::IsWindowEnabled(hwndFocus
) ||
2586 !::IsWindowVisible(hwndFocus
) )
2588 // it would enter an infinite loop if we do this!
2589 canSafelyCallIsDlgMsg
= false;
2594 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2596 // it's a top level window, don't go further -- e.g. even
2597 // if the parent of a dialog is disabled, this doesn't
2598 // break navigation inside the dialog
2602 hwndFocus
= ::GetParent(hwndFocus
);
2606 return canSafelyCallIsDlgMsg
;
2609 // ---------------------------------------------------------------------------
2610 // message params unpackers
2611 // ---------------------------------------------------------------------------
2613 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2614 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2616 *id
= LOWORD(wParam
);
2617 *hwnd
= (WXHWND
)lParam
;
2618 *cmd
= HIWORD(wParam
);
2621 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2622 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2624 *state
= LOWORD(wParam
);
2625 *minimized
= HIWORD(wParam
);
2626 *hwnd
= (WXHWND
)lParam
;
2629 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2630 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2632 *code
= LOWORD(wParam
);
2633 *pos
= HIWORD(wParam
);
2634 *hwnd
= (WXHWND
)lParam
;
2637 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2638 WXHDC
*hdc
, WXHWND
*hwnd
)
2640 *hwnd
= (WXHWND
)lParam
;
2641 *hdc
= (WXHDC
)wParam
;
2644 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2645 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2647 *item
= (WXWORD
)wParam
;
2648 *flags
= HIWORD(wParam
);
2649 *hmenu
= (WXHMENU
)lParam
;
2652 // ---------------------------------------------------------------------------
2653 // Main wxWidgets window proc and the window proc for wxWindow
2654 // ---------------------------------------------------------------------------
2656 // Hook for new window just as it's being created, when the window isn't yet
2657 // associated with the handle
2658 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2660 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2661 // window being created and insures that it's always unset back later
2662 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2664 gs_winBeingCreated
= winBeingCreated
;
2667 wxWindowCreationHook::~wxWindowCreationHook()
2669 gs_winBeingCreated
= NULL
;
2673 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2675 // trace all messages: useful for the debugging but noticeably slows down
2676 // the code so don't do it by default
2677 #if wxDEBUG_LEVEL >= 2
2678 // notice that we cast wParam and lParam to long to avoid mismatch with
2679 // format specifiers in 64 bit builds where they are both int64 quantities
2681 // casting like this loses information, of course, but it shouldn't matter
2682 // much for this diagnostic code and it keeps the code simple
2683 wxLogTrace("winmsg",
2684 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2685 wxGetMessageName(message
), hWnd
, (long)wParam
, (long)lParam
);
2686 #endif // wxDEBUG_LEVEL >= 2
2688 wxWindowMSW
*wnd
= wxFindWinFromHandle(hWnd
);
2690 // when we get the first message for the HWND we just created, we associate
2691 // it with wxWindow stored in gs_winBeingCreated
2692 if ( !wnd
&& gs_winBeingCreated
)
2694 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2695 wnd
= gs_winBeingCreated
;
2696 gs_winBeingCreated
= NULL
;
2697 wnd
->SetHWND((WXHWND
)hWnd
);
2702 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2703 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2705 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2711 wxWindowMSW::MSWHandleMessage(WXLRESULT
*result
,
2716 // did we process the message?
2717 bool processed
= false;
2727 // for most messages we should return 0 when we do process the message
2735 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2738 // return 0 to allow window creation
2739 rc
.result
= mayCreate
? 0 : -1;
2745 // never set processed to true and *always* pass WM_DESTROY to
2746 // DefWindowProc() as Windows may do some internal cleanup when
2747 // processing it and failing to pass the message along may cause
2748 // memory and resource leaks!
2749 (void)HandleDestroy();
2753 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2757 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2760 #if !defined(__WXWINCE__)
2763 LPRECT pRect
= (LPRECT
)lParam
;
2765 rc
.SetLeft(pRect
->left
);
2766 rc
.SetTop(pRect
->top
);
2767 rc
.SetRight(pRect
->right
);
2768 rc
.SetBottom(pRect
->bottom
);
2769 processed
= HandleMoving(rc
);
2771 pRect
->left
= rc
.GetLeft();
2772 pRect
->top
= rc
.GetTop();
2773 pRect
->right
= rc
.GetRight();
2774 pRect
->bottom
= rc
.GetBottom();
2779 case WM_ENTERSIZEMOVE
:
2781 processed
= HandleEnterSizeMove();
2785 case WM_EXITSIZEMOVE
:
2787 processed
= HandleExitSizeMove();
2793 LPRECT pRect
= (LPRECT
)lParam
;
2795 rc
.SetLeft(pRect
->left
);
2796 rc
.SetTop(pRect
->top
);
2797 rc
.SetRight(pRect
->right
);
2798 rc
.SetBottom(pRect
->bottom
);
2799 processed
= HandleSizing(rc
);
2801 pRect
->left
= rc
.GetLeft();
2802 pRect
->top
= rc
.GetTop();
2803 pRect
->right
= rc
.GetRight();
2804 pRect
->bottom
= rc
.GetBottom();
2808 #endif // !__WXWINCE__
2810 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2811 case WM_ACTIVATEAPP
:
2812 // This implicitly sends a wxEVT_ACTIVATE_APP event
2813 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2819 WXWORD state
, minimized
;
2821 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2823 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2828 processed
= HandleSetFocus((WXHWND
)wParam
);
2832 processed
= HandleKillFocus((WXHWND
)wParam
);
2835 case WM_PRINTCLIENT
:
2836 processed
= HandlePrintClient((WXHDC
)wParam
);
2842 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2844 processed
= HandlePaint();
2848 processed
= HandlePaint();
2853 #ifdef __WXUNIVERSAL__
2854 // Universal uses its own wxFrame/wxDialog, so we don't receive
2855 // close events unless we have this.
2857 #endif // __WXUNIVERSAL__
2859 // don't let the DefWindowProc() destroy our window - we'll do it
2860 // ourselves in ~wxWindow
2866 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2870 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2871 GET_Y_LPARAM(lParam
),
2875 #ifdef HAVE_TRACKMOUSEEVENT
2877 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2879 if ( m_mouseInWindow
)
2881 GenerateMouseLeave();
2884 // always pass processed back as false, this allows the window
2885 // manager to process the message too. This is needed to
2886 // ensure windows XP themes work properly as the mouse moves
2887 // over widgets like buttons. So don't set processed to true here.
2889 #endif // HAVE_TRACKMOUSEEVENT
2891 #if wxUSE_MOUSEWHEEL
2893 processed
= HandleMouseWheel(wxMOUSE_WHEEL_VERTICAL
, wParam
, lParam
);
2896 case WM_MOUSEHWHEEL
:
2897 processed
= HandleMouseWheel(wxMOUSE_WHEEL_HORIZONTAL
, wParam
, lParam
);
2899 #endif // wxUSE_MOUSEWHEEL
2901 case WM_LBUTTONDOWN
:
2903 case WM_LBUTTONDBLCLK
:
2904 case WM_RBUTTONDOWN
:
2906 case WM_RBUTTONDBLCLK
:
2907 case WM_MBUTTONDOWN
:
2909 case WM_MBUTTONDBLCLK
:
2910 #ifdef wxHAS_XBUTTON
2911 case WM_XBUTTONDOWN
:
2913 case WM_XBUTTONDBLCLK
:
2914 #endif // wxHAS_XBUTTON
2916 #ifdef __WXMICROWIN__
2917 // MicroWindows seems to ignore the fact that a window is
2918 // disabled. So catch mouse events and throw them away if
2920 wxWindowMSW
* win
= this;
2923 if (!win
->IsEnabled())
2929 win
= win
->GetParent();
2930 if ( !win
|| win
->IsTopLevel() )
2937 #endif // __WXMICROWIN__
2938 int x
= GET_X_LPARAM(lParam
),
2939 y
= GET_Y_LPARAM(lParam
);
2942 // redirect the event to a static control if necessary by
2943 // finding one under mouse because under CE the static controls
2944 // don't generate mouse events (even with SS_NOTIFY)
2946 if ( GetCapture() == this )
2948 // but don't do it if the mouse is captured by this window
2949 // because then it should really get this event itself
2954 win
= FindWindowForMouseEvent(this, &x
, &y
);
2956 // this should never happen
2957 wxCHECK_MSG( win
, 0,
2958 wxT("FindWindowForMouseEvent() returned NULL") );
2961 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2963 SHRGINFO shrgi
= {0};
2965 shrgi
.cbSize
= sizeof(SHRGINFO
);
2966 shrgi
.hwndClient
= (HWND
) GetHWND();
2970 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2971 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2973 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2976 pt
= ClientToScreen(pt
);
2978 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2980 evtCtx
.SetEventObject(this);
2981 if (HandleWindowEvent(evtCtx
))
2990 #else // !__WXWINCE__
2991 wxWindowMSW
*win
= this;
2992 #endif // __WXWINCE__/!__WXWINCE__
2994 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2996 // if the app didn't eat the event, handle it in the default
2997 // way, that is by giving this window the focus
3000 // for the standard classes their WndProc sets the focus to
3001 // them anyhow and doing it from here results in some weird
3002 // problems, so don't do it for them (unnecessary anyhow)
3003 if ( !win
->IsOfStandardClass() )
3005 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
3017 case MM_JOY1BUTTONDOWN
:
3018 case MM_JOY2BUTTONDOWN
:
3019 case MM_JOY1BUTTONUP
:
3020 case MM_JOY2BUTTONUP
:
3021 processed
= HandleJoystickEvent(message
,
3026 #endif // __WXMICROWIN__
3032 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
3034 processed
= HandleCommand(id
, cmd
, hwnd
);
3039 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
3042 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3043 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3044 // apparently doesn't always behave properly and needs some help
3045 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3046 case WM_NOTIFYFORMAT
:
3047 if ( lParam
== NF_QUERY
)
3050 rc
.result
= NFR_UNICODE
;
3053 #endif // wxUSE_UNICODE_MSLU
3055 // for these messages we must return true if process the message
3058 processed
= MSWOnDrawItem(wParam
, (WXDRAWITEMSTRUCT
*)lParam
);
3063 case WM_MEASUREITEM
:
3064 processed
= MSWOnMeasureItem(wParam
, (WXMEASUREITEMSTRUCT
*)lParam
);
3068 #endif // defined(WM_DRAWITEM)
3071 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3073 // we always want to get the char events
3074 rc
.result
= DLGC_WANTCHARS
;
3076 if ( HasFlag(wxWANTS_CHARS
) )
3078 // in fact, we want everything
3079 rc
.result
|= DLGC_WANTARROWS
|
3086 //else: get the dlg code from the DefWindowProc()
3091 // Generate the key down event in any case.
3092 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3093 if ( m_lastKeydownProcessed
)
3095 // If it was processed by an event handler, we stop here,
3096 // notably we intentionally don't generate char event then.
3099 else // key down event not handled
3101 // Examine the event to decide whether we need to generate a
3102 // char event for it ourselves or let Windows do it. Window
3103 // mostly only does it for the keys which produce printable
3104 // characters (although there are exceptions, e.g. VK_ESCAPE or
3105 // VK_BACK (but not VK_DELETE)) while we do it for all keys
3106 // except the modifier ones (the wisdom of this is debatable
3107 // but by now this decision is enshrined forever due to
3108 // backwards compatibility).
3111 // No wxEVT_CHAR events are generated for these keys at all.
3119 // Windows will send us WM_CHAR for these ones so we'll
3120 // generate wxEVT_CHAR for them later when we get it.
3156 // special case of VK_APPS: treat it the same as right mouse
3157 // click because both usually pop up a context menu
3159 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3164 if ( (wParam
>= '0' && wParam
<= '9') ||
3165 (wParam
>= 'A' && wParam
<= 'Z') )
3167 // We'll get WM_CHAR for those later too.
3171 // But for the rest we won't get WM_CHAR later so we do
3172 // need to generate the event right now.
3173 wxKeyEvent
event(wxEVT_CHAR
);
3174 InitAnyKeyEvent(event
, wParam
, lParam
);
3176 // Set the "extended" bit in lParam because we want to
3177 // generate CHAR events with WXK_HOME and not
3178 // WXK_NUMPAD_HOME even if the "Home" key on numpad was
3180 event
.m_keyCode
= wxMSWKeyboard::VKToWX
3183 lParam
| (KF_EXTENDED
<< 16)
3186 // Don't produce events without any valid character
3187 // code (even if this shouldn't normally happen...).
3188 if ( event
.m_keyCode
!= WXK_NONE
)
3189 processed
= HandleWindowEvent(event
);
3192 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3199 // special case of VK_APPS: treat it the same as right mouse button
3200 if ( wParam
== VK_APPS
)
3202 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3207 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3212 case WM_CHAR
: // Always an ASCII character
3213 if ( m_lastKeydownProcessed
)
3215 // The key was handled in the EVT_KEY_DOWN and handling
3216 // a key in an EVT_KEY_DOWN handler is meant, by
3217 // design, to prevent EVT_CHARs from happening
3218 m_lastKeydownProcessed
= false;
3223 processed
= HandleChar((WORD
)wParam
, lParam
);
3227 case WM_IME_STARTCOMPOSITION
:
3228 // IME popup needs Escape as it should undo the changes in its
3229 // entry window instead of e.g. closing the dialog for which the
3230 // IME is used (and losing all the changes in the IME window).
3231 gs_modalEntryWindowCount
++;
3234 case WM_IME_ENDCOMPOSITION
:
3235 gs_modalEntryWindowCount
--;
3240 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3242 #endif // wxUSE_HOTKEY
3247 processed
= HandleClipboardEvent(message
);
3255 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3257 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3263 // CTLCOLOR messages are sent by children to query the parent for their
3265 #ifndef __WXMICROWIN__
3266 case WM_CTLCOLORMSGBOX
:
3267 case WM_CTLCOLOREDIT
:
3268 case WM_CTLCOLORLISTBOX
:
3269 case WM_CTLCOLORBTN
:
3270 case WM_CTLCOLORDLG
:
3271 case WM_CTLCOLORSCROLLBAR
:
3272 case WM_CTLCOLORSTATIC
:
3276 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3278 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3281 #endif // !__WXMICROWIN__
3283 case WM_SYSCOLORCHANGE
:
3284 // the return value for this message is ignored
3285 processed
= HandleSysColorChange();
3288 #if !defined(__WXWINCE__)
3289 case WM_DISPLAYCHANGE
:
3290 processed
= HandleDisplayChange();
3294 case WM_PALETTECHANGED
:
3295 processed
= HandlePaletteChanged((WXHWND
)wParam
);
3298 case WM_CAPTURECHANGED
:
3299 processed
= HandleCaptureChanged((WXHWND
)lParam
);
3302 case WM_SETTINGCHANGE
:
3303 processed
= HandleSettingChange(wParam
, lParam
);
3306 case WM_QUERYNEWPALETTE
:
3307 processed
= HandleQueryNewPalette();
3312 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
3313 // check if an override was configured for this window
3314 EraseBgHooks::const_iterator it
= gs_eraseBgHooks
.find(this);
3315 if ( it
!= gs_eraseBgHooks
.end() )
3316 processed
= it
->second
->MSWEraseBgHook((WXHDC
)wParam
);
3318 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
3319 processed
= HandleEraseBkgnd((WXHDC
)wParam
);
3324 // we processed the message, i.e. erased the background
3329 #if !defined(__WXWINCE__)
3331 processed
= HandleDropFiles(wParam
);
3336 processed
= HandleInitDialog((WXHWND
)wParam
);
3340 // we never set focus from here
3345 #if !defined(__WXWINCE__)
3346 case WM_QUERYENDSESSION
:
3347 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3351 processed
= HandleEndSession(wParam
!= 0, lParam
);
3354 case WM_GETMINMAXINFO
:
3355 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3360 processed
= HandleSetCursor((WXHWND
)wParam
,
3361 LOWORD(lParam
), // hit test
3362 HIWORD(lParam
)); // mouse msg
3366 // returning TRUE stops the DefWindowProc() from further
3367 // processing this message - exactly what we need because we've
3368 // just set the cursor.
3373 #if wxUSE_ACCESSIBILITY
3376 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3377 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3379 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3381 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3387 #if defined(WM_HELP)
3390 // by default, WM_HELP is propagated by DefWindowProc() upwards
3391 // to the window parent but as we do it ourselves already
3392 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3393 // to get the other events if we process this message at all
3396 // WM_HELP doesn't use lParam under CE
3398 HELPINFO
* info
= (HELPINFO
*) lParam
;
3399 if ( info
->iContextType
== HELPINFO_WINDOW
)
3401 #endif // !__WXWINCE__
3402 wxHelpEvent helpEvent
3407 wxGetMousePosition() // what else?
3409 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3413 helpEvent
.SetEventObject(this);
3414 HandleWindowEvent(helpEvent
);
3417 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3419 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3420 helpEvent
.SetEventObject(this);
3421 HandleWindowEvent(helpEvent
);
3424 else // unknown help event?
3428 #endif // !__WXWINCE__
3433 #if !defined(__WXWINCE__)
3434 case WM_CONTEXTMENU
:
3436 // we don't convert from screen to client coordinates as
3437 // the event may be handled by a parent window
3438 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3440 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3442 // we could have got an event from our child, reflect it back
3443 // to it if this is the case
3444 wxWindowMSW
*win
= NULL
;
3445 WXHWND hWnd
= (WXHWND
)wParam
;
3446 if ( hWnd
!= m_hWnd
)
3448 win
= FindItemByHWND(hWnd
);
3454 evtCtx
.SetEventObject(win
);
3455 processed
= win
->HandleWindowEvent(evtCtx
);
3462 // we're only interested in our own menus, not MF_SYSMENU
3463 if ( HIWORD(wParam
) == MF_POPUP
)
3465 // handle menu chars for ownerdrawn menu items
3466 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3467 if ( i
!= wxNOT_FOUND
)
3469 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3474 #endif // wxUSE_MENUS
3477 case WM_POWERBROADCAST
:
3480 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3481 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3484 #endif // __WXWINCE__
3487 // If we want the default themed border then we need to draw it ourselves
3490 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3491 const wxBorder border
= TranslateBorder(GetBorder());
3492 if (theme
&& border
== wxBORDER_THEME
)
3494 // first ask the widget to calculate the border size
3495 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3498 // now alter the client size making room for drawing a
3501 NCCALCSIZE_PARAMS
*csparam
= NULL
;
3504 csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3505 rect
= &csparam
->rgrc
[0];
3509 rect
= (RECT
*)lParam
;
3512 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3513 RECT rcClient
= { 0, 0, 0, 0 };
3514 wxClientDC
dc((wxWindow
*)this);
3515 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3517 if ( theme
->GetThemeBackgroundContentRect
3524 &rcClient
) == S_OK
)
3526 InflateRect(&rcClient
, -1, -1);
3528 csparam
->rgrc
[0] = rcClient
;
3530 *((RECT
*)lParam
) = rcClient
;
3532 // WVR_REDRAW triggers a bug whereby child windows are moved up and left,
3534 // rc.result = WVR_REDRAW;
3542 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3543 const wxBorder border
= TranslateBorder(GetBorder());
3544 if (theme
&& border
== wxBORDER_THEME
)
3546 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3547 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3550 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3551 wxWindowDC
dc((wxWindow
*)this);
3552 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3554 // Clip the DC so that you only draw on the non-client area
3556 wxCopyRectToRECT(GetSize(), rcBorder
);
3559 theme
->GetThemeBackgroundContentRect(
3560 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3561 InflateRect(&rcClient
, -1, -1);
3563 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3564 rcClient
.right
, rcClient
.bottom
);
3566 // Make sure the background is in a proper state
3567 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3569 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3575 nState
= ETS_DISABLED
;
3576 // should we check this?
3577 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3578 // nState = ETS_READONLY;
3580 nState
= ETS_NORMAL
;
3581 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3586 #endif // wxUSE_UXTHEME
3589 // try a custom message handler
3590 const MSWMessageHandlers::const_iterator
3591 i
= gs_messageHandlers
.find(message
);
3592 if ( i
!= gs_messageHandlers
.end() )
3594 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3601 *result
= rc
.result
;
3606 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
3609 if ( !MSWHandleMessage(&result
, message
, wParam
, lParam
) )
3611 #if wxDEBUG_LEVEL >= 2
3612 wxLogTrace("winmsg", wxT("Forwarding %s to DefWindowProc."),
3613 wxGetMessageName(message
));
3614 #endif // wxDEBUG_LEVEL >= 2
3615 result
= MSWDefWindowProc(message
, wParam
, lParam
);
3621 // ----------------------------------------------------------------------------
3622 // wxWindow <-> HWND map
3623 // ----------------------------------------------------------------------------
3625 wxWindow
*wxFindWinFromHandle(HWND hwnd
)
3627 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3628 return i
== gs_windowHandles
.end() ? NULL
: i
->second
;
3631 void wxAssociateWinWithHandle(HWND hwnd
, wxWindowMSW
*win
)
3633 // adding NULL hwnd is (first) surely a result of an error and
3634 // (secondly) breaks menu command processing
3635 wxCHECK_RET( hwnd
!= (HWND
)NULL
,
3636 wxT("attempt to add a NULL hwnd to window list ignored") );
3639 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3640 if ( i
!= gs_windowHandles
.end() )
3642 if ( i
->second
!= win
)
3646 wxT("HWND %p already associated with another window (%s)"),
3647 hwnd
, win
->GetClassInfo()->GetClassName()
3651 //else: this actually happens currently because we associate the window
3652 // with its HWND during creation (if we create it) and also when
3653 // SubclassWin() is called later, this is ok
3655 #endif // wxDEBUG_LEVEL
3657 gs_windowHandles
[hwnd
] = (wxWindow
*)win
;
3660 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3662 gs_windowHandles
.erase(GetHwndOf(win
));
3665 // ----------------------------------------------------------------------------
3666 // various MSW speciic class dependent functions
3667 // ----------------------------------------------------------------------------
3669 // Default destroyer - override if you destroy it in some other way
3670 // (e.g. with MDI child windows)
3671 void wxWindowMSW::MSWDestroyWindow()
3675 void wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3678 int& w
, int& h
) const
3680 // CW_USEDEFAULT can't be used for child windows so just position them at
3681 // the origin by default
3682 x
= pos
.x
== wxDefaultCoord
? 0 : pos
.x
;
3683 y
= pos
.y
== wxDefaultCoord
? 0 : pos
.y
;
3685 AdjustForParentClientOrigin(x
, y
);
3687 // We don't have any clearly good choice for the size by default neither
3688 // but we must use something non-zero.
3689 w
= WidthDefault(size
.x
);
3690 h
= HeightDefault(size
.y
);
3693 NB: there used to be some code here which set the initial size of the
3694 window to the client size of the parent if no explicit size was
3695 specified. This was wrong because wxWidgets programs often assume
3696 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3697 it. To see why, you should understand that Windows sends WM_SIZE from
3698 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3699 from some base class ctor and so this WM_SIZE is not processed in the
3700 real class' OnSize() (because it's not fully constructed yet and the
3701 event goes to some base class OnSize() instead). So the WM_SIZE we
3702 rely on is the one sent when the parent frame resizes its children
3703 but here is the problem: if the child already has just the right
3704 size, nothing will happen as both wxWidgets and Windows check for
3705 this and ignore any attempts to change the window size to the size it
3706 already has - so no WM_SIZE would be sent.
3710 WXHWND
wxWindowMSW::MSWGetParent() const
3712 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3715 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3716 const wxChar
*title
,
3720 WXDWORD extendedStyle
)
3722 // check a common bug in the user code: if the window is created with a
3723 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3724 // single wxWindow object and this results in all sorts of trouble,
3725 // especially for wxTLWs
3726 wxCHECK_MSG( !m_hWnd
, true, "window can't be recreated" );
3728 // this can happen if this function is called using the return value of
3729 // wxApp::GetRegisteredClassName() which failed
3730 wxCHECK_MSG( wclass
, false, "failed to register window class?" );
3733 // choose the position/size for the new window
3735 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3737 // controlId is menu handle for the top level windows, so set it to 0
3738 // unless we're creating a child window
3739 int controlId
= style
& WS_CHILD
? GetId() : 0;
3741 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3742 // which is the same but without CS_[HV]REDRAW class styles so using it
3743 // ensures that the window is not fully repainted on each resize
3744 wxString
className(wclass
);
3745 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3747 className
+= wxApp::GetNoRedrawClassSuffix();
3750 // do create the window
3751 wxWindowCreationHook
hook(this);
3753 m_hWnd
= (WXHWND
)::CreateWindowEx
3757 title
? title
: m_windowName
.t_str(),
3760 (HWND
)MSWGetParent(),
3761 (HMENU
)wxUIntToPtr(controlId
),
3763 NULL
// no extra data
3768 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3773 SubclassWin(m_hWnd
);
3778 // ===========================================================================
3779 // MSW message handlers
3780 // ===========================================================================
3782 // ---------------------------------------------------------------------------
3784 // ---------------------------------------------------------------------------
3786 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3788 #ifndef __WXMICROWIN__
3789 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3790 HWND hWnd
= hdr
->hwndFrom
;
3791 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
3793 // if the control is one of our windows, let it handle the message itself
3796 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3799 // VZ: why did we do it? normally this is unnecessary and, besides, it
3800 // breaks the message processing for the toolbars because the tooltip
3801 // notifications were being forwarded to the toolbar child controls
3802 // (if it had any) before being passed to the toolbar itself, so in my
3803 // example the tooltip for the combobox was always shown instead of the
3804 // correct button tooltips
3806 // try all our children
3807 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3810 wxWindow
*child
= node
->GetData();
3811 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3816 node
= node
->GetNext();
3820 // by default, handle it ourselves
3821 return MSWOnNotify(idCtrl
, lParam
, result
);
3822 #else // __WXMICROWIN__
3829 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3831 const wxString
& ttip
)
3833 // I don't know why it happens, but the versions of comctl32.dll starting
3834 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3835 // this message is supposed to be sent to Unicode programs only) -- hence
3836 // we need to handle it as well, otherwise no tooltips will be shown in
3839 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3842 // not a tooltip message or no tooltip to show anyhow
3847 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3849 // We don't want to use the szText buffer because it has a limit of 80
3850 // bytes and this is not enough, especially for Unicode build where it
3851 // limits the tooltip string length to only 40 characters
3853 // The best would be, of course, to not impose any length limitations at
3854 // all but then the buffer would have to be dynamic and someone would have
3855 // to free it and we don't have the tooltip owner object here any more, so
3856 // for now use our own static buffer with a higher fixed max length.
3858 // Note that using a static buffer should not be a problem as only a single
3859 // tooltip can be shown at the same time anyhow.
3861 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3863 // We need to convert tooltip from multi byte to Unicode on the fly.
3864 static wchar_t buf
[513];
3866 // Truncate tooltip length if needed as otherwise we might not have
3867 // enough space for it in the buffer and MultiByteToWideChar() would
3869 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3871 // Convert to WideChar without adding the NULL character. The NULL
3872 // character is added afterwards (this is more efficient).
3873 int len
= ::MultiByteToWideChar
3885 wxLogLastError(wxT("MultiByteToWideChar()"));
3889 ttText
->lpszText
= (LPSTR
) buf
;
3891 else // TTN_NEEDTEXTA
3892 #endif // !wxUSE_UNICODE
3894 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3895 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3896 // to copy the string we have into the buffer
3897 static wxChar buf
[513];
3898 wxStrlcpy(buf
, ttip
.c_str(), WXSIZEOF(buf
));
3899 ttText
->lpszText
= buf
;
3905 #endif // wxUSE_TOOLTIPS
3907 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3909 WXLPARAM
* WXUNUSED(result
))
3914 NMHDR
* hdr
= (NMHDR
*)lParam
;
3915 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3922 wxUnusedVar(lParam
);
3923 #endif // wxUSE_TOOLTIPS
3928 // ---------------------------------------------------------------------------
3929 // end session messages
3930 // ---------------------------------------------------------------------------
3932 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3934 #ifdef ENDSESSION_LOGOFF
3935 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3936 event
.SetEventObject(wxTheApp
);
3937 event
.SetCanVeto(true);
3938 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3940 bool rc
= wxTheApp
->ProcessEvent(event
);
3944 // we may end only if the app didn't veto session closing (double
3946 *mayEnd
= !event
.GetVeto();
3951 wxUnusedVar(logOff
);
3952 wxUnusedVar(mayEnd
);
3957 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3959 #ifdef ENDSESSION_LOGOFF
3960 // do nothing if the session isn't ending
3965 if ( (this != wxTheApp
->GetTopWindow()) )
3968 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3969 event
.SetEventObject(wxTheApp
);
3970 event
.SetCanVeto(false);
3971 event
.SetLoggingOff((logOff
& ENDSESSION_LOGOFF
) != 0);
3973 return wxTheApp
->ProcessEvent(event
);
3975 wxUnusedVar(endSession
);
3976 wxUnusedVar(logOff
);
3981 // ---------------------------------------------------------------------------
3982 // window creation/destruction
3983 // ---------------------------------------------------------------------------
3985 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3988 // VZ: why is this commented out for WinCE? If it doesn't support
3989 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3990 // not with multiple #ifdef's!
3992 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3993 EnsureParentHasControlParentStyle(GetParent());
3994 #endif // !__WXWINCE__
4001 bool wxWindowMSW::HandleDestroy()
4003 // delete our drop target if we've got one
4004 #if wxUSE_DRAG_AND_DROP
4005 if ( m_dropTarget
!= NULL
)
4007 m_dropTarget
->Revoke(m_hWnd
);
4009 wxDELETE(m_dropTarget
);
4011 #endif // wxUSE_DRAG_AND_DROP
4013 // WM_DESTROY handled
4017 // ---------------------------------------------------------------------------
4019 // ---------------------------------------------------------------------------
4021 bool wxWindowMSW::HandleActivate(int state
,
4022 bool WXUNUSED(minimized
),
4023 WXHWND
WXUNUSED(activate
))
4025 wxActivateEvent
event(wxEVT_ACTIVATE
,
4026 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
4028 event
.SetEventObject(this);
4030 return HandleWindowEvent(event
);
4033 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
4035 // Strangly enough, some controls get set focus events when they are being
4036 // deleted, even if they already had focus before.
4037 if ( m_isBeingDeleted
)
4042 // notify the parent keeping track of focus for the kbd navigation
4043 // purposes that we got it
4044 wxChildFocusEvent
eventFocus((wxWindow
*)this);
4045 (void)HandleWindowEvent(eventFocus
);
4051 m_caret
->OnSetFocus();
4053 #endif // wxUSE_CARET
4055 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
4056 event
.SetEventObject(this);
4058 // wxFindWinFromHandle() may return NULL, it is ok
4059 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4061 return HandleWindowEvent(event
);
4064 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4070 m_caret
->OnKillFocus();
4072 #endif // wxUSE_CARET
4074 // Don't send the event when in the process of being deleted. This can
4075 // only cause problems if the event handler tries to access the object.
4076 if ( m_isBeingDeleted
)
4081 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4082 event
.SetEventObject(this);
4084 // wxFindWinFromHandle() may return NULL, it is ok
4085 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4087 return HandleWindowEvent(event
);
4090 // ---------------------------------------------------------------------------
4092 // ---------------------------------------------------------------------------
4094 void wxWindowMSW::SetLabel( const wxString
& label
)
4096 SetWindowText(GetHwnd(), label
.c_str());
4099 wxString
wxWindowMSW::GetLabel() const
4101 return wxGetWindowText(GetHWND());
4104 // ---------------------------------------------------------------------------
4106 // ---------------------------------------------------------------------------
4108 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4110 wxShowEvent
event(GetId(), show
);
4111 event
.SetEventObject(this);
4113 return HandleWindowEvent(event
);
4116 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4118 wxInitDialogEvent
event(GetId());
4119 event
.SetEventObject(this);
4121 return HandleWindowEvent(event
);
4124 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4126 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4127 wxUnusedVar(wParam
);
4129 #else // __WXMICROWIN__
4130 HDROP hFilesInfo
= (HDROP
) wParam
;
4132 // Get the total number of files dropped
4133 UINT gwFilesDropped
= ::DragQueryFile
4141 wxString
*files
= new wxString
[gwFilesDropped
];
4142 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4144 // first get the needed buffer length (+1 for terminating NUL)
4145 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4147 // and now get the file name
4148 ::DragQueryFile(hFilesInfo
, wIndex
,
4149 wxStringBuffer(files
[wIndex
], len
), len
);
4152 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4153 event
.SetEventObject(this);
4156 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4157 event
.m_pos
.x
= dropPoint
.x
;
4158 event
.m_pos
.y
= dropPoint
.y
;
4160 DragFinish(hFilesInfo
);
4162 return HandleWindowEvent(event
);
4167 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4169 int WXUNUSED(mouseMsg
))
4171 #ifndef __WXMICROWIN__
4172 // the logic is as follows:
4173 // 0. if we're busy, set the busy cursor (even for non client elements)
4174 // 1. don't set custom cursor for non client area of enabled windows
4175 // 2. ask user EVT_SET_CURSOR handler for the cursor
4176 // 3. if still no cursor but we're in a TLW, set the global cursor
4178 HCURSOR hcursor
= 0;
4181 hcursor
= wxGetCurrentBusyCursor();
4185 if ( nHitTest
!= HTCLIENT
)
4188 // first ask the user code - it may wish to set the cursor in some very
4189 // specific way (for example, depending on the current position)
4191 wxGetCursorPosMSW(&pt
);
4195 ScreenToClient(&x
, &y
);
4196 wxSetCursorEvent
event(x
, y
);
4197 event
.SetId(GetId());
4198 event
.SetEventObject(this);
4200 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4201 if ( processedEvtSetCursor
&& event
.HasCursor() )
4203 hcursor
= GetHcursorOf(event
.GetCursor());
4208 // the test for processedEvtSetCursor is here to prevent using
4209 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4210 // nothing from it - this is a way to say that our cursor shouldn't
4211 // be used for this point
4212 if ( !processedEvtSetCursor
&& m_cursor
.IsOk() )
4214 hcursor
= GetHcursorOf(m_cursor
);
4217 if ( !hcursor
&& !GetParent() )
4219 const wxCursor
*cursor
= wxGetGlobalCursor();
4220 if ( cursor
&& cursor
->IsOk() )
4222 hcursor
= GetHcursorOf(*cursor
);
4231 ::SetCursor(hcursor
);
4233 // cursor set, stop here
4236 #endif // __WXMICROWIN__
4238 // pass up the window chain
4242 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4243 WXLPARAM
WXUNUSED(lParam
),
4244 bool *WXUNUSED_IN_WINCE(vetoed
))
4250 wxEventType evtType
;
4253 case PBT_APMQUERYSUSPEND
:
4254 evtType
= wxEVT_POWER_SUSPENDING
;
4257 case PBT_APMQUERYSUSPENDFAILED
:
4258 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4261 case PBT_APMSUSPEND
:
4262 evtType
= wxEVT_POWER_SUSPENDED
;
4265 case PBT_APMRESUMESUSPEND
:
4266 evtType
= wxEVT_POWER_RESUME
;
4270 wxLogDebug(wxT("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4273 // these messages are currently not mapped to wx events
4274 case PBT_APMQUERYSTANDBY
:
4275 case PBT_APMQUERYSTANDBYFAILED
:
4276 case PBT_APMSTANDBY
:
4277 case PBT_APMRESUMESTANDBY
:
4278 case PBT_APMBATTERYLOW
:
4279 case PBT_APMPOWERSTATUSCHANGE
:
4280 case PBT_APMOEMEVENT
:
4281 case PBT_APMRESUMECRITICAL
:
4282 #ifdef PBT_APMRESUMEAUTOMATIC
4283 case PBT_APMRESUMEAUTOMATIC
:
4285 evtType
= wxEVT_NULL
;
4289 // don't handle unknown messages
4290 if ( evtType
== wxEVT_NULL
)
4293 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4295 wxPowerEvent
event(evtType
);
4296 if ( !HandleWindowEvent(event
) )
4299 *vetoed
= event
.IsVetoed();
4305 bool wxWindowMSW::IsDoubleBuffered() const
4307 for ( const wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4309 if ( wxHasWindowExStyle(win
, WS_EX_COMPOSITED
) )
4312 if ( win
->IsTopLevel() )
4319 void wxWindowMSW::SetDoubleBuffered(bool on
)
4321 // Get the current extended style bits
4322 long exstyle
= wxGetWindowExStyle(this);
4324 // Twiddle the bit as needed
4326 exstyle
|= WS_EX_COMPOSITED
;
4328 exstyle
&= ~WS_EX_COMPOSITED
;
4331 wxSetWindowExStyle(this, exstyle
);
4334 // ---------------------------------------------------------------------------
4335 // owner drawn stuff
4336 // ---------------------------------------------------------------------------
4338 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4339 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4340 #define WXUNUSED_UNLESS_ODRAWN(param) param
4342 #define WXUNUSED_UNLESS_ODRAWN(param)
4346 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4347 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4349 #if wxUSE_OWNER_DRAWN
4351 #if wxUSE_MENUS_NATIVE
4352 // is it a menu item?
4353 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4354 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4356 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4358 // see comment before the same test in MSWOnMeasureItem() below
4362 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4363 false, wxT("MSWOnDrawItem: bad wxMenuItem pointer") );
4365 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4366 // the DC from being released
4367 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4368 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4369 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4370 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4372 return pMenuItem
->OnDrawItem
4376 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4377 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4380 #endif // wxUSE_MENUS_NATIVE
4382 #endif // USE_OWNER_DRAWN
4384 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4386 #if wxUSE_OWNER_DRAWN
4387 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4388 #else // !wxUSE_OWNER_DRAWN
4389 // we may still have owner-drawn buttons internally because we have to make
4390 // them owner-drawn to support colour change
4393 wxDynamicCast(FindItem(id
), wxButton
)
4398 #endif // USE_OWNER_DRAWN
4402 return item
->MSWOnDraw(itemStruct
);
4405 #endif // wxUSE_CONTROLS
4411 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4413 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4414 // is it a menu item?
4415 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4416 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4418 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4420 // according to Carsten Fuchs the pointer may be NULL under XP if an
4421 // MDI child frame is initially maximized, see this for more info:
4422 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4424 // so silently ignore it instead of asserting
4428 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4429 false, wxT("MSWOnMeasureItem: bad wxMenuItem pointer") );
4432 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4434 pMeasureStruct
->itemWidth
= w
;
4435 pMeasureStruct
->itemHeight
= h
;
4440 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4443 return item
->MSWOnMeasure(itemStruct
);
4447 wxUnusedVar(itemStruct
);
4448 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4453 // ---------------------------------------------------------------------------
4454 // colours and palettes
4455 // ---------------------------------------------------------------------------
4457 bool wxWindowMSW::HandleSysColorChange()
4459 wxSysColourChangedEvent event
;
4460 event
.SetEventObject(this);
4462 (void)HandleWindowEvent(event
);
4464 // always let the system carry on the default processing to allow the
4465 // native controls to react to the colours update
4469 bool wxWindowMSW::HandleDisplayChange()
4471 wxDisplayChangedEvent event
;
4472 event
.SetEventObject(this);
4474 return HandleWindowEvent(event
);
4477 #ifndef __WXMICROWIN__
4479 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4481 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4485 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4488 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4490 #endif // wxUSE_CONTROLS
4493 return *brush
!= NULL
;
4496 #endif // __WXMICROWIN__
4498 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4501 // same as below except we don't respond to our own messages
4502 if ( hWndPalChange
!= GetHWND() )
4504 // check to see if we our our parents have a custom palette
4505 wxWindowMSW
*win
= this;
4506 while ( win
&& !win
->HasCustomPalette() )
4508 win
= win
->GetParent();
4511 if ( win
&& win
->HasCustomPalette() )
4513 // realize the palette to see whether redrawing is needed
4514 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4515 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4516 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4518 int result
= ::RealizePalette(hdc
);
4520 // restore the palette (before releasing the DC)
4521 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4522 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4523 ::RealizePalette(hdc
);
4524 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4526 // now check for the need to redraw
4528 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4532 #endif // wxUSE_PALETTE
4534 wxPaletteChangedEvent
event(GetId());
4535 event
.SetEventObject(this);
4536 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4538 return HandleWindowEvent(event
);
4541 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4543 // notify windows on the capture stack about lost capture
4544 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4545 wxWindowBase::NotifyCaptureLost();
4547 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4548 wxMouseCaptureChangedEvent
event(GetId(), win
);
4549 event
.SetEventObject(this);
4550 return HandleWindowEvent(event
);
4553 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4555 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4556 // we need to send this to child windows (it is only sent to top-level
4557 // windows) so {list,tree}ctrls can adjust their font size if necessary
4558 // this is exactly how explorer does it to enable the font size changes
4560 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4563 // top-level windows already get this message from the system
4564 wxWindow
*win
= node
->GetData();
4565 if ( !win
->IsTopLevel() )
4567 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4570 node
= node
->GetNext();
4573 // let the system handle it
4577 bool wxWindowMSW::HandleQueryNewPalette()
4581 // check to see if we our our parents have a custom palette
4582 wxWindowMSW
*win
= this;
4583 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4584 if (win
->HasCustomPalette()) {
4585 /* realize the palette to see whether redrawing is needed */
4586 HDC hdc
= ::GetDC((HWND
) GetHWND());
4587 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4588 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4590 int result
= ::RealizePalette(hdc
);
4591 /* restore the palette (before releasing the DC) */
4592 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4593 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4594 ::RealizePalette(hdc
);
4595 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4596 /* now check for the need to redraw */
4598 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4600 #endif // wxUSE_PALETTE
4602 wxQueryNewPaletteEvent
event(GetId());
4603 event
.SetEventObject(this);
4605 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4608 // Responds to colour changes: passes event on to children.
4609 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4611 // the top level window also reset the standard colour map as it might have
4612 // changed (there is no need to do it for the non top level windows as we
4613 // only have to do it once)
4617 gs_hasStdCmap
= false;
4619 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4622 // Only propagate to non-top-level windows because Windows already
4623 // sends this event to all top-level ones
4624 wxWindow
*win
= node
->GetData();
4625 if ( !win
->IsTopLevel() )
4627 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4628 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4629 // the standard controls
4630 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4633 node
= node
->GetNext();
4637 extern wxCOLORMAP
*wxGetStdColourMap()
4639 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4640 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4642 if ( !gs_hasStdCmap
)
4644 static bool s_coloursInit
= false;
4646 if ( !s_coloursInit
)
4648 // When a bitmap is loaded, the RGB values can change (apparently
4649 // because Windows adjusts them to care for the old programs always
4650 // using 0xc0c0c0 while the transparent colour for the new Windows
4651 // versions is different). But we do this adjustment ourselves so
4652 // we want to avoid Windows' "help" and for this we need to have a
4653 // reference bitmap which can tell us what the RGB values change
4655 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4656 wxBitmap
stdColourBitmap(wxT("wxBITMAP_STD_COLOURS"));
4657 if ( stdColourBitmap
.IsOk() )
4659 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4660 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4661 wxT("forgot to update wxBITMAP_STD_COLOURS!") );
4664 memDC
.SelectObject(stdColourBitmap
);
4667 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4669 memDC
.GetPixel(i
, 0, &colour
);
4670 s_stdColours
[i
] = wxColourToRGB(colour
);
4673 else // wxBITMAP_STD_COLOURS couldn't be loaded
4675 s_stdColours
[0] = RGB(000,000,000); // black
4676 s_stdColours
[1] = RGB(128,128,128); // dark grey
4677 s_stdColours
[2] = RGB(192,192,192); // light grey
4678 s_stdColours
[3] = RGB(255,255,255); // white
4679 //s_stdColours[4] = RGB(000,000,255); // blue
4680 //s_stdColours[5] = RGB(255,000,255); // magenta
4683 s_coloursInit
= true;
4686 gs_hasStdCmap
= true;
4688 // create the colour map
4689 #define INIT_CMAP_ENTRY(col) \
4690 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4691 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4693 INIT_CMAP_ENTRY(BTNTEXT
);
4694 INIT_CMAP_ENTRY(BTNSHADOW
);
4695 INIT_CMAP_ENTRY(BTNFACE
);
4696 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4698 #undef INIT_CMAP_ENTRY
4704 #if wxUSE_UXTHEME && !defined(TMT_FILLCOLOR)
4705 #define TMT_FILLCOLOR 3802
4706 #define TMT_TEXTCOLOR 3803
4707 #define TMT_BORDERCOLOR 3801
4710 wxColour
wxWindowMSW::MSWGetThemeColour(const wchar_t *themeName
,
4713 MSWThemeColour themeColour
,
4714 wxSystemColour fallback
) const
4717 const wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
4720 int themeProperty
= 0;
4722 // TODO: Convert this into a table? Sure would be faster.
4723 switch ( themeColour
)
4725 case ThemeColourBackground
:
4726 themeProperty
= TMT_FILLCOLOR
;
4728 case ThemeColourText
:
4729 themeProperty
= TMT_TEXTCOLOR
;
4731 case ThemeColourBorder
:
4732 themeProperty
= TMT_BORDERCOLOR
;
4735 wxFAIL_MSG(wxT("unsupported theme colour"));
4738 wxUxThemeHandle
hTheme((const wxWindow
*)this, themeName
);
4740 HRESULT hr
= theme
->GetThemeColor
4749 if ( SUCCEEDED(hr
) )
4750 return wxRGBToColour(col
);
4754 "GetThemeColor(%s, %i, %i, %i)",
4755 themeName
, themePart
, themeState
, themeProperty
),
4759 wxUnusedVar(themeName
);
4760 wxUnusedVar(themePart
);
4761 wxUnusedVar(themeState
);
4762 wxUnusedVar(themeColour
);
4764 return wxSystemSettings::GetColour(fallback
);
4767 // ---------------------------------------------------------------------------
4769 // ---------------------------------------------------------------------------
4771 // this variable is used to check that a paint event handler which processed
4772 // the event did create a wxPaintDC inside its code and called BeginPaint() to
4773 // validate the invalidated window area as otherwise we'd keep getting an
4774 // endless stream of WM_PAINT messages for this window resulting in a lot of
4775 // difficult to debug problems (e.g. impossibility to repaint other windows,
4776 // lack of timer and idle events and so on)
4777 extern bool wxDidCreatePaintDC
;
4778 bool wxDidCreatePaintDC
= false;
4780 bool wxWindowMSW::HandlePaint()
4782 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4785 wxLogLastError(wxT("CreateRectRgn"));
4787 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4789 wxLogLastError(wxT("GetUpdateRgn"));
4792 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4794 wxDidCreatePaintDC
= false;
4796 wxPaintEvent
event(m_windowId
);
4797 event
.SetEventObject(this);
4799 bool processed
= HandleWindowEvent(event
);
4801 if ( processed
&& !wxDidCreatePaintDC
)
4803 // do call MSWDefWindowProc() to validate the update region to avoid
4804 // the problems mentioned above
4808 // note that we must generate NC event after the normal one as otherwise
4809 // BeginPaint() will happily overwrite our decorations with the background
4811 wxNcPaintEvent
eventNc(m_windowId
);
4812 eventNc
.SetEventObject(this);
4813 HandleWindowEvent(eventNc
);
4815 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4816 // be called from inside the event handlers called above)
4817 m_updateRegion
.Clear();
4822 // Can be called from an application's OnPaint handler
4823 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4825 #ifdef __WXUNIVERSAL__
4828 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4831 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4836 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4838 if ( IsBeingDeleted() )
4840 // We can get WM_ERASEBKGND after starting the destruction of our top
4841 // level parent. Handling it in this case is unnecessary and can be
4842 // actually harmful as e.g. wxStaticBox::GetClientSize() doesn't work
4843 // without a valid TLW parent (because it uses dialog units internally
4844 // which use the dialog font), so just don't do anything then.
4848 switch ( GetBackgroundStyle() )
4850 case wxBG_STYLE_ERASE
:
4851 case wxBG_STYLE_COLOUR
:
4852 // we need to generate an erase background event
4854 wxDCTemp
dc(hdc
, GetClientSize());
4855 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4858 impl
->SetWindow((wxWindow
*)this);
4860 wxEraseEvent
event(m_windowId
, &dc
);
4861 event
.SetEventObject(this);
4862 bool rc
= HandleWindowEvent(event
);
4864 // must be called manually as ~wxDC doesn't do anything for
4866 impl
->SelectOldObjects(hdc
);
4870 // background erased by the user-defined handler
4876 case wxBG_STYLE_SYSTEM
:
4877 if ( !DoEraseBackground(hdc
) )
4879 // let the default processing to take place if we didn't erase
4880 // the background ourselves
4885 case wxBG_STYLE_PAINT
:
4886 case wxBG_STYLE_TRANSPARENT
:
4887 // no need to do anything here at all, background will be entirely
4888 // redrawn in WM_PAINT handler
4892 wxFAIL_MSG( "unknown background style" );
4898 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
4900 bool wxWindowMSW::MSWHasEraseBgHook() const
4902 return gs_eraseBgHooks
.find(const_cast<wxWindowMSW
*>(this))
4903 != gs_eraseBgHooks
.end();
4906 void wxWindowMSW::MSWSetEraseBgHook(wxWindow
*child
)
4910 if ( !gs_eraseBgHooks
.insert(
4911 EraseBgHooks::value_type(this, child
)).second
)
4913 wxFAIL_MSG( wxT("Setting erase background hook twice?") );
4916 else // reset the hook
4918 if ( gs_eraseBgHooks
.erase(this) != 1 )
4920 wxFAIL_MSG( wxT("Resetting erase background which was not set?") );
4925 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
4927 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4929 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4933 // erase just the client area of the window, this is important for the
4934 // frames to avoid drawing over the toolbar part of the window (you might
4935 // think using WS_CLIPCHILDREN would prevent this from happening, but it
4938 wxCopyRectToRECT(GetClientRect(), rc
);
4939 ::FillRect((HDC
)hDC
, &rc
, hbr
);
4945 wxWindowMSW::MSWGetBgBrushForChild(WXHDC hDC
, wxWindowMSW
*child
)
4947 // Test for the custom background brush first.
4948 WXHBRUSH hbrush
= MSWGetCustomBgBrush();
4951 // We assume that this is either a stipple or hatched brush and not a
4952 // solid one as otherwise it would have been enough to set the
4953 // background colour and such brushes need to be positioned correctly
4954 // in order to align when different windows are painted, so do it here.
4956 ::GetWindowRect(GetHwndOf(child
), &rc
);
4958 ::MapWindowPoints(NULL
, GetHwnd(), (POINT
*)&rc
, 1);
4960 if ( !::SetBrushOrgEx((HDC
)hDC
, -rc
.left
, -rc
.top
, NULL
) )
4962 wxLogLastError(wxT("SetBrushOrgEx(bg brush)"));
4968 // Otherwise see if we have a custom background colour.
4972 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4974 return (WXHBRUSH
)GetHbrushOf(*brush
);
4980 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
)
4982 // Use the special wxWindowBeingErased variable if it is set as the child
4984 wxWindowMSW
* const child
=
4986 wxWindowBeingErased
? wxWindowBeingErased
:
4990 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4992 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, child
);
4996 // don't use the parent background if we're not transparent
4997 if ( !win
->HasTransparentBackground() )
5000 // background is not inherited beyond top level windows
5001 if ( win
->IsTopLevel() )
5008 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
5010 // we receive this message when DrawThemeParentBackground() is
5011 // called from def window proc of several controls under XP and we
5012 // must draw properly themed background here
5014 // note that naively I'd expect filling the client rect with the
5015 // brush returned by MSWGetBgBrush() work -- but for some reason it
5016 // doesn't and we have to call parents MSWPrintChild() which is
5017 // supposed to call DrawThemeBackground() with appropriate params
5019 // also note that in this case lParam == PRF_CLIENT but we're
5020 // clearly expected to paint the background and nothing else!
5022 if ( IsTopLevel() || InheritsBackgroundColour() )
5025 // sometimes we don't want the parent to handle it at all, instead
5026 // return whatever value this window wants
5027 if ( !MSWShouldPropagatePrintChild() )
5028 return MSWPrintChild(hDC
, (wxWindow
*)this);
5030 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
5032 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
5035 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
5042 // ---------------------------------------------------------------------------
5043 // moving and resizing
5044 // ---------------------------------------------------------------------------
5046 bool wxWindowMSW::HandleMinimize()
5048 wxIconizeEvent
event(m_windowId
);
5049 event
.SetEventObject(this);
5051 return HandleWindowEvent(event
);
5054 bool wxWindowMSW::HandleMaximize()
5056 wxMaximizeEvent
event(m_windowId
);
5057 event
.SetEventObject(this);
5059 return HandleWindowEvent(event
);
5062 bool wxWindowMSW::HandleMove(int x
, int y
)
5065 wxMoveEvent
event(point
, m_windowId
);
5066 event
.SetEventObject(this);
5068 return HandleWindowEvent(event
);
5071 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
5073 wxMoveEvent
event(rect
, m_windowId
);
5074 event
.SetEventObject(this);
5076 bool rc
= HandleWindowEvent(event
);
5078 rect
= event
.GetRect();
5082 bool wxWindowMSW::HandleEnterSizeMove()
5084 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
5085 event
.SetEventType(wxEVT_MOVE_START
);
5086 event
.SetEventObject(this);
5088 return HandleWindowEvent(event
);
5091 bool wxWindowMSW::HandleExitSizeMove()
5093 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
5094 event
.SetEventType(wxEVT_MOVE_END
);
5095 event
.SetEventObject(this);
5097 return HandleWindowEvent(event
);
5100 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
5102 #if wxUSE_DEFERRED_SIZING
5103 // when we resize this window, its children are probably going to be
5104 // repositioned as well, prepare to use DeferWindowPos() for them
5105 int numChildren
= 0;
5106 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
5108 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
5113 // Protect against valid m_hDWP being overwritten
5114 bool useDefer
= false;
5116 if ( numChildren
> 1 )
5120 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
5123 wxLogLastError(wxT("BeginDeferWindowPos"));
5129 #endif // wxUSE_DEFERRED_SIZING
5131 // update this window size
5132 bool processed
= false;
5136 wxFAIL_MSG( wxT("unexpected WM_SIZE parameter") );
5137 // fall through nevertheless
5141 // we're not interested in these messages at all
5144 case SIZE_MINIMIZED
:
5145 processed
= HandleMinimize();
5148 case SIZE_MAXIMIZED
:
5149 /* processed = */ HandleMaximize();
5150 // fall through to send a normal size event as well
5153 // don't use w and h parameters as they specify the client size
5154 // while according to the docs EVT_SIZE handler is supposed to
5155 // receive the total size
5156 wxSizeEvent
event(GetSize(), m_windowId
);
5157 event
.SetEventObject(this);
5159 processed
= HandleWindowEvent(event
);
5162 #if wxUSE_DEFERRED_SIZING
5163 // and finally change the positions of all child windows at once
5164 if ( useDefer
&& m_hDWP
)
5166 // reset m_hDWP to NULL so that child windows don't try to use our
5167 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
5168 // happen anyhow normally but who knows what weird flow of control we
5169 // may have depending on what the users EVT_SIZE handler does...)
5170 HDWP hDWP
= (HDWP
)m_hDWP
;
5173 // do put all child controls in place at once
5174 if ( !::EndDeferWindowPos(hDWP
) )
5176 wxLogLastError(wxT("EndDeferWindowPos"));
5179 // Reset our children's pending pos/size values.
5180 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
5182 node
= node
->GetNext() )
5184 wxWindowMSW
* const child
= node
->GetData();
5185 child
->MSWEndDeferWindowPos();
5188 #endif // wxUSE_DEFERRED_SIZING
5193 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
5195 wxSizeEvent
event(rect
, m_windowId
);
5196 event
.SetEventObject(this);
5198 bool rc
= HandleWindowEvent(event
);
5200 rect
= event
.GetRect();
5204 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5209 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5213 int minWidth
= GetMinWidth(),
5214 minHeight
= GetMinHeight(),
5215 maxWidth
= GetMaxWidth(),
5216 maxHeight
= GetMaxHeight();
5218 if ( minWidth
!= wxDefaultCoord
)
5220 info
->ptMinTrackSize
.x
= minWidth
;
5224 if ( minHeight
!= wxDefaultCoord
)
5226 info
->ptMinTrackSize
.y
= minHeight
;
5230 if ( maxWidth
!= wxDefaultCoord
)
5232 info
->ptMaxTrackSize
.x
= maxWidth
;
5236 if ( maxHeight
!= wxDefaultCoord
)
5238 info
->ptMaxTrackSize
.y
= maxHeight
;
5246 // ---------------------------------------------------------------------------
5248 // ---------------------------------------------------------------------------
5250 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5252 // sign extend to int from short before comparing with the other int ids
5253 int id
= (signed short)id_
;
5255 #if wxUSE_MENUS_NATIVE
5256 if ( !cmd
&& wxCurrentPopupMenu
)
5258 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5259 wxCurrentPopupMenu
= NULL
;
5261 return popupMenu
->MSWCommand(cmd
, id
);
5263 #endif // wxUSE_MENUS_NATIVE
5265 wxWindow
*win
= NULL
;
5267 // first try to find it from HWND - this works even with the broken
5268 // programs using the same ids for different controls
5271 win
= wxFindWinFromHandle(control
);
5282 return win
->MSWCommand(cmd
, id
);
5285 // the messages sent from the in-place edit control used by the treectrl
5286 // for label editing have id == 0, but they should _not_ be treated as menu
5287 // messages (they are EN_XXX ones, in fact) so don't translate anything
5288 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5291 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, id
);
5292 event
.SetEventObject(this);
5295 return HandleWindowEvent(event
);
5299 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5300 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5301 // notifications to its parent which we want to reflect back to
5303 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5304 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5306 #endif // wxUSE_SPINCTRL
5308 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5309 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5310 // notifications to its parent which we want to reflect back to
5312 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5313 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5321 // ---------------------------------------------------------------------------
5323 // ---------------------------------------------------------------------------
5325 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5329 // our client coords are not quite the same as Windows ones
5330 wxPoint pt
= GetClientAreaOrigin();
5331 event
.m_x
= x
- pt
.x
;
5332 event
.m_y
= y
- pt
.y
;
5334 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5335 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5336 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5337 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5338 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5339 #ifdef wxHAS_XBUTTON
5340 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5341 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5342 #endif // wxHAS_XBUTTON
5343 event
.m_altDown
= ::wxIsAltDown();
5346 event
.SetTimestamp(::GetMessageTime());
5349 event
.SetEventObject(this);
5350 event
.SetId(GetId());
5352 #if wxUSE_MOUSEEVENT_HACK
5353 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5354 gs_lastMouseEvent
.type
= event
.GetEventType();
5355 #endif // wxUSE_MOUSEEVENT_HACK
5359 // Windows doesn't send the mouse events to the static controls (which are
5360 // transparent in the sense that their WM_NCHITTEST handler returns
5361 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5362 // and so we manually check if we don't have a child window under mouse and if
5363 // we do, send the event to it instead of the window Windows had sent WM_XXX
5366 // Notice that this is not done for the mouse move events because this could
5367 // (would?) be too slow, but only for clicks which means that the static texts
5368 // still don't get move, enter nor leave events.
5369 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5371 wxCHECK_MSG( x
&& y
, win
, wxT("NULL pointer in FindWindowForMouseEvent") );
5373 // first try to find a non transparent child: this allows us to send events
5374 // to a static text which is inside a static box, for example
5375 POINT pt
= { *x
, *y
};
5376 HWND hwnd
= GetHwndOf(win
),
5380 hwndUnderMouse
= ::ChildWindowFromPoint
5386 hwndUnderMouse
= ::ChildWindowFromPointEx
5396 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5398 // now try any child window at all
5399 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5402 // check that we have a child window which is susceptible to receive mouse
5403 // events: for this it must be shown and enabled
5404 if ( hwndUnderMouse
&&
5405 hwndUnderMouse
!= hwnd
&&
5406 ::IsWindowVisible(hwndUnderMouse
) &&
5407 ::IsWindowEnabled(hwndUnderMouse
) )
5409 wxWindow
*winUnderMouse
= wxFindWinFromHandle(hwndUnderMouse
);
5410 if ( winUnderMouse
)
5412 // translate the mouse coords to the other window coords
5413 win
->ClientToScreen(x
, y
);
5414 winUnderMouse
->ScreenToClient(x
, y
);
5416 win
= winUnderMouse
;
5422 #endif // __WXWINCE__
5424 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5426 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5427 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5428 // from the message id and take the value in the table to get wxWin event
5430 static const wxEventType eventsMouse
[] =
5441 wxEVT_MIDDLE_DCLICK
,
5442 0, // this one is for wxEVT_MOTION which is not used here
5451 #ifdef wxHAS_XBUTTON
5452 // the same messages are used for both auxillary mouse buttons so we need
5453 // to adjust the index manually
5456 case WM_XBUTTONDOWN
:
5458 case WM_XBUTTONDBLCLK
:
5459 if ( flags
& MK_XBUTTON2
)
5460 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5462 #endif // wxHAS_XBUTTON
5464 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5465 InitMouseEvent(event
, x
, y
, flags
);
5467 return HandleWindowEvent(event
);
5470 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5472 if ( !m_mouseInWindow
)
5474 // it would be wrong to assume that just because we get a mouse move
5475 // event that the mouse is inside the window: although this is usually
5476 // true, it is not if we had captured the mouse, so we need to check
5477 // the mouse coordinates here
5478 if ( !HasCapture() || IsMouseInWindow() )
5480 // Generate an ENTER event
5481 m_mouseInWindow
= true;
5483 #ifdef HAVE_TRACKMOUSEEVENT
5484 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5486 static const _TrackMouseEvent_t
5487 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5488 #else // !__WXWINCE__
5489 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5490 static bool s_initDone
= false;
5493 // see comment in wxApp::GetComCtl32Version() explaining the
5494 // use of wxLoadedDLL
5495 wxLoadedDLL
dllComCtl32(wxT("comctl32.dll"));
5496 if ( dllComCtl32
.IsLoaded() )
5498 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5499 dllComCtl32
.RawGetSymbol(wxT("_TrackMouseEvent"));
5505 if ( s_pfn_TrackMouseEvent
)
5506 #endif // __WXWINCE__/!__WXWINCE__
5508 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5510 trackinfo
.dwFlags
= TME_LEAVE
;
5511 trackinfo
.hwndTrack
= GetHwnd();
5513 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5515 #endif // HAVE_TRACKMOUSEEVENT
5517 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5518 InitMouseEvent(event
, x
, y
, flags
);
5520 (void)HandleWindowEvent(event
);
5523 #ifdef HAVE_TRACKMOUSEEVENT
5524 else // mouse not in window
5526 // Check if we need to send a LEAVE event
5527 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5528 // send it here if we are using native mouse leave tracking
5529 if ( HasCapture() && !IsMouseInWindow() )
5531 GenerateMouseLeave();
5534 #endif // HAVE_TRACKMOUSEEVENT
5536 #if wxUSE_MOUSEEVENT_HACK
5537 // Windows often generates mouse events even if mouse position hasn't
5538 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5540 // Filter this out as it can result in unexpected behaviour compared to
5542 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5543 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5544 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5545 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5547 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5549 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5554 #endif // wxUSE_MOUSEEVENT_HACK
5556 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5561 wxWindowMSW::HandleMouseWheel(wxMouseWheelAxis axis
,
5562 WXWPARAM wParam
, WXLPARAM lParam
)
5564 #if wxUSE_MOUSEWHEEL
5565 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5566 // forwarded up to the parent by DefWindowProc()) and not in the client
5567 // ones as all the other messages, translate them to the client coords for
5570 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5571 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5572 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5573 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5574 event
.m_wheelDelta
= WHEEL_DELTA
;
5575 event
.m_wheelAxis
= axis
;
5577 static int s_linesPerRotation
= -1;
5578 if ( s_linesPerRotation
== -1 )
5580 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5581 &s_linesPerRotation
, 0))
5583 // this is not supposed to happen
5584 wxLogLastError(wxT("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5586 // the default is 3, so use it if SystemParametersInfo() failed
5587 s_linesPerRotation
= 3;
5591 event
.m_linesPerAction
= s_linesPerRotation
;
5592 return HandleWindowEvent(event
);
5594 #else // !wxUSE_MOUSEWHEEL
5595 wxUnusedVar(wParam
);
5596 wxUnusedVar(lParam
);
5599 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5602 void wxWindowMSW::GenerateMouseLeave()
5604 m_mouseInWindow
= false;
5607 if ( wxIsShiftDown() )
5609 if ( wxIsCtrlDown() )
5610 state
|= MK_CONTROL
;
5612 // Only the high-order bit should be tested
5613 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5614 state
|= MK_LBUTTON
;
5615 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5616 state
|= MK_MBUTTON
;
5617 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5618 state
|= MK_RBUTTON
;
5621 wxGetCursorPosMSW(&pt
);
5623 // we need to have client coordinates here for symmetry with
5624 // wxEVT_ENTER_WINDOW
5625 RECT rect
= wxGetWindowRect(GetHwnd());
5629 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5630 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5632 (void)HandleWindowEvent(event
);
5635 // ---------------------------------------------------------------------------
5636 // keyboard handling
5637 // ---------------------------------------------------------------------------
5642 // Implementation of InitAnyKeyEvent() which can also be used when there is no
5643 // associated window: this can happen for the wxEVT_CHAR_HOOK events created by
5644 // the global keyboard hook (e.g. the event might have happened in a non-wx
5647 MSWInitAnyKeyEvent(wxKeyEvent
& event
,
5650 const wxWindowBase
*win
/* may be NULL */)
5654 event
.SetId(win
->GetId());
5655 event
.SetEventObject(const_cast<wxWindowBase
*>(win
));
5657 else // No associated window.
5659 // Use wxID_ANY for compatibility with the old code even if wxID_NONE
5660 // would arguably make more sense.
5661 event
.SetId(wxID_ANY
);
5664 event
.m_shiftDown
= wxIsShiftDown();
5665 event
.m_controlDown
= wxIsCtrlDown();
5666 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5668 event
.m_rawCode
= (wxUint32
) wParam
;
5669 event
.m_rawFlags
= (wxUint32
) lParam
;
5671 event
.SetTimestamp(::GetMessageTime());
5675 } // anonymous namespace
5678 wxWindowMSW::InitAnyKeyEvent(wxKeyEvent
& event
,
5680 WXLPARAM lParam
) const
5682 MSWInitAnyKeyEvent(event
, wParam
, lParam
, this);
5686 wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5688 WXLPARAM lParam
) const
5690 // Catch any attempts to use this with WM_CHAR, it wouldn't work because
5691 // wParam is supposed to be a virtual key and not a character here.
5692 wxASSERT_MSG( evType
!= wxEVT_CHAR
&& evType
!= wxEVT_CHAR_HOOK
,
5693 "CreateKeyEvent() can't be used for char events" );
5695 wxKeyEvent
event(evType
);
5696 InitAnyKeyEvent(event
, wParam
, lParam
);
5698 event
.m_keyCode
= wxMSWKeyboard::VKToWX
5704 #endif // wxUSE_UNICODE
5711 wxWindowMSW::CreateCharEvent(wxEventType evType
,
5713 WXLPARAM lParam
) const
5715 wxKeyEvent
event(evType
);
5716 InitAnyKeyEvent(event
, wParam
, lParam
);
5719 // TODO: wParam uses UTF-16 so this is incorrect for characters outside of
5720 // the BMP, we should use WM_UNICHAR to handle them.
5721 event
.m_uniChar
= wParam
;
5722 #endif // wxUSE_UNICODE
5724 // Set non-Unicode key code too for compatibility if possible.
5725 if ( wParam
< 0x80 )
5727 // It's an ASCII character, no need to translate it.
5728 event
.m_keyCode
= wParam
;
5732 // Check if this key can be represented (as a single character) in the
5734 const wchar_t wc
= wParam
;
5736 if ( wxConvLibc
.FromWChar(&ch
, 1, &wc
, 1) != wxCONV_FAILED
)
5738 // For compatibility continue to provide the key code in this field
5739 // even though using GetUnicodeKey() is recommended now.
5740 event
.m_keyCode
= static_cast<unsigned char>(ch
);
5742 //else: Key can't be represented in the current locale, leave m_keyCode
5743 // as WXK_NONE and use GetUnicodeKey() to access the character.
5746 // the alphanumeric keys produced by pressing AltGr+something on European
5747 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5748 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5749 // alphanumeric, so pretend that there are no modifiers at all (the
5750 // KEY_DOWN event would still have the correct modifiers if they're really
5752 if ( event
.m_controlDown
&& event
.m_altDown
&&
5753 (event
.m_keyCode
>= 32 && event
.m_keyCode
< 256) )
5755 event
.m_controlDown
=
5756 event
.m_altDown
= false;
5762 // isASCII is true only when we're called from WM_CHAR handler and not from
5764 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
)
5766 wxKeyEvent
event(CreateCharEvent(wxEVT_CHAR
, wParam
, lParam
));
5767 return HandleWindowEvent(event
);
5770 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5772 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, wParam
, lParam
));
5773 return HandleWindowEvent(event
);
5776 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5778 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, wParam
, lParam
));
5779 return HandleWindowEvent(event
);
5783 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5784 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5786 // FIXME: implement GetMenuItemCount for WinCE, possibly
5787 // in terms of GetMenuItemInfo
5789 const HMENU hmenu
= (HMENU
)lParam
;
5791 WinStruct
<MENUITEMINFO
> mii
;
5793 // we could use MIIM_FTYPE here as we only need to know if the item is
5794 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5795 // MIIM_FTYPE is not supported under Win95
5796 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5798 // find if we have this letter in any owner drawn item
5799 const int count
= ::GetMenuItemCount(hmenu
);
5800 for ( int i
= 0; i
< count
; i
++ )
5802 // previous loop iteration could modify it, reset it back before
5803 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5806 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5808 if ( mii
.fType
== MFT_OWNERDRAW
)
5810 // dwItemData member of the MENUITEMINFO is a
5811 // pointer to the associated wxMenuItem -- see the
5812 // menu creation code
5813 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5815 const wxString
label(item
->GetItemLabel());
5816 const wxChar
*p
= wxStrchr(label
.t_str(), wxT('&'));
5819 if ( *p
== wxT('&') )
5821 // this is not the accel char, find the real one
5822 p
= wxStrchr(p
+ 1, wxT('&'));
5824 else // got the accel char
5826 // FIXME-UNICODE: this comparison doesn't risk to work
5827 // for non ASCII accelerator characters I'm afraid, but
5829 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5835 // this one doesn't match
5842 else // failed to get the menu text?
5844 // it's not fatal, so don't show error, but still log it
5845 wxLogLastError(wxT("GetMenuItemInfo"));
5852 #endif // wxUSE_MENUS
5854 bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg
)
5856 const wxEventType type
= nMsg
== WM_CUT
? wxEVT_COMMAND_TEXT_CUT
5857 : nMsg
== WM_COPY
? wxEVT_COMMAND_TEXT_COPY
5858 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE
;
5859 wxClipboardTextEvent
evt(type
, GetId());
5861 evt
.SetEventObject(this);
5863 return HandleWindowEvent(evt
);
5866 // ---------------------------------------------------------------------------
5868 // ---------------------------------------------------------------------------
5870 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5874 if ( flags
& JOY_BUTTON1CHG
)
5875 change
= wxJOY_BUTTON1
;
5876 if ( flags
& JOY_BUTTON2CHG
)
5877 change
= wxJOY_BUTTON2
;
5878 if ( flags
& JOY_BUTTON3CHG
)
5879 change
= wxJOY_BUTTON3
;
5880 if ( flags
& JOY_BUTTON4CHG
)
5881 change
= wxJOY_BUTTON4
;
5884 if ( flags
& JOY_BUTTON1
)
5885 buttons
|= wxJOY_BUTTON1
;
5886 if ( flags
& JOY_BUTTON2
)
5887 buttons
|= wxJOY_BUTTON2
;
5888 if ( flags
& JOY_BUTTON3
)
5889 buttons
|= wxJOY_BUTTON3
;
5890 if ( flags
& JOY_BUTTON4
)
5891 buttons
|= wxJOY_BUTTON4
;
5893 // the event ids aren't consecutive so we can't use table based lookup
5895 wxEventType eventType
;
5900 eventType
= wxEVT_JOY_MOVE
;
5905 eventType
= wxEVT_JOY_MOVE
;
5910 eventType
= wxEVT_JOY_ZMOVE
;
5915 eventType
= wxEVT_JOY_ZMOVE
;
5918 case MM_JOY1BUTTONDOWN
:
5920 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5923 case MM_JOY2BUTTONDOWN
:
5925 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5928 case MM_JOY1BUTTONUP
:
5930 eventType
= wxEVT_JOY_BUTTON_UP
;
5933 case MM_JOY2BUTTONUP
:
5935 eventType
= wxEVT_JOY_BUTTON_UP
;
5939 wxFAIL_MSG(wxT("no such joystick event"));
5944 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5945 if ( eventType
== wxEVT_JOY_ZMOVE
)
5946 event
.SetZPosition(x
);
5948 event
.SetPosition(wxPoint(x
, y
));
5949 event
.SetEventObject(this);
5951 return HandleWindowEvent(event
);
5961 // ---------------------------------------------------------------------------
5963 // ---------------------------------------------------------------------------
5965 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5966 WXWORD pos
, WXHWND control
)
5968 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5970 wxWindow
*child
= wxFindWinFromHandle(control
);
5972 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5975 wxScrollWinEvent event
;
5976 event
.SetPosition(pos
);
5977 event
.SetOrientation(orientation
);
5978 event
.SetEventObject(this);
5983 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5987 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5991 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5995 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5999 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
6003 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
6006 case SB_THUMBPOSITION
:
6008 // under Win32, the scrollbar range and position are 32 bit integers,
6009 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
6010 // explicitly query the scrollbar for the correct position (this must
6011 // be done only for these two SB_ events as they are the only one
6012 // carrying the scrollbar position)
6014 WinStruct
<SCROLLINFO
> scrollInfo
;
6015 scrollInfo
.fMask
= SIF_TRACKPOS
;
6017 if ( !::GetScrollInfo(GetHwnd(),
6018 WXOrientToSB(orientation
),
6021 // Not necessarily an error, if there are no scrollbars yet.
6022 // wxLogLastError(wxT("GetScrollInfo"));
6025 event
.SetPosition(scrollInfo
.nTrackPos
);
6028 event
.SetEventType( wParam
== SB_THUMBPOSITION
6029 ? wxEVT_SCROLLWIN_THUMBRELEASE
6030 : wxEVT_SCROLLWIN_THUMBTRACK
);
6037 return HandleWindowEvent(event
);
6040 // ----------------------------------------------------------------------------
6041 // custom message handlers
6042 // ----------------------------------------------------------------------------
6045 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
6047 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
6048 false, wxT("registering handler for the same message twice") );
6050 gs_messageHandlers
[msg
] = handler
;
6055 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
6057 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
6058 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
6059 wxT("unregistering non-registered handler?") );
6061 gs_messageHandlers
.erase(i
);
6064 // ===========================================================================
6066 // ===========================================================================
6068 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
6071 HDC dc
= ::GetDC((HWND
) wnd
);
6074 // the_font.UseResource();
6075 // the_font.RealizeResource();
6076 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
6078 was
= (HFONT
) SelectObject(dc
,fnt
);
6080 GetTextMetrics(dc
, &tm
);
6083 SelectObject(dc
,was
);
6085 ReleaseDC((HWND
)wnd
, dc
);
6088 *x
= tm
.tmAveCharWidth
;
6090 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
6092 // the_font.ReleaseResource();
6095 // ----------------------------------------------------------------------------
6097 // ----------------------------------------------------------------------------
6099 namespace wxMSWKeyboard
6105 // use the "extended" bit of lParam to distinguish extended keys from normal
6106 // keys as the same virtual key code is sent for both by Windows
6108 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
6110 // except that if lParam is 0, it means we don't have real lParam from
6111 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
6112 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
6113 // non-numpad (hence extended) key as this is a more common case
6114 return !lParam
|| (HIWORD(lParam
) & KF_EXTENDED
) ? keyExtended
: keyNormal
;
6117 // this array contains the Windows virtual key codes which map one to one to
6118 // WXK_xxx constants and is used in wxMSWKeyboard::VKToWX/WXToVK() below
6120 // note that keys having a normal and numpad version (e.g. WXK_HOME and
6121 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
6122 const struct wxKeyMapping
6126 } gs_specialKeys
[] =
6128 { VK_CANCEL
, WXK_CANCEL
},
6129 { VK_BACK
, WXK_BACK
},
6130 { VK_TAB
, WXK_TAB
},
6131 { VK_CLEAR
, WXK_CLEAR
},
6132 { VK_SHIFT
, WXK_SHIFT
},
6133 { VK_CONTROL
, WXK_CONTROL
},
6134 { VK_MENU
, WXK_ALT
},
6135 { VK_PAUSE
, WXK_PAUSE
},
6136 { VK_CAPITAL
, WXK_CAPITAL
},
6137 { VK_SPACE
, WXK_SPACE
},
6138 { VK_ESCAPE
, WXK_ESCAPE
},
6139 { VK_SELECT
, WXK_SELECT
},
6140 { VK_PRINT
, WXK_PRINT
},
6141 { VK_EXECUTE
, WXK_EXECUTE
},
6142 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
6143 { VK_HELP
, WXK_HELP
},
6145 { VK_NUMPAD0
, WXK_NUMPAD0
},
6146 { VK_NUMPAD1
, WXK_NUMPAD1
},
6147 { VK_NUMPAD2
, WXK_NUMPAD2
},
6148 { VK_NUMPAD3
, WXK_NUMPAD3
},
6149 { VK_NUMPAD4
, WXK_NUMPAD4
},
6150 { VK_NUMPAD5
, WXK_NUMPAD5
},
6151 { VK_NUMPAD6
, WXK_NUMPAD6
},
6152 { VK_NUMPAD7
, WXK_NUMPAD7
},
6153 { VK_NUMPAD8
, WXK_NUMPAD8
},
6154 { VK_NUMPAD9
, WXK_NUMPAD9
},
6155 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
6156 { VK_ADD
, WXK_NUMPAD_ADD
},
6157 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
6158 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
6159 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
6170 { VK_F10
, WXK_F10
},
6171 { VK_F11
, WXK_F11
},
6172 { VK_F12
, WXK_F12
},
6173 { VK_F13
, WXK_F13
},
6174 { VK_F14
, WXK_F14
},
6175 { VK_F15
, WXK_F15
},
6176 { VK_F16
, WXK_F16
},
6177 { VK_F17
, WXK_F17
},
6178 { VK_F18
, WXK_F18
},
6179 { VK_F19
, WXK_F19
},
6180 { VK_F20
, WXK_F20
},
6181 { VK_F21
, WXK_F21
},
6182 { VK_F22
, WXK_F22
},
6183 { VK_F23
, WXK_F23
},
6184 { VK_F24
, WXK_F24
},
6186 { VK_NUMLOCK
, WXK_NUMLOCK
},
6187 { VK_SCROLL
, WXK_SCROLL
},
6190 { VK_LWIN
, WXK_WINDOWS_LEFT
},
6191 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
6192 { VK_APPS
, WXK_WINDOWS_MENU
},
6193 #endif // VK_APPS defined
6196 } // anonymous namespace
6198 int VKToWX(WXWORD vk
, WXLPARAM lParam
, wchar_t *uc
)
6202 // check the table first
6203 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6205 if ( gs_specialKeys
[n
].vk
== vk
)
6207 wxk
= gs_specialKeys
[n
].wxk
;
6208 if ( wxk
< WXK_START
)
6210 // Unicode code for this key is the same as its ASCII code.
6219 // keys requiring special handling
6234 // MapVirtualKey() returns 0 if it fails to convert the virtual
6235 // key which nicely corresponds to our WXK_NONE.
6236 wxk
= ::MapVirtualKey(vk
, MAPVK_VK_TO_CHAR
);
6238 if ( HIWORD(wxk
) & 0x8000 )
6240 // It's a dead key and we don't return anything at all for them
6241 // as we simply don't have any way to indicate the difference
6242 // between e.g. a normal "'" and "'" as a dead key -- and
6243 // generating the same events for them just doesn't seem like a
6248 // In any case return this as a Unicode character value.
6252 // For compatibility with the old non-Unicode code we continue
6253 // returning key codes for Latin-1 characters directly
6254 // (normally it would really only make sense to do it for the
6255 // ASCII characters, not Latin-1 ones).
6258 // But for anything beyond this we can only return the key
6259 // value as a real Unicode character, not a wxKeyCode
6260 // because this enum values clash with Unicode characters
6261 // (e.g. WXK_LBUTTON also happens to be U+012C a.k.a.
6262 // "LATIN CAPITAL LETTER I WITH BREVE").
6267 // handle extended keys
6269 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
6273 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
6277 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6281 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6285 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6289 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6293 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6297 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6301 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6305 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6309 // don't use ChooseNormalOrExtended() here as the keys are reversed
6310 // here: numpad enter is the extended one
6311 wxk
= HIWORD(lParam
) & KF_EXTENDED
? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6318 if ( (vk
>= '0' && vk
<= '9') || (vk
>= 'A' && vk
<= 'Z') )
6320 // A simple alphanumeric key and the values of them coincide in
6321 // Windows and wx for both ASCII and Unicode codes.
6324 else // Something we simply don't know about at all.
6336 WXWORD
WXToVK(int wxk
, bool *isExtended
)
6338 // check the table first
6339 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6341 if ( gs_specialKeys
[n
].wxk
== wxk
)
6343 // All extended keys (i.e. non-numpad versions of the keys that
6344 // exist both in the numpad and outside of it) are dealt with
6347 *isExtended
= false;
6349 return gs_specialKeys
[n
].vk
;
6353 // and then check for special keys not included in the table
6354 bool extended
= false;
6360 case WXK_NUMPAD_PAGEUP
:
6366 case WXK_NUMPAD_PAGEDOWN
:
6372 case WXK_NUMPAD_END
:
6378 case WXK_NUMPAD_HOME
:
6384 case WXK_NUMPAD_LEFT
:
6396 case WXK_NUMPAD_RIGHT
:
6402 case WXK_NUMPAD_DOWN
:
6408 case WXK_NUMPAD_INSERT
:
6414 case WXK_NUMPAD_DELETE
:
6419 // no VkKeyScan() under CE unfortunately, we need to test how does
6420 // it handle OEM keys
6422 // check to see if its one of the OEM key codes.
6423 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6429 #endif // !__WXWINCE__
6436 *isExtended
= extended
;
6441 } // namespace wxMSWKeyboard
6443 // small helper for wxGetKeyState() and wxGetMouseState()
6444 static inline bool wxIsKeyDown(WXWORD vk
)
6446 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6447 #ifdef SM_SWAPBUTTON
6448 if ( vk
== VK_LBUTTON
|| vk
== VK_RBUTTON
)
6450 if ( ::GetSystemMetrics(SM_SWAPBUTTON
) )
6452 if ( vk
== VK_LBUTTON
)
6454 else // vk == VK_RBUTTON
6458 #endif // SM_SWAPBUTTON
6460 // the low order bit indicates whether the key was pressed since the last
6461 // call and the high order one indicates whether it is down right now and
6462 // we only want that one
6463 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6466 bool wxGetKeyState(wxKeyCode key
)
6468 // although this does work under Windows, it is not supported under other
6469 // platforms so don't allow it, you must use wxGetMouseState() instead
6470 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6471 key
!= VK_RBUTTON
&&
6473 wxT("can't use wxGetKeyState() for mouse buttons") );
6475 const WXWORD vk
= wxMSWKeyboard::WXToVK(key
);
6477 // if the requested key is a LED key, return true if the led is pressed
6478 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6480 // low order bit means LED is highlighted and high order one means the
6481 // key is down; for compatibility with the other ports return true if
6482 // either one is set
6483 return GetKeyState(vk
) != 0;
6488 return wxIsKeyDown(vk
);
6493 wxMouseState
wxGetMouseState()
6497 wxGetCursorPosMSW(&pt
);
6501 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6502 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6503 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6504 #ifdef wxHAS_XBUTTON
6505 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6506 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6507 #endif // wxHAS_XBUTTON
6509 ms
.SetControlDown(wxIsCtrlDown ());
6510 ms
.SetShiftDown (wxIsShiftDown());
6511 ms
.SetAltDown (wxIsAltDown ());
6512 // ms.SetMetaDown();
6518 wxWindow
*wxGetActiveWindow()
6520 HWND hWnd
= GetActiveWindow();
6523 return wxFindWinFromHandle(hWnd
);
6528 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6530 HWND hwnd
= (HWND
)hWnd
;
6532 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6533 // by code in msw/radiobox.cpp), for all the others we just search up the
6535 wxWindow
*win
= NULL
;
6538 win
= wxFindWinFromHandle(hwnd
);
6541 #if wxUSE_RADIOBOX && !defined(__WXUNIVERSAL__)
6542 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6543 // wxWindow class which overrides WM_GETDLGCODE processing to
6544 // do it as well, win would be already non NULL
6545 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6547 win
= wxRadioBox::GetFromRadioButtonHWND(hwnd
);
6549 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6550 #endif // wxUSE_RADIOBOX
6552 // spin control text buddy window should be mapped to spin ctrl
6553 // itself so try it too
6554 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6557 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6559 #endif // wxUSE_SPINCTRL
6563 while ( hwnd
&& !win
)
6565 // this is a really ugly hack needed to avoid mistakenly returning the
6566 // parent frame wxWindow for the find/replace modeless dialog HWND -
6567 // this, in turn, is needed to call IsDialogMessage() from
6568 // wxApp::ProcessMessage() as for this we must return NULL from here
6570 // FIXME: this is clearly not the best way to do it but I think we'll
6571 // need to change HWND <-> wxWindow code more heavily than I can
6572 // do it now to fix it
6573 #ifndef __WXMICROWIN__
6574 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6576 // it's a dialog box, don't go upwards
6581 hwnd
= ::GetParent(hwnd
);
6582 win
= wxFindWinFromHandle(hwnd
);
6588 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6590 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6591 // in active frames and dialogs, regardless of where the focus is.
6592 static HHOOK wxTheKeyboardHook
= 0;
6595 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6597 DWORD hiWord
= HIWORD(lParam
);
6598 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6601 int id
= wxMSWKeyboard::VKToWX(wParam
, lParam
, &uc
);
6603 // Don't intercept keyboard entry (notably Escape) if a modal window
6604 // (not managed by wx, e.g. IME one) is currently opened as more often
6605 // than not it needs all the keys for itself.
6607 // Also don't catch it if a window currently captures the mouse as
6608 // Escape is normally used to release the mouse capture and if you
6609 // really need to catch all the keys in the window that has mouse
6610 // capture it can be easily done in its own EVT_CHAR handler as it is
6611 // certain to have focus while it has the capture.
6612 if ( !gs_modalEntryWindowCount
&& !::GetCapture() )
6616 || static_cast<int>(uc
) != WXK_NONE
6617 #endif // wxUSE_UNICODE
6620 wxWindow
const* win
= wxWindow::DoFindFocus();
6623 // Even if the focus got lost somehow, still send the event
6624 // to the top level parent to allow a wxDialog to always
6626 win
= wxGetActiveWindow();
6629 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6630 MSWInitAnyKeyEvent(event
, wParam
, lParam
, win
);
6632 event
.m_keyCode
= id
;
6634 event
.m_uniChar
= uc
;
6635 #endif // wxUSE_UNICODE
6637 wxEvtHandler
* const handler
= win
? win
->GetEventHandler()
6640 if ( handler
&& handler
->ProcessEvent(event
) )
6642 if ( !event
.IsNextEventAllowed() )
6644 // Stop processing of this event.
6652 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6655 void wxSetKeyboardHook(bool doIt
)
6659 wxTheKeyboardHook
= ::SetWindowsHookEx
6662 (HOOKPROC
)wxKeyboardHook
,
6663 NULL
, // must be NULL for process hook
6664 ::GetCurrentThreadId()
6666 if ( !wxTheKeyboardHook
)
6668 wxLogLastError(wxT("SetWindowsHookEx(wxKeyboardHook)"));
6673 if ( wxTheKeyboardHook
)
6674 ::UnhookWindowsHookEx(wxTheKeyboardHook
);
6678 #endif // !__WXMICROWIN__
6680 #if wxDEBUG_LEVEL >= 2
6681 const wxChar
*wxGetMessageName(int message
)
6685 case 0x0000: return wxT("WM_NULL");
6686 case 0x0001: return wxT("WM_CREATE");
6687 case 0x0002: return wxT("WM_DESTROY");
6688 case 0x0003: return wxT("WM_MOVE");
6689 case 0x0005: return wxT("WM_SIZE");
6690 case 0x0006: return wxT("WM_ACTIVATE");
6691 case 0x0007: return wxT("WM_SETFOCUS");
6692 case 0x0008: return wxT("WM_KILLFOCUS");
6693 case 0x000A: return wxT("WM_ENABLE");
6694 case 0x000B: return wxT("WM_SETREDRAW");
6695 case 0x000C: return wxT("WM_SETTEXT");
6696 case 0x000D: return wxT("WM_GETTEXT");
6697 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6698 case 0x000F: return wxT("WM_PAINT");
6699 case 0x0010: return wxT("WM_CLOSE");
6700 case 0x0011: return wxT("WM_QUERYENDSESSION");
6701 case 0x0012: return wxT("WM_QUIT");
6702 case 0x0013: return wxT("WM_QUERYOPEN");
6703 case 0x0014: return wxT("WM_ERASEBKGND");
6704 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6705 case 0x0016: return wxT("WM_ENDSESSION");
6706 case 0x0017: return wxT("WM_SYSTEMERROR");
6707 case 0x0018: return wxT("WM_SHOWWINDOW");
6708 case 0x0019: return wxT("WM_CTLCOLOR");
6709 case 0x001A: return wxT("WM_WININICHANGE");
6710 case 0x001B: return wxT("WM_DEVMODECHANGE");
6711 case 0x001C: return wxT("WM_ACTIVATEAPP");
6712 case 0x001D: return wxT("WM_FONTCHANGE");
6713 case 0x001E: return wxT("WM_TIMECHANGE");
6714 case 0x001F: return wxT("WM_CANCELMODE");
6715 case 0x0020: return wxT("WM_SETCURSOR");
6716 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6717 case 0x0022: return wxT("WM_CHILDACTIVATE");
6718 case 0x0023: return wxT("WM_QUEUESYNC");
6719 case 0x0024: return wxT("WM_GETMINMAXINFO");
6720 case 0x0026: return wxT("WM_PAINTICON");
6721 case 0x0027: return wxT("WM_ICONERASEBKGND");
6722 case 0x0028: return wxT("WM_NEXTDLGCTL");
6723 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6724 case 0x002B: return wxT("WM_DRAWITEM");
6725 case 0x002C: return wxT("WM_MEASUREITEM");
6726 case 0x002D: return wxT("WM_DELETEITEM");
6727 case 0x002E: return wxT("WM_VKEYTOITEM");
6728 case 0x002F: return wxT("WM_CHARTOITEM");
6729 case 0x0030: return wxT("WM_SETFONT");
6730 case 0x0031: return wxT("WM_GETFONT");
6731 case 0x0037: return wxT("WM_QUERYDRAGICON");
6732 case 0x0039: return wxT("WM_COMPAREITEM");
6733 case 0x0041: return wxT("WM_COMPACTING");
6734 case 0x0044: return wxT("WM_COMMNOTIFY");
6735 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6736 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6737 case 0x0048: return wxT("WM_POWER");
6739 case 0x004A: return wxT("WM_COPYDATA");
6740 case 0x004B: return wxT("WM_CANCELJOURNAL");
6741 case 0x004E: return wxT("WM_NOTIFY");
6742 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6743 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6744 case 0x0052: return wxT("WM_TCARD");
6745 case 0x0053: return wxT("WM_HELP");
6746 case 0x0054: return wxT("WM_USERCHANGED");
6747 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6748 case 0x007B: return wxT("WM_CONTEXTMENU");
6749 case 0x007C: return wxT("WM_STYLECHANGING");
6750 case 0x007D: return wxT("WM_STYLECHANGED");
6751 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6752 case 0x007F: return wxT("WM_GETICON");
6753 case 0x0080: return wxT("WM_SETICON");
6755 case 0x0081: return wxT("WM_NCCREATE");
6756 case 0x0082: return wxT("WM_NCDESTROY");
6757 case 0x0083: return wxT("WM_NCCALCSIZE");
6758 case 0x0084: return wxT("WM_NCHITTEST");
6759 case 0x0085: return wxT("WM_NCPAINT");
6760 case 0x0086: return wxT("WM_NCACTIVATE");
6761 case 0x0087: return wxT("WM_GETDLGCODE");
6762 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6763 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6764 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6765 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6766 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6767 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6768 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6769 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6770 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6771 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6773 case 0x00B0: return wxT("EM_GETSEL");
6774 case 0x00B1: return wxT("EM_SETSEL");
6775 case 0x00B2: return wxT("EM_GETRECT");
6776 case 0x00B3: return wxT("EM_SETRECT");
6777 case 0x00B4: return wxT("EM_SETRECTNP");
6778 case 0x00B5: return wxT("EM_SCROLL");
6779 case 0x00B6: return wxT("EM_LINESCROLL");
6780 case 0x00B7: return wxT("EM_SCROLLCARET");
6781 case 0x00B8: return wxT("EM_GETMODIFY");
6782 case 0x00B9: return wxT("EM_SETMODIFY");
6783 case 0x00BA: return wxT("EM_GETLINECOUNT");
6784 case 0x00BB: return wxT("EM_LINEINDEX");
6785 case 0x00BC: return wxT("EM_SETHANDLE");
6786 case 0x00BD: return wxT("EM_GETHANDLE");
6787 case 0x00BE: return wxT("EM_GETTHUMB");
6788 case 0x00C1: return wxT("EM_LINELENGTH");
6789 case 0x00C2: return wxT("EM_REPLACESEL");
6790 case 0x00C4: return wxT("EM_GETLINE");
6791 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6792 case 0x00C6: return wxT("EM_CANUNDO");
6793 case 0x00C7: return wxT("EM_UNDO");
6794 case 0x00C8: return wxT("EM_FMTLINES");
6795 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6796 case 0x00CB: return wxT("EM_SETTABSTOPS");
6797 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6798 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6799 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6800 case 0x00CF: return wxT("EM_SETREADONLY");
6801 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6802 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6803 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6804 case 0x00D3: return wxT("EM_SETMARGINS");
6805 case 0x00D4: return wxT("EM_GETMARGINS");
6806 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6807 case 0x00D6: return wxT("EM_POSFROMCHAR");
6808 case 0x00D7: return wxT("EM_CHARFROMPOS");
6809 case 0x00D8: return wxT("EM_SETIMESTATUS");
6810 case 0x00D9: return wxT("EM_GETIMESTATUS");
6812 case 0x0100: return wxT("WM_KEYDOWN");
6813 case 0x0101: return wxT("WM_KEYUP");
6814 case 0x0102: return wxT("WM_CHAR");
6815 case 0x0103: return wxT("WM_DEADCHAR");
6816 case 0x0104: return wxT("WM_SYSKEYDOWN");
6817 case 0x0105: return wxT("WM_SYSKEYUP");
6818 case 0x0106: return wxT("WM_SYSCHAR");
6819 case 0x0107: return wxT("WM_SYSDEADCHAR");
6820 case 0x0108: return wxT("WM_KEYLAST");
6822 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6823 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6824 case 0x010F: return wxT("WM_IME_COMPOSITION");
6826 case 0x0110: return wxT("WM_INITDIALOG");
6827 case 0x0111: return wxT("WM_COMMAND");
6828 case 0x0112: return wxT("WM_SYSCOMMAND");
6829 case 0x0113: return wxT("WM_TIMER");
6830 case 0x0114: return wxT("WM_HSCROLL");
6831 case 0x0115: return wxT("WM_VSCROLL");
6832 case 0x0116: return wxT("WM_INITMENU");
6833 case 0x0117: return wxT("WM_INITMENUPOPUP");
6834 case 0x011F: return wxT("WM_MENUSELECT");
6835 case 0x0120: return wxT("WM_MENUCHAR");
6836 case 0x0121: return wxT("WM_ENTERIDLE");
6838 case 0x0127: return wxT("WM_CHANGEUISTATE");
6839 case 0x0128: return wxT("WM_UPDATEUISTATE");
6840 case 0x0129: return wxT("WM_QUERYUISTATE");
6842 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6843 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6844 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6845 case 0x0135: return wxT("WM_CTLCOLORBTN");
6846 case 0x0136: return wxT("WM_CTLCOLORDLG");
6847 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6848 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6849 case 0x01E1: return wxT("MN_GETHMENU");
6851 case 0x0200: return wxT("WM_MOUSEMOVE");
6852 case 0x0201: return wxT("WM_LBUTTONDOWN");
6853 case 0x0202: return wxT("WM_LBUTTONUP");
6854 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6855 case 0x0204: return wxT("WM_RBUTTONDOWN");
6856 case 0x0205: return wxT("WM_RBUTTONUP");
6857 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6858 case 0x0207: return wxT("WM_MBUTTONDOWN");
6859 case 0x0208: return wxT("WM_MBUTTONUP");
6860 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6861 case 0x020A: return wxT("WM_MOUSEWHEEL");
6862 case 0x020B: return wxT("WM_XBUTTONDOWN");
6863 case 0x020C: return wxT("WM_XBUTTONUP");
6864 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6865 case 0x0210: return wxT("WM_PARENTNOTIFY");
6866 case 0x0211: return wxT("WM_ENTERMENULOOP");
6867 case 0x0212: return wxT("WM_EXITMENULOOP");
6869 case 0x0213: return wxT("WM_NEXTMENU");
6870 case 0x0214: return wxT("WM_SIZING");
6871 case 0x0215: return wxT("WM_CAPTURECHANGED");
6872 case 0x0216: return wxT("WM_MOVING");
6873 case 0x0218: return wxT("WM_POWERBROADCAST");
6874 case 0x0219: return wxT("WM_DEVICECHANGE");
6876 case 0x0220: return wxT("WM_MDICREATE");
6877 case 0x0221: return wxT("WM_MDIDESTROY");
6878 case 0x0222: return wxT("WM_MDIACTIVATE");
6879 case 0x0223: return wxT("WM_MDIRESTORE");
6880 case 0x0224: return wxT("WM_MDINEXT");
6881 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6882 case 0x0226: return wxT("WM_MDITILE");
6883 case 0x0227: return wxT("WM_MDICASCADE");
6884 case 0x0228: return wxT("WM_MDIICONARRANGE");
6885 case 0x0229: return wxT("WM_MDIGETACTIVE");
6886 case 0x0230: return wxT("WM_MDISETMENU");
6887 case 0x0233: return wxT("WM_DROPFILES");
6889 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6890 case 0x0282: return wxT("WM_IME_NOTIFY");
6891 case 0x0283: return wxT("WM_IME_CONTROL");
6892 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6893 case 0x0285: return wxT("WM_IME_SELECT");
6894 case 0x0286: return wxT("WM_IME_CHAR");
6895 case 0x0290: return wxT("WM_IME_KEYDOWN");
6896 case 0x0291: return wxT("WM_IME_KEYUP");
6898 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6899 case 0x02A1: return wxT("WM_MOUSEHOVER");
6900 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6901 case 0x02A3: return wxT("WM_MOUSELEAVE");
6903 case 0x0300: return wxT("WM_CUT");
6904 case 0x0301: return wxT("WM_COPY");
6905 case 0x0302: return wxT("WM_PASTE");
6906 case 0x0303: return wxT("WM_CLEAR");
6907 case 0x0304: return wxT("WM_UNDO");
6908 case 0x0305: return wxT("WM_RENDERFORMAT");
6909 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6910 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6911 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6912 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6913 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6914 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6915 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6916 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6917 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6918 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6919 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6920 case 0x0311: return wxT("WM_PALETTECHANGED");
6921 case 0x0312: return wxT("WM_HOTKEY");
6923 case 0x0317: return wxT("WM_PRINT");
6924 case 0x0318: return wxT("WM_PRINTCLIENT");
6926 // common controls messages - although they're not strictly speaking
6927 // standard, it's nice to decode them nevertheless
6930 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6931 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6932 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6933 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6934 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6935 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6936 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6937 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6938 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6939 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6940 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6941 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6942 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6943 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6944 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6945 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6946 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6947 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6948 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6949 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6950 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6951 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6952 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6953 case 0x1000 + 18: return wxT("LVM_HITTEST");
6954 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6955 case 0x1000 + 20: return wxT("LVM_SCROLL");
6956 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6957 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6958 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6959 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6960 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6961 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6962 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6963 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6964 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6965 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6966 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6967 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6968 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6969 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6970 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6971 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6972 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6973 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6974 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6975 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6976 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6977 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6978 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6979 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6980 case 0x1000 + 42: return wxT("LVM_UPDATE");
6981 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6982 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6983 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6984 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6985 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6986 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6987 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6988 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6989 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6990 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6991 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6992 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6993 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6994 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6995 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6996 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6997 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6998 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6999 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
7000 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
7001 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
7002 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
7003 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
7004 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
7005 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
7006 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
7009 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
7010 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
7011 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
7012 case 0x1100 + 2: return wxT("TVM_EXPAND");
7013 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
7014 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
7015 case 0x1100 + 6: return wxT("TVM_GETINDENT");
7016 case 0x1100 + 7: return wxT("TVM_SETINDENT");
7017 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
7018 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
7019 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
7020 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
7021 case 0x1100 + 12: return wxT("TVM_GETITEMA");
7022 case 0x1100 + 62: return wxT("TVM_GETITEMW");
7023 case 0x1100 + 13: return wxT("TVM_SETITEMA");
7024 case 0x1100 + 63: return wxT("TVM_SETITEMW");
7025 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
7026 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
7027 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
7028 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
7029 case 0x1100 + 17: return wxT("TVM_HITTEST");
7030 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
7031 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
7032 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
7033 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
7034 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
7035 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
7036 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
7037 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
7038 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
7041 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
7042 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
7043 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
7044 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
7045 case 0x1200 + 3: return wxT("HDM_GETITEMA");
7046 case 0x1200 + 11: return wxT("HDM_GETITEMW");
7047 case 0x1200 + 4: return wxT("HDM_SETITEMA");
7048 case 0x1200 + 12: return wxT("HDM_SETITEMW");
7049 case 0x1200 + 5: return wxT("HDM_LAYOUT");
7050 case 0x1200 + 6: return wxT("HDM_HITTEST");
7051 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
7052 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
7053 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
7054 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
7055 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
7056 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
7057 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
7058 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
7061 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
7062 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
7063 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
7064 case 0x1300 + 5: return wxT("TCM_GETITEMA");
7065 case 0x1300 + 60: return wxT("TCM_GETITEMW");
7066 case 0x1300 + 6: return wxT("TCM_SETITEMA");
7067 case 0x1300 + 61: return wxT("TCM_SETITEMW");
7068 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
7069 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
7070 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
7071 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
7072 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
7073 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
7074 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
7075 case 0x1300 + 13: return wxT("TCM_HITTEST");
7076 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
7077 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
7078 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
7079 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
7080 case 0x1300 + 43: return wxT("TCM_SETPADDING");
7081 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
7082 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
7083 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
7084 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
7085 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
7086 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
7087 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
7090 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
7091 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
7092 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
7093 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
7094 case WM_USER
+5: return wxT("TB_INDETERMINATE");
7095 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
7096 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
7097 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
7098 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
7099 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
7100 case WM_USER
+17: return wxT("TB_SETSTATE");
7101 case WM_USER
+18: return wxT("TB_GETSTATE");
7102 case WM_USER
+19: return wxT("TB_ADDBITMAP");
7103 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
7104 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
7105 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
7106 case WM_USER
+23: return wxT("TB_GETBUTTON");
7107 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
7108 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
7109 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
7110 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
7111 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
7112 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
7113 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
7114 case WM_USER
+29: return wxT("TB_GETITEMRECT");
7115 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
7116 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
7117 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
7118 case WM_USER
+33: return wxT("TB_AUTOSIZE");
7119 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
7120 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
7121 case WM_USER
+37: return wxT("TB_SETPARENT");
7122 case WM_USER
+39: return wxT("TB_SETROWS");
7123 case WM_USER
+40: return wxT("TB_GETROWS");
7124 case WM_USER
+42: return wxT("TB_SETCMDID");
7125 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
7126 case WM_USER
+44: return wxT("TB_GETBITMAP");
7127 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
7128 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
7129 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
7130 case WM_USER
+47: return wxT("TB_SETINDENT");
7131 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
7132 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
7133 case WM_USER
+50: return wxT("TB_LOADIMAGES");
7134 case WM_USER
+51: return wxT("TB_GETRECT");
7135 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
7136 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
7137 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
7138 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
7139 case WM_USER
+56: return wxT("TB_SETSTYLE");
7140 case WM_USER
+57: return wxT("TB_GETSTYLE");
7141 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
7142 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
7143 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
7144 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
7145 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
7148 static wxString s_szBuf
;
7149 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
7150 return s_szBuf
.c_str();
7153 #endif // wxDEBUG_LEVEL >= 2
7155 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
7159 HWND hwnd
= GetHwndOf(win
);
7160 HDC hdc
= ::GetDC(hwnd
);
7162 #if !wxDIALOG_UNIT_COMPATIBILITY
7163 // and select the current font into it
7164 HFONT hfont
= GetHfontOf(win
->GetFont());
7167 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
7171 // finally retrieve the text metrics from it
7172 GetTextMetrics(hdc
, &tm
);
7174 #if !wxDIALOG_UNIT_COMPATIBILITY
7178 (void)::SelectObject(hdc
, hfont
);
7182 ::ReleaseDC(hwnd
, hdc
);
7187 // Find the wxWindow at the current mouse position, returning the mouse
7189 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
7191 pt
= wxGetMousePosition();
7192 return wxFindWindowAtPoint(pt
);
7195 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
7201 HWND hWnd
= ::WindowFromPoint(pt2
);
7204 // WindowFromPoint() ignores the disabled children but we're supposed
7205 // to take them into account, so check if we have a child at this
7206 // coordinate using ChildWindowFromPointEx().
7211 ::ScreenToClient(hWnd
, &pt2
);
7212 HWND child
= ::ChildWindowFromPointEx(hWnd
, pt2
, CWP_SKIPINVISIBLE
);
7213 if ( child
== hWnd
|| !child
)
7216 // ChildWindowFromPointEx() only examines the immediate children
7217 // but we want to get the deepest (top in Z-order) one, so continue
7218 // iterating for as long as it finds anything.
7223 return wxGetWindowFromHWND((WXHWND
)hWnd
);
7226 // Get the current mouse position.
7227 wxPoint
wxGetMousePosition()
7230 wxGetCursorPosMSW(&pt
);
7232 return wxPoint(pt
.x
, pt
.y
);
7237 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7238 static void WinCEUnregisterHotKey(int modifiers
, int id
)
7240 // Register hotkeys for the hardware buttons
7242 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
7244 UnregisterFunc1Proc procUnregisterFunc
;
7245 hCoreDll
= LoadLibrary(wxT("coredll.dll"));
7248 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, wxT("UnregisterFunc1"));
7249 if (procUnregisterFunc
)
7250 procUnregisterFunc(modifiers
, id
);
7251 FreeLibrary(hCoreDll
);
7256 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
7258 UINT win_modifiers
=0;
7259 if ( modifiers
& wxMOD_ALT
)
7260 win_modifiers
|= MOD_ALT
;
7261 if ( modifiers
& wxMOD_SHIFT
)
7262 win_modifiers
|= MOD_SHIFT
;
7263 if ( modifiers
& wxMOD_CONTROL
)
7264 win_modifiers
|= MOD_CONTROL
;
7265 if ( modifiers
& wxMOD_WIN
)
7266 win_modifiers
|= MOD_WIN
;
7268 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7269 // Required for PPC and Smartphone hardware buttons
7270 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
7271 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
7274 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
7276 wxLogLastError(wxT("RegisterHotKey"));
7284 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
7286 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7287 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
7290 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
7292 wxLogLastError(wxT("UnregisterHotKey"));
7302 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
7304 int win_modifiers
= LOWORD(lParam
);
7306 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, HIWORD(lParam
)));
7307 event
.SetId(wParam
);
7308 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
7309 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
7310 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
7311 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
7313 return HandleWindowEvent(event
);
7316 #endif // wxUSE_ACCEL
7318 #endif // wxUSE_HOTKEY
7320 // Not tested under WinCE
7323 // this class installs a message hook which really wakes up our idle processing
7324 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
7325 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
7326 // being dragged or even inside ::MessageBox()) and so don't control message
7327 // dispatching otherwise
7328 class wxIdleWakeUpModule
: public wxModule
7331 virtual bool OnInit()
7333 ms_hMsgHookProc
= ::SetWindowsHookEx
7336 &wxIdleWakeUpModule::MsgHookProc
,
7338 GetCurrentThreadId()
7341 if ( !ms_hMsgHookProc
)
7343 wxLogLastError(wxT("SetWindowsHookEx(WH_GETMESSAGE)"));
7351 virtual void OnExit()
7353 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
7356 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
7358 MSG
*msg
= (MSG
*)lParam
;
7360 // only process the message if it is actually going to be removed from
7361 // the message queue, this prevents that the same event from being
7362 // processed multiple times if now someone just called PeekMessage()
7363 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7365 wxTheApp
->ProcessPendingEvents();
7368 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7372 static HHOOK ms_hMsgHookProc
;
7374 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7377 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7379 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7381 #endif // __WXWINCE__
7386 static void wxAdjustZOrder(wxWindow
* parent
)
7388 if (wxDynamicCast(parent
, wxStaticBox
))
7390 // Set the z-order correctly
7391 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7394 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7397 wxWindow
*childWin
= current
->GetData();
7398 wxAdjustZOrder(childWin
);
7399 current
= current
->GetNext();
7404 // We need to adjust the z-order of static boxes in WinCE, to
7405 // make 'contained' controls visible
7406 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7409 wxAdjustZOrder(this);