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"
84 #include "wx/tooltip.h"
92 #include "wx/spinctrl.h"
93 #endif // wxUSE_SPINCTRL
95 #include "wx/notebook.h"
96 #include "wx/listctrl.h"
97 #include "wx/dynlib.h"
101 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
102 #include <shellapi.h>
103 #include <mmsystem.h>
107 #include <windowsx.h>
110 #if !defined __WXWINCE__ && !defined NEED_PBT_H
114 #if defined(__WXWINCE__)
115 #include "wx/msw/wince/missing.h"
118 #include <shellapi.h>
120 #include <aygshell.h>
125 #include "wx/msw/uxtheme.h"
126 #define EP_EDITTEXT 1
129 #define ETS_SELECTED 3
130 #define ETS_DISABLED 4
131 #define ETS_FOCUSED 5
132 #define ETS_READONLY 6
136 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
137 #define HAVE_TRACKMOUSEEVENT
138 #endif // everything needed for TrackMouseEvent()
140 // if this is set to 1, we use deferred window sizing to reduce flicker when
141 // resizing complicated window hierarchies, but this can in theory result in
142 // different behaviour than the old code so we keep the possibility to use it
143 // by setting this to 0 (in the future this should be removed completely)
145 #define USE_DEFERRED_SIZING 0
147 #define USE_DEFERRED_SIZING 1
150 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
151 // when mouse position didnd't change
153 #define wxUSE_MOUSEEVENT_HACK 0
155 #define wxUSE_MOUSEEVENT_HACK 1
158 // not all compilers/platforms have X button related declarations (notably
159 // Windows CE doesn't, and probably some old SDKs don't neither)
160 #ifdef WM_XBUTTONDOWN
161 #define wxHAS_XBUTTON
164 // ---------------------------------------------------------------------------
166 // ---------------------------------------------------------------------------
168 #if wxUSE_MENUS_NATIVE
169 wxMenu
*wxCurrentPopupMenu
= NULL
;
170 #endif // wxUSE_MENUS_NATIVE
173 extern wxChar
*wxCanvasClassName
;
175 extern const wxChar
*wxCanvasClassName
;
178 // true if we had already created the std colour map, used by
179 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
180 static bool gs_hasStdCmap
= false;
182 // last mouse event information we need to filter out the duplicates
183 #if wxUSE_MOUSEEVENT_HACK
184 static struct MouseEventInfoDummy
186 // mouse position (in screen coordinates)
189 // last mouse event type
192 #endif // wxUSE_MOUSEEVENT_HACK
194 // hash containing the registered handlers for the custom messages
195 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
196 wxIntegerHash
, wxIntegerEqual
,
199 static MSWMessageHandlers gs_messageHandlers
;
201 // ---------------------------------------------------------------------------
203 // ---------------------------------------------------------------------------
205 // the window proc for all our windows
206 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
207 WPARAM wParam
, LPARAM lParam
);
211 const wxChar
*wxGetMessageName(int message
);
214 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
215 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
216 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
218 // get the text metrics for the current font
219 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
222 // find the window for the mouse event at the specified position
223 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
224 #endif // __WXWINCE__
226 // wrapper around BringWindowToTop() API
227 static inline void wxBringWindowToTop(HWND hwnd
)
229 #ifdef __WXMICROWIN__
230 // It seems that MicroWindows brings the _parent_ of the window to the top,
231 // which can be the wrong one.
233 // activate (set focus to) specified window
237 // raise top level parent to top of z order
238 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
240 wxLogLastError(_T("SetWindowPos"));
246 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
247 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
250 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
251 parent as well as otherwise several Win32 functions using
252 GetNextDlgTabItem() to iterate over all controls such as
253 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
254 all of them iterate over all the controls starting from the currently
255 focused one and stop iterating when they get back to the focus but
256 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
257 get back to the initial (focused) window: as we do have this style,
258 GetNextDlgTabItem() will leave this window and continue in its parent,
259 but if the parent doesn't have it, it wouldn't recurse inside it later
260 on and so wouldn't have a chance of getting back to this window either.
262 while ( parent
&& !parent
->IsTopLevel() )
264 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
265 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
267 // force the parent to have this style
268 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
269 exStyle
| WS_EX_CONTROLPARENT
);
272 parent
= parent
->GetParent();
276 #endif // !__WXWINCE__
279 // On Windows CE, GetCursorPos can return an error, so use this function
281 bool GetCursorPosWinCE(POINT
* pt
)
283 if (!GetCursorPos(pt
))
285 DWORD pos
= GetMessagePos();
293 // ---------------------------------------------------------------------------
295 // ---------------------------------------------------------------------------
297 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
299 #ifdef __WXUNIVERSAL__
300 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
302 #if wxUSE_EXTENDED_RTTI
304 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
305 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
306 // windows with negative ids never can be recreated anyway
308 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
310 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
311 if ( win
&& win
->GetId() < 0 )
316 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
318 // make wxWindowList known before the property is used
320 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
322 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
324 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
327 WX_DEFINE_FLAGS( wxWindowStyle
)
329 wxBEGIN_FLAGS( wxWindowStyle
)
330 // new style border flags, we put them first to
331 // use them for streaming out
333 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
334 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
335 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
336 wxFLAGS_MEMBER(wxBORDER_RAISED
)
337 wxFLAGS_MEMBER(wxBORDER_STATIC
)
338 wxFLAGS_MEMBER(wxBORDER_NONE
)
340 // old style border flags
341 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
342 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
343 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
344 wxFLAGS_MEMBER(wxRAISED_BORDER
)
345 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
346 wxFLAGS_MEMBER(wxBORDER
)
348 // standard window styles
349 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
350 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
351 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
352 wxFLAGS_MEMBER(wxWANTS_CHARS
)
353 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
354 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
355 wxFLAGS_MEMBER(wxVSCROLL
)
356 wxFLAGS_MEMBER(wxHSCROLL
)
358 wxEND_FLAGS( wxWindowStyle
)
360 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
361 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
362 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
363 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
364 // Always constructor Properties first
366 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
367 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
368 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
369 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
370 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
372 // Then all relations of the object graph
374 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
376 // and finally all other properties
378 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
379 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
380 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
381 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
382 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
384 // possible property candidates (not in xrc) or not valid in all subclasses
385 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
386 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
387 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
388 // MaxHeight, Width , MinHeight , Width
389 // TODO switch label to control and title to toplevels
391 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
392 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
393 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
394 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
399 wxEND_PROPERTIES_TABLE()
401 wxBEGIN_HANDLERS_TABLE(wxWindow
)
402 wxEND_HANDLERS_TABLE()
404 wxCONSTRUCTOR_DUMMY(wxWindow
)
407 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
409 #endif // __WXUNIVERSAL__/__WXMSW__
411 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
412 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
413 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
415 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
419 // ===========================================================================
421 // ===========================================================================
423 // ---------------------------------------------------------------------------
424 // wxWindow utility functions
425 // ---------------------------------------------------------------------------
427 // Find an item given the MS Windows id
428 wxWindow
*wxWindowMSW::FindItem(long id
) const
431 wxControl
*item
= wxDynamicCastThis(wxControl
);
434 // is it us or one of our "internal" children?
435 if ( item
->GetId() == id
436 #ifndef __WXUNIVERSAL__
437 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
438 #endif // __WXUNIVERSAL__
444 #endif // wxUSE_CONTROLS
446 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
449 wxWindow
*childWin
= current
->GetData();
451 wxWindow
*wnd
= childWin
->FindItem(id
);
455 current
= current
->GetNext();
461 // Find an item given the MS Windows handle
462 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
464 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
467 wxWindow
*parent
= current
->GetData();
469 // Do a recursive search.
470 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
476 || parent
->IsKindOf(CLASSINFO(wxControl
))
477 #endif // wxUSE_CONTROLS
480 wxWindow
*item
= current
->GetData();
481 if ( item
->GetHWND() == hWnd
)
485 if ( item
->ContainsHWND(hWnd
) )
490 current
= current
->GetNext();
495 // Default command handler
496 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
501 // ----------------------------------------------------------------------------
502 // constructors and such
503 // ----------------------------------------------------------------------------
505 void wxWindowMSW::Init()
508 m_isBeingDeleted
= false;
510 m_mouseInWindow
= false;
511 m_lastKeydownProcessed
= false;
521 m_pendingPosition
= wxDefaultPosition
;
522 m_pendingSize
= wxDefaultSize
;
525 m_contextMenuEnabled
= false;
530 wxWindowMSW::~wxWindowMSW()
532 m_isBeingDeleted
= true;
534 #ifndef __WXUNIVERSAL__
535 // VS: make sure there's no wxFrame with last focus set to us:
536 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
538 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
541 if ( frame
->GetLastFocus() == this )
543 frame
->SetLastFocus(NULL
);
546 // apparently sometimes we can end up with our grand parent
547 // pointing to us as well: this is surely a bug in focus handling
548 // code but it's not clear where it happens so for now just try to
549 // fix it here by not breaking out of the loop
553 #endif // __WXUNIVERSAL__
555 // VS: destroy children first and _then_ detach *this from its parent.
556 // If we did it the other way around, children wouldn't be able
557 // find their parent frame (see above).
562 // VZ: test temp removed to understand what really happens here
563 //if (::IsWindow(GetHwnd()))
565 if ( !::DestroyWindow(GetHwnd()) )
566 wxLogLastError(wxT("DestroyWindow"));
569 // remove hWnd <-> wxWindow association
570 wxRemoveHandleAssociation(this);
575 // real construction (Init() must have been called before!)
576 bool wxWindowMSW::Create(wxWindow
*parent
,
581 const wxString
& name
)
583 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
585 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
588 parent
->AddChild(this);
591 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
593 #ifdef __WXUNIVERSAL__
594 // no borders, we draw them ourselves
595 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
599 msflags
&= ~WS_BORDER
;
600 #endif // wxUniversal
604 msflags
|= WS_VISIBLE
;
607 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
615 // ---------------------------------------------------------------------------
617 // ---------------------------------------------------------------------------
619 void wxWindowMSW::SetFocus()
621 HWND hWnd
= GetHwnd();
622 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
624 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
628 if ( !::SetFocus(hWnd
) )
630 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
631 // was there really an error?
632 DWORD dwRes
= ::GetLastError();
635 HWND hwndFocus
= ::GetFocus();
636 if ( hwndFocus
!= hWnd
)
638 wxLogApiError(_T("SetFocus"), dwRes
);
645 void wxWindowMSW::SetFocusFromKbd()
647 // when the focus is given to the control with DLGC_HASSETSEL style from
648 // keyboard its contents should be entirely selected: this is what
649 // ::IsDialogMessage() does and so we should do it as well to provide the
650 // same LNF as the native programs
651 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
653 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
656 // do this after (maybe) setting the selection as like this when
657 // wxEVT_SET_FOCUS handler is called, the selection would have been already
658 // set correctly -- this may be important
659 wxWindowBase::SetFocusFromKbd();
662 // Get the window with the focus
663 wxWindow
*wxWindowBase::DoFindFocus()
665 HWND hWnd
= ::GetFocus();
668 return wxGetWindowFromHWND((WXHWND
)hWnd
);
674 void wxWindowMSW::DoEnable( bool enable
)
676 HWND hWnd
= GetHwnd();
678 ::EnableWindow(hWnd
, (BOOL
)enable
);
681 bool wxWindowMSW::Show(bool show
)
683 if ( !wxWindowBase::Show(show
) )
686 HWND hWnd
= GetHwnd();
688 // we could be called before the underlying window is created (this is
689 // actually useful to prevent it from being initially shown), e.g.
691 // wxFoo *foo = new wxFoo;
693 // foo->Create(parent, ...);
695 // should work without errors
698 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
705 wxWindowMSW::MSWShowWithEffect(bool show
,
710 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
712 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
713 static bool s_initDone
= false;
718 wxDynamicLibrary
dllUser32(_T("user32.dll"), wxDL_VERBATIM
);
719 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
723 // notice that it's ok to unload user32.dll here as it won't be really
724 // unloaded, being still in use because we link to it statically too
727 if ( !s_pfnAnimateWindow
)
730 // prepare to use AnimateWindow()
733 timeout
= 200; // this is the default animation timeout, per MSDN
735 DWORD dwFlags
= show
? 0 : AW_HIDE
;
736 bool needsDir
= false;
739 case wxSHOW_EFFECT_ROLL
:
743 case wxSHOW_EFFECT_SLIDE
:
748 case wxSHOW_EFFECT_BLEND
:
752 case wxSHOW_EFFECT_EXPAND
:
753 dwFlags
|= AW_CENTER
;
757 case wxSHOW_EFFECT_MAX
:
758 wxFAIL_MSG( _T("invalid window show effect") );
762 wxFAIL_MSG( _T("unknown window show effect") );
771 dwFlags
|= AW_VER_NEGATIVE
;
775 dwFlags
|= AW_VER_POSITIVE
;
779 dwFlags
|= AW_HOR_NEGATIVE
;
783 dwFlags
|= AW_HOR_POSITIVE
;
787 wxFAIL_MSG( _T("unknown window effect direction") );
791 else // animation effect which doesn't need the direction
793 wxASSERT_MSG( dir
== wxBOTTOM
,
794 _T("non-default direction used unnecessarily") );
798 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
800 wxLogLastError(_T("AnimateWindow"));
808 // Raise the window to the top of the Z order
809 void wxWindowMSW::Raise()
811 wxBringWindowToTop(GetHwnd());
814 // Lower the window to the bottom of the Z order
815 void wxWindowMSW::Lower()
817 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
818 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
821 void wxWindowMSW::DoCaptureMouse()
823 HWND hWnd
= GetHwnd();
830 void wxWindowMSW::DoReleaseMouse()
832 if ( !::ReleaseCapture() )
834 wxLogLastError(_T("ReleaseCapture"));
838 /* static */ wxWindow
*wxWindowBase::GetCapture()
840 HWND hwnd
= ::GetCapture();
841 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
844 bool wxWindowMSW::SetFont(const wxFont
& font
)
846 if ( !wxWindowBase::SetFont(font
) )
852 HWND hWnd
= GetHwnd();
855 WXHANDLE hFont
= m_font
.GetResourceHandle();
857 wxASSERT_MSG( hFont
, wxT("should have valid font") );
859 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
864 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
866 if ( !wxWindowBase::SetCursor(cursor
) )
872 // don't "overwrite" busy cursor
873 if ( m_cursor
.Ok() && !wxIsBusy() )
875 // normally we should change the cursor only if it's over this window
876 // but we should do it always if we capture the mouse currently
877 bool set
= HasCapture();
880 HWND hWnd
= GetHwnd();
884 ::GetCursorPosWinCE(&point
);
886 ::GetCursorPos(&point
);
889 RECT rect
= wxGetWindowRect(hWnd
);
891 set
= ::PtInRect(&rect
, point
) != 0;
896 ::SetCursor(GetHcursorOf(m_cursor
));
898 //else: will be set later when the mouse enters this window
904 void wxWindowMSW::WarpPointer(int x
, int y
)
906 ClientToScreen(&x
, &y
);
908 if ( !::SetCursorPos(x
, y
) )
910 wxLogLastError(_T("SetCursorPos"));
914 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
916 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
917 // to use it on older systems -- and could possibly do some harm
918 static int s_needToUpdate
= -1;
919 if ( s_needToUpdate
== -1 )
922 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
926 if ( s_needToUpdate
)
928 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
929 // won't send WM_UPDATEUISTATE
930 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
934 // ---------------------------------------------------------------------------
936 // ---------------------------------------------------------------------------
938 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
940 #ifdef __WXMICROWIN__
941 return ::GetScrollPosWX(hWnd
, wOrient
);
943 WinStruct
<SCROLLINFO
> scrollInfo
;
944 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
945 scrollInfo
.fMask
= SIF_POS
;
946 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
948 return scrollInfo
.nPos
;
953 int wxWindowMSW::GetScrollPos(int orient
) const
955 HWND hWnd
= GetHwnd();
956 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
958 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
961 // This now returns the whole range, not just the number
962 // of positions that we can scroll.
963 int wxWindowMSW::GetScrollRange(int orient
) const
966 HWND hWnd
= GetHwnd();
970 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
973 WinStruct
<SCROLLINFO
> scrollInfo
;
974 scrollInfo
.fMask
= SIF_RANGE
;
975 if ( !::GetScrollInfo(hWnd
,
976 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
979 // Most of the time this is not really an error, since the return
980 // value can also be zero when there is no scrollbar yet.
981 // wxLogLastError(_T("GetScrollInfo"));
983 maxPos
= scrollInfo
.nMax
;
985 // undo "range - 1" done in SetScrollbar()
989 int wxWindowMSW::GetScrollThumb(int orient
) const
991 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
994 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
996 HWND hWnd
= GetHwnd();
997 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
999 WinStruct
<SCROLLINFO
> info
;
1003 info
.fMask
= SIF_POS
;
1004 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1006 // disable scrollbar instead of removing it then
1007 info
.fMask
|= SIF_DISABLENOSCROLL
;
1010 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1014 // New function that will replace some of the above.
1015 void wxWindowMSW::SetScrollbar(int orient
,
1021 WinStruct
<SCROLLINFO
> info
;
1022 info
.nPage
= pageSize
;
1023 info
.nMin
= 0; // range is nMax - nMin + 1
1024 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1026 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1027 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1029 // disable scrollbar instead of removing it then
1030 info
.fMask
|= SIF_DISABLENOSCROLL
;
1033 HWND hWnd
= GetHwnd();
1036 // We have to set the variables here to make them valid in events
1037 // triggered by ::SetScrollInfo()
1038 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1040 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1045 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1051 wxCopyRectToRECT(*prect
, rect
);
1061 // FIXME: is this the exact equivalent of the line below?
1062 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1064 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1068 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1070 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1073 for ( int n
= 0; n
< count
; n
++ )
1075 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1077 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1078 if ( posNew
== pos
)
1080 // don't bother to continue, we're already at top/bottom
1087 return pos
!= posStart
;
1090 bool wxWindowMSW::ScrollLines(int lines
)
1092 bool down
= lines
> 0;
1094 return ScrollVertically(GetHwnd(),
1095 down
? SB_LINEDOWN
: SB_LINEUP
,
1096 down
? lines
: -lines
);
1099 bool wxWindowMSW::ScrollPages(int pages
)
1101 bool down
= pages
> 0;
1103 return ScrollVertically(GetHwnd(),
1104 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1105 down
? pages
: -pages
);
1108 // ----------------------------------------------------------------------------
1110 // ----------------------------------------------------------------------------
1112 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1117 const HWND hwnd
= GetHwnd();
1118 wxCHECK_RET( hwnd
, _T("layout direction must be set after window creation") );
1120 LONG styleOld
= ::GetWindowLong(hwnd
, GWL_EXSTYLE
);
1122 LONG styleNew
= styleOld
;
1125 case wxLayout_LeftToRight
:
1126 styleNew
&= ~WS_EX_LAYOUTRTL
;
1129 case wxLayout_RightToLeft
:
1130 styleNew
|= WS_EX_LAYOUTRTL
;
1134 wxFAIL_MSG(_T("unsupported layout direction"));
1138 if ( styleNew
!= styleOld
)
1140 ::SetWindowLong(hwnd
, GWL_EXSTYLE
, styleNew
);
1145 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1148 return wxLayout_Default
;
1150 const HWND hwnd
= GetHwnd();
1151 wxCHECK_MSG( hwnd
, wxLayout_Default
, _T("invalid window") );
1153 return ::GetWindowLong(hwnd
, GWL_EXSTYLE
) & WS_EX_LAYOUTRTL
1154 ? wxLayout_RightToLeft
1155 : wxLayout_LeftToRight
;
1160 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1161 wxCoord
WXUNUSED(width
),
1162 wxCoord
WXUNUSED(widthTotal
)) const
1164 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1165 // redo it ourselves
1169 // ---------------------------------------------------------------------------
1171 // ---------------------------------------------------------------------------
1173 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1175 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1177 HWND hwnd
= (HWND
)hWnd
;
1178 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1180 wxAssociateWinWithHandle(hwnd
, this);
1182 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1184 // we don't need to subclass the window of our own class (in the Windows
1185 // sense of the word)
1186 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1188 wxSetWindowProc(hwnd
, wxWndProc
);
1192 // don't bother restoring it either: this also makes it easy to
1193 // implement IsOfStandardClass() method which returns true for the
1194 // standard controls and false for the wxWidgets own windows as it can
1195 // simply check m_oldWndProc
1196 m_oldWndProc
= NULL
;
1199 // we're officially created now, send the event
1200 wxWindowCreateEvent
event((wxWindow
*)this);
1201 (void)GetEventHandler()->ProcessEvent(event
);
1204 void wxWindowMSW::UnsubclassWin()
1206 wxRemoveHandleAssociation(this);
1208 // Restore old Window proc
1209 HWND hwnd
= GetHwnd();
1214 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1218 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1220 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1223 m_oldWndProc
= NULL
;
1228 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1232 if ( !::DestroyWindow(GetHwnd()) )
1233 wxLogLastError(wxT("DestroyWindow"));
1236 WXHWND wxhwnd
= (WXHWND
)handle
;
1239 SubclassWin(wxhwnd
);
1242 void wxWindowMSW::DissociateHandle()
1244 // this also calls SetHWND(0) for us
1249 bool wxCheckWindowWndProc(WXHWND hWnd
,
1250 WXFARPROC
WXUNUSED(wndProc
))
1252 // TODO: This list of window class names should be factored out so they can be
1253 // managed in one place and then accessed from here and other places, such as
1254 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1257 extern wxChar
*wxCanvasClassName
;
1258 extern wxChar
*wxCanvasClassNameNR
;
1260 extern const wxChar
*wxCanvasClassName
;
1261 extern const wxChar
*wxCanvasClassNameNR
;
1263 extern const wxChar
*wxMDIFrameClassName
;
1264 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1265 extern const wxChar
*wxMDIChildFrameClassName
;
1266 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1267 wxString
str(wxGetWindowClass(hWnd
));
1268 if (str
== wxCanvasClassName
||
1269 str
== wxCanvasClassNameNR
||
1271 str
== _T("wxGLCanvasClass") ||
1272 str
== _T("wxGLCanvasClassNR") ||
1273 #endif // wxUSE_GLCANVAS
1274 str
== wxMDIFrameClassName
||
1275 str
== wxMDIFrameClassNameNoRedraw
||
1276 str
== wxMDIChildFrameClassName
||
1277 str
== wxMDIChildFrameClassNameNoRedraw
||
1278 str
== _T("wxTLWHiddenParent"))
1279 return true; // Effectively means don't subclass
1284 // ----------------------------------------------------------------------------
1286 // ----------------------------------------------------------------------------
1288 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1290 long flagsOld
= GetWindowStyleFlag();
1291 if ( flags
== flagsOld
)
1294 // update the internal variable
1295 wxWindowBase::SetWindowStyleFlag(flags
);
1297 // and the real window flags
1298 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1301 void wxWindowMSW::SetExtraStyle(long exflags
)
1303 long exflagsOld
= GetExtraStyle();
1304 if ( exflags
== exflagsOld
)
1307 // update the internal variable
1308 wxWindowBase::SetExtraStyle(exflags
);
1310 // and the real window flags
1311 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1314 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1316 // now update the Windows style as well if needed - and if the window had
1317 // been already created
1321 // we may need to call SetWindowPos() when we change some styles
1322 bool callSWP
= false;
1325 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1327 // this is quite a horrible hack but we need it because MSWGetStyle()
1328 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1329 // and so we have to modify the window exflags temporarily to get the
1330 // correct exstyleOld
1331 long exflagsNew
= GetExtraStyle();
1332 wxWindowBase::SetExtraStyle(exflagsOld
);
1335 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1337 wxWindowBase::SetExtraStyle(exflagsNew
);
1340 if ( style
!= styleOld
)
1342 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1343 // this function so instead of simply setting the style to the new
1344 // value we clear the bits which were set in styleOld but are set in
1345 // the new one and set the ones which were not set before
1346 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1347 styleReal
&= ~styleOld
;
1350 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1352 // we need to call SetWindowPos() if any of the styles affecting the
1353 // frame appearance have changed
1354 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1363 // and the extended style
1364 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1366 if ( exstyle
!= exstyleOld
)
1368 exstyleReal
&= ~exstyleOld
;
1369 exstyleReal
|= exstyle
;
1371 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1373 // ex style changes don't take effect without calling SetWindowPos
1379 // we must call SetWindowPos() to flush the cached extended style and
1380 // also to make the change to wxSTAY_ON_TOP style take effect: just
1381 // setting the style simply doesn't work
1382 if ( !::SetWindowPos(GetHwnd(),
1383 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1386 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1388 wxLogLastError(_T("SetWindowPos"));
1393 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1395 return wxBORDER_THEME
;
1398 wxBorder
wxWindowMSW::GetDefaultBorder() const
1400 return wxWindowBase::GetDefaultBorder();
1403 // Translate wxBORDER_THEME (and other border styles if necessary to the value
1404 // that makes most sense for this Windows environment
1405 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1407 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1408 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1409 return wxBORDER_SIMPLE
;
1411 return wxBORDER_NONE
;
1414 if (border
== wxBORDER_THEME
)
1416 if (CanApplyThemeBorder())
1418 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1420 return wxBORDER_THEME
;
1429 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1431 // translate common wxWidgets styles to Windows ones
1433 // most of windows are child ones, those which are not (such as
1434 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1435 WXDWORD style
= WS_CHILD
;
1437 // using this flag results in very significant reduction in flicker,
1438 // especially with controls inside the static boxes (as the interior of the
1439 // box is not redrawn twice), but sometimes results in redraw problems, so
1440 // optionally allow the old code to continue to use it provided a special
1441 // system option is turned on
1442 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1443 || (flags
& wxCLIP_CHILDREN
) )
1444 style
|= WS_CLIPCHILDREN
;
1446 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1447 // don't support overlapping windows and it only makes sense for them and,
1448 // presumably, gives the system some extra work (to manage more clipping
1449 // regions), so avoid it alltogether
1452 if ( flags
& wxVSCROLL
)
1453 style
|= WS_VSCROLL
;
1455 if ( flags
& wxHSCROLL
)
1456 style
|= WS_HSCROLL
;
1458 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1460 // After translation, border is now optimized for the specific version of Windows
1461 // and theme engine presence.
1463 // WS_BORDER is only required for wxBORDER_SIMPLE
1464 if ( border
== wxBORDER_SIMPLE
)
1467 // now deal with ext style if the caller wants it
1473 if ( flags
& wxTRANSPARENT_WINDOW
)
1474 *exstyle
|= WS_EX_TRANSPARENT
;
1480 case wxBORDER_DEFAULT
:
1481 wxFAIL_MSG( _T("unknown border style") );
1485 case wxBORDER_SIMPLE
:
1486 case wxBORDER_THEME
:
1489 case wxBORDER_STATIC
:
1490 *exstyle
|= WS_EX_STATICEDGE
;
1493 case wxBORDER_RAISED
:
1494 *exstyle
|= WS_EX_DLGMODALFRAME
;
1497 case wxBORDER_SUNKEN
:
1498 *exstyle
|= WS_EX_CLIENTEDGE
;
1499 style
&= ~WS_BORDER
;
1502 // case wxBORDER_DOUBLE:
1503 // *exstyle |= WS_EX_DLGMODALFRAME;
1507 // wxUniv doesn't use Windows dialog navigation functions at all
1508 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1509 // to make the dialog navigation work with the nested panels we must
1510 // use this style (top level windows such as dialogs don't need it)
1511 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1513 *exstyle
|= WS_EX_CONTROLPARENT
;
1515 #endif // __WXUNIVERSAL__
1521 // Setup background and foreground colours correctly
1522 void wxWindowMSW::SetupColours()
1525 SetBackgroundColour(GetParent()->GetBackgroundColour());
1528 bool wxWindowMSW::IsMouseInWindow() const
1530 // get the mouse position
1533 ::GetCursorPosWinCE(&pt
);
1535 ::GetCursorPos(&pt
);
1538 // find the window which currently has the cursor and go up the window
1539 // chain until we find this window - or exhaust it
1540 HWND hwnd
= ::WindowFromPoint(pt
);
1541 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1542 hwnd
= ::GetParent(hwnd
);
1544 return hwnd
!= NULL
;
1547 void wxWindowMSW::OnInternalIdle()
1549 #ifndef HAVE_TRACKMOUSEEVENT
1550 // Check if we need to send a LEAVE event
1551 if ( m_mouseInWindow
)
1553 // note that we should generate the leave event whether the window has
1554 // or doesn't have mouse capture
1555 if ( !IsMouseInWindow() )
1557 GenerateMouseLeave();
1560 #endif // !HAVE_TRACKMOUSEEVENT
1562 if (wxUpdateUIEvent::CanUpdate(this) && IsShown())
1563 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1566 // Set this window to be the child of 'parent'.
1567 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1569 if ( !wxWindowBase::Reparent(parent
) )
1572 HWND hWndChild
= GetHwnd();
1573 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1575 ::SetParent(hWndChild
, hWndParent
);
1578 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1580 EnsureParentHasControlParentStyle(GetParent());
1582 #endif // !__WXWINCE__
1587 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1589 #ifndef __WXMICROWIN__
1590 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1594 void wxWindowMSW::Freeze()
1596 if ( !m_frozenness
++ )
1599 SendSetRedraw(GetHwnd(), false);
1603 void wxWindowMSW::Thaw()
1605 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1607 if ( --m_frozenness
== 0 )
1611 SendSetRedraw(GetHwnd(), true);
1613 // we need to refresh everything or otherwise the invalidated area
1614 // is not going to be repainted
1620 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1622 HWND hWnd
= GetHwnd();
1629 wxCopyRectToRECT(*rect
, mswRect
);
1637 // RedrawWindow not available on SmartPhone or eVC++ 3
1638 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1639 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1643 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1645 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1650 void wxWindowMSW::Update()
1652 if ( !::UpdateWindow(GetHwnd()) )
1654 wxLogLastError(_T("UpdateWindow"));
1657 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1658 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1659 // handler needs to be really drawn right now
1664 // ---------------------------------------------------------------------------
1666 // ---------------------------------------------------------------------------
1668 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1672 // we need to lower the sibling static boxes so controls contained within can be
1674 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1676 // no sibling static boxes if we have no parent (ie TLW)
1680 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1682 node
= node
->GetNext() )
1684 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1687 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1688 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1693 #else // !wxUSE_STATBOX
1695 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1699 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1701 #endif // drag and drop is used
1703 #if wxUSE_DRAG_AND_DROP
1704 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1706 if ( m_dropTarget
!= 0 ) {
1707 m_dropTarget
->Revoke(m_hWnd
);
1708 delete m_dropTarget
;
1711 m_dropTarget
= pDropTarget
;
1712 if ( m_dropTarget
!= 0 )
1714 AdjustStaticBoxZOrder(GetParent());
1715 m_dropTarget
->Register(m_hWnd
);
1718 #endif // wxUSE_DRAG_AND_DROP
1720 // old-style file manager drag&drop support: we retain the old-style
1721 // DragAcceptFiles in parallel with SetDropTarget.
1722 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1725 HWND hWnd
= GetHwnd();
1728 AdjustStaticBoxZOrder(GetParent());
1729 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1734 // ----------------------------------------------------------------------------
1736 // ----------------------------------------------------------------------------
1740 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1742 wxWindowBase::DoSetToolTip(tooltip
);
1745 m_tooltip
->SetWindow((wxWindow
*)this);
1748 #endif // wxUSE_TOOLTIPS
1750 // ---------------------------------------------------------------------------
1751 // moving and resizing
1752 // ---------------------------------------------------------------------------
1754 bool wxWindowMSW::IsSizeDeferred() const
1756 #if USE_DEFERRED_SIZING
1757 if ( m_pendingPosition
!= wxDefaultPosition
||
1758 m_pendingSize
!= wxDefaultSize
)
1760 #endif // USE_DEFERRED_SIZING
1766 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1768 #if USE_DEFERRED_SIZING
1769 // if SetSize() had been called at wx level but not realized at Windows
1770 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1771 // the new and not the old position to the other wx code
1772 if ( m_pendingSize
!= wxDefaultSize
)
1775 *x
= m_pendingSize
.x
;
1777 *y
= m_pendingSize
.y
;
1779 else // use current size
1780 #endif // USE_DEFERRED_SIZING
1782 RECT rect
= wxGetWindowRect(GetHwnd());
1785 *x
= rect
.right
- rect
.left
;
1787 *y
= rect
.bottom
- rect
.top
;
1791 // Get size *available for subwindows* i.e. excluding menu bar etc.
1792 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1794 #if USE_DEFERRED_SIZING
1795 if ( m_pendingSize
!= wxDefaultSize
)
1797 // we need to calculate the client size corresponding to pending size
1799 rect
.left
= m_pendingPosition
.x
;
1800 rect
.top
= m_pendingPosition
.y
;
1801 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1802 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1804 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1807 *x
= rect
.right
- rect
.left
;
1809 *y
= rect
.bottom
- rect
.top
;
1812 #endif // USE_DEFERRED_SIZING
1814 RECT rect
= wxGetClientRect(GetHwnd());
1823 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1825 wxWindow
* const parent
= GetParent();
1828 if ( m_pendingPosition
!= wxDefaultPosition
)
1830 pos
= m_pendingPosition
;
1832 else // use current position
1834 RECT rect
= wxGetWindowRect(GetHwnd());
1837 point
.x
= rect
.left
;
1840 // we do the adjustments with respect to the parent only for the "real"
1841 // children, not for the dialogs/frames
1842 if ( !IsTopLevel() )
1844 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1846 // In RTL mode, we want the logical left x-coordinate,
1847 // which would be the physical right x-coordinate.
1848 point
.x
= rect
.right
;
1851 // Since we now have the absolute screen coords, if there's a
1852 // parent we must subtract its top left corner
1855 ::ScreenToClient(GetHwndOf(parent
), &point
);
1863 // we also must adjust by the client area offset: a control which is just
1864 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1865 if ( parent
&& !IsTopLevel() )
1867 const wxPoint
pt(parent
->GetClientAreaOrigin());
1878 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1886 ::ScreenToClient(GetHwnd(), &pt
);
1894 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1902 ::ClientToScreen(GetHwnd(), &pt
);
1911 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1913 #if USE_DEFERRED_SIZING
1914 // if our parent had prepared a defer window handle for us, use it (unless
1915 // we are a top level window)
1916 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1918 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1921 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1922 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1925 wxLogLastError(_T("DeferWindowPos"));
1931 // hdwp must be updated as it may have been changed
1932 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1937 // did deferred move, remember new coordinates of the window as they're
1938 // different from what Windows would return for it
1942 // otherwise (or if deferring failed) move the window in place immediately
1943 #endif // USE_DEFERRED_SIZING
1944 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1946 wxLogLastError(wxT("MoveWindow"));
1949 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1950 // ignored otherwise
1954 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1956 // TODO: is this consistent with other platforms?
1957 // Still, negative width or height shouldn't be allowed
1963 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1965 #if USE_DEFERRED_SIZING
1966 m_pendingPosition
= wxPoint(x
, y
);
1967 m_pendingSize
= wxSize(width
, height
);
1968 #endif // USE_DEFERRED_SIZING
1972 // set the size of the window: if the dimensions are positive, just use them,
1973 // but if any of them is equal to -1, it means that we must find the value for
1974 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1975 // which case -1 is a valid value for x and y)
1977 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1978 // the width/height to best suit our contents, otherwise we reuse the current
1980 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1982 // get the current size and position...
1983 int currentX
, currentY
;
1984 int currentW
, currentH
;
1986 GetPosition(¤tX
, ¤tY
);
1987 GetSize(¤tW
, ¤tH
);
1989 // ... and don't do anything (avoiding flicker) if it's already ok unless
1990 // we're forced to resize the window
1991 if ( x
== currentX
&& y
== currentY
&&
1992 width
== currentW
&& height
== currentH
&&
1993 !(sizeFlags
& wxSIZE_FORCE
) )
1998 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2000 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2003 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2005 wxSize size
= wxDefaultSize
;
2006 if ( width
== wxDefaultCoord
)
2008 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2010 size
= DoGetBestSize();
2015 // just take the current one
2020 if ( height
== wxDefaultCoord
)
2022 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2024 if ( size
.x
== wxDefaultCoord
)
2026 size
= DoGetBestSize();
2028 //else: already called DoGetBestSize() above
2034 // just take the current one
2039 DoMoveWindow(x
, y
, width
, height
);
2042 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2044 // setting the client size is less obvious than it could have been
2045 // because in the result of changing the total size the window scrollbar
2046 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2047 // doesn't take neither into account) and so the client size will not be
2048 // correct as the difference between the total and client size changes --
2049 // so we keep changing it until we get it right
2051 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2052 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2053 // may become 3 if the window had 0 size originally and so we didn't
2054 // calculate the scrollbar correction correctly during the first iteration)
2055 // but just to be on the safe side we check for it instead of making it an
2056 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2057 for ( int i
= 0; i
< 4; i
++ )
2060 ::GetClientRect(GetHwnd(), &rectClient
);
2062 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2063 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2064 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2069 // Find the difference between the entire window (title bar and all)
2070 // and the client area; add this to the new client size to move the
2073 ::GetWindowRect(GetHwnd(), &rectWin
);
2075 const int widthWin
= rectWin
.right
- rectWin
.left
,
2076 heightWin
= rectWin
.bottom
- rectWin
.top
;
2078 // MoveWindow positions the child windows relative to the parent, so
2079 // adjust if necessary
2080 if ( !IsTopLevel() )
2082 wxWindow
*parent
= GetParent();
2085 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2089 // don't call DoMoveWindow() because we want to move window immediately
2090 // and not defer it here as otherwise the value returned by
2091 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2093 if ( !::MoveWindow(GetHwnd(),
2096 width
+ widthWin
- rectClient
.right
,
2097 height
+ heightWin
- rectClient
.bottom
,
2100 wxLogLastError(_T("MoveWindow"));
2105 // ---------------------------------------------------------------------------
2107 // ---------------------------------------------------------------------------
2109 int wxWindowMSW::GetCharHeight() const
2111 return wxGetTextMetrics(this).tmHeight
;
2114 int wxWindowMSW::GetCharWidth() const
2116 // +1 is needed because Windows apparently adds it when calculating the
2117 // dialog units size in pixels
2118 #if wxDIALOG_UNIT_COMPATIBILITY
2119 return wxGetTextMetrics(this).tmAveCharWidth
;
2121 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2125 void wxWindowMSW::GetTextExtent(const wxString
& string
,
2127 int *descent
, int *externalLeading
,
2128 const wxFont
*theFont
) const
2130 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
2131 _T("invalid font in GetTextExtent()") );
2135 fontToUse
= *theFont
;
2137 fontToUse
= GetFont();
2139 WindowHDC
hdc(GetHwnd());
2140 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
2144 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2145 GetTextMetrics(hdc
, &tm
);
2152 *descent
= tm
.tmDescent
;
2153 if ( externalLeading
)
2154 *externalLeading
= tm
.tmExternalLeading
;
2157 // ---------------------------------------------------------------------------
2159 // ---------------------------------------------------------------------------
2161 #if wxUSE_MENUS_NATIVE
2163 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2164 // immediately, without waiting for the next event loop iteration
2166 // NB: this function should probably be made public later as it can almost
2167 // surely replace wxYield() elsewhere as well
2168 static void wxYieldForCommandsOnly()
2170 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2171 // want to process it here)
2173 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2175 if ( msg
.message
== WM_QUIT
)
2177 // if we retrieved a WM_QUIT, insert back into the message queue.
2178 ::PostQuitMessage(0);
2182 // luckily (as we don't have access to wxEventLoopImpl method from here
2183 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2185 ::TranslateMessage(&msg
);
2186 ::DispatchMessage(&msg
);
2190 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2192 menu
->SetInvokingWindow(this);
2195 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2197 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2198 x
= mouse
.x
; y
= mouse
.y
;
2201 HWND hWnd
= GetHwnd();
2202 HMENU hMenu
= GetHmenuOf(menu
);
2206 ::ClientToScreen(hWnd
, &point
);
2207 wxCurrentPopupMenu
= menu
;
2208 #if defined(__WXWINCE__)
2209 static const UINT flags
= 0;
2210 #else // !__WXWINCE__
2211 UINT flags
= TPM_RIGHTBUTTON
;
2212 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2213 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2214 // side and not to use it there neither -- modify the test if it does work
2216 if ( wxGetWinVersion() >= wxWinVersion_5
)
2218 // using TPM_RECURSE allows us to show a popup menu while another menu
2219 // is opened which can be useful and is supported by the other
2220 // platforms, so allow it under Windows too
2221 flags
|= TPM_RECURSE
;
2223 #endif // __WXWINCE__/!__WXWINCE__
2225 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2227 // we need to do it right now as otherwise the events are never going to be
2228 // sent to wxCurrentPopupMenu from HandleCommand()
2230 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2231 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2232 // destroyed as soon as we return (it can be a local variable in the caller
2233 // for example) and so we do need to process the event immediately
2234 wxYieldForCommandsOnly();
2236 wxCurrentPopupMenu
= NULL
;
2238 menu
->SetInvokingWindow(NULL
);
2243 #endif // wxUSE_MENUS_NATIVE
2245 // ===========================================================================
2246 // pre/post message processing
2247 // ===========================================================================
2249 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2252 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2254 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2257 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2259 // wxUniversal implements tab traversal itself
2260 #ifndef __WXUNIVERSAL__
2261 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2263 // intercept dialog navigation keys
2264 MSG
*msg
= (MSG
*)pMsg
;
2266 // here we try to do all the job which ::IsDialogMessage() usually does
2268 if ( msg
->message
== WM_KEYDOWN
)
2270 bool bCtrlDown
= wxIsCtrlDown();
2271 bool bShiftDown
= wxIsShiftDown();
2273 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2274 // don't process it if it's the case (except for Ctrl-Tab/Enter
2275 // combinations which are always processed)
2276 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2278 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2279 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2280 // it, of course, implies them
2281 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2283 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2286 bool bForward
= true,
2287 bWindowChange
= false,
2290 // should we process this message specially?
2291 bool bProcess
= true;
2292 switch ( msg
->wParam
)
2295 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2297 // let the control have the TAB
2300 else // use it for navigation
2302 // Ctrl-Tab cycles thru notebook pages
2303 bWindowChange
= bCtrlDown
;
2304 bForward
= !bShiftDown
;
2311 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2319 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2328 // we treat PageUp/Dn as arrows because chances are that
2329 // a control which needs arrows also needs them for
2330 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2331 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2333 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2334 bWindowChange
= true;
2340 // currently active button should get enter press even
2341 // if there is a default button elsewhere so check if
2342 // this window is a button first
2343 wxWindow
*btn
= NULL
;
2344 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2346 // let IsDialogMessage() handle this for all
2347 // buttons except the owner-drawn ones which it
2348 // just seems to ignore
2349 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2350 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2352 // emulate the button click
2353 btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2358 else // not a button itself, do we have default button?
2360 // check if this window or any of its ancestors
2361 // wants the message for itself (we always reserve
2362 // Ctrl-Enter for dialog navigation though)
2363 wxWindow
*win
= this;
2366 // this will contain the dialog code of this
2367 // window and all of its parent windows in turn
2368 LONG lDlgCode2
= lDlgCode
;
2372 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2374 // as it wants to process Enter itself,
2375 // don't call IsDialogMessage() which
2380 // don't propagate keyboard messages beyond
2381 // the first top level window parent
2382 if ( win
->IsTopLevel() )
2385 win
= win
->GetParent();
2387 lDlgCode2
= ::SendMessage
2398 win
= wxGetTopLevelParent(win
);
2401 wxTopLevelWindow
* const
2402 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2405 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2410 if ( btn
&& btn
->IsEnabled() )
2412 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2416 #endif // wxUSE_BUTTON
2419 // map Enter presses into button presses on PDAs
2420 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2421 event
.SetEventObject(this);
2422 if ( GetEventHandler()->ProcessEvent(event
) )
2424 #endif // __WXWINCE__
2434 wxNavigationKeyEvent event
;
2435 event
.SetDirection(bForward
);
2436 event
.SetWindowChange(bWindowChange
);
2437 event
.SetFromTab(bFromTab
);
2438 event
.SetEventObject(this);
2440 if ( GetEventHandler()->ProcessEvent(event
) )
2442 // as we don't call IsDialogMessage(), which would take of
2443 // this by default, we need to manually send this message
2444 // so that controls can change their UI state if needed
2445 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2452 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2454 // IsDialogMessage() did something...
2458 #endif // __WXUNIVERSAL__
2463 // relay mouse move events to the tooltip control
2464 MSG
*msg
= (MSG
*)pMsg
;
2465 if ( msg
->message
== WM_MOUSEMOVE
)
2466 wxToolTip::RelayEvent(pMsg
);
2468 #endif // wxUSE_TOOLTIPS
2473 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2475 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2476 return m_acceleratorTable
.Translate(this, pMsg
);
2480 #endif // wxUSE_ACCEL
2483 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2485 // all tests below have to deal with various bugs/misfeatures of
2486 // IsDialogMessage(): we have to prevent it from being called from our
2487 // MSWProcessMessage() in some situations
2489 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2490 // message even when there is no cancel button and when the message is
2491 // needed by the control itself: in particular, it prevents the tree in
2492 // place edit control from being closed with Escape in a dialog
2493 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2498 // ::IsDialogMessage() is broken and may sometimes hang the application by
2499 // going into an infinite loop when it tries to find the control to give
2500 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2501 // situations when this may happen and not call it then
2502 if ( msg
->message
!= WM_SYSCHAR
)
2505 // assume we can call it by default
2506 bool canSafelyCallIsDlgMsg
= true;
2508 HWND hwndFocus
= ::GetFocus();
2510 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2511 // ::IsDialogMessage() will also enter an infinite loop, because it will
2512 // recursively check the child windows but not the window itself and so if
2513 // none of the children accepts focus it loops forever (as it only stops
2514 // when it gets back to the window it started from)
2516 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2517 // style has the focus, it can happen. One such possibility is if
2518 // all windows are either toplevel, wxDialog, wxPanel or static
2519 // controls and no window can actually accept keyboard input.
2520 #if !defined(__WXWINCE__)
2521 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2523 // pessimistic by default
2524 canSafelyCallIsDlgMsg
= false;
2525 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2527 node
= node
->GetNext() )
2529 wxWindow
* const win
= node
->GetData();
2530 if ( win
->CanAcceptFocus() &&
2531 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2532 WS_EX_CONTROLPARENT
) )
2534 // it shouldn't hang...
2535 canSafelyCallIsDlgMsg
= true;
2541 #endif // !__WXWINCE__
2543 if ( canSafelyCallIsDlgMsg
)
2545 // ::IsDialogMessage() can enter in an infinite loop when the
2546 // currently focused window is disabled or hidden and its
2547 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2551 if ( !::IsWindowEnabled(hwndFocus
) ||
2552 !::IsWindowVisible(hwndFocus
) )
2554 // it would enter an infinite loop if we do this!
2555 canSafelyCallIsDlgMsg
= false;
2560 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2562 // it's a top level window, don't go further -- e.g. even
2563 // if the parent of a dialog is disabled, this doesn't
2564 // break navigation inside the dialog
2568 hwndFocus
= ::GetParent(hwndFocus
);
2572 return canSafelyCallIsDlgMsg
;
2575 // ---------------------------------------------------------------------------
2576 // message params unpackers
2577 // ---------------------------------------------------------------------------
2579 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2580 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2582 *id
= LOWORD(wParam
);
2583 *hwnd
= (WXHWND
)lParam
;
2584 *cmd
= HIWORD(wParam
);
2587 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2588 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2590 *state
= LOWORD(wParam
);
2591 *minimized
= HIWORD(wParam
);
2592 *hwnd
= (WXHWND
)lParam
;
2595 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2596 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2598 *code
= LOWORD(wParam
);
2599 *pos
= HIWORD(wParam
);
2600 *hwnd
= (WXHWND
)lParam
;
2603 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2604 WXHDC
*hdc
, WXHWND
*hwnd
)
2606 *hwnd
= (WXHWND
)lParam
;
2607 *hdc
= (WXHDC
)wParam
;
2610 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2611 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2613 *item
= (WXWORD
)wParam
;
2614 *flags
= HIWORD(wParam
);
2615 *hmenu
= (WXHMENU
)lParam
;
2618 // ---------------------------------------------------------------------------
2619 // Main wxWidgets window proc and the window proc for wxWindow
2620 // ---------------------------------------------------------------------------
2622 // Hook for new window just as it's being created, when the window isn't yet
2623 // associated with the handle
2624 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2626 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2627 // window being created and insures that it's always unset back later
2628 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2630 gs_winBeingCreated
= winBeingCreated
;
2633 wxWindowCreationHook::~wxWindowCreationHook()
2635 gs_winBeingCreated
= NULL
;
2639 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2641 // trace all messages - useful for the debugging
2643 wxLogTrace(wxTraceMessages
,
2644 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2645 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2646 #endif // __WXDEBUG__
2648 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2650 // when we get the first message for the HWND we just created, we associate
2651 // it with wxWindow stored in gs_winBeingCreated
2652 if ( !wnd
&& gs_winBeingCreated
)
2654 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2655 wnd
= gs_winBeingCreated
;
2656 gs_winBeingCreated
= NULL
;
2657 wnd
->SetHWND((WXHWND
)hWnd
);
2662 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2663 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2665 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2670 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2672 // did we process the message?
2673 bool processed
= false;
2683 // for most messages we should return 0 when we do process the message
2691 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2694 // return 0 to allow window creation
2695 rc
.result
= mayCreate
? 0 : -1;
2701 // never set processed to true and *always* pass WM_DESTROY to
2702 // DefWindowProc() as Windows may do some internal cleanup when
2703 // processing it and failing to pass the message along may cause
2704 // memory and resource leaks!
2705 (void)HandleDestroy();
2709 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2713 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2716 #if !defined(__WXWINCE__)
2719 LPRECT pRect
= (LPRECT
)lParam
;
2721 rc
.SetLeft(pRect
->left
);
2722 rc
.SetTop(pRect
->top
);
2723 rc
.SetRight(pRect
->right
);
2724 rc
.SetBottom(pRect
->bottom
);
2725 processed
= HandleMoving(rc
);
2727 pRect
->left
= rc
.GetLeft();
2728 pRect
->top
= rc
.GetTop();
2729 pRect
->right
= rc
.GetRight();
2730 pRect
->bottom
= rc
.GetBottom();
2735 case WM_ENTERSIZEMOVE
:
2737 processed
= HandleEnterSizeMove();
2741 case WM_EXITSIZEMOVE
:
2743 processed
= HandleExitSizeMove();
2749 LPRECT pRect
= (LPRECT
)lParam
;
2751 rc
.SetLeft(pRect
->left
);
2752 rc
.SetTop(pRect
->top
);
2753 rc
.SetRight(pRect
->right
);
2754 rc
.SetBottom(pRect
->bottom
);
2755 processed
= HandleSizing(rc
);
2757 pRect
->left
= rc
.GetLeft();
2758 pRect
->top
= rc
.GetTop();
2759 pRect
->right
= rc
.GetRight();
2760 pRect
->bottom
= rc
.GetBottom();
2764 #endif // !__WXWINCE__
2766 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2767 case WM_ACTIVATEAPP
:
2768 // This implicitly sends a wxEVT_ACTIVATE_APP event
2769 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2775 WXWORD state
, minimized
;
2777 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2779 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2784 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2788 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2791 case WM_PRINTCLIENT
:
2792 processed
= HandlePrintClient((WXHDC
)wParam
);
2798 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2800 processed
= HandlePaint();
2804 processed
= HandlePaint();
2809 #ifdef __WXUNIVERSAL__
2810 // Universal uses its own wxFrame/wxDialog, so we don't receive
2811 // close events unless we have this.
2813 #endif // __WXUNIVERSAL__
2815 // don't let the DefWindowProc() destroy our window - we'll do it
2816 // ourselves in ~wxWindow
2822 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2826 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2827 GET_Y_LPARAM(lParam
),
2831 #ifdef HAVE_TRACKMOUSEEVENT
2833 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2835 if ( m_mouseInWindow
)
2837 GenerateMouseLeave();
2840 // always pass processed back as false, this allows the window
2841 // manager to process the message too. This is needed to
2842 // ensure windows XP themes work properly as the mouse moves
2843 // over widgets like buttons. So don't set processed to true here.
2845 #endif // HAVE_TRACKMOUSEEVENT
2847 #if wxUSE_MOUSEWHEEL
2849 processed
= HandleMouseWheel(wParam
, lParam
);
2853 case WM_LBUTTONDOWN
:
2855 case WM_LBUTTONDBLCLK
:
2856 case WM_RBUTTONDOWN
:
2858 case WM_RBUTTONDBLCLK
:
2859 case WM_MBUTTONDOWN
:
2861 case WM_MBUTTONDBLCLK
:
2862 #ifdef wxHAS_XBUTTON
2863 case WM_XBUTTONDOWN
:
2865 case WM_XBUTTONDBLCLK
:
2866 #endif // wxHAS_XBUTTON
2868 #ifdef __WXMICROWIN__
2869 // MicroWindows seems to ignore the fact that a window is
2870 // disabled. So catch mouse events and throw them away if
2872 wxWindowMSW
* win
= this;
2875 if (!win
->IsEnabled())
2881 win
= win
->GetParent();
2882 if ( !win
|| win
->IsTopLevel() )
2889 #endif // __WXMICROWIN__
2890 int x
= GET_X_LPARAM(lParam
),
2891 y
= GET_Y_LPARAM(lParam
);
2894 // redirect the event to a static control if necessary by
2895 // finding one under mouse because under CE the static controls
2896 // don't generate mouse events (even with SS_NOTIFY)
2898 if ( GetCapture() == this )
2900 // but don't do it if the mouse is captured by this window
2901 // because then it should really get this event itself
2906 win
= FindWindowForMouseEvent(this, &x
, &y
);
2908 // this should never happen
2909 wxCHECK_MSG( win
, 0,
2910 _T("FindWindowForMouseEvent() returned NULL") );
2913 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2915 SHRGINFO shrgi
= {0};
2917 shrgi
.cbSize
= sizeof(SHRGINFO
);
2918 shrgi
.hwndClient
= (HWND
) GetHWND();
2922 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2923 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2925 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2928 pt
= ClientToScreen(pt
);
2930 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2932 evtCtx
.SetEventObject(this);
2933 if (GetEventHandler()->ProcessEvent(evtCtx
))
2942 #else // !__WXWINCE__
2943 wxWindowMSW
*win
= this;
2944 #endif // __WXWINCE__/!__WXWINCE__
2946 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2948 // if the app didn't eat the event, handle it in the default
2949 // way, that is by giving this window the focus
2952 // for the standard classes their WndProc sets the focus to
2953 // them anyhow and doing it from here results in some weird
2954 // problems, so don't do it for them (unnecessary anyhow)
2955 if ( !win
->IsOfStandardClass() )
2957 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
2969 case MM_JOY1BUTTONDOWN
:
2970 case MM_JOY2BUTTONDOWN
:
2971 case MM_JOY1BUTTONUP
:
2972 case MM_JOY2BUTTONUP
:
2973 processed
= HandleJoystickEvent(message
,
2974 GET_X_LPARAM(lParam
),
2975 GET_Y_LPARAM(lParam
),
2978 #endif // __WXMICROWIN__
2984 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2986 processed
= HandleCommand(id
, cmd
, hwnd
);
2991 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2994 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2995 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2996 // apparently doesn't always behave properly and needs some help
2997 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2998 case WM_NOTIFYFORMAT
:
2999 if ( lParam
== NF_QUERY
)
3002 rc
.result
= NFR_UNICODE
;
3005 #endif // wxUSE_UNICODE_MSLU
3007 // for these messages we must return true if process the message
3010 case WM_MEASUREITEM
:
3012 int idCtrl
= (UINT
)wParam
;
3013 if ( message
== WM_DRAWITEM
)
3015 processed
= MSWOnDrawItem(idCtrl
,
3016 (WXDRAWITEMSTRUCT
*)lParam
);
3020 processed
= MSWOnMeasureItem(idCtrl
,
3021 (WXMEASUREITEMSTRUCT
*)lParam
);
3028 #endif // defined(WM_DRAWITEM)
3031 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3033 // we always want to get the char events
3034 rc
.result
= DLGC_WANTCHARS
;
3036 if ( HasFlag(wxWANTS_CHARS
) )
3038 // in fact, we want everything
3039 rc
.result
|= DLGC_WANTARROWS
|
3046 //else: get the dlg code from the DefWindowProc()
3051 // If this has been processed by an event handler, return 0 now
3052 // (we've handled it).
3053 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3054 if ( m_lastKeydownProcessed
)
3063 // we consider these messages "not interesting" to OnChar, so
3064 // just don't do anything more with them
3074 // avoid duplicate messages to OnChar for these ASCII keys:
3075 // they will be translated by TranslateMessage() and received
3107 // but set processed to false, not true to still pass them
3108 // to the control's default window proc - otherwise
3109 // built-in keyboard handling won't work
3114 // special case of VK_APPS: treat it the same as right mouse
3115 // click because both usually pop up a context menu
3117 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3122 // do generate a CHAR event
3123 processed
= HandleChar((WORD
)wParam
, lParam
);
3126 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3133 // special case of VK_APPS: treat it the same as right mouse button
3134 if ( wParam
== VK_APPS
)
3136 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3141 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3146 case WM_CHAR
: // Always an ASCII character
3147 if ( m_lastKeydownProcessed
)
3149 // The key was handled in the EVT_KEY_DOWN and handling
3150 // a key in an EVT_KEY_DOWN handler is meant, by
3151 // design, to prevent EVT_CHARs from happening
3152 m_lastKeydownProcessed
= false;
3157 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3163 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3165 #endif // wxUSE_HOTKEY
3172 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3174 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3180 // CTLCOLOR messages are sent by children to query the parent for their
3182 #ifndef __WXMICROWIN__
3183 case WM_CTLCOLORMSGBOX
:
3184 case WM_CTLCOLOREDIT
:
3185 case WM_CTLCOLORLISTBOX
:
3186 case WM_CTLCOLORBTN
:
3187 case WM_CTLCOLORDLG
:
3188 case WM_CTLCOLORSCROLLBAR
:
3189 case WM_CTLCOLORSTATIC
:
3193 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3195 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3198 #endif // !__WXMICROWIN__
3200 case WM_SYSCOLORCHANGE
:
3201 // the return value for this message is ignored
3202 processed
= HandleSysColorChange();
3205 #if !defined(__WXWINCE__)
3206 case WM_DISPLAYCHANGE
:
3207 processed
= HandleDisplayChange();
3211 case WM_PALETTECHANGED
:
3212 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
3215 case WM_CAPTURECHANGED
:
3216 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
3219 case WM_SETTINGCHANGE
:
3220 processed
= HandleSettingChange(wParam
, lParam
);
3223 case WM_QUERYNEWPALETTE
:
3224 processed
= HandleQueryNewPalette();
3228 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
3231 // we processed the message, i.e. erased the background
3236 #if !defined(__WXWINCE__)
3238 processed
= HandleDropFiles(wParam
);
3243 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
3247 // we never set focus from here
3252 #if !defined(__WXWINCE__)
3253 case WM_QUERYENDSESSION
:
3254 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3258 processed
= HandleEndSession(wParam
!= 0, lParam
);
3261 case WM_GETMINMAXINFO
:
3262 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3267 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
3268 LOWORD(lParam
), // hit test
3269 HIWORD(lParam
)); // mouse msg
3273 // returning TRUE stops the DefWindowProc() from further
3274 // processing this message - exactly what we need because we've
3275 // just set the cursor.
3280 #if wxUSE_ACCESSIBILITY
3283 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3284 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3286 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3288 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3294 #if defined(WM_HELP)
3297 // by default, WM_HELP is propagated by DefWindowProc() upwards
3298 // to the window parent but as we do it ourselves already
3299 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3300 // to get the other events if we process this message at all
3303 // WM_HELP doesn't use lParam under CE
3305 HELPINFO
* info
= (HELPINFO
*) lParam
;
3306 if ( info
->iContextType
== HELPINFO_WINDOW
)
3308 #endif // !__WXWINCE__
3309 wxHelpEvent helpEvent
3314 wxGetMousePosition() // what else?
3316 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3320 helpEvent
.SetEventObject(this);
3321 GetEventHandler()->ProcessEvent(helpEvent
);
3324 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3326 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3327 helpEvent
.SetEventObject(this);
3328 GetEventHandler()->ProcessEvent(helpEvent
);
3331 else // unknown help event?
3335 #endif // !__WXWINCE__
3340 #if !defined(__WXWINCE__)
3341 case WM_CONTEXTMENU
:
3343 // we don't convert from screen to client coordinates as
3344 // the event may be handled by a parent window
3345 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3347 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3349 // we could have got an event from our child, reflect it back
3350 // to it if this is the case
3351 wxWindowMSW
*win
= NULL
;
3352 if ( (WXHWND
)wParam
!= m_hWnd
)
3354 win
= FindItemByHWND((WXHWND
)wParam
);
3360 evtCtx
.SetEventObject(win
);
3361 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
3368 // we're only interested in our own menus, not MF_SYSMENU
3369 if ( HIWORD(wParam
) == MF_POPUP
)
3371 // handle menu chars for ownerdrawn menu items
3372 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3373 if ( i
!= wxNOT_FOUND
)
3375 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3380 #endif // wxUSE_MENUS
3383 case WM_POWERBROADCAST
:
3386 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3387 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3390 #endif // __WXWINCE__
3393 // If we want the default themed border then we need to draw it ourselves
3396 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3397 const wxBorder border
= TranslateBorder(GetBorder());
3398 if (theme
&& border
== wxBORDER_THEME
)
3400 // first ask the widget to calculate the border size
3401 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3404 // now alter the client size making room for drawing a themed border
3405 NCCALCSIZE_PARAMS
*csparam
= NULL
;
3409 csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3410 rect
= csparam
->rgrc
[0];
3414 rect
= *((RECT
*)lParam
);
3416 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3417 RECT rcClient
= { 0, 0, 0, 0 };
3418 wxClientDC
dc((wxWindow
*)this);
3420 if (theme
->GetThemeBackgroundContentRect(
3421 hTheme
, GetHdcOf(dc
), EP_EDITTEXT
, ETS_NORMAL
,
3422 &rect
, &rcClient
) == S_OK
)
3424 InflateRect(&rcClient
, -1, -1);
3426 csparam
->rgrc
[0] = rcClient
;
3428 *((RECT
*)lParam
) = rcClient
;
3429 rc
.result
= WVR_REDRAW
;
3437 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3438 const wxBorder border
= TranslateBorder(GetBorder());
3439 if (theme
&& border
== wxBORDER_THEME
)
3441 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3442 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3445 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3446 wxWindowDC
dc((wxWindow
*)this);
3448 // Clip the DC so that you only draw on the non-client area
3450 wxCopyRectToRECT(GetSize(), rcBorder
);
3453 theme
->GetThemeBackgroundContentRect(
3454 hTheme
, GetHdcOf(dc
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3455 InflateRect(&rcClient
, -1, -1);
3457 ::ExcludeClipRect(GetHdcOf(dc
), rcClient
.left
, rcClient
.top
,
3458 rcClient
.right
, rcClient
.bottom
);
3460 // Make sure the background is in a proper state
3461 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3463 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(dc
), &rcBorder
);
3469 nState
= ETS_DISABLED
;
3470 // should we check this?
3471 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3472 // nState = ETS_READONLY;
3474 nState
= ETS_NORMAL
;
3475 theme
->DrawThemeBackground(hTheme
, GetHdcOf(dc
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3480 #endif // wxUSE_UXTHEME
3483 // try a custom message handler
3484 const MSWMessageHandlers::const_iterator
3485 i
= gs_messageHandlers
.find(message
);
3486 if ( i
!= gs_messageHandlers
.end() )
3488 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3495 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3496 wxGetMessageName(message
));
3497 #endif // __WXDEBUG__
3498 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3504 // ----------------------------------------------------------------------------
3505 // wxWindow <-> HWND map
3506 // ----------------------------------------------------------------------------
3508 wxWinHashTable
*wxWinHandleHash
= NULL
;
3510 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3512 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3515 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3517 // adding NULL hWnd is (first) surely a result of an error and
3518 // (secondly) breaks menu command processing
3519 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3520 wxT("attempt to add a NULL hWnd to window list ignored") );
3522 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3524 if ( oldWin
&& (oldWin
!= win
) )
3526 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3527 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3530 #endif // __WXDEBUG__
3533 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3537 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3539 wxWinHandleHash
->Delete((long)win
->GetHWND());
3542 // ----------------------------------------------------------------------------
3543 // various MSW speciic class dependent functions
3544 // ----------------------------------------------------------------------------
3546 // Default destroyer - override if you destroy it in some other way
3547 // (e.g. with MDI child windows)
3548 void wxWindowMSW::MSWDestroyWindow()
3552 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3555 int& w
, int& h
) const
3557 // yes, those are just some arbitrary hardcoded numbers
3558 static const int DEFAULT_Y
= 200;
3560 bool nonDefault
= false;
3562 if ( pos
.x
== wxDefaultCoord
)
3564 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3565 // can just as well set it to CW_USEDEFAULT as well
3571 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3572 // neither because it is not handled as a special value by Windows then
3573 // and so we have to choose some default value for it
3575 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3581 NB: there used to be some code here which set the initial size of the
3582 window to the client size of the parent if no explicit size was
3583 specified. This was wrong because wxWidgets programs often assume
3584 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3585 it. To see why, you should understand that Windows sends WM_SIZE from
3586 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3587 from some base class ctor and so this WM_SIZE is not processed in the
3588 real class' OnSize() (because it's not fully constructed yet and the
3589 event goes to some base class OnSize() instead). So the WM_SIZE we
3590 rely on is the one sent when the parent frame resizes its children
3591 but here is the problem: if the child already has just the right
3592 size, nothing will happen as both wxWidgets and Windows check for
3593 this and ignore any attempts to change the window size to the size it
3594 already has - so no WM_SIZE would be sent.
3598 // we don't use CW_USEDEFAULT here for several reasons:
3600 // 1. it results in huge frames on modern screens (1000*800 is not
3601 // uncommon on my 1280*1024 screen) which is way too big for a half
3602 // empty frame of most of wxWidgets samples for example)
3604 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3605 // the default is for whatever reason 8*8 which breaks client <->
3606 // window size calculations (it would be nice if it didn't, but it
3607 // does and the simplest way to fix it seemed to change the broken
3608 // default size anyhow)
3610 // 3. there is just no advantage in doing it: with x and y it is
3611 // possible that [future versions of] Windows position the new top
3612 // level window in some smart way which we can't do, but we can
3613 // guess a reasonably good size for a new window just as well
3616 // However, on PocketPC devices, we must use the default
3617 // size if possible.
3619 if (size
.x
== wxDefaultCoord
)
3623 if (size
.y
== wxDefaultCoord
)
3628 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3632 w
= WidthDefault(size
.x
);
3633 h
= HeightDefault(size
.y
);
3636 AdjustForParentClientOrigin(x
, y
);
3641 WXHWND
wxWindowMSW::MSWGetParent() const
3643 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3646 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3647 const wxChar
*title
,
3651 WXDWORD extendedStyle
)
3653 // choose the position/size for the new window
3655 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3657 // controlId is menu handle for the top level windows, so set it to 0
3658 // unless we're creating a child window
3659 int controlId
= style
& WS_CHILD
? GetId() : 0;
3661 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3662 // which is the same but without CS_[HV]REDRAW class styles so using it
3663 // ensures that the window is not fully repainted on each resize
3664 wxString
className(wclass
);
3665 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3667 className
+= wxT("NR");
3670 // do create the window
3671 wxWindowCreationHook
hook(this);
3673 m_hWnd
= (WXHWND
)::CreateWindowEx
3677 title
? title
: m_windowName
.wx_str(),
3680 (HWND
)MSWGetParent(),
3683 NULL
// no extra data
3688 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3693 SubclassWin(m_hWnd
);
3698 // ===========================================================================
3699 // MSW message handlers
3700 // ===========================================================================
3702 // ---------------------------------------------------------------------------
3704 // ---------------------------------------------------------------------------
3706 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3708 #ifndef __WXMICROWIN__
3709 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3710 HWND hWnd
= hdr
->hwndFrom
;
3711 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3713 // if the control is one of our windows, let it handle the message itself
3716 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3719 // VZ: why did we do it? normally this is unnecessary and, besides, it
3720 // breaks the message processing for the toolbars because the tooltip
3721 // notifications were being forwarded to the toolbar child controls
3722 // (if it had any) before being passed to the toolbar itself, so in my
3723 // example the tooltip for the combobox was always shown instead of the
3724 // correct button tooltips
3726 // try all our children
3727 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3730 wxWindow
*child
= node
->GetData();
3731 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3736 node
= node
->GetNext();
3740 // by default, handle it ourselves
3741 return MSWOnNotify(idCtrl
, lParam
, result
);
3742 #else // __WXMICROWIN__
3749 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3751 const wxString
& ttip
)
3753 // I don't know why it happens, but the versions of comctl32.dll starting
3754 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3755 // this message is supposed to be sent to Unicode programs only) -- hence
3756 // we need to handle it as well, otherwise no tooltips will be shown in
3759 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3762 // not a tooltip message or no tooltip to show anyhow
3767 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3769 // We don't want to use the szText buffer because it has a limit of 80
3770 // bytes and this is not enough, especially for Unicode build where it
3771 // limits the tooltip string length to only 40 characters
3773 // The best would be, of course, to not impose any length limitations at
3774 // all but then the buffer would have to be dynamic and someone would have
3775 // to free it and we don't have the tooltip owner object here any more, so
3776 // for now use our own static buffer with a higher fixed max length.
3778 // Note that using a static buffer should not be a problem as only a single
3779 // tooltip can be shown at the same time anyhow.
3781 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3783 // We need to convert tooltip from multi byte to Unicode on the fly.
3784 static wchar_t buf
[513];
3786 // Truncate tooltip length if needed as otherwise we might not have
3787 // enough space for it in the buffer and MultiByteToWideChar() would
3789 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3791 // Convert to WideChar without adding the NULL character. The NULL
3792 // character is added afterwards (this is more efficient).
3793 int len
= ::MultiByteToWideChar
3805 wxLogLastError(_T("MultiByteToWideChar()"));
3809 ttText
->lpszText
= (LPSTR
) buf
;
3811 else // TTN_NEEDTEXTA
3812 #endif // !wxUSE_UNICODE
3814 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3815 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3816 // to copy the string we have into the buffer
3817 static wxChar buf
[513];
3818 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3819 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3820 ttText
->lpszText
= buf
;
3826 #endif // wxUSE_TOOLTIPS
3828 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3830 WXLPARAM
* WXUNUSED(result
))
3835 NMHDR
* hdr
= (NMHDR
*)lParam
;
3836 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3843 wxUnusedVar(lParam
);
3844 #endif // wxUSE_TOOLTIPS
3849 // ---------------------------------------------------------------------------
3850 // end session messages
3851 // ---------------------------------------------------------------------------
3853 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3855 #ifdef ENDSESSION_LOGOFF
3856 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3857 event
.SetEventObject(wxTheApp
);
3858 event
.SetCanVeto(true);
3859 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3861 bool rc
= wxTheApp
->ProcessEvent(event
);
3865 // we may end only if the app didn't veto session closing (double
3867 *mayEnd
= !event
.GetVeto();
3872 wxUnusedVar(logOff
);
3873 wxUnusedVar(mayEnd
);
3878 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3880 #ifdef ENDSESSION_LOGOFF
3881 // do nothing if the session isn't ending
3886 if ( (this != wxTheApp
->GetTopWindow()) )
3889 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3890 event
.SetEventObject(wxTheApp
);
3891 event
.SetCanVeto(false);
3892 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3894 return wxTheApp
->ProcessEvent(event
);
3896 wxUnusedVar(endSession
);
3897 wxUnusedVar(logOff
);
3902 // ---------------------------------------------------------------------------
3903 // window creation/destruction
3904 // ---------------------------------------------------------------------------
3906 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3909 // VZ: why is this commented out for WinCE? If it doesn't support
3910 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3911 // not with multiple #ifdef's!
3913 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3914 EnsureParentHasControlParentStyle(GetParent());
3915 #endif // !__WXWINCE__
3922 bool wxWindowMSW::HandleDestroy()
3926 // delete our drop target if we've got one
3927 #if wxUSE_DRAG_AND_DROP
3928 if ( m_dropTarget
!= NULL
)
3930 m_dropTarget
->Revoke(m_hWnd
);
3932 delete m_dropTarget
;
3933 m_dropTarget
= NULL
;
3935 #endif // wxUSE_DRAG_AND_DROP
3937 // WM_DESTROY handled
3941 // ---------------------------------------------------------------------------
3943 // ---------------------------------------------------------------------------
3945 bool wxWindowMSW::HandleActivate(int state
,
3946 bool WXUNUSED(minimized
),
3947 WXHWND
WXUNUSED(activate
))
3949 wxActivateEvent
event(wxEVT_ACTIVATE
,
3950 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3952 event
.SetEventObject(this);
3954 return GetEventHandler()->ProcessEvent(event
);
3957 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3959 // Strangly enough, some controls get set focus events when they are being
3960 // deleted, even if they already had focus before.
3961 if ( m_isBeingDeleted
)
3966 // notify the parent keeping track of focus for the kbd navigation
3967 // purposes that we got it
3968 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3969 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3975 m_caret
->OnSetFocus();
3977 #endif // wxUSE_CARET
3980 // If it's a wxTextCtrl don't send the event as it will be done
3981 // after the control gets to process it from EN_FOCUS handler
3982 if ( wxDynamicCastThis(wxTextCtrl
) )
3986 #endif // wxUSE_TEXTCTRL
3988 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3989 event
.SetEventObject(this);
3991 // wxFindWinFromHandle() may return NULL, it is ok
3992 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3994 return GetEventHandler()->ProcessEvent(event
);
3997 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4003 m_caret
->OnKillFocus();
4005 #endif // wxUSE_CARET
4008 // If it's a wxTextCtrl don't send the event as it will be done
4009 // after the control gets to process it.
4010 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
4017 // Don't send the event when in the process of being deleted. This can
4018 // only cause problems if the event handler tries to access the object.
4019 if ( m_isBeingDeleted
)
4024 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4025 event
.SetEventObject(this);
4027 // wxFindWinFromHandle() may return NULL, it is ok
4028 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4030 return GetEventHandler()->ProcessEvent(event
);
4033 // ---------------------------------------------------------------------------
4035 // ---------------------------------------------------------------------------
4037 void wxWindowMSW::SetLabel( const wxString
& label
)
4039 SetWindowText(GetHwnd(), label
.c_str());
4042 wxString
wxWindowMSW::GetLabel() const
4044 return wxGetWindowText(GetHWND());
4047 // ---------------------------------------------------------------------------
4049 // ---------------------------------------------------------------------------
4051 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4053 wxShowEvent
event(GetId(), show
);
4054 event
.SetEventObject(this);
4056 return GetEventHandler()->ProcessEvent(event
);
4059 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4061 wxInitDialogEvent
event(GetId());
4062 event
.SetEventObject(this);
4064 return GetEventHandler()->ProcessEvent(event
);
4067 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4069 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4070 wxUnusedVar(wParam
);
4072 #else // __WXMICROWIN__
4073 HDROP hFilesInfo
= (HDROP
) wParam
;
4075 // Get the total number of files dropped
4076 UINT gwFilesDropped
= ::DragQueryFile
4084 wxString
*files
= new wxString
[gwFilesDropped
];
4085 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4087 // first get the needed buffer length (+1 for terminating NUL)
4088 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4090 // and now get the file name
4091 ::DragQueryFile(hFilesInfo
, wIndex
,
4092 wxStringBuffer(files
[wIndex
], len
), len
);
4094 DragFinish (hFilesInfo
);
4096 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4097 event
.SetEventObject(this);
4100 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4101 event
.m_pos
.x
= dropPoint
.x
;
4102 event
.m_pos
.y
= dropPoint
.y
;
4104 return GetEventHandler()->ProcessEvent(event
);
4109 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4111 int WXUNUSED(mouseMsg
))
4113 #ifndef __WXMICROWIN__
4114 // the logic is as follows:
4115 // 0. if we're busy, set the busy cursor (even for non client elements)
4116 // 1. don't set custom cursor for non client area of enabled windows
4117 // 2. ask user EVT_SET_CURSOR handler for the cursor
4118 // 3. if still no cursor but we're in a TLW, set the global cursor
4120 HCURSOR hcursor
= 0;
4123 hcursor
= wxGetCurrentBusyCursor();
4127 if ( nHitTest
!= HTCLIENT
)
4130 // first ask the user code - it may wish to set the cursor in some very
4131 // specific way (for example, depending on the current position)
4134 if ( !::GetCursorPosWinCE(&pt
))
4136 if ( !::GetCursorPos(&pt
) )
4139 wxLogLastError(wxT("GetCursorPos"));
4144 ScreenToClient(&x
, &y
);
4145 wxSetCursorEvent
event(x
, y
);
4147 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
4148 if ( processedEvtSetCursor
&& event
.HasCursor() )
4150 hcursor
= GetHcursorOf(event
.GetCursor());
4155 // the test for processedEvtSetCursor is here to prevent using
4156 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4157 // nothing from it - this is a way to say that our cursor shouldn't
4158 // be used for this point
4159 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4161 hcursor
= GetHcursorOf(m_cursor
);
4164 if ( !hcursor
&& !GetParent() )
4166 const wxCursor
*cursor
= wxGetGlobalCursor();
4167 if ( cursor
&& cursor
->Ok() )
4169 hcursor
= GetHcursorOf(*cursor
);
4178 ::SetCursor(hcursor
);
4180 // cursor set, stop here
4183 #endif // __WXMICROWIN__
4185 // pass up the window chain
4189 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4190 WXLPARAM
WXUNUSED(lParam
),
4191 bool *WXUNUSED_IN_WINCE(vetoed
))
4197 wxEventType evtType
;
4200 case PBT_APMQUERYSUSPEND
:
4201 evtType
= wxEVT_POWER_SUSPENDING
;
4204 case PBT_APMQUERYSUSPENDFAILED
:
4205 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4208 case PBT_APMSUSPEND
:
4209 evtType
= wxEVT_POWER_SUSPENDED
;
4212 case PBT_APMRESUMESUSPEND
:
4213 #ifdef PBT_APMRESUMEAUTOMATIC
4214 case PBT_APMRESUMEAUTOMATIC
:
4216 evtType
= wxEVT_POWER_RESUME
;
4220 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4223 // these messages are currently not mapped to wx events
4224 case PBT_APMQUERYSTANDBY
:
4225 case PBT_APMQUERYSTANDBYFAILED
:
4226 case PBT_APMSTANDBY
:
4227 case PBT_APMRESUMESTANDBY
:
4228 case PBT_APMBATTERYLOW
:
4229 case PBT_APMPOWERSTATUSCHANGE
:
4230 case PBT_APMOEMEVENT
:
4231 case PBT_APMRESUMECRITICAL
:
4232 evtType
= wxEVT_NULL
;
4236 // don't handle unknown messages
4237 if ( evtType
== wxEVT_NULL
)
4240 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4242 wxPowerEvent
event(evtType
);
4243 if ( !GetEventHandler()->ProcessEvent(event
) )
4246 *vetoed
= event
.IsVetoed();
4252 bool wxWindowMSW::IsDoubleBuffered() const
4254 for ( const wxWindowMSW
*wnd
= this;
4255 wnd
&& !wnd
->IsTopLevel(); wnd
=
4258 if ( ::GetWindowLong(GetHwndOf(wnd
), GWL_EXSTYLE
) & WS_EX_COMPOSITED
)
4265 // ---------------------------------------------------------------------------
4266 // owner drawn stuff
4267 // ---------------------------------------------------------------------------
4269 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4270 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4271 #define WXUNUSED_UNLESS_ODRAWN(param) param
4273 #define WXUNUSED_UNLESS_ODRAWN(param)
4277 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4278 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4280 #if wxUSE_OWNER_DRAWN
4282 #if wxUSE_MENUS_NATIVE
4283 // is it a menu item?
4284 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4285 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4287 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4289 // see comment before the same test in MSWOnMeasureItem() below
4293 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4294 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
4296 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4297 // the DC from being released
4298 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4299 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4300 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4301 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4303 return pMenuItem
->OnDrawItem
4307 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4308 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4311 #endif // wxUSE_MENUS_NATIVE
4313 #endif // USE_OWNER_DRAWN
4315 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4317 #if wxUSE_OWNER_DRAWN
4318 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4319 #else // !wxUSE_OWNER_DRAWN
4320 // we may still have owner-drawn buttons internally because we have to make
4321 // them owner-drawn to support colour change
4324 wxDynamicCast(FindItem(id
), wxButton
)
4329 #endif // USE_OWNER_DRAWN
4333 return item
->MSWOnDraw(itemStruct
);
4336 #endif // wxUSE_CONTROLS
4342 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4344 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4345 // is it a menu item?
4346 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4347 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4349 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4351 // according to Carsten Fuchs the pointer may be NULL under XP if an
4352 // MDI child frame is initially maximized, see this for more info:
4353 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4355 // so silently ignore it instead of asserting
4359 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4360 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4363 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4365 pMeasureStruct
->itemWidth
= w
;
4366 pMeasureStruct
->itemHeight
= h
;
4371 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4374 return item
->MSWOnMeasure(itemStruct
);
4378 wxUnusedVar(itemStruct
);
4379 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4384 // ---------------------------------------------------------------------------
4385 // colours and palettes
4386 // ---------------------------------------------------------------------------
4388 bool wxWindowMSW::HandleSysColorChange()
4390 wxSysColourChangedEvent event
;
4391 event
.SetEventObject(this);
4393 (void)GetEventHandler()->ProcessEvent(event
);
4395 // always let the system carry on the default processing to allow the
4396 // native controls to react to the colours update
4400 bool wxWindowMSW::HandleDisplayChange()
4402 wxDisplayChangedEvent event
;
4403 event
.SetEventObject(this);
4405 return GetEventHandler()->ProcessEvent(event
);
4408 #ifndef __WXMICROWIN__
4410 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4412 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4416 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4419 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4421 #endif // wxUSE_CONTROLS
4424 return *brush
!= NULL
;
4427 #endif // __WXMICROWIN__
4429 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4432 // same as below except we don't respond to our own messages
4433 if ( hWndPalChange
!= GetHWND() )
4435 // check to see if we our our parents have a custom palette
4436 wxWindowMSW
*win
= this;
4437 while ( win
&& !win
->HasCustomPalette() )
4439 win
= win
->GetParent();
4442 if ( win
&& win
->HasCustomPalette() )
4444 // realize the palette to see whether redrawing is needed
4445 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4446 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4447 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4449 int result
= ::RealizePalette(hdc
);
4451 // restore the palette (before releasing the DC)
4452 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4453 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4454 ::RealizePalette(hdc
);
4455 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4457 // now check for the need to redraw
4459 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4463 #endif // wxUSE_PALETTE
4465 wxPaletteChangedEvent
event(GetId());
4466 event
.SetEventObject(this);
4467 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4469 return GetEventHandler()->ProcessEvent(event
);
4472 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4474 // notify windows on the capture stack about lost capture
4475 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4476 wxWindowBase::NotifyCaptureLost();
4478 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4479 wxMouseCaptureChangedEvent
event(GetId(), win
);
4480 event
.SetEventObject(this);
4481 return GetEventHandler()->ProcessEvent(event
);
4484 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4486 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4487 // we need to send this to child windows (it is only sent to top-level
4488 // windows) so {list,tree}ctrls can adjust their font size if necessary
4489 // this is exactly how explorer does it to enable the font size changes
4491 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4494 // top-level windows already get this message from the system
4495 wxWindow
*win
= node
->GetData();
4496 if ( !win
->IsTopLevel() )
4498 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4501 node
= node
->GetNext();
4504 // let the system handle it
4508 bool wxWindowMSW::HandleQueryNewPalette()
4512 // check to see if we our our parents have a custom palette
4513 wxWindowMSW
*win
= this;
4514 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4515 if (win
->HasCustomPalette()) {
4516 /* realize the palette to see whether redrawing is needed */
4517 HDC hdc
= ::GetDC((HWND
) GetHWND());
4518 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4519 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4521 int result
= ::RealizePalette(hdc
);
4522 /* restore the palette (before releasing the DC) */
4523 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4524 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4525 ::RealizePalette(hdc
);
4526 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4527 /* now check for the need to redraw */
4529 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4531 #endif // wxUSE_PALETTE
4533 wxQueryNewPaletteEvent
event(GetId());
4534 event
.SetEventObject(this);
4536 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
4539 // Responds to colour changes: passes event on to children.
4540 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4542 // the top level window also reset the standard colour map as it might have
4543 // changed (there is no need to do it for the non top level windows as we
4544 // only have to do it once)
4548 gs_hasStdCmap
= false;
4550 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4553 // Only propagate to non-top-level windows because Windows already
4554 // sends this event to all top-level ones
4555 wxWindow
*win
= node
->GetData();
4556 if ( !win
->IsTopLevel() )
4558 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4559 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4560 // the standard controls
4561 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4564 node
= node
->GetNext();
4568 extern wxCOLORMAP
*wxGetStdColourMap()
4570 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4571 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4573 if ( !gs_hasStdCmap
)
4575 static bool s_coloursInit
= false;
4577 if ( !s_coloursInit
)
4579 // When a bitmap is loaded, the RGB values can change (apparently
4580 // because Windows adjusts them to care for the old programs always
4581 // using 0xc0c0c0 while the transparent colour for the new Windows
4582 // versions is different). But we do this adjustment ourselves so
4583 // we want to avoid Windows' "help" and for this we need to have a
4584 // reference bitmap which can tell us what the RGB values change
4586 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4587 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4588 if ( stdColourBitmap
.Ok() )
4590 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4591 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4592 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4595 memDC
.SelectObject(stdColourBitmap
);
4598 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4600 memDC
.GetPixel(i
, 0, &colour
);
4601 s_stdColours
[i
] = wxColourToRGB(colour
);
4604 else // wxBITMAP_STD_COLOURS couldn't be loaded
4606 s_stdColours
[0] = RGB(000,000,000); // black
4607 s_stdColours
[1] = RGB(128,128,128); // dark grey
4608 s_stdColours
[2] = RGB(192,192,192); // light grey
4609 s_stdColours
[3] = RGB(255,255,255); // white
4610 //s_stdColours[4] = RGB(000,000,255); // blue
4611 //s_stdColours[5] = RGB(255,000,255); // magenta
4614 s_coloursInit
= true;
4617 gs_hasStdCmap
= true;
4619 // create the colour map
4620 #define INIT_CMAP_ENTRY(col) \
4621 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4622 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4624 INIT_CMAP_ENTRY(BTNTEXT
);
4625 INIT_CMAP_ENTRY(BTNSHADOW
);
4626 INIT_CMAP_ENTRY(BTNFACE
);
4627 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4629 #undef INIT_CMAP_ENTRY
4635 // ---------------------------------------------------------------------------
4637 // ---------------------------------------------------------------------------
4639 bool wxWindowMSW::HandlePaint()
4641 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4643 wxLogLastError(wxT("CreateRectRgn"));
4644 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4645 wxLogLastError(wxT("GetUpdateRgn"));
4647 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4649 wxPaintEvent
event(m_windowId
);
4650 event
.SetEventObject(this);
4652 bool processed
= GetEventHandler()->ProcessEvent(event
);
4654 // note that we must generate NC event after the normal one as otherwise
4655 // BeginPaint() will happily overwrite our decorations with the background
4657 wxNcPaintEvent
eventNc(m_windowId
);
4658 eventNc
.SetEventObject(this);
4659 GetEventHandler()->ProcessEvent(eventNc
);
4661 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4662 // be called from inside the event handlers called above)
4663 m_updateRegion
.Clear();
4668 // Can be called from an application's OnPaint handler
4669 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4671 #ifdef __WXUNIVERSAL__
4674 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
4677 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4682 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4684 wxDCTemp
dc(hdc
, GetClientSize());
4687 dc
.SetWindow((wxWindow
*)this);
4689 wxEraseEvent
event(m_windowId
, &dc
);
4690 event
.SetEventObject(this);
4691 bool rc
= GetEventHandler()->ProcessEvent(event
);
4693 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4694 dc
.SelectOldObjects(hdc
);
4699 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4701 // standard non top level controls (i.e. except the dialogs) always erase
4702 // their background themselves in HandleCtlColor() or have some control-
4703 // specific ways to set the colours (common controls)
4704 if ( IsOfStandardClass() && !IsTopLevel() )
4710 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4712 // don't skip the event here, custom background means that the app
4713 // is drawing it itself in its OnPaint(), so don't draw it at all
4714 // now to avoid flicker
4719 // do default background painting
4720 if ( !DoEraseBackground(GetHdcOf(*event
.GetDC())) )
4722 // let the system paint the background
4727 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4729 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4733 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4739 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4743 // our background colour applies to:
4744 // 1. this window itself, always
4745 // 2. all children unless the colour is "not inheritable"
4746 // 3. even if it is not inheritable, our immediate transparent
4747 // children should still inherit it -- but not any transparent
4748 // children because it would look wrong if a child of non
4749 // transparent child would show our bg colour when the child itself
4751 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4754 (win
&& win
->HasTransparentBackground() &&
4755 win
->GetParent() == this) )
4757 // draw children with the same colour as the parent
4759 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4761 return (WXHBRUSH
)GetHbrushOf(*brush
);
4768 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4771 hWndToPaint
= GetHWND();
4773 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4775 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4779 // background is not inherited beyond top level windows
4780 if ( win
->IsTopLevel() )
4787 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4789 // we receive this message when DrawThemeParentBackground() is
4790 // called from def window proc of several controls under XP and we
4791 // must draw properly themed background here
4793 // note that naively I'd expect filling the client rect with the
4794 // brush returned by MSWGetBgBrush() work -- but for some reason it
4795 // doesn't and we have to call parents MSWPrintChild() which is
4796 // supposed to call DrawThemeBackground() with appropriate params
4798 // also note that in this case lParam == PRF_CLIENT but we're
4799 // clearly expected to paint the background and nothing else!
4801 if ( IsTopLevel() || InheritsBackgroundColour() )
4804 // sometimes we don't want the parent to handle it at all, instead
4805 // return whatever value this window wants
4806 if ( !MSWShouldPropagatePrintChild() )
4807 return MSWPrintChild(hDC
, (wxWindow
*)this);
4809 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4811 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4814 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4821 // ---------------------------------------------------------------------------
4822 // moving and resizing
4823 // ---------------------------------------------------------------------------
4825 bool wxWindowMSW::HandleMinimize()
4827 wxIconizeEvent
event(m_windowId
);
4828 event
.SetEventObject(this);
4830 return GetEventHandler()->ProcessEvent(event
);
4833 bool wxWindowMSW::HandleMaximize()
4835 wxMaximizeEvent
event(m_windowId
);
4836 event
.SetEventObject(this);
4838 return GetEventHandler()->ProcessEvent(event
);
4841 bool wxWindowMSW::HandleMove(int x
, int y
)
4844 wxMoveEvent
event(point
, m_windowId
);
4845 event
.SetEventObject(this);
4847 return GetEventHandler()->ProcessEvent(event
);
4850 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4852 wxMoveEvent
event(rect
, m_windowId
);
4853 event
.SetEventObject(this);
4855 bool rc
= GetEventHandler()->ProcessEvent(event
);
4857 rect
= event
.GetRect();
4861 bool wxWindowMSW::HandleEnterSizeMove()
4863 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4864 event
.SetEventType(wxEVT_MOVE_START
);
4865 event
.SetEventObject(this);
4867 return GetEventHandler()->ProcessEvent(event
);
4870 bool wxWindowMSW::HandleExitSizeMove()
4872 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4873 event
.SetEventType(wxEVT_MOVE_END
);
4874 event
.SetEventObject(this);
4876 return GetEventHandler()->ProcessEvent(event
);
4879 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4881 #if USE_DEFERRED_SIZING
4882 // when we resize this window, its children are probably going to be
4883 // repositioned as well, prepare to use DeferWindowPos() for them
4884 int numChildren
= 0;
4885 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4887 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4892 // Protect against valid m_hDWP being overwritten
4893 bool useDefer
= false;
4895 if ( numChildren
> 1 )
4899 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4902 wxLogLastError(_T("BeginDeferWindowPos"));
4908 #endif // USE_DEFERRED_SIZING
4910 // update this window size
4911 bool processed
= false;
4915 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4916 // fall through nevertheless
4920 // we're not interested in these messages at all
4923 case SIZE_MINIMIZED
:
4924 processed
= HandleMinimize();
4927 case SIZE_MAXIMIZED
:
4928 /* processed = */ HandleMaximize();
4929 // fall through to send a normal size event as well
4932 // don't use w and h parameters as they specify the client size
4933 // while according to the docs EVT_SIZE handler is supposed to
4934 // receive the total size
4935 wxSizeEvent
event(GetSize(), m_windowId
);
4936 event
.SetEventObject(this);
4938 processed
= GetEventHandler()->ProcessEvent(event
);
4941 #if USE_DEFERRED_SIZING
4942 // and finally change the positions of all child windows at once
4943 if ( useDefer
&& m_hDWP
)
4945 // reset m_hDWP to NULL so that child windows don't try to use our
4946 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4947 // happen anyhow normally but who knows what weird flow of control we
4948 // may have depending on what the users EVT_SIZE handler does...)
4949 HDWP hDWP
= (HDWP
)m_hDWP
;
4952 // do put all child controls in place at once
4953 if ( !::EndDeferWindowPos(hDWP
) )
4955 wxLogLastError(_T("EndDeferWindowPos"));
4958 // Reset our children's pending pos/size values.
4959 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4961 node
= node
->GetNext() )
4963 wxWindowMSW
*child
= node
->GetData();
4964 child
->m_pendingPosition
= wxDefaultPosition
;
4965 child
->m_pendingSize
= wxDefaultSize
;
4968 #endif // USE_DEFERRED_SIZING
4973 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4975 wxSizeEvent
event(rect
, m_windowId
);
4976 event
.SetEventObject(this);
4978 bool rc
= GetEventHandler()->ProcessEvent(event
);
4980 rect
= event
.GetRect();
4984 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4989 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4993 int minWidth
= GetMinWidth(),
4994 minHeight
= GetMinHeight(),
4995 maxWidth
= GetMaxWidth(),
4996 maxHeight
= GetMaxHeight();
4998 if ( minWidth
!= wxDefaultCoord
)
5000 info
->ptMinTrackSize
.x
= minWidth
;
5004 if ( minHeight
!= wxDefaultCoord
)
5006 info
->ptMinTrackSize
.y
= minHeight
;
5010 if ( maxWidth
!= wxDefaultCoord
)
5012 info
->ptMaxTrackSize
.x
= maxWidth
;
5016 if ( maxHeight
!= wxDefaultCoord
)
5018 info
->ptMaxTrackSize
.y
= maxHeight
;
5026 // ---------------------------------------------------------------------------
5028 // ---------------------------------------------------------------------------
5030 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5032 // sign extend to int from short before comparing with the other int ids
5033 int id
= (signed short)id_
;
5035 #if wxUSE_MENUS_NATIVE
5036 if ( !cmd
&& wxCurrentPopupMenu
)
5038 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5039 wxCurrentPopupMenu
= NULL
;
5041 return popupMenu
->MSWCommand(cmd
, id
);
5043 #endif // wxUSE_MENUS_NATIVE
5045 wxWindow
*win
= NULL
;
5047 // first try to find it from HWND - this works even with the broken
5048 // programs using the same ids for different controls
5051 win
= wxFindWinFromHandle(control
);
5062 return win
->MSWCommand(cmd
, id
);
5065 // the messages sent from the in-place edit control used by the treectrl
5066 // for label editing have id == 0, but they should _not_ be treated as menu
5067 // messages (they are EN_XXX ones, in fact) so don't translate anything
5068 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5071 // If no child window, it may be an accelerator, e.g. for a popup menu
5074 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
5075 event
.SetEventObject(this);
5079 return GetEventHandler()->ProcessEvent(event
);
5083 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5084 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5085 // notifications to its parent which we want to reflect back to
5087 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5088 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5090 #endif // wxUSE_SPINCTRL
5092 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5093 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5094 // notifications to its parent which we want to reflect back to
5096 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5097 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5105 // ---------------------------------------------------------------------------
5107 // ---------------------------------------------------------------------------
5109 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5113 // our client coords are not quite the same as Windows ones
5114 wxPoint pt
= GetClientAreaOrigin();
5115 event
.m_x
= x
- pt
.x
;
5116 event
.m_y
= y
- pt
.y
;
5118 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5119 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5120 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5121 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5122 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5123 #ifdef wxHAS_XBUTTON
5124 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5125 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5126 #endif // wxHAS_XBUTTON
5127 event
.m_altDown
= ::wxIsAltDown();
5130 event
.SetTimestamp(::GetMessageTime());
5133 event
.SetEventObject(this);
5134 event
.SetId(GetId());
5136 #if wxUSE_MOUSEEVENT_HACK
5137 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5138 gs_lastMouseEvent
.type
= event
.GetEventType();
5139 #endif // wxUSE_MOUSEEVENT_HACK
5143 // Windows doesn't send the mouse events to the static controls (which are
5144 // transparent in the sense that their WM_NCHITTEST handler returns
5145 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5146 // and so we manually check if we don't have a child window under mouse and if
5147 // we do, send the event to it instead of the window Windows had sent WM_XXX
5150 // Notice that this is not done for the mouse move events because this could
5151 // (would?) be too slow, but only for clicks which means that the static texts
5152 // still don't get move, enter nor leave events.
5153 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5155 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
5157 // first try to find a non transparent child: this allows us to send events
5158 // to a static text which is inside a static box, for example
5159 POINT pt
= { *x
, *y
};
5160 HWND hwnd
= GetHwndOf(win
),
5164 hwndUnderMouse
= ::ChildWindowFromPoint
5170 hwndUnderMouse
= ::ChildWindowFromPointEx
5180 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5182 // now try any child window at all
5183 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5186 // check that we have a child window which is susceptible to receive mouse
5187 // events: for this it must be shown and enabled
5188 if ( hwndUnderMouse
&&
5189 hwndUnderMouse
!= hwnd
&&
5190 ::IsWindowVisible(hwndUnderMouse
) &&
5191 ::IsWindowEnabled(hwndUnderMouse
) )
5193 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
5194 if ( winUnderMouse
)
5196 // translate the mouse coords to the other window coords
5197 win
->ClientToScreen(x
, y
);
5198 winUnderMouse
->ScreenToClient(x
, y
);
5200 win
= winUnderMouse
;
5206 #endif // __WXWINCE__
5208 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5210 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5211 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5212 // from the message id and take the value in the table to get wxWin event
5214 static const wxEventType eventsMouse
[] =
5225 wxEVT_MIDDLE_DCLICK
,
5226 0, // this one is for wxEVT_MOTION which is not used here
5235 #ifdef wxHAS_XBUTTON
5236 // the same messages are used for both auxillary mouse buttons so we need
5237 // to adjust the index manually
5240 case WM_XBUTTONDOWN
:
5242 case WM_XBUTTONDBLCLK
:
5243 if ( flags
& MK_XBUTTON2
)
5244 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5246 #endif // wxHAS_XBUTTON
5248 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5249 InitMouseEvent(event
, x
, y
, flags
);
5251 return GetEventHandler()->ProcessEvent(event
);
5254 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5256 if ( !m_mouseInWindow
)
5258 // it would be wrong to assume that just because we get a mouse move
5259 // event that the mouse is inside the window: although this is usually
5260 // true, it is not if we had captured the mouse, so we need to check
5261 // the mouse coordinates here
5262 if ( !HasCapture() || IsMouseInWindow() )
5264 // Generate an ENTER event
5265 m_mouseInWindow
= true;
5267 #ifdef HAVE_TRACKMOUSEEVENT
5268 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5270 static const _TrackMouseEvent_t
5271 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5272 #else // !__WXWINCE__
5273 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5274 static bool s_initDone
= false;
5279 wxDynamicLibrary
dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM
);
5280 if ( dllComCtl32
.IsLoaded() )
5282 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5283 dllComCtl32
.GetSymbol(_T("_TrackMouseEvent"));
5288 // notice that it's ok to unload comctl32.dll here as it won't
5289 // be really unloaded, being still in use because we link to it
5293 if ( s_pfn_TrackMouseEvent
)
5294 #endif // __WXWINCE__/!__WXWINCE__
5296 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5298 trackinfo
.dwFlags
= TME_LEAVE
;
5299 trackinfo
.hwndTrack
= GetHwnd();
5301 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5303 #endif // HAVE_TRACKMOUSEEVENT
5305 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5306 InitMouseEvent(event
, x
, y
, flags
);
5308 (void)GetEventHandler()->ProcessEvent(event
);
5311 #ifdef HAVE_TRACKMOUSEEVENT
5312 else // mouse not in window
5314 // Check if we need to send a LEAVE event
5315 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5316 // send it here if we are using native mouse leave tracking
5317 if ( HasCapture() && !IsMouseInWindow() )
5319 GenerateMouseLeave();
5322 #endif // HAVE_TRACKMOUSEEVENT
5324 #if wxUSE_MOUSEEVENT_HACK
5325 // Windows often generates mouse events even if mouse position hasn't
5326 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5328 // Filter this out as it can result in unexpected behaviour compared to
5330 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5331 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5332 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5333 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5335 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5337 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5342 #endif // wxUSE_MOUSEEVENT_HACK
5344 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5348 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5350 #if wxUSE_MOUSEWHEEL
5351 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5352 // forwarded up to the parent by DefWindowProc()) and not in the client
5353 // ones as all the other messages, translate them to the client coords for
5356 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5357 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5358 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5359 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5360 event
.m_wheelDelta
= WHEEL_DELTA
;
5362 static int s_linesPerRotation
= -1;
5363 if ( s_linesPerRotation
== -1 )
5365 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5366 &s_linesPerRotation
, 0))
5368 // this is not supposed to happen
5369 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5371 // the default is 3, so use it if SystemParametersInfo() failed
5372 s_linesPerRotation
= 3;
5376 event
.m_linesPerAction
= s_linesPerRotation
;
5377 return GetEventHandler()->ProcessEvent(event
);
5379 #else // !wxUSE_MOUSEWHEEL
5380 wxUnusedVar(wParam
);
5381 wxUnusedVar(lParam
);
5384 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5387 void wxWindowMSW::GenerateMouseLeave()
5389 m_mouseInWindow
= false;
5392 if ( wxIsShiftDown() )
5394 if ( wxIsCtrlDown() )
5395 state
|= MK_CONTROL
;
5397 // Only the high-order bit should be tested
5398 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5399 state
|= MK_LBUTTON
;
5400 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5401 state
|= MK_MBUTTON
;
5402 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5403 state
|= MK_RBUTTON
;
5407 if ( !::GetCursorPosWinCE(&pt
) )
5409 if ( !::GetCursorPos(&pt
) )
5412 wxLogLastError(_T("GetCursorPos"));
5415 // we need to have client coordinates here for symmetry with
5416 // wxEVT_ENTER_WINDOW
5417 RECT rect
= wxGetWindowRect(GetHwnd());
5421 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5422 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5424 (void)GetEventHandler()->ProcessEvent(event
);
5427 // ---------------------------------------------------------------------------
5428 // keyboard handling
5429 // ---------------------------------------------------------------------------
5431 // create the key event of the given type for the given key - used by
5432 // HandleChar and HandleKeyDown/Up
5433 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5436 WXWPARAM wParam
) const
5438 wxKeyEvent
event(evType
);
5439 event
.SetId(GetId());
5440 event
.m_shiftDown
= wxIsShiftDown();
5441 event
.m_controlDown
= wxIsCtrlDown();
5442 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5444 event
.SetEventObject((wxWindow
*)this); // const_cast
5445 event
.m_keyCode
= id
;
5447 event
.m_uniChar
= (wxChar
) wParam
;
5449 event
.m_rawCode
= (wxUint32
) wParam
;
5450 event
.m_rawFlags
= (wxUint32
) lParam
;
5452 event
.SetTimestamp(::GetMessageTime());
5455 // translate the position to client coords
5458 GetCursorPosWinCE(&pt
);
5463 GetWindowRect(GetHwnd(),&rect
);
5473 // isASCII is true only when we're called from WM_CHAR handler and not from
5475 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5482 else // we're called from WM_KEYDOWN
5484 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5485 // to get numpad key codes: CHAR events should use the logical keys
5486 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5487 id
= wxCharCodeMSWToWX(wParam
);
5490 // it's ASCII and will be processed here only when called from
5491 // WM_CHAR (i.e. when isASCII = true), don't process it now
5496 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5498 // the alphanumeric keys produced by pressing AltGr+something on European
5499 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5500 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5501 // alphanumeric, so pretend that there are no modifiers at all (the
5502 // KEY_DOWN event would still have the correct modifiers if they're really
5504 if ( event
.m_controlDown
&& event
.m_altDown
&&
5505 (id
>= 32 && id
< 256) )
5507 event
.m_controlDown
=
5508 event
.m_altDown
= false;
5511 return GetEventHandler()->ProcessEvent(event
);
5514 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5516 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5520 // normal ASCII char
5524 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5525 return GetEventHandler()->ProcessEvent(event
);
5528 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5530 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5534 // normal ASCII char
5538 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5539 return GetEventHandler()->ProcessEvent(event
);
5543 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5544 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5546 // FIXME: implement GetMenuItemCount for WinCE, possibly
5547 // in terms of GetMenuItemInfo
5549 const HMENU hmenu
= (HMENU
)lParam
;
5553 mii
.cbSize
= sizeof(MENUITEMINFO
);
5555 // we could use MIIM_FTYPE here as we only need to know if the item is
5556 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5557 // MIIM_FTYPE is not supported under Win95
5558 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5560 // find if we have this letter in any owner drawn item
5561 const int count
= ::GetMenuItemCount(hmenu
);
5562 for ( int i
= 0; i
< count
; i
++ )
5564 // previous loop iteration could modify it, reset it back before
5565 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5568 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5570 if ( mii
.fType
== MFT_OWNERDRAW
)
5572 // dwItemData member of the MENUITEMINFO is a
5573 // pointer to the associated wxMenuItem -- see the
5574 // menu creation code
5575 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5577 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), _T('&'));
5580 if ( *p
== _T('&') )
5582 // this is not the accel char, find the real one
5583 p
= wxStrchr(p
+ 1, _T('&'));
5585 else // got the accel char
5587 // FIXME-UNICODE: this comparison doesn't risk to work
5588 // for non ASCII accelerator characters I'm afraid, but
5590 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5596 // this one doesn't match
5603 else // failed to get the menu text?
5605 // it's not fatal, so don't show error, but still log it
5606 wxLogLastError(_T("GetMenuItemInfo"));
5613 bool wxWindowMSW::HandleClipboardEvent( WXUINT nMsg
)
5615 const wxEventType type
= ( nMsg
== WM_CUT
) ? wxEVT_COMMAND_TEXT_CUT
:
5616 ( nMsg
== WM_COPY
) ? wxEVT_COMMAND_TEXT_COPY
:
5617 /*( nMsg == WM_PASTE ) ? */ wxEVT_COMMAND_TEXT_PASTE
;
5618 wxClipboardTextEvent
evt(type
, GetId());
5620 evt
.SetEventObject(this);
5622 return GetEventHandler()->ProcessEvent(evt
);
5624 #endif // wxUSE_MENUS
5626 // ---------------------------------------------------------------------------
5628 // ---------------------------------------------------------------------------
5630 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5634 if ( flags
& JOY_BUTTON1CHG
)
5635 change
= wxJOY_BUTTON1
;
5636 if ( flags
& JOY_BUTTON2CHG
)
5637 change
= wxJOY_BUTTON2
;
5638 if ( flags
& JOY_BUTTON3CHG
)
5639 change
= wxJOY_BUTTON3
;
5640 if ( flags
& JOY_BUTTON4CHG
)
5641 change
= wxJOY_BUTTON4
;
5644 if ( flags
& JOY_BUTTON1
)
5645 buttons
|= wxJOY_BUTTON1
;
5646 if ( flags
& JOY_BUTTON2
)
5647 buttons
|= wxJOY_BUTTON2
;
5648 if ( flags
& JOY_BUTTON3
)
5649 buttons
|= wxJOY_BUTTON3
;
5650 if ( flags
& JOY_BUTTON4
)
5651 buttons
|= wxJOY_BUTTON4
;
5653 // the event ids aren't consecutive so we can't use table based lookup
5655 wxEventType eventType
;
5660 eventType
= wxEVT_JOY_MOVE
;
5665 eventType
= wxEVT_JOY_MOVE
;
5670 eventType
= wxEVT_JOY_ZMOVE
;
5675 eventType
= wxEVT_JOY_ZMOVE
;
5678 case MM_JOY1BUTTONDOWN
:
5680 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5683 case MM_JOY2BUTTONDOWN
:
5685 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5688 case MM_JOY1BUTTONUP
:
5690 eventType
= wxEVT_JOY_BUTTON_UP
;
5693 case MM_JOY2BUTTONUP
:
5695 eventType
= wxEVT_JOY_BUTTON_UP
;
5699 wxFAIL_MSG(wxT("no such joystick event"));
5704 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5705 event
.SetPosition(wxPoint(x
, y
));
5706 event
.SetEventObject(this);
5708 return GetEventHandler()->ProcessEvent(event
);
5718 // ---------------------------------------------------------------------------
5720 // ---------------------------------------------------------------------------
5722 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5723 WXWORD pos
, WXHWND control
)
5725 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5727 wxWindow
*child
= wxFindWinFromHandle(control
);
5729 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5732 wxScrollWinEvent event
;
5733 event
.SetPosition(pos
);
5734 event
.SetOrientation(orientation
);
5735 event
.SetEventObject(this);
5740 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5744 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5748 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5752 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5756 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5760 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5763 case SB_THUMBPOSITION
:
5765 // under Win32, the scrollbar range and position are 32 bit integers,
5766 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5767 // explicitly query the scrollbar for the correct position (this must
5768 // be done only for these two SB_ events as they are the only one
5769 // carrying the scrollbar position)
5771 WinStruct
<SCROLLINFO
> scrollInfo
;
5772 scrollInfo
.fMask
= SIF_TRACKPOS
;
5774 if ( !::GetScrollInfo(GetHwnd(),
5775 orientation
== wxHORIZONTAL
? SB_HORZ
5779 // Not necessarily an error, if there are no scrollbars yet.
5780 // wxLogLastError(_T("GetScrollInfo"));
5783 event
.SetPosition(scrollInfo
.nTrackPos
);
5786 event
.SetEventType( wParam
== SB_THUMBPOSITION
5787 ? wxEVT_SCROLLWIN_THUMBRELEASE
5788 : wxEVT_SCROLLWIN_THUMBTRACK
);
5795 return GetEventHandler()->ProcessEvent(event
);
5798 // ----------------------------------------------------------------------------
5799 // custom message handlers
5800 // ----------------------------------------------------------------------------
5803 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5805 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5806 false, _T("registering handler for the same message twice") );
5808 gs_messageHandlers
[msg
] = handler
;
5813 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5815 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5816 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5817 _T("unregistering non-registered handler?") );
5819 gs_messageHandlers
.erase(i
);
5822 // ===========================================================================
5824 // ===========================================================================
5826 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5829 HDC dc
= ::GetDC((HWND
) wnd
);
5832 // the_font.UseResource();
5833 // the_font.RealizeResource();
5834 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5836 was
= (HFONT
) SelectObject(dc
,fnt
);
5838 GetTextMetrics(dc
, &tm
);
5841 SelectObject(dc
,was
);
5843 ReleaseDC((HWND
)wnd
, dc
);
5846 *x
= tm
.tmAveCharWidth
;
5848 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5850 // the_font.ReleaseResource();
5853 // use the "extended" bit (24) of lParam to distinguish extended keys
5854 // from normal keys as the same key is sent
5856 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5858 // except that if lParam is 0, it means we don't have real lParam from
5859 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5860 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5861 // non-numpad (hence extended) key as this is a more common case
5862 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5865 // this array contains the Windows virtual key codes which map one to one to
5866 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5868 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5869 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5870 static const struct wxKeyMapping
5874 } gs_specialKeys
[] =
5876 { VK_CANCEL
, WXK_CANCEL
},
5877 { VK_BACK
, WXK_BACK
},
5878 { VK_TAB
, WXK_TAB
},
5879 { VK_CLEAR
, WXK_CLEAR
},
5880 { VK_SHIFT
, WXK_SHIFT
},
5881 { VK_CONTROL
, WXK_CONTROL
},
5882 { VK_MENU
, WXK_ALT
},
5883 { VK_PAUSE
, WXK_PAUSE
},
5884 { VK_CAPITAL
, WXK_CAPITAL
},
5885 { VK_SPACE
, WXK_SPACE
},
5886 { VK_ESCAPE
, WXK_ESCAPE
},
5887 { VK_SELECT
, WXK_SELECT
},
5888 { VK_PRINT
, WXK_PRINT
},
5889 { VK_EXECUTE
, WXK_EXECUTE
},
5890 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5891 { VK_HELP
, WXK_HELP
},
5893 { VK_NUMPAD0
, WXK_NUMPAD0
},
5894 { VK_NUMPAD1
, WXK_NUMPAD1
},
5895 { VK_NUMPAD2
, WXK_NUMPAD2
},
5896 { VK_NUMPAD3
, WXK_NUMPAD3
},
5897 { VK_NUMPAD4
, WXK_NUMPAD4
},
5898 { VK_NUMPAD5
, WXK_NUMPAD5
},
5899 { VK_NUMPAD6
, WXK_NUMPAD6
},
5900 { VK_NUMPAD7
, WXK_NUMPAD7
},
5901 { VK_NUMPAD8
, WXK_NUMPAD8
},
5902 { VK_NUMPAD9
, WXK_NUMPAD9
},
5903 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5904 { VK_ADD
, WXK_NUMPAD_ADD
},
5905 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5906 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5907 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5918 { VK_F10
, WXK_F10
},
5919 { VK_F11
, WXK_F11
},
5920 { VK_F12
, WXK_F12
},
5921 { VK_F13
, WXK_F13
},
5922 { VK_F14
, WXK_F14
},
5923 { VK_F15
, WXK_F15
},
5924 { VK_F16
, WXK_F16
},
5925 { VK_F17
, WXK_F17
},
5926 { VK_F18
, WXK_F18
},
5927 { VK_F19
, WXK_F19
},
5928 { VK_F20
, WXK_F20
},
5929 { VK_F21
, WXK_F21
},
5930 { VK_F22
, WXK_F22
},
5931 { VK_F23
, WXK_F23
},
5932 { VK_F24
, WXK_F24
},
5934 { VK_NUMLOCK
, WXK_NUMLOCK
},
5935 { VK_SCROLL
, WXK_SCROLL
},
5938 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5939 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5940 { VK_APPS
, WXK_WINDOWS_MENU
},
5941 #endif // VK_APPS defined
5944 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5945 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5946 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5948 // check the table first
5949 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5951 if ( gs_specialKeys
[n
].vk
== vk
)
5952 return gs_specialKeys
[n
].wxk
;
5955 // keys requiring special handling
5959 // the mapping for these keys may be incorrect on non-US keyboards so
5960 // maybe we shouldn't map them to ASCII values at all
5961 case VK_OEM_1
: wxk
= ';'; break;
5962 case VK_OEM_PLUS
: wxk
= '+'; break;
5963 case VK_OEM_COMMA
: wxk
= ','; break;
5964 case VK_OEM_MINUS
: wxk
= '-'; break;
5965 case VK_OEM_PERIOD
: wxk
= '.'; break;
5966 case VK_OEM_2
: wxk
= '/'; break;
5967 case VK_OEM_3
: wxk
= '~'; break;
5968 case VK_OEM_4
: wxk
= '['; break;
5969 case VK_OEM_5
: wxk
= '\\'; break;
5970 case VK_OEM_6
: wxk
= ']'; break;
5971 case VK_OEM_7
: wxk
= '\''; break;
5973 // handle extended keys
5975 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5979 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
5983 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
5987 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
5991 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
5995 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
5999 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6003 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6007 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6011 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6015 // don't use ChooseNormalOrExtended() here as the keys are reversed
6016 // here: numpad enter is the extended one
6017 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6027 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
6032 // check the table first
6033 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6035 if ( gs_specialKeys
[n
].wxk
== wxk
)
6036 return gs_specialKeys
[n
].vk
;
6039 // and then check for special keys not included in the table
6044 case WXK_NUMPAD_PAGEUP
:
6049 case WXK_NUMPAD_PAGEDOWN
:
6054 case WXK_NUMPAD_END
:
6059 case WXK_NUMPAD_HOME
:
6064 case WXK_NUMPAD_LEFT
:
6074 case WXK_NUMPAD_RIGHT
:
6079 case WXK_NUMPAD_DOWN
:
6084 case WXK_NUMPAD_INSERT
:
6089 case WXK_NUMPAD_DELETE
:
6103 #ifndef SM_SWAPBUTTON
6104 #define SM_SWAPBUTTON 23
6107 // small helper for wxGetKeyState() and wxGetMouseState()
6108 static inline bool wxIsKeyDown(WXWORD vk
)
6113 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_RBUTTON
;
6116 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_LBUTTON
;
6119 // the low order bit indicates whether the key was pressed since the last
6120 // call and the high order one indicates whether it is down right now and
6121 // we only want that one
6122 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6125 bool wxGetKeyState(wxKeyCode key
)
6127 // although this does work under Windows, it is not supported under other
6128 // platforms so don't allow it, you must use wxGetMouseState() instead
6129 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6130 key
!= VK_RBUTTON
&&
6132 wxT("can't use wxGetKeyState() for mouse buttons") );
6134 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6136 // if the requested key is a LED key, return true if the led is pressed
6137 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6139 // low order bit means LED is highlighted and high order one means the
6140 // key is down; for compatibility with the other ports return true if
6141 // either one is set
6142 return GetKeyState(vk
) != 0;
6147 return wxIsKeyDown(vk
);
6152 wxMouseState
wxGetMouseState()
6156 GetCursorPos( &pt
);
6160 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6161 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6162 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6163 #ifdef wxHAS_XBUTTON
6164 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6165 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6166 #endif // wxHAS_XBUTTON
6168 ms
.SetControlDown(wxIsCtrlDown ());
6169 ms
.SetShiftDown (wxIsShiftDown());
6170 ms
.SetAltDown (wxIsAltDown ());
6171 // ms.SetMetaDown();
6177 wxWindow
*wxGetActiveWindow()
6179 HWND hWnd
= GetActiveWindow();
6182 return wxFindWinFromHandle((WXHWND
) hWnd
);
6187 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6189 HWND hwnd
= (HWND
)hWnd
;
6191 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6192 // by code in msw/radiobox.cpp), for all the others we just search up the
6194 wxWindow
*win
= (wxWindow
*)NULL
;
6197 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6201 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6202 // wxWindow class which overrides WM_GETDLGCODE processing to
6203 // do it as well, win would be already non NULL
6204 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6206 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6208 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6209 #endif // wxUSE_RADIOBOX
6211 // spin control text buddy window should be mapped to spin ctrl
6212 // itself so try it too
6213 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6216 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6218 #endif // wxUSE_SPINCTRL
6222 while ( hwnd
&& !win
)
6224 // this is a really ugly hack needed to avoid mistakenly returning the
6225 // parent frame wxWindow for the find/replace modeless dialog HWND -
6226 // this, in turn, is needed to call IsDialogMessage() from
6227 // wxApp::ProcessMessage() as for this we must return NULL from here
6229 // FIXME: this is clearly not the best way to do it but I think we'll
6230 // need to change HWND <-> wxWindow code more heavily than I can
6231 // do it now to fix it
6232 #ifndef __WXMICROWIN__
6233 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6235 // it's a dialog box, don't go upwards
6240 hwnd
= ::GetParent(hwnd
);
6241 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6247 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6249 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6250 // in active frames and dialogs, regardless of where the focus is.
6251 static HHOOK wxTheKeyboardHook
= 0;
6252 static FARPROC wxTheKeyboardHookProc
= 0;
6253 int APIENTRY _EXPORT
6254 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
6256 void wxSetKeyboardHook(bool doIt
)
6260 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
6261 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
6263 GetCurrentThreadId()
6264 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
6269 UnhookWindowsHookEx(wxTheKeyboardHook
);
6273 int APIENTRY _EXPORT
6274 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6276 DWORD hiWord
= HIWORD(lParam
);
6277 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6279 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6282 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6283 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6284 event
.m_altDown
= true;
6286 event
.SetEventObject(NULL
);
6287 event
.m_keyCode
= id
;
6288 event
.m_shiftDown
= wxIsShiftDown();
6289 event
.m_controlDown
= wxIsCtrlDown();
6291 event
.SetTimestamp(::GetMessageTime());
6293 wxWindow
*win
= wxGetActiveWindow();
6294 wxEvtHandler
*handler
;
6297 handler
= win
->GetEventHandler();
6298 event
.SetId(win
->GetId());
6303 event
.SetId(wxID_ANY
);
6306 if ( handler
&& handler
->ProcessEvent(event
) )
6314 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6317 #endif // !__WXMICROWIN__
6320 const wxChar
*wxGetMessageName(int message
)
6324 case 0x0000: return wxT("WM_NULL");
6325 case 0x0001: return wxT("WM_CREATE");
6326 case 0x0002: return wxT("WM_DESTROY");
6327 case 0x0003: return wxT("WM_MOVE");
6328 case 0x0005: return wxT("WM_SIZE");
6329 case 0x0006: return wxT("WM_ACTIVATE");
6330 case 0x0007: return wxT("WM_SETFOCUS");
6331 case 0x0008: return wxT("WM_KILLFOCUS");
6332 case 0x000A: return wxT("WM_ENABLE");
6333 case 0x000B: return wxT("WM_SETREDRAW");
6334 case 0x000C: return wxT("WM_SETTEXT");
6335 case 0x000D: return wxT("WM_GETTEXT");
6336 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6337 case 0x000F: return wxT("WM_PAINT");
6338 case 0x0010: return wxT("WM_CLOSE");
6339 case 0x0011: return wxT("WM_QUERYENDSESSION");
6340 case 0x0012: return wxT("WM_QUIT");
6341 case 0x0013: return wxT("WM_QUERYOPEN");
6342 case 0x0014: return wxT("WM_ERASEBKGND");
6343 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6344 case 0x0016: return wxT("WM_ENDSESSION");
6345 case 0x0017: return wxT("WM_SYSTEMERROR");
6346 case 0x0018: return wxT("WM_SHOWWINDOW");
6347 case 0x0019: return wxT("WM_CTLCOLOR");
6348 case 0x001A: return wxT("WM_WININICHANGE");
6349 case 0x001B: return wxT("WM_DEVMODECHANGE");
6350 case 0x001C: return wxT("WM_ACTIVATEAPP");
6351 case 0x001D: return wxT("WM_FONTCHANGE");
6352 case 0x001E: return wxT("WM_TIMECHANGE");
6353 case 0x001F: return wxT("WM_CANCELMODE");
6354 case 0x0020: return wxT("WM_SETCURSOR");
6355 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6356 case 0x0022: return wxT("WM_CHILDACTIVATE");
6357 case 0x0023: return wxT("WM_QUEUESYNC");
6358 case 0x0024: return wxT("WM_GETMINMAXINFO");
6359 case 0x0026: return wxT("WM_PAINTICON");
6360 case 0x0027: return wxT("WM_ICONERASEBKGND");
6361 case 0x0028: return wxT("WM_NEXTDLGCTL");
6362 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6363 case 0x002B: return wxT("WM_DRAWITEM");
6364 case 0x002C: return wxT("WM_MEASUREITEM");
6365 case 0x002D: return wxT("WM_DELETEITEM");
6366 case 0x002E: return wxT("WM_VKEYTOITEM");
6367 case 0x002F: return wxT("WM_CHARTOITEM");
6368 case 0x0030: return wxT("WM_SETFONT");
6369 case 0x0031: return wxT("WM_GETFONT");
6370 case 0x0037: return wxT("WM_QUERYDRAGICON");
6371 case 0x0039: return wxT("WM_COMPAREITEM");
6372 case 0x0041: return wxT("WM_COMPACTING");
6373 case 0x0044: return wxT("WM_COMMNOTIFY");
6374 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6375 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6376 case 0x0048: return wxT("WM_POWER");
6378 case 0x004A: return wxT("WM_COPYDATA");
6379 case 0x004B: return wxT("WM_CANCELJOURNAL");
6380 case 0x004E: return wxT("WM_NOTIFY");
6381 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6382 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6383 case 0x0052: return wxT("WM_TCARD");
6384 case 0x0053: return wxT("WM_HELP");
6385 case 0x0054: return wxT("WM_USERCHANGED");
6386 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6387 case 0x007B: return wxT("WM_CONTEXTMENU");
6388 case 0x007C: return wxT("WM_STYLECHANGING");
6389 case 0x007D: return wxT("WM_STYLECHANGED");
6390 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6391 case 0x007F: return wxT("WM_GETICON");
6392 case 0x0080: return wxT("WM_SETICON");
6394 case 0x0081: return wxT("WM_NCCREATE");
6395 case 0x0082: return wxT("WM_NCDESTROY");
6396 case 0x0083: return wxT("WM_NCCALCSIZE");
6397 case 0x0084: return wxT("WM_NCHITTEST");
6398 case 0x0085: return wxT("WM_NCPAINT");
6399 case 0x0086: return wxT("WM_NCACTIVATE");
6400 case 0x0087: return wxT("WM_GETDLGCODE");
6401 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6402 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6403 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6404 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6405 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6406 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6407 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6408 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6409 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6410 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6412 case 0x00B0: return wxT("EM_GETSEL");
6413 case 0x00B1: return wxT("EM_SETSEL");
6414 case 0x00B2: return wxT("EM_GETRECT");
6415 case 0x00B3: return wxT("EM_SETRECT");
6416 case 0x00B4: return wxT("EM_SETRECTNP");
6417 case 0x00B5: return wxT("EM_SCROLL");
6418 case 0x00B6: return wxT("EM_LINESCROLL");
6419 case 0x00B7: return wxT("EM_SCROLLCARET");
6420 case 0x00B8: return wxT("EM_GETMODIFY");
6421 case 0x00B9: return wxT("EM_SETMODIFY");
6422 case 0x00BA: return wxT("EM_GETLINECOUNT");
6423 case 0x00BB: return wxT("EM_LINEINDEX");
6424 case 0x00BC: return wxT("EM_SETHANDLE");
6425 case 0x00BD: return wxT("EM_GETHANDLE");
6426 case 0x00BE: return wxT("EM_GETTHUMB");
6427 case 0x00C1: return wxT("EM_LINELENGTH");
6428 case 0x00C2: return wxT("EM_REPLACESEL");
6429 case 0x00C4: return wxT("EM_GETLINE");
6430 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6431 case 0x00C6: return wxT("EM_CANUNDO");
6432 case 0x00C7: return wxT("EM_UNDO");
6433 case 0x00C8: return wxT("EM_FMTLINES");
6434 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6435 case 0x00CB: return wxT("EM_SETTABSTOPS");
6436 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6437 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6438 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6439 case 0x00CF: return wxT("EM_SETREADONLY");
6440 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6441 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6442 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6443 case 0x00D3: return wxT("EM_SETMARGINS");
6444 case 0x00D4: return wxT("EM_GETMARGINS");
6445 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6446 case 0x00D6: return wxT("EM_POSFROMCHAR");
6447 case 0x00D7: return wxT("EM_CHARFROMPOS");
6448 case 0x00D8: return wxT("EM_SETIMESTATUS");
6449 case 0x00D9: return wxT("EM_GETIMESTATUS");
6451 case 0x0100: return wxT("WM_KEYDOWN");
6452 case 0x0101: return wxT("WM_KEYUP");
6453 case 0x0102: return wxT("WM_CHAR");
6454 case 0x0103: return wxT("WM_DEADCHAR");
6455 case 0x0104: return wxT("WM_SYSKEYDOWN");
6456 case 0x0105: return wxT("WM_SYSKEYUP");
6457 case 0x0106: return wxT("WM_SYSCHAR");
6458 case 0x0107: return wxT("WM_SYSDEADCHAR");
6459 case 0x0108: return wxT("WM_KEYLAST");
6461 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6462 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6463 case 0x010F: return wxT("WM_IME_COMPOSITION");
6465 case 0x0110: return wxT("WM_INITDIALOG");
6466 case 0x0111: return wxT("WM_COMMAND");
6467 case 0x0112: return wxT("WM_SYSCOMMAND");
6468 case 0x0113: return wxT("WM_TIMER");
6469 case 0x0114: return wxT("WM_HSCROLL");
6470 case 0x0115: return wxT("WM_VSCROLL");
6471 case 0x0116: return wxT("WM_INITMENU");
6472 case 0x0117: return wxT("WM_INITMENUPOPUP");
6473 case 0x011F: return wxT("WM_MENUSELECT");
6474 case 0x0120: return wxT("WM_MENUCHAR");
6475 case 0x0121: return wxT("WM_ENTERIDLE");
6477 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6478 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6479 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6480 case 0x0135: return wxT("WM_CTLCOLORBTN");
6481 case 0x0136: return wxT("WM_CTLCOLORDLG");
6482 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6483 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6484 case 0x01E1: return wxT("MN_GETHMENU");
6486 case 0x0200: return wxT("WM_MOUSEMOVE");
6487 case 0x0201: return wxT("WM_LBUTTONDOWN");
6488 case 0x0202: return wxT("WM_LBUTTONUP");
6489 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6490 case 0x0204: return wxT("WM_RBUTTONDOWN");
6491 case 0x0205: return wxT("WM_RBUTTONUP");
6492 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6493 case 0x0207: return wxT("WM_MBUTTONDOWN");
6494 case 0x0208: return wxT("WM_MBUTTONUP");
6495 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6496 case 0x020A: return wxT("WM_MOUSEWHEEL");
6497 case 0x020B: return wxT("WM_XBUTTONDOWN");
6498 case 0x020C: return wxT("WM_XBUTTONUP");
6499 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6500 case 0x0210: return wxT("WM_PARENTNOTIFY");
6501 case 0x0211: return wxT("WM_ENTERMENULOOP");
6502 case 0x0212: return wxT("WM_EXITMENULOOP");
6504 case 0x0213: return wxT("WM_NEXTMENU");
6505 case 0x0214: return wxT("WM_SIZING");
6506 case 0x0215: return wxT("WM_CAPTURECHANGED");
6507 case 0x0216: return wxT("WM_MOVING");
6508 case 0x0218: return wxT("WM_POWERBROADCAST");
6509 case 0x0219: return wxT("WM_DEVICECHANGE");
6511 case 0x0220: return wxT("WM_MDICREATE");
6512 case 0x0221: return wxT("WM_MDIDESTROY");
6513 case 0x0222: return wxT("WM_MDIACTIVATE");
6514 case 0x0223: return wxT("WM_MDIRESTORE");
6515 case 0x0224: return wxT("WM_MDINEXT");
6516 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6517 case 0x0226: return wxT("WM_MDITILE");
6518 case 0x0227: return wxT("WM_MDICASCADE");
6519 case 0x0228: return wxT("WM_MDIICONARRANGE");
6520 case 0x0229: return wxT("WM_MDIGETACTIVE");
6521 case 0x0230: return wxT("WM_MDISETMENU");
6522 case 0x0233: return wxT("WM_DROPFILES");
6524 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6525 case 0x0282: return wxT("WM_IME_NOTIFY");
6526 case 0x0283: return wxT("WM_IME_CONTROL");
6527 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6528 case 0x0285: return wxT("WM_IME_SELECT");
6529 case 0x0286: return wxT("WM_IME_CHAR");
6530 case 0x0290: return wxT("WM_IME_KEYDOWN");
6531 case 0x0291: return wxT("WM_IME_KEYUP");
6533 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6534 case 0x02A1: return wxT("WM_MOUSEHOVER");
6535 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6536 case 0x02A3: return wxT("WM_MOUSELEAVE");
6538 case 0x0300: return wxT("WM_CUT");
6539 case 0x0301: return wxT("WM_COPY");
6540 case 0x0302: return wxT("WM_PASTE");
6541 case 0x0303: return wxT("WM_CLEAR");
6542 case 0x0304: return wxT("WM_UNDO");
6543 case 0x0305: return wxT("WM_RENDERFORMAT");
6544 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6545 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6546 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6547 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6548 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6549 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6550 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6551 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6552 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6553 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6554 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6555 case 0x0311: return wxT("WM_PALETTECHANGED");
6556 case 0x0312: return wxT("WM_HOTKEY");
6558 case 0x0317: return wxT("WM_PRINT");
6559 case 0x0318: return wxT("WM_PRINTCLIENT");
6561 // common controls messages - although they're not strictly speaking
6562 // standard, it's nice to decode them nevertheless
6565 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6566 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6567 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6568 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6569 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6570 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6571 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6572 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6573 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6574 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6575 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6576 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6577 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6578 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6579 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6580 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6581 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6582 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6583 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6584 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6585 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6586 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6587 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6588 case 0x1000 + 18: return wxT("LVM_HITTEST");
6589 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6590 case 0x1000 + 20: return wxT("LVM_SCROLL");
6591 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6592 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6593 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6594 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6595 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6596 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6597 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6598 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6599 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6600 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6601 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6602 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6603 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6604 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6605 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6606 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6607 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6608 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6609 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6610 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6611 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6612 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6613 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6614 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6615 case 0x1000 + 42: return wxT("LVM_UPDATE");
6616 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6617 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6618 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6619 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6620 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6621 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6622 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6623 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6624 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6625 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6626 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6627 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6628 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6629 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6630 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6631 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6632 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6633 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6634 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6635 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6636 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6637 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6638 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6639 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6640 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6641 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6644 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6645 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6646 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6647 case 0x1100 + 2: return wxT("TVM_EXPAND");
6648 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6649 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6650 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6651 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6652 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6653 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6654 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6655 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6656 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6657 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6658 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6659 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6660 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6661 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6662 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6663 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6664 case 0x1100 + 17: return wxT("TVM_HITTEST");
6665 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6666 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6667 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6668 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6669 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6670 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6671 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6672 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6673 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6676 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6677 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6678 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6679 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6680 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6681 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6682 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6683 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6684 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6685 case 0x1200 + 6: return wxT("HDM_HITTEST");
6686 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6687 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6688 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6689 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6690 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6691 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6692 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6693 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6696 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6697 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6698 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6699 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6700 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6701 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6702 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6703 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6704 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6705 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6706 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6707 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6708 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6709 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6710 case 0x1300 + 13: return wxT("TCM_HITTEST");
6711 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6712 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6713 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6714 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6715 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6716 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6717 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6718 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6719 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6720 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6721 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6722 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6725 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6726 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6727 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6728 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6729 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6730 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6731 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6732 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6733 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6734 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6735 case WM_USER
+17: return wxT("TB_SETSTATE");
6736 case WM_USER
+18: return wxT("TB_GETSTATE");
6737 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6738 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6739 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6740 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6741 case WM_USER
+23: return wxT("TB_GETBUTTON");
6742 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6743 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6744 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6745 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6746 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6747 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6748 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6749 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6750 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6751 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6752 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6753 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6754 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6755 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6756 case WM_USER
+37: return wxT("TB_SETPARENT");
6757 case WM_USER
+39: return wxT("TB_SETROWS");
6758 case WM_USER
+40: return wxT("TB_GETROWS");
6759 case WM_USER
+42: return wxT("TB_SETCMDID");
6760 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6761 case WM_USER
+44: return wxT("TB_GETBITMAP");
6762 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6763 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6764 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6765 case WM_USER
+47: return wxT("TB_SETINDENT");
6766 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6767 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6768 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6769 case WM_USER
+51: return wxT("TB_GETRECT");
6770 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6771 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6772 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6773 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6774 case WM_USER
+56: return wxT("TB_SETSTYLE");
6775 case WM_USER
+57: return wxT("TB_GETSTYLE");
6776 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6777 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6778 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6779 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6780 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6783 static wxString s_szBuf
;
6784 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6785 return s_szBuf
.c_str();
6788 #endif //__WXDEBUG__
6790 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6794 HWND hwnd
= GetHwndOf(win
);
6795 HDC hdc
= ::GetDC(hwnd
);
6797 #if !wxDIALOG_UNIT_COMPATIBILITY
6798 // and select the current font into it
6799 HFONT hfont
= GetHfontOf(win
->GetFont());
6802 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6806 // finally retrieve the text metrics from it
6807 GetTextMetrics(hdc
, &tm
);
6809 #if !wxDIALOG_UNIT_COMPATIBILITY
6813 (void)::SelectObject(hdc
, hfont
);
6817 ::ReleaseDC(hwnd
, hdc
);
6822 // Find the wxWindow at the current mouse position, returning the mouse
6824 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6826 pt
= wxGetMousePosition();
6827 return wxFindWindowAtPoint(pt
);
6830 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6836 HWND hWnd
= ::WindowFromPoint(pt2
);
6838 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6841 // Get the current mouse position.
6842 wxPoint
wxGetMousePosition()
6846 GetCursorPosWinCE(&pt
);
6848 GetCursorPos( & pt
);
6851 return wxPoint(pt
.x
, pt
.y
);
6856 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6857 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6859 // Register hotkeys for the hardware buttons
6861 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6863 UnregisterFunc1Proc procUnregisterFunc
;
6864 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6867 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6868 if (procUnregisterFunc
)
6869 procUnregisterFunc(modifiers
, id
);
6870 FreeLibrary(hCoreDll
);
6875 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6877 UINT win_modifiers
=0;
6878 if ( modifiers
& wxMOD_ALT
)
6879 win_modifiers
|= MOD_ALT
;
6880 if ( modifiers
& wxMOD_SHIFT
)
6881 win_modifiers
|= MOD_SHIFT
;
6882 if ( modifiers
& wxMOD_CONTROL
)
6883 win_modifiers
|= MOD_CONTROL
;
6884 if ( modifiers
& wxMOD_WIN
)
6885 win_modifiers
|= MOD_WIN
;
6887 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6888 // Required for PPC and Smartphone hardware buttons
6889 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6890 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6893 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6895 wxLogLastError(_T("RegisterHotKey"));
6903 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6905 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6906 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6909 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6911 wxLogLastError(_T("UnregisterHotKey"));
6921 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6923 int hotkeyId
= wParam
;
6924 int virtualKey
= HIWORD(lParam
);
6925 int win_modifiers
= LOWORD(lParam
);
6927 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6928 event
.SetId(hotkeyId
);
6929 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6930 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6931 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6932 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6934 return GetEventHandler()->ProcessEvent(event
);
6937 #endif // wxUSE_ACCEL
6939 #endif // wxUSE_HOTKEY
6941 // Not tested under WinCE
6944 // this class installs a message hook which really wakes up our idle processing
6945 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6946 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6947 // being dragged or even inside ::MessageBox()) and so don't control message
6948 // dispatching otherwise
6949 class wxIdleWakeUpModule
: public wxModule
6952 virtual bool OnInit()
6954 ms_hMsgHookProc
= ::SetWindowsHookEx
6957 &wxIdleWakeUpModule::MsgHookProc
,
6959 GetCurrentThreadId()
6962 if ( !ms_hMsgHookProc
)
6964 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6972 virtual void OnExit()
6974 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
6977 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6979 MSG
*msg
= (MSG
*)lParam
;
6981 // only process the message if it is actually going to be removed from
6982 // the message queue, this prevents that the same event from being
6983 // processed multiple times if now someone just called PeekMessage()
6984 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
6986 wxTheApp
->ProcessPendingEvents();
6989 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
6993 static HHOOK ms_hMsgHookProc
;
6995 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
6998 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7000 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7002 #endif // __WXWINCE__
7007 static void wxAdjustZOrder(wxWindow
* parent
)
7009 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7011 // Set the z-order correctly
7012 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7015 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7018 wxWindow
*childWin
= current
->GetData();
7019 wxAdjustZOrder(childWin
);
7020 current
= current
->GetNext();
7025 // We need to adjust the z-order of static boxes in WinCE, to
7026 // make 'contained' controls visible
7027 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7030 wxAdjustZOrder(this);