1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/window.cpp
3 // Purpose: wxWindowMSW
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/window.h"
30 #include "wx/msw/wrapwin.h"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
56 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
60 #include "wx/hashmap.h"
61 #include "wx/evtloop.h"
63 #include "wx/sysopt.h"
65 #if wxUSE_DRAG_AND_DROP
69 #if wxUSE_ACCESSIBILITY
70 #include "wx/access.h"
74 #define WM_GETOBJECT 0x003D
77 #define OBJID_CLIENT 0xFFFFFFFC
81 #include "wx/msw/private.h"
82 #include "wx/msw/dcclient.h"
85 #include "wx/tooltip.h"
93 #include "wx/spinctrl.h"
94 #endif // wxUSE_SPINCTRL
96 #include "wx/notebook.h"
97 #include "wx/listctrl.h"
98 #include "wx/dynlib.h"
102 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
103 #include <shellapi.h>
104 #include <mmsystem.h>
108 #include <windowsx.h>
111 #if !defined __WXWINCE__ && !defined NEED_PBT_H
115 #if defined(__WXWINCE__)
116 #include "wx/msw/wince/missing.h"
119 #include <shellapi.h>
121 #include <aygshell.h>
126 #include "wx/msw/uxtheme.h"
127 #define EP_EDITTEXT 1
130 #define ETS_SELECTED 3
131 #define ETS_DISABLED 4
132 #define ETS_FOCUSED 5
133 #define ETS_READONLY 6
137 // define the constants used by AnimateWindow() if our SDK doesn't have them
139 #define AW_HOR_POSITIVE 0x00000001
140 #define AW_HOR_NEGATIVE 0x00000002
141 #define AW_VER_POSITIVE 0x00000004
142 #define AW_VER_NEGATIVE 0x00000008
143 #define AW_CENTER 0x00000010
144 #define AW_HIDE 0x00010000
145 #define AW_ACTIVATE 0x00020000
146 #define AW_SLIDE 0x00040000
147 #define AW_BLEND 0x00080000
150 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
151 #define HAVE_TRACKMOUSEEVENT
152 #endif // everything needed for TrackMouseEvent()
154 // if this is set to 1, we use deferred window sizing to reduce flicker when
155 // resizing complicated window hierarchies, but this can in theory result in
156 // different behaviour than the old code so we keep the possibility to use it
157 // by setting this to 0 (in the future this should be removed completely)
159 #define USE_DEFERRED_SIZING 0
161 #define USE_DEFERRED_SIZING 1
164 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
165 // when mouse position didnd't change
167 #define wxUSE_MOUSEEVENT_HACK 0
169 #define wxUSE_MOUSEEVENT_HACK 1
172 // not all compilers/platforms have X button related declarations (notably
173 // Windows CE doesn't, and probably some old SDKs don't neither)
174 #ifdef WM_XBUTTONDOWN
175 #define wxHAS_XBUTTON
178 // ---------------------------------------------------------------------------
180 // ---------------------------------------------------------------------------
183 extern wxChar
*wxCanvasClassName
;
185 extern const wxChar
*wxCanvasClassName
;
188 // true if we had already created the std colour map, used by
189 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
190 static bool gs_hasStdCmap
= false;
192 // last mouse event information we need to filter out the duplicates
193 #if wxUSE_MOUSEEVENT_HACK
194 static struct MouseEventInfoDummy
196 // mouse position (in screen coordinates)
199 // last mouse event type
202 #endif // wxUSE_MOUSEEVENT_HACK
204 // hash containing the registered handlers for the custom messages
205 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
206 wxIntegerHash
, wxIntegerEqual
,
209 static MSWMessageHandlers gs_messageHandlers
;
211 // ---------------------------------------------------------------------------
213 // ---------------------------------------------------------------------------
215 // the window proc for all our windows
216 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
217 WPARAM wParam
, LPARAM lParam
);
221 const wxChar
*wxGetMessageName(int message
);
224 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
225 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
226 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
228 // get the text metrics for the current font
229 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
232 // find the window for the mouse event at the specified position
233 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
234 #endif // __WXWINCE__
236 // wrapper around BringWindowToTop() API
237 static inline void wxBringWindowToTop(HWND hwnd
)
239 #ifdef __WXMICROWIN__
240 // It seems that MicroWindows brings the _parent_ of the window to the top,
241 // which can be the wrong one.
243 // activate (set focus to) specified window
247 // raise top level parent to top of z order
248 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
250 wxLogLastError(_T("SetWindowPos"));
256 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
257 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
260 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
261 parent as well as otherwise several Win32 functions using
262 GetNextDlgTabItem() to iterate over all controls such as
263 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
264 all of them iterate over all the controls starting from the currently
265 focused one and stop iterating when they get back to the focus but
266 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
267 get back to the initial (focused) window: as we do have this style,
268 GetNextDlgTabItem() will leave this window and continue in its parent,
269 but if the parent doesn't have it, it wouldn't recurse inside it later
270 on and so wouldn't have a chance of getting back to this window either.
272 while ( parent
&& !parent
->IsTopLevel() )
274 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
275 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
277 // force the parent to have this style
278 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
279 exStyle
| WS_EX_CONTROLPARENT
);
282 parent
= parent
->GetParent();
286 #endif // !__WXWINCE__
289 // On Windows CE, GetCursorPos can return an error, so use this function
291 bool GetCursorPosWinCE(POINT
* pt
)
293 if (!GetCursorPos(pt
))
295 DWORD pos
= GetMessagePos();
303 // ---------------------------------------------------------------------------
305 // ---------------------------------------------------------------------------
307 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
309 #ifdef __WXUNIVERSAL__
310 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
312 #if wxUSE_EXTENDED_RTTI
314 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
315 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
316 // windows with negative ids never can be recreated anyway
318 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
320 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
321 if ( win
&& win
->GetId() < 0 )
326 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
328 // make wxWindowList known before the property is used
330 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
332 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
334 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
337 WX_DEFINE_FLAGS( wxWindowStyle
)
339 wxBEGIN_FLAGS( wxWindowStyle
)
340 // new style border flags, we put them first to
341 // use them for streaming out
343 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
344 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
345 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
346 wxFLAGS_MEMBER(wxBORDER_RAISED
)
347 wxFLAGS_MEMBER(wxBORDER_STATIC
)
348 wxFLAGS_MEMBER(wxBORDER_NONE
)
350 // old style border flags
351 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
352 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
353 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
354 wxFLAGS_MEMBER(wxRAISED_BORDER
)
355 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
356 wxFLAGS_MEMBER(wxBORDER
)
358 // standard window styles
359 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
360 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
361 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
362 wxFLAGS_MEMBER(wxWANTS_CHARS
)
363 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
364 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
365 wxFLAGS_MEMBER(wxVSCROLL
)
366 wxFLAGS_MEMBER(wxHSCROLL
)
368 wxEND_FLAGS( wxWindowStyle
)
370 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
371 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
372 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
373 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
374 // Always constructor Properties first
376 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
377 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
378 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
379 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
380 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
382 // Then all relations of the object graph
384 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
386 // and finally all other properties
388 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
389 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
390 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
391 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
392 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
394 // possible property candidates (not in xrc) or not valid in all subclasses
395 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
396 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
397 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
398 // MaxHeight, Width , MinHeight , Width
399 // TODO switch label to control and title to toplevels
401 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
402 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
403 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
404 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
409 wxEND_PROPERTIES_TABLE()
411 wxBEGIN_HANDLERS_TABLE(wxWindow
)
412 wxEND_HANDLERS_TABLE()
414 wxCONSTRUCTOR_DUMMY(wxWindow
)
417 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
419 #endif // __WXUNIVERSAL__/__WXMSW__
421 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
422 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
423 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
425 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
429 // ===========================================================================
431 // ===========================================================================
433 // ---------------------------------------------------------------------------
434 // wxWindow utility functions
435 // ---------------------------------------------------------------------------
437 // Find an item given the MS Windows id
438 wxWindow
*wxWindowMSW::FindItem(long id
) const
441 wxControl
*item
= wxDynamicCastThis(wxControl
);
444 // is it us or one of our "internal" children?
445 if ( item
->GetId() == id
446 #ifndef __WXUNIVERSAL__
447 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
448 #endif // __WXUNIVERSAL__
454 #endif // wxUSE_CONTROLS
456 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
459 wxWindow
*childWin
= current
->GetData();
461 wxWindow
*wnd
= childWin
->FindItem(id
);
465 current
= current
->GetNext();
471 // Find an item given the MS Windows handle
472 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
474 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
477 wxWindow
*parent
= current
->GetData();
479 // Do a recursive search.
480 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
486 || parent
->IsKindOf(CLASSINFO(wxControl
))
487 #endif // wxUSE_CONTROLS
490 wxWindow
*item
= current
->GetData();
491 if ( item
->GetHWND() == hWnd
)
495 if ( item
->ContainsHWND(hWnd
) )
500 current
= current
->GetNext();
505 // Default command handler
506 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
511 // ----------------------------------------------------------------------------
512 // constructors and such
513 // ----------------------------------------------------------------------------
515 void wxWindowMSW::Init()
518 m_isBeingDeleted
= false;
520 m_mouseInWindow
= false;
521 m_lastKeydownProcessed
= false;
531 m_pendingPosition
= wxDefaultPosition
;
532 m_pendingSize
= wxDefaultSize
;
535 m_contextMenuEnabled
= false;
540 wxWindowMSW::~wxWindowMSW()
542 m_isBeingDeleted
= true;
544 #ifndef __WXUNIVERSAL__
545 // VS: make sure there's no wxFrame with last focus set to us:
546 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
548 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
551 if ( frame
->GetLastFocus() == this )
553 frame
->SetLastFocus(NULL
);
556 // apparently sometimes we can end up with our grand parent
557 // pointing to us as well: this is surely a bug in focus handling
558 // code but it's not clear where it happens so for now just try to
559 // fix it here by not breaking out of the loop
563 #endif // __WXUNIVERSAL__
565 // VS: destroy children first and _then_ detach *this from its parent.
566 // If we did it the other way around, children wouldn't be able
567 // find their parent frame (see above).
572 // VZ: test temp removed to understand what really happens here
573 //if (::IsWindow(GetHwnd()))
575 if ( !::DestroyWindow(GetHwnd()) )
576 wxLogLastError(wxT("DestroyWindow"));
579 // remove hWnd <-> wxWindow association
580 wxRemoveHandleAssociation(this);
585 // real construction (Init() must have been called before!)
586 bool wxWindowMSW::Create(wxWindow
*parent
,
591 const wxString
& name
)
593 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
595 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
598 parent
->AddChild(this);
601 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
603 #ifdef __WXUNIVERSAL__
604 // no borders, we draw them ourselves
605 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
609 msflags
&= ~WS_BORDER
;
610 #endif // wxUniversal
614 msflags
|= WS_VISIBLE
;
617 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
625 // ---------------------------------------------------------------------------
627 // ---------------------------------------------------------------------------
629 void wxWindowMSW::SetFocus()
631 HWND hWnd
= GetHwnd();
632 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
634 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
638 if ( !::SetFocus(hWnd
) )
640 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
641 // was there really an error?
642 DWORD dwRes
= ::GetLastError();
645 HWND hwndFocus
= ::GetFocus();
646 if ( hwndFocus
!= hWnd
)
648 wxLogApiError(_T("SetFocus"), dwRes
);
655 void wxWindowMSW::SetFocusFromKbd()
657 // when the focus is given to the control with DLGC_HASSETSEL style from
658 // keyboard its contents should be entirely selected: this is what
659 // ::IsDialogMessage() does and so we should do it as well to provide the
660 // same LNF as the native programs
661 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
663 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
666 // do this after (maybe) setting the selection as like this when
667 // wxEVT_SET_FOCUS handler is called, the selection would have been already
668 // set correctly -- this may be important
669 wxWindowBase::SetFocusFromKbd();
672 // Get the window with the focus
673 wxWindow
*wxWindowBase::DoFindFocus()
675 HWND hWnd
= ::GetFocus();
678 return wxGetWindowFromHWND((WXHWND
)hWnd
);
684 void wxWindowMSW::DoEnable( bool enable
)
686 HWND hWnd
= GetHwnd();
688 ::EnableWindow(hWnd
, (BOOL
)enable
);
691 bool wxWindowMSW::Show(bool show
)
693 if ( !wxWindowBase::Show(show
) )
696 HWND hWnd
= GetHwnd();
698 // we could be called before the underlying window is created (this is
699 // actually useful to prevent it from being initially shown), e.g.
701 // wxFoo *foo = new wxFoo;
703 // foo->Create(parent, ...);
705 // should work without errors
708 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
715 wxWindowMSW::MSWShowWithEffect(bool show
,
720 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
722 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
723 static bool s_initDone
= false;
728 wxDynamicLibrary
dllUser32(_T("user32.dll"), wxDL_VERBATIM
);
729 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
733 // notice that it's ok to unload user32.dll here as it won't be really
734 // unloaded, being still in use because we link to it statically too
737 if ( !s_pfnAnimateWindow
)
740 // prepare to use AnimateWindow()
743 timeout
= 200; // this is the default animation timeout, per MSDN
745 DWORD dwFlags
= show
? 0 : AW_HIDE
;
746 bool needsDir
= false;
749 case wxSHOW_EFFECT_ROLL
:
753 case wxSHOW_EFFECT_SLIDE
:
758 case wxSHOW_EFFECT_BLEND
:
762 case wxSHOW_EFFECT_EXPAND
:
763 dwFlags
|= AW_CENTER
;
767 case wxSHOW_EFFECT_MAX
:
768 wxFAIL_MSG( _T("invalid window show effect") );
772 wxFAIL_MSG( _T("unknown window show effect") );
781 dwFlags
|= AW_VER_NEGATIVE
;
785 dwFlags
|= AW_VER_POSITIVE
;
789 dwFlags
|= AW_HOR_NEGATIVE
;
793 dwFlags
|= AW_HOR_POSITIVE
;
797 wxFAIL_MSG( _T("unknown window effect direction") );
801 else // animation effect which doesn't need the direction
803 wxASSERT_MSG( dir
== wxBOTTOM
,
804 _T("non-default direction used unnecessarily") );
808 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
810 wxLogLastError(_T("AnimateWindow"));
818 // Raise the window to the top of the Z order
819 void wxWindowMSW::Raise()
821 wxBringWindowToTop(GetHwnd());
824 // Lower the window to the bottom of the Z order
825 void wxWindowMSW::Lower()
827 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
828 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
831 void wxWindowMSW::DoCaptureMouse()
833 HWND hWnd
= GetHwnd();
840 void wxWindowMSW::DoReleaseMouse()
842 if ( !::ReleaseCapture() )
844 wxLogLastError(_T("ReleaseCapture"));
848 /* static */ wxWindow
*wxWindowBase::GetCapture()
850 HWND hwnd
= ::GetCapture();
851 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
854 bool wxWindowMSW::SetFont(const wxFont
& font
)
856 if ( !wxWindowBase::SetFont(font
) )
862 HWND hWnd
= GetHwnd();
865 WXHANDLE hFont
= m_font
.GetResourceHandle();
867 wxASSERT_MSG( hFont
, wxT("should have valid font") );
869 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
874 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
876 if ( !wxWindowBase::SetCursor(cursor
) )
882 // don't "overwrite" busy cursor
883 if ( m_cursor
.Ok() && !wxIsBusy() )
885 // normally we should change the cursor only if it's over this window
886 // but we should do it always if we capture the mouse currently
887 bool set
= HasCapture();
890 HWND hWnd
= GetHwnd();
894 ::GetCursorPosWinCE(&point
);
896 ::GetCursorPos(&point
);
899 RECT rect
= wxGetWindowRect(hWnd
);
901 set
= ::PtInRect(&rect
, point
) != 0;
906 ::SetCursor(GetHcursorOf(m_cursor
));
908 //else: will be set later when the mouse enters this window
914 void wxWindowMSW::WarpPointer(int x
, int y
)
916 ClientToScreen(&x
, &y
);
918 if ( !::SetCursorPos(x
, y
) )
920 wxLogLastError(_T("SetCursorPos"));
924 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
926 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
927 // to use it on older systems -- and could possibly do some harm
928 static int s_needToUpdate
= -1;
929 if ( s_needToUpdate
== -1 )
932 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
936 if ( s_needToUpdate
)
938 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
939 // won't send WM_UPDATEUISTATE
940 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
944 // ---------------------------------------------------------------------------
946 // ---------------------------------------------------------------------------
948 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
950 #ifdef __WXMICROWIN__
951 return ::GetScrollPosWX(hWnd
, wOrient
);
953 WinStruct
<SCROLLINFO
> scrollInfo
;
954 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
955 scrollInfo
.fMask
= SIF_POS
;
956 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
958 return scrollInfo
.nPos
;
963 int wxWindowMSW::GetScrollPos(int orient
) const
965 HWND hWnd
= GetHwnd();
966 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
968 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
971 // This now returns the whole range, not just the number
972 // of positions that we can scroll.
973 int wxWindowMSW::GetScrollRange(int orient
) const
976 HWND hWnd
= GetHwnd();
980 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
983 WinStruct
<SCROLLINFO
> scrollInfo
;
984 scrollInfo
.fMask
= SIF_RANGE
;
985 if ( !::GetScrollInfo(hWnd
,
986 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
989 // Most of the time this is not really an error, since the return
990 // value can also be zero when there is no scrollbar yet.
991 // wxLogLastError(_T("GetScrollInfo"));
993 maxPos
= scrollInfo
.nMax
;
995 // undo "range - 1" done in SetScrollbar()
999 int wxWindowMSW::GetScrollThumb(int orient
) const
1001 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
1004 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
1006 HWND hWnd
= GetHwnd();
1007 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
1009 WinStruct
<SCROLLINFO
> info
;
1013 info
.fMask
= SIF_POS
;
1014 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1016 // disable scrollbar instead of removing it then
1017 info
.fMask
|= SIF_DISABLENOSCROLL
;
1020 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1024 // New function that will replace some of the above.
1025 void wxWindowMSW::SetScrollbar(int orient
,
1031 WinStruct
<SCROLLINFO
> info
;
1032 info
.nPage
= pageSize
;
1033 info
.nMin
= 0; // range is nMax - nMin + 1
1034 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1036 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1037 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1039 // disable scrollbar instead of removing it then
1040 info
.fMask
|= SIF_DISABLENOSCROLL
;
1043 HWND hWnd
= GetHwnd();
1046 // We have to set the variables here to make them valid in events
1047 // triggered by ::SetScrollInfo()
1048 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1050 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1055 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1061 wxCopyRectToRECT(*prect
, rect
);
1071 // FIXME: is this the exact equivalent of the line below?
1072 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1074 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1078 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1080 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1083 for ( int n
= 0; n
< count
; n
++ )
1085 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1087 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1088 if ( posNew
== pos
)
1090 // don't bother to continue, we're already at top/bottom
1097 return pos
!= posStart
;
1100 bool wxWindowMSW::ScrollLines(int lines
)
1102 bool down
= lines
> 0;
1104 return ScrollVertically(GetHwnd(),
1105 down
? SB_LINEDOWN
: SB_LINEUP
,
1106 down
? lines
: -lines
);
1109 bool wxWindowMSW::ScrollPages(int pages
)
1111 bool down
= pages
> 0;
1113 return ScrollVertically(GetHwnd(),
1114 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1115 down
? pages
: -pages
);
1118 // ----------------------------------------------------------------------------
1120 // ----------------------------------------------------------------------------
1122 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1127 const HWND hwnd
= GetHwnd();
1128 wxCHECK_RET( hwnd
, _T("layout direction must be set after window creation") );
1130 LONG styleOld
= ::GetWindowLong(hwnd
, GWL_EXSTYLE
);
1132 LONG styleNew
= styleOld
;
1135 case wxLayout_LeftToRight
:
1136 styleNew
&= ~WS_EX_LAYOUTRTL
;
1139 case wxLayout_RightToLeft
:
1140 styleNew
|= WS_EX_LAYOUTRTL
;
1144 wxFAIL_MSG(_T("unsupported layout direction"));
1148 if ( styleNew
!= styleOld
)
1150 ::SetWindowLong(hwnd
, GWL_EXSTYLE
, styleNew
);
1155 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1158 return wxLayout_Default
;
1160 const HWND hwnd
= GetHwnd();
1161 wxCHECK_MSG( hwnd
, wxLayout_Default
, _T("invalid window") );
1163 return ::GetWindowLong(hwnd
, GWL_EXSTYLE
) & WS_EX_LAYOUTRTL
1164 ? wxLayout_RightToLeft
1165 : wxLayout_LeftToRight
;
1170 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1171 wxCoord
WXUNUSED(width
),
1172 wxCoord
WXUNUSED(widthTotal
)) const
1174 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1175 // redo it ourselves
1179 // ---------------------------------------------------------------------------
1181 // ---------------------------------------------------------------------------
1183 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1185 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1187 HWND hwnd
= (HWND
)hWnd
;
1188 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1190 wxAssociateWinWithHandle(hwnd
, this);
1192 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1194 // we don't need to subclass the window of our own class (in the Windows
1195 // sense of the word)
1196 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1198 wxSetWindowProc(hwnd
, wxWndProc
);
1202 // don't bother restoring it either: this also makes it easy to
1203 // implement IsOfStandardClass() method which returns true for the
1204 // standard controls and false for the wxWidgets own windows as it can
1205 // simply check m_oldWndProc
1206 m_oldWndProc
= NULL
;
1209 // we're officially created now, send the event
1210 wxWindowCreateEvent
event((wxWindow
*)this);
1211 (void)HandleWindowEvent(event
);
1214 void wxWindowMSW::UnsubclassWin()
1216 wxRemoveHandleAssociation(this);
1218 // Restore old Window proc
1219 HWND hwnd
= GetHwnd();
1224 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1228 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1230 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1233 m_oldWndProc
= NULL
;
1238 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1242 if ( !::DestroyWindow(GetHwnd()) )
1243 wxLogLastError(wxT("DestroyWindow"));
1246 WXHWND wxhwnd
= (WXHWND
)handle
;
1249 SubclassWin(wxhwnd
);
1252 void wxWindowMSW::DissociateHandle()
1254 // this also calls SetHWND(0) for us
1259 bool wxCheckWindowWndProc(WXHWND hWnd
,
1260 WXFARPROC
WXUNUSED(wndProc
))
1262 // TODO: This list of window class names should be factored out so they can be
1263 // managed in one place and then accessed from here and other places, such as
1264 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1267 extern wxChar
*wxCanvasClassName
;
1268 extern wxChar
*wxCanvasClassNameNR
;
1270 extern const wxChar
*wxCanvasClassName
;
1271 extern const wxChar
*wxCanvasClassNameNR
;
1273 extern const wxChar
*wxMDIFrameClassName
;
1274 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1275 extern const wxChar
*wxMDIChildFrameClassName
;
1276 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1277 wxString
str(wxGetWindowClass(hWnd
));
1278 if (str
== wxCanvasClassName
||
1279 str
== wxCanvasClassNameNR
||
1281 str
== _T("wxGLCanvasClass") ||
1282 str
== _T("wxGLCanvasClassNR") ||
1283 #endif // wxUSE_GLCANVAS
1284 str
== wxMDIFrameClassName
||
1285 str
== wxMDIFrameClassNameNoRedraw
||
1286 str
== wxMDIChildFrameClassName
||
1287 str
== wxMDIChildFrameClassNameNoRedraw
||
1288 str
== _T("wxTLWHiddenParent"))
1289 return true; // Effectively means don't subclass
1294 // ----------------------------------------------------------------------------
1296 // ----------------------------------------------------------------------------
1298 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1300 long flagsOld
= GetWindowStyleFlag();
1301 if ( flags
== flagsOld
)
1304 // update the internal variable
1305 wxWindowBase::SetWindowStyleFlag(flags
);
1307 // and the real window flags
1308 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1311 void wxWindowMSW::SetExtraStyle(long exflags
)
1313 long exflagsOld
= GetExtraStyle();
1314 if ( exflags
== exflagsOld
)
1317 // update the internal variable
1318 wxWindowBase::SetExtraStyle(exflags
);
1320 // and the real window flags
1321 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1324 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1326 // now update the Windows style as well if needed - and if the window had
1327 // been already created
1331 // we may need to call SetWindowPos() when we change some styles
1332 bool callSWP
= false;
1335 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1337 // this is quite a horrible hack but we need it because MSWGetStyle()
1338 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1339 // and so we have to modify the window exflags temporarily to get the
1340 // correct exstyleOld
1341 long exflagsNew
= GetExtraStyle();
1342 wxWindowBase::SetExtraStyle(exflagsOld
);
1345 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1347 wxWindowBase::SetExtraStyle(exflagsNew
);
1350 if ( style
!= styleOld
)
1352 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1353 // this function so instead of simply setting the style to the new
1354 // value we clear the bits which were set in styleOld but are set in
1355 // the new one and set the ones which were not set before
1356 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1357 styleReal
&= ~styleOld
;
1360 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1362 // we need to call SetWindowPos() if any of the styles affecting the
1363 // frame appearance have changed
1364 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1373 // and the extended style
1374 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1376 if ( exstyle
!= exstyleOld
)
1378 exstyleReal
&= ~exstyleOld
;
1379 exstyleReal
|= exstyle
;
1381 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1383 // ex style changes don't take effect without calling SetWindowPos
1389 // we must call SetWindowPos() to flush the cached extended style and
1390 // also to make the change to wxSTAY_ON_TOP style take effect: just
1391 // setting the style simply doesn't work
1392 if ( !::SetWindowPos(GetHwnd(),
1393 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1396 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1398 wxLogLastError(_T("SetWindowPos"));
1403 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1405 return wxBORDER_THEME
;
1408 wxBorder
wxWindowMSW::GetDefaultBorder() const
1410 return wxWindowBase::GetDefaultBorder();
1413 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1414 // that makes most sense for this Windows environment
1415 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1417 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1418 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1419 return wxBORDER_SIMPLE
;
1421 return wxBORDER_NONE
;
1424 if (border
== wxBORDER_THEME
)
1426 if (CanApplyThemeBorder())
1428 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1430 return wxBORDER_THEME
;
1432 return wxBORDER_SUNKEN
;
1440 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1442 // translate common wxWidgets styles to Windows ones
1444 // most of windows are child ones, those which are not (such as
1445 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1446 WXDWORD style
= WS_CHILD
;
1448 // using this flag results in very significant reduction in flicker,
1449 // especially with controls inside the static boxes (as the interior of the
1450 // box is not redrawn twice), but sometimes results in redraw problems, so
1451 // optionally allow the old code to continue to use it provided a special
1452 // system option is turned on
1453 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1454 || (flags
& wxCLIP_CHILDREN
) )
1455 style
|= WS_CLIPCHILDREN
;
1457 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1458 // don't support overlapping windows and it only makes sense for them and,
1459 // presumably, gives the system some extra work (to manage more clipping
1460 // regions), so avoid it alltogether
1463 if ( flags
& wxVSCROLL
)
1464 style
|= WS_VSCROLL
;
1466 if ( flags
& wxHSCROLL
)
1467 style
|= WS_HSCROLL
;
1469 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1471 // After translation, border is now optimized for the specific version of Windows
1472 // and theme engine presence.
1474 // WS_BORDER is only required for wxBORDER_SIMPLE
1475 if ( border
== wxBORDER_SIMPLE
)
1478 // now deal with ext style if the caller wants it
1484 if ( flags
& wxTRANSPARENT_WINDOW
)
1485 *exstyle
|= WS_EX_TRANSPARENT
;
1491 case wxBORDER_DEFAULT
:
1492 wxFAIL_MSG( _T("unknown border style") );
1496 case wxBORDER_SIMPLE
:
1497 case wxBORDER_THEME
:
1500 case wxBORDER_STATIC
:
1501 *exstyle
|= WS_EX_STATICEDGE
;
1504 case wxBORDER_RAISED
:
1505 *exstyle
|= WS_EX_DLGMODALFRAME
;
1508 case wxBORDER_SUNKEN
:
1509 *exstyle
|= WS_EX_CLIENTEDGE
;
1510 style
&= ~WS_BORDER
;
1513 // case wxBORDER_DOUBLE:
1514 // *exstyle |= WS_EX_DLGMODALFRAME;
1518 // wxUniv doesn't use Windows dialog navigation functions at all
1519 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1520 // to make the dialog navigation work with the nested panels we must
1521 // use this style (top level windows such as dialogs don't need it)
1522 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1524 *exstyle
|= WS_EX_CONTROLPARENT
;
1526 #endif // __WXUNIVERSAL__
1532 // Setup background and foreground colours correctly
1533 void wxWindowMSW::SetupColours()
1536 SetBackgroundColour(GetParent()->GetBackgroundColour());
1539 bool wxWindowMSW::IsMouseInWindow() const
1541 // get the mouse position
1544 ::GetCursorPosWinCE(&pt
);
1546 ::GetCursorPos(&pt
);
1549 // find the window which currently has the cursor and go up the window
1550 // chain until we find this window - or exhaust it
1551 HWND hwnd
= ::WindowFromPoint(pt
);
1552 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1553 hwnd
= ::GetParent(hwnd
);
1555 return hwnd
!= NULL
;
1558 void wxWindowMSW::OnInternalIdle()
1560 #ifndef HAVE_TRACKMOUSEEVENT
1561 // Check if we need to send a LEAVE event
1562 if ( m_mouseInWindow
)
1564 // note that we should generate the leave event whether the window has
1565 // or doesn't have mouse capture
1566 if ( !IsMouseInWindow() )
1568 GenerateMouseLeave();
1571 #endif // !HAVE_TRACKMOUSEEVENT
1573 if (wxUpdateUIEvent::CanUpdate(this) && IsShown())
1574 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1577 // Set this window to be the child of 'parent'.
1578 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1580 if ( !wxWindowBase::Reparent(parent
) )
1583 HWND hWndChild
= GetHwnd();
1584 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1586 ::SetParent(hWndChild
, hWndParent
);
1589 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1591 EnsureParentHasControlParentStyle(GetParent());
1593 #endif // !__WXWINCE__
1598 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1600 #ifndef __WXMICROWIN__
1601 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1605 void wxWindowMSW::Freeze()
1607 if ( !m_frozenness
++ )
1610 SendSetRedraw(GetHwnd(), false);
1614 void wxWindowMSW::Thaw()
1616 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1618 if ( --m_frozenness
== 0 )
1622 SendSetRedraw(GetHwnd(), true);
1624 // we need to refresh everything or otherwise the invalidated area
1625 // is not going to be repainted
1631 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1633 HWND hWnd
= GetHwnd();
1640 wxCopyRectToRECT(*rect
, mswRect
);
1648 // RedrawWindow not available on SmartPhone or eVC++ 3
1649 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1650 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1654 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1656 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1661 void wxWindowMSW::Update()
1663 if ( !::UpdateWindow(GetHwnd()) )
1665 wxLogLastError(_T("UpdateWindow"));
1668 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1669 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1670 // handler needs to be really drawn right now
1675 // ---------------------------------------------------------------------------
1677 // ---------------------------------------------------------------------------
1679 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1683 // we need to lower the sibling static boxes so controls contained within can be
1685 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1687 // no sibling static boxes if we have no parent (ie TLW)
1691 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1693 node
= node
->GetNext() )
1695 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1698 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1699 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1704 #else // !wxUSE_STATBOX
1706 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1710 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1712 #endif // drag and drop is used
1714 #if wxUSE_DRAG_AND_DROP
1715 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1717 if ( m_dropTarget
!= 0 ) {
1718 m_dropTarget
->Revoke(m_hWnd
);
1719 delete m_dropTarget
;
1722 m_dropTarget
= pDropTarget
;
1723 if ( m_dropTarget
!= 0 )
1725 AdjustStaticBoxZOrder(GetParent());
1726 m_dropTarget
->Register(m_hWnd
);
1729 #endif // wxUSE_DRAG_AND_DROP
1731 // old-style file manager drag&drop support: we retain the old-style
1732 // DragAcceptFiles in parallel with SetDropTarget.
1733 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1736 HWND hWnd
= GetHwnd();
1739 AdjustStaticBoxZOrder(GetParent());
1740 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1745 // ----------------------------------------------------------------------------
1747 // ----------------------------------------------------------------------------
1751 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1753 wxWindowBase::DoSetToolTip(tooltip
);
1756 m_tooltip
->SetWindow((wxWindow
*)this);
1759 #endif // wxUSE_TOOLTIPS
1761 // ---------------------------------------------------------------------------
1762 // moving and resizing
1763 // ---------------------------------------------------------------------------
1765 bool wxWindowMSW::IsSizeDeferred() const
1767 #if USE_DEFERRED_SIZING
1768 if ( m_pendingPosition
!= wxDefaultPosition
||
1769 m_pendingSize
!= wxDefaultSize
)
1771 #endif // USE_DEFERRED_SIZING
1777 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1779 #if USE_DEFERRED_SIZING
1780 // if SetSize() had been called at wx level but not realized at Windows
1781 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1782 // the new and not the old position to the other wx code
1783 if ( m_pendingSize
!= wxDefaultSize
)
1786 *x
= m_pendingSize
.x
;
1788 *y
= m_pendingSize
.y
;
1790 else // use current size
1791 #endif // USE_DEFERRED_SIZING
1793 RECT rect
= wxGetWindowRect(GetHwnd());
1796 *x
= rect
.right
- rect
.left
;
1798 *y
= rect
.bottom
- rect
.top
;
1802 // Get size *available for subwindows* i.e. excluding menu bar etc.
1803 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1805 #if USE_DEFERRED_SIZING
1806 if ( m_pendingSize
!= wxDefaultSize
)
1808 // we need to calculate the client size corresponding to pending size
1810 rect
.left
= m_pendingPosition
.x
;
1811 rect
.top
= m_pendingPosition
.y
;
1812 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1813 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1815 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1818 *x
= rect
.right
- rect
.left
;
1820 *y
= rect
.bottom
- rect
.top
;
1823 #endif // USE_DEFERRED_SIZING
1825 RECT rect
= wxGetClientRect(GetHwnd());
1834 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1836 wxWindow
* const parent
= GetParent();
1839 if ( m_pendingPosition
!= wxDefaultPosition
)
1841 pos
= m_pendingPosition
;
1843 else // use current position
1845 RECT rect
= wxGetWindowRect(GetHwnd());
1848 point
.x
= rect
.left
;
1851 // we do the adjustments with respect to the parent only for the "real"
1852 // children, not for the dialogs/frames
1853 if ( !IsTopLevel() )
1855 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1857 // In RTL mode, we want the logical left x-coordinate,
1858 // which would be the physical right x-coordinate.
1859 point
.x
= rect
.right
;
1862 // Since we now have the absolute screen coords, if there's a
1863 // parent we must subtract its top left corner
1866 ::ScreenToClient(GetHwndOf(parent
), &point
);
1874 // we also must adjust by the client area offset: a control which is just
1875 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1876 if ( parent
&& !IsTopLevel() )
1878 const wxPoint
pt(parent
->GetClientAreaOrigin());
1889 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1897 ::ScreenToClient(GetHwnd(), &pt
);
1905 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1913 ::ClientToScreen(GetHwnd(), &pt
);
1922 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1924 #if USE_DEFERRED_SIZING
1925 // if our parent had prepared a defer window handle for us, use it (unless
1926 // we are a top level window)
1927 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1929 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1932 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1933 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1936 wxLogLastError(_T("DeferWindowPos"));
1942 // hdwp must be updated as it may have been changed
1943 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1948 // did deferred move, remember new coordinates of the window as they're
1949 // different from what Windows would return for it
1953 // otherwise (or if deferring failed) move the window in place immediately
1954 #endif // USE_DEFERRED_SIZING
1955 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1957 wxLogLastError(wxT("MoveWindow"));
1960 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1961 // ignored otherwise
1965 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1967 // TODO: is this consistent with other platforms?
1968 // Still, negative width or height shouldn't be allowed
1974 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1976 #if USE_DEFERRED_SIZING
1977 m_pendingPosition
= wxPoint(x
, y
);
1978 m_pendingSize
= wxSize(width
, height
);
1979 #endif // USE_DEFERRED_SIZING
1983 // set the size of the window: if the dimensions are positive, just use them,
1984 // but if any of them is equal to -1, it means that we must find the value for
1985 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1986 // which case -1 is a valid value for x and y)
1988 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1989 // the width/height to best suit our contents, otherwise we reuse the current
1991 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1993 // get the current size and position...
1994 int currentX
, currentY
;
1995 int currentW
, currentH
;
1997 GetPosition(¤tX
, ¤tY
);
1998 GetSize(¤tW
, ¤tH
);
2000 // ... and don't do anything (avoiding flicker) if it's already ok unless
2001 // we're forced to resize the window
2002 if ( x
== currentX
&& y
== currentY
&&
2003 width
== currentW
&& height
== currentH
&&
2004 !(sizeFlags
& wxSIZE_FORCE
) )
2009 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2011 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2014 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2016 wxSize size
= wxDefaultSize
;
2017 if ( width
== wxDefaultCoord
)
2019 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2021 size
= DoGetBestSize();
2026 // just take the current one
2031 if ( height
== wxDefaultCoord
)
2033 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2035 if ( size
.x
== wxDefaultCoord
)
2037 size
= DoGetBestSize();
2039 //else: already called DoGetBestSize() above
2045 // just take the current one
2050 DoMoveWindow(x
, y
, width
, height
);
2053 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2055 // setting the client size is less obvious than it could have been
2056 // because in the result of changing the total size the window scrollbar
2057 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2058 // doesn't take neither into account) and so the client size will not be
2059 // correct as the difference between the total and client size changes --
2060 // so we keep changing it until we get it right
2062 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2063 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2064 // may become 3 if the window had 0 size originally and so we didn't
2065 // calculate the scrollbar correction correctly during the first iteration)
2066 // but just to be on the safe side we check for it instead of making it an
2067 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2068 for ( int i
= 0; i
< 4; i
++ )
2071 ::GetClientRect(GetHwnd(), &rectClient
);
2073 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2074 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2075 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2080 // Find the difference between the entire window (title bar and all)
2081 // and the client area; add this to the new client size to move the
2084 ::GetWindowRect(GetHwnd(), &rectWin
);
2086 const int widthWin
= rectWin
.right
- rectWin
.left
,
2087 heightWin
= rectWin
.bottom
- rectWin
.top
;
2089 // MoveWindow positions the child windows relative to the parent, so
2090 // adjust if necessary
2091 if ( !IsTopLevel() )
2093 wxWindow
*parent
= GetParent();
2096 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2100 // don't call DoMoveWindow() because we want to move window immediately
2101 // and not defer it here as otherwise the value returned by
2102 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2104 if ( !::MoveWindow(GetHwnd(),
2107 width
+ widthWin
- rectClient
.right
,
2108 height
+ heightWin
- rectClient
.bottom
,
2111 wxLogLastError(_T("MoveWindow"));
2116 // ---------------------------------------------------------------------------
2118 // ---------------------------------------------------------------------------
2120 int wxWindowMSW::GetCharHeight() const
2122 return wxGetTextMetrics(this).tmHeight
;
2125 int wxWindowMSW::GetCharWidth() const
2127 // +1 is needed because Windows apparently adds it when calculating the
2128 // dialog units size in pixels
2129 #if wxDIALOG_UNIT_COMPATIBILITY
2130 return wxGetTextMetrics(this).tmAveCharWidth
;
2132 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2136 void wxWindowMSW::GetTextExtent(const wxString
& string
,
2138 int *descent
, int *externalLeading
,
2139 const wxFont
*theFont
) const
2141 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
2142 _T("invalid font in GetTextExtent()") );
2146 fontToUse
= *theFont
;
2148 fontToUse
= GetFont();
2150 WindowHDC
hdc(GetHwnd());
2151 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
2155 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2156 GetTextMetrics(hdc
, &tm
);
2163 *descent
= tm
.tmDescent
;
2164 if ( externalLeading
)
2165 *externalLeading
= tm
.tmExternalLeading
;
2168 // ---------------------------------------------------------------------------
2170 // ---------------------------------------------------------------------------
2172 #if wxUSE_MENUS_NATIVE
2174 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2175 // immediately, without waiting for the next event loop iteration
2177 // NB: this function should probably be made public later as it can almost
2178 // surely replace wxYield() elsewhere as well
2179 static void wxYieldForCommandsOnly()
2181 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2182 // want to process it here)
2184 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2186 if ( msg
.message
== WM_QUIT
)
2188 // if we retrieved a WM_QUIT, insert back into the message queue.
2189 ::PostQuitMessage(0);
2193 // luckily (as we don't have access to wxEventLoopImpl method from here
2194 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2196 ::TranslateMessage(&msg
);
2197 ::DispatchMessage(&msg
);
2201 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2203 menu
->SetInvokingWindow(this);
2206 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2208 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2209 x
= mouse
.x
; y
= mouse
.y
;
2212 HWND hWnd
= GetHwnd();
2213 HMENU hMenu
= GetHmenuOf(menu
);
2217 ::ClientToScreen(hWnd
, &point
);
2218 #if defined(__WXWINCE__)
2219 static const UINT flags
= 0;
2220 #else // !__WXWINCE__
2221 UINT flags
= TPM_RIGHTBUTTON
;
2222 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2223 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2224 // side and not to use it there neither -- modify the test if it does work
2226 if ( wxGetWinVersion() >= wxWinVersion_5
)
2228 // using TPM_RECURSE allows us to show a popup menu while another menu
2229 // is opened which can be useful and is supported by the other
2230 // platforms, so allow it under Windows too
2231 flags
|= TPM_RECURSE
;
2233 #endif // __WXWINCE__/!__WXWINCE__
2235 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2237 // we need to do it right now as otherwise the events are never going to be
2238 // sent to wxCurrentPopupMenu from HandleCommand()
2240 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2241 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2242 // destroyed as soon as we return (it can be a local variable in the caller
2243 // for example) and so we do need to process the event immediately
2244 wxYieldForCommandsOnly();
2246 menu
->SetInvokingWindow(NULL
);
2251 #endif // wxUSE_MENUS_NATIVE
2253 // ===========================================================================
2254 // pre/post message processing
2255 // ===========================================================================
2257 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2260 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2262 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2265 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2267 // wxUniversal implements tab traversal itself
2268 #ifndef __WXUNIVERSAL__
2269 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2271 // intercept dialog navigation keys
2272 MSG
*msg
= (MSG
*)pMsg
;
2274 // here we try to do all the job which ::IsDialogMessage() usually does
2276 if ( msg
->message
== WM_KEYDOWN
)
2278 bool bCtrlDown
= wxIsCtrlDown();
2279 bool bShiftDown
= wxIsShiftDown();
2281 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2282 // don't process it if it's the case (except for Ctrl-Tab/Enter
2283 // combinations which are always processed)
2284 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2286 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2287 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2288 // it, of course, implies them
2289 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2291 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2294 bool bForward
= true,
2295 bWindowChange
= false,
2298 // should we process this message specially?
2299 bool bProcess
= true;
2300 switch ( msg
->wParam
)
2303 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2305 // let the control have the TAB
2308 else // use it for navigation
2310 // Ctrl-Tab cycles thru notebook pages
2311 bWindowChange
= bCtrlDown
;
2312 bForward
= !bShiftDown
;
2319 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2327 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2336 // we treat PageUp/Dn as arrows because chances are that
2337 // a control which needs arrows also needs them for
2338 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2339 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2341 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2342 bWindowChange
= true;
2348 // currently active button should get enter press even
2349 // if there is a default button elsewhere so check if
2350 // this window is a button first
2351 wxWindow
*btn
= NULL
;
2352 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2354 // let IsDialogMessage() handle this for all
2355 // buttons except the owner-drawn ones which it
2356 // just seems to ignore
2357 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2358 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2360 // emulate the button click
2361 btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2366 else // not a button itself, do we have default button?
2368 // check if this window or any of its ancestors
2369 // wants the message for itself (we always reserve
2370 // Ctrl-Enter for dialog navigation though)
2371 wxWindow
*win
= this;
2374 // this will contain the dialog code of this
2375 // window and all of its parent windows in turn
2376 LONG lDlgCode2
= lDlgCode
;
2380 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2382 // as it wants to process Enter itself,
2383 // don't call IsDialogMessage() which
2388 // don't propagate keyboard messages beyond
2389 // the first top level window parent
2390 if ( win
->IsTopLevel() )
2393 win
= win
->GetParent();
2395 lDlgCode2
= ::SendMessage
2406 win
= wxGetTopLevelParent(win
);
2409 wxTopLevelWindow
* const
2410 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2413 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2418 if ( btn
&& btn
->IsEnabled() )
2420 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2424 #endif // wxUSE_BUTTON
2427 // map Enter presses into button presses on PDAs
2428 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2429 event
.SetEventObject(this);
2430 if ( HandleWindowEvent(event
) )
2432 #endif // __WXWINCE__
2442 wxNavigationKeyEvent event
;
2443 event
.SetDirection(bForward
);
2444 event
.SetWindowChange(bWindowChange
);
2445 event
.SetFromTab(bFromTab
);
2446 event
.SetEventObject(this);
2448 if ( HandleWindowEvent(event
) )
2450 // as we don't call IsDialogMessage(), which would take of
2451 // this by default, we need to manually send this message
2452 // so that controls can change their UI state if needed
2453 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2460 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2462 // IsDialogMessage() did something...
2466 #endif // __WXUNIVERSAL__
2471 // relay mouse move events to the tooltip control
2472 MSG
*msg
= (MSG
*)pMsg
;
2473 if ( msg
->message
== WM_MOUSEMOVE
)
2474 wxToolTip::RelayEvent(pMsg
);
2476 #endif // wxUSE_TOOLTIPS
2481 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2483 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2484 return m_acceleratorTable
.Translate(this, pMsg
);
2488 #endif // wxUSE_ACCEL
2491 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2493 // all tests below have to deal with various bugs/misfeatures of
2494 // IsDialogMessage(): we have to prevent it from being called from our
2495 // MSWProcessMessage() in some situations
2497 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2498 // message even when there is no cancel button and when the message is
2499 // needed by the control itself: in particular, it prevents the tree in
2500 // place edit control from being closed with Escape in a dialog
2501 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2506 // ::IsDialogMessage() is broken and may sometimes hang the application by
2507 // going into an infinite loop when it tries to find the control to give
2508 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2509 // situations when this may happen and not call it then
2510 if ( msg
->message
!= WM_SYSCHAR
)
2513 // assume we can call it by default
2514 bool canSafelyCallIsDlgMsg
= true;
2516 HWND hwndFocus
= ::GetFocus();
2518 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2519 // ::IsDialogMessage() will also enter an infinite loop, because it will
2520 // recursively check the child windows but not the window itself and so if
2521 // none of the children accepts focus it loops forever (as it only stops
2522 // when it gets back to the window it started from)
2524 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2525 // style has the focus, it can happen. One such possibility is if
2526 // all windows are either toplevel, wxDialog, wxPanel or static
2527 // controls and no window can actually accept keyboard input.
2528 #if !defined(__WXWINCE__)
2529 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2531 // pessimistic by default
2532 canSafelyCallIsDlgMsg
= false;
2533 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2535 node
= node
->GetNext() )
2537 wxWindow
* const win
= node
->GetData();
2538 if ( win
->CanAcceptFocus() &&
2539 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2540 WS_EX_CONTROLPARENT
) )
2542 // it shouldn't hang...
2543 canSafelyCallIsDlgMsg
= true;
2549 #endif // !__WXWINCE__
2551 if ( canSafelyCallIsDlgMsg
)
2553 // ::IsDialogMessage() can enter in an infinite loop when the
2554 // currently focused window is disabled or hidden and its
2555 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2559 if ( !::IsWindowEnabled(hwndFocus
) ||
2560 !::IsWindowVisible(hwndFocus
) )
2562 // it would enter an infinite loop if we do this!
2563 canSafelyCallIsDlgMsg
= false;
2568 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2570 // it's a top level window, don't go further -- e.g. even
2571 // if the parent of a dialog is disabled, this doesn't
2572 // break navigation inside the dialog
2576 hwndFocus
= ::GetParent(hwndFocus
);
2580 return canSafelyCallIsDlgMsg
;
2583 // ---------------------------------------------------------------------------
2584 // message params unpackers
2585 // ---------------------------------------------------------------------------
2587 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2588 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2590 *id
= LOWORD(wParam
);
2591 *hwnd
= (WXHWND
)lParam
;
2592 *cmd
= HIWORD(wParam
);
2595 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2596 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2598 *state
= LOWORD(wParam
);
2599 *minimized
= HIWORD(wParam
);
2600 *hwnd
= (WXHWND
)lParam
;
2603 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2604 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2606 *code
= LOWORD(wParam
);
2607 *pos
= HIWORD(wParam
);
2608 *hwnd
= (WXHWND
)lParam
;
2611 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2612 WXHDC
*hdc
, WXHWND
*hwnd
)
2614 *hwnd
= (WXHWND
)lParam
;
2615 *hdc
= (WXHDC
)wParam
;
2618 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2619 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2621 *item
= (WXWORD
)wParam
;
2622 *flags
= HIWORD(wParam
);
2623 *hmenu
= (WXHMENU
)lParam
;
2626 // ---------------------------------------------------------------------------
2627 // Main wxWidgets window proc and the window proc for wxWindow
2628 // ---------------------------------------------------------------------------
2630 // Hook for new window just as it's being created, when the window isn't yet
2631 // associated with the handle
2632 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2634 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2635 // window being created and insures that it's always unset back later
2636 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2638 gs_winBeingCreated
= winBeingCreated
;
2641 wxWindowCreationHook::~wxWindowCreationHook()
2643 gs_winBeingCreated
= NULL
;
2647 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2649 // trace all messages - useful for the debugging
2651 wxLogTrace(wxTraceMessages
,
2652 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2653 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2654 #endif // __WXDEBUG__
2656 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2658 // when we get the first message for the HWND we just created, we associate
2659 // it with wxWindow stored in gs_winBeingCreated
2660 if ( !wnd
&& gs_winBeingCreated
)
2662 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2663 wnd
= gs_winBeingCreated
;
2664 gs_winBeingCreated
= NULL
;
2665 wnd
->SetHWND((WXHWND
)hWnd
);
2670 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2671 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2673 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2678 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2680 // did we process the message?
2681 bool processed
= false;
2691 // for most messages we should return 0 when we do process the message
2699 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2702 // return 0 to allow window creation
2703 rc
.result
= mayCreate
? 0 : -1;
2709 // never set processed to true and *always* pass WM_DESTROY to
2710 // DefWindowProc() as Windows may do some internal cleanup when
2711 // processing it and failing to pass the message along may cause
2712 // memory and resource leaks!
2713 (void)HandleDestroy();
2717 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2721 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2724 #if !defined(__WXWINCE__)
2727 LPRECT pRect
= (LPRECT
)lParam
;
2729 rc
.SetLeft(pRect
->left
);
2730 rc
.SetTop(pRect
->top
);
2731 rc
.SetRight(pRect
->right
);
2732 rc
.SetBottom(pRect
->bottom
);
2733 processed
= HandleMoving(rc
);
2735 pRect
->left
= rc
.GetLeft();
2736 pRect
->top
= rc
.GetTop();
2737 pRect
->right
= rc
.GetRight();
2738 pRect
->bottom
= rc
.GetBottom();
2743 case WM_ENTERSIZEMOVE
:
2745 processed
= HandleEnterSizeMove();
2749 case WM_EXITSIZEMOVE
:
2751 processed
= HandleExitSizeMove();
2757 LPRECT pRect
= (LPRECT
)lParam
;
2759 rc
.SetLeft(pRect
->left
);
2760 rc
.SetTop(pRect
->top
);
2761 rc
.SetRight(pRect
->right
);
2762 rc
.SetBottom(pRect
->bottom
);
2763 processed
= HandleSizing(rc
);
2765 pRect
->left
= rc
.GetLeft();
2766 pRect
->top
= rc
.GetTop();
2767 pRect
->right
= rc
.GetRight();
2768 pRect
->bottom
= rc
.GetBottom();
2772 #endif // !__WXWINCE__
2774 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2775 case WM_ACTIVATEAPP
:
2776 // This implicitly sends a wxEVT_ACTIVATE_APP event
2777 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2783 WXWORD state
, minimized
;
2785 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2787 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2792 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2796 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2799 case WM_PRINTCLIENT
:
2800 processed
= HandlePrintClient((WXHDC
)wParam
);
2806 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2808 processed
= HandlePaint();
2812 processed
= HandlePaint();
2817 #ifdef __WXUNIVERSAL__
2818 // Universal uses its own wxFrame/wxDialog, so we don't receive
2819 // close events unless we have this.
2821 #endif // __WXUNIVERSAL__
2823 // don't let the DefWindowProc() destroy our window - we'll do it
2824 // ourselves in ~wxWindow
2830 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2834 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2835 GET_Y_LPARAM(lParam
),
2839 #ifdef HAVE_TRACKMOUSEEVENT
2841 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2843 if ( m_mouseInWindow
)
2845 GenerateMouseLeave();
2848 // always pass processed back as false, this allows the window
2849 // manager to process the message too. This is needed to
2850 // ensure windows XP themes work properly as the mouse moves
2851 // over widgets like buttons. So don't set processed to true here.
2853 #endif // HAVE_TRACKMOUSEEVENT
2855 #if wxUSE_MOUSEWHEEL
2857 processed
= HandleMouseWheel(wParam
, lParam
);
2861 case WM_LBUTTONDOWN
:
2863 case WM_LBUTTONDBLCLK
:
2864 case WM_RBUTTONDOWN
:
2866 case WM_RBUTTONDBLCLK
:
2867 case WM_MBUTTONDOWN
:
2869 case WM_MBUTTONDBLCLK
:
2870 #ifdef wxHAS_XBUTTON
2871 case WM_XBUTTONDOWN
:
2873 case WM_XBUTTONDBLCLK
:
2874 #endif // wxHAS_XBUTTON
2876 #ifdef __WXMICROWIN__
2877 // MicroWindows seems to ignore the fact that a window is
2878 // disabled. So catch mouse events and throw them away if
2880 wxWindowMSW
* win
= this;
2883 if (!win
->IsEnabled())
2889 win
= win
->GetParent();
2890 if ( !win
|| win
->IsTopLevel() )
2897 #endif // __WXMICROWIN__
2898 int x
= GET_X_LPARAM(lParam
),
2899 y
= GET_Y_LPARAM(lParam
);
2902 // redirect the event to a static control if necessary by
2903 // finding one under mouse because under CE the static controls
2904 // don't generate mouse events (even with SS_NOTIFY)
2906 if ( GetCapture() == this )
2908 // but don't do it if the mouse is captured by this window
2909 // because then it should really get this event itself
2914 win
= FindWindowForMouseEvent(this, &x
, &y
);
2916 // this should never happen
2917 wxCHECK_MSG( win
, 0,
2918 _T("FindWindowForMouseEvent() returned NULL") );
2921 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2923 SHRGINFO shrgi
= {0};
2925 shrgi
.cbSize
= sizeof(SHRGINFO
);
2926 shrgi
.hwndClient
= (HWND
) GetHWND();
2930 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2931 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2933 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2936 pt
= ClientToScreen(pt
);
2938 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2940 evtCtx
.SetEventObject(this);
2941 if (HandleWindowEvent(evtCtx
))
2950 #else // !__WXWINCE__
2951 wxWindowMSW
*win
= this;
2952 #endif // __WXWINCE__/!__WXWINCE__
2954 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2956 // if the app didn't eat the event, handle it in the default
2957 // way, that is by giving this window the focus
2960 // for the standard classes their WndProc sets the focus to
2961 // them anyhow and doing it from here results in some weird
2962 // problems, so don't do it for them (unnecessary anyhow)
2963 if ( !win
->IsOfStandardClass() )
2965 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
2977 case MM_JOY1BUTTONDOWN
:
2978 case MM_JOY2BUTTONDOWN
:
2979 case MM_JOY1BUTTONUP
:
2980 case MM_JOY2BUTTONUP
:
2981 processed
= HandleJoystickEvent(message
,
2982 GET_X_LPARAM(lParam
),
2983 GET_Y_LPARAM(lParam
),
2986 #endif // __WXMICROWIN__
2992 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2994 processed
= HandleCommand(id
, cmd
, hwnd
);
2999 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
3002 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3003 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3004 // apparently doesn't always behave properly and needs some help
3005 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3006 case WM_NOTIFYFORMAT
:
3007 if ( lParam
== NF_QUERY
)
3010 rc
.result
= NFR_UNICODE
;
3013 #endif // wxUSE_UNICODE_MSLU
3015 // for these messages we must return true if process the message
3018 case WM_MEASUREITEM
:
3020 int idCtrl
= (UINT
)wParam
;
3021 if ( message
== WM_DRAWITEM
)
3023 processed
= MSWOnDrawItem(idCtrl
,
3024 (WXDRAWITEMSTRUCT
*)lParam
);
3028 processed
= MSWOnMeasureItem(idCtrl
,
3029 (WXMEASUREITEMSTRUCT
*)lParam
);
3036 #endif // defined(WM_DRAWITEM)
3039 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3041 // we always want to get the char events
3042 rc
.result
= DLGC_WANTCHARS
;
3044 if ( HasFlag(wxWANTS_CHARS
) )
3046 // in fact, we want everything
3047 rc
.result
|= DLGC_WANTARROWS
|
3054 //else: get the dlg code from the DefWindowProc()
3059 // If this has been processed by an event handler, return 0 now
3060 // (we've handled it).
3061 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3062 if ( m_lastKeydownProcessed
)
3071 // we consider these messages "not interesting" to OnChar, so
3072 // just don't do anything more with them
3082 // avoid duplicate messages to OnChar for these ASCII keys:
3083 // they will be translated by TranslateMessage() and received
3115 // but set processed to false, not true to still pass them
3116 // to the control's default window proc - otherwise
3117 // built-in keyboard handling won't work
3122 // special case of VK_APPS: treat it the same as right mouse
3123 // click because both usually pop up a context menu
3125 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3130 // do generate a CHAR event
3131 processed
= HandleChar((WORD
)wParam
, lParam
);
3134 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3141 // special case of VK_APPS: treat it the same as right mouse button
3142 if ( wParam
== VK_APPS
)
3144 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3149 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3154 case WM_CHAR
: // Always an ASCII character
3155 if ( m_lastKeydownProcessed
)
3157 // The key was handled in the EVT_KEY_DOWN and handling
3158 // a key in an EVT_KEY_DOWN handler is meant, by
3159 // design, to prevent EVT_CHARs from happening
3160 m_lastKeydownProcessed
= false;
3165 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3171 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3173 #endif // wxUSE_HOTKEY
3180 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3182 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3188 // CTLCOLOR messages are sent by children to query the parent for their
3190 #ifndef __WXMICROWIN__
3191 case WM_CTLCOLORMSGBOX
:
3192 case WM_CTLCOLOREDIT
:
3193 case WM_CTLCOLORLISTBOX
:
3194 case WM_CTLCOLORBTN
:
3195 case WM_CTLCOLORDLG
:
3196 case WM_CTLCOLORSCROLLBAR
:
3197 case WM_CTLCOLORSTATIC
:
3201 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3203 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3206 #endif // !__WXMICROWIN__
3208 case WM_SYSCOLORCHANGE
:
3209 // the return value for this message is ignored
3210 processed
= HandleSysColorChange();
3213 #if !defined(__WXWINCE__)
3214 case WM_DISPLAYCHANGE
:
3215 processed
= HandleDisplayChange();
3219 case WM_PALETTECHANGED
:
3220 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
3223 case WM_CAPTURECHANGED
:
3224 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
3227 case WM_SETTINGCHANGE
:
3228 processed
= HandleSettingChange(wParam
, lParam
);
3231 case WM_QUERYNEWPALETTE
:
3232 processed
= HandleQueryNewPalette();
3236 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
3239 // we processed the message, i.e. erased the background
3244 #if !defined(__WXWINCE__)
3246 processed
= HandleDropFiles(wParam
);
3251 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
3255 // we never set focus from here
3260 #if !defined(__WXWINCE__)
3261 case WM_QUERYENDSESSION
:
3262 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3266 processed
= HandleEndSession(wParam
!= 0, lParam
);
3269 case WM_GETMINMAXINFO
:
3270 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3275 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
3276 LOWORD(lParam
), // hit test
3277 HIWORD(lParam
)); // mouse msg
3281 // returning TRUE stops the DefWindowProc() from further
3282 // processing this message - exactly what we need because we've
3283 // just set the cursor.
3288 #if wxUSE_ACCESSIBILITY
3291 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3292 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3294 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3296 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3302 #if defined(WM_HELP)
3305 // by default, WM_HELP is propagated by DefWindowProc() upwards
3306 // to the window parent but as we do it ourselves already
3307 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3308 // to get the other events if we process this message at all
3311 // WM_HELP doesn't use lParam under CE
3313 HELPINFO
* info
= (HELPINFO
*) lParam
;
3314 if ( info
->iContextType
== HELPINFO_WINDOW
)
3316 #endif // !__WXWINCE__
3317 wxHelpEvent helpEvent
3322 wxGetMousePosition() // what else?
3324 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3328 helpEvent
.SetEventObject(this);
3329 HandleWindowEvent(helpEvent
);
3332 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3334 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3335 helpEvent
.SetEventObject(this);
3336 HandleWindowEvent(helpEvent
);
3339 else // unknown help event?
3343 #endif // !__WXWINCE__
3348 #if !defined(__WXWINCE__)
3349 case WM_CONTEXTMENU
:
3351 // we don't convert from screen to client coordinates as
3352 // the event may be handled by a parent window
3353 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3355 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3357 // we could have got an event from our child, reflect it back
3358 // to it if this is the case
3359 wxWindowMSW
*win
= NULL
;
3360 if ( (WXHWND
)wParam
!= m_hWnd
)
3362 win
= FindItemByHWND((WXHWND
)wParam
);
3368 evtCtx
.SetEventObject(win
);
3369 processed
= win
->HandleWindowEvent(evtCtx
);
3376 // we're only interested in our own menus, not MF_SYSMENU
3377 if ( HIWORD(wParam
) == MF_POPUP
)
3379 // handle menu chars for ownerdrawn menu items
3380 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3381 if ( i
!= wxNOT_FOUND
)
3383 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3388 #endif // wxUSE_MENUS
3391 case WM_POWERBROADCAST
:
3394 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3395 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3398 #endif // __WXWINCE__
3401 // If we want the default themed border then we need to draw it ourselves
3404 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3405 const wxBorder border
= TranslateBorder(GetBorder());
3406 if (theme
&& border
== wxBORDER_THEME
)
3408 // first ask the widget to calculate the border size
3409 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3412 // now alter the client size making room for drawing a themed border
3413 NCCALCSIZE_PARAMS
*csparam
= NULL
;
3417 csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3418 rect
= csparam
->rgrc
[0];
3422 rect
= *((RECT
*)lParam
);
3424 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3425 RECT rcClient
= { 0, 0, 0, 0 };
3426 wxClientDC
dc((wxWindow
*)this);
3427 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3429 if (theme
->GetThemeBackgroundContentRect(
3430 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
,
3431 &rect
, &rcClient
) == S_OK
)
3433 InflateRect(&rcClient
, -1, -1);
3435 csparam
->rgrc
[0] = rcClient
;
3437 *((RECT
*)lParam
) = rcClient
;
3438 rc
.result
= WVR_REDRAW
;
3446 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3447 const wxBorder border
= TranslateBorder(GetBorder());
3448 if (theme
&& border
== wxBORDER_THEME
)
3450 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3451 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3454 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3455 wxWindowDC
dc((wxWindow
*)this);
3456 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3458 // Clip the DC so that you only draw on the non-client area
3460 wxCopyRectToRECT(GetSize(), rcBorder
);
3463 theme
->GetThemeBackgroundContentRect(
3464 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3465 InflateRect(&rcClient
, -1, -1);
3467 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3468 rcClient
.right
, rcClient
.bottom
);
3470 // Make sure the background is in a proper state
3471 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3473 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3479 nState
= ETS_DISABLED
;
3480 // should we check this?
3481 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3482 // nState = ETS_READONLY;
3484 nState
= ETS_NORMAL
;
3485 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3490 #endif // wxUSE_UXTHEME
3493 // try a custom message handler
3494 const MSWMessageHandlers::const_iterator
3495 i
= gs_messageHandlers
.find(message
);
3496 if ( i
!= gs_messageHandlers
.end() )
3498 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3505 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3506 wxGetMessageName(message
));
3507 #endif // __WXDEBUG__
3508 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3514 // ----------------------------------------------------------------------------
3515 // wxWindow <-> HWND map
3516 // ----------------------------------------------------------------------------
3518 wxWinHashTable
*wxWinHandleHash
= NULL
;
3520 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3522 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3525 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3527 // adding NULL hWnd is (first) surely a result of an error and
3528 // (secondly) breaks menu command processing
3529 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3530 wxT("attempt to add a NULL hWnd to window list ignored") );
3532 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3534 if ( oldWin
&& (oldWin
!= win
) )
3536 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3537 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3540 #endif // __WXDEBUG__
3543 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3547 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3549 wxWinHandleHash
->Delete((long)win
->GetHWND());
3552 // ----------------------------------------------------------------------------
3553 // various MSW speciic class dependent functions
3554 // ----------------------------------------------------------------------------
3556 // Default destroyer - override if you destroy it in some other way
3557 // (e.g. with MDI child windows)
3558 void wxWindowMSW::MSWDestroyWindow()
3562 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3565 int& w
, int& h
) const
3567 // yes, those are just some arbitrary hardcoded numbers
3568 static const int DEFAULT_Y
= 200;
3570 bool nonDefault
= false;
3572 if ( pos
.x
== wxDefaultCoord
)
3574 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3575 // can just as well set it to CW_USEDEFAULT as well
3581 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3582 // neither because it is not handled as a special value by Windows then
3583 // and so we have to choose some default value for it
3585 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3591 NB: there used to be some code here which set the initial size of the
3592 window to the client size of the parent if no explicit size was
3593 specified. This was wrong because wxWidgets programs often assume
3594 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3595 it. To see why, you should understand that Windows sends WM_SIZE from
3596 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3597 from some base class ctor and so this WM_SIZE is not processed in the
3598 real class' OnSize() (because it's not fully constructed yet and the
3599 event goes to some base class OnSize() instead). So the WM_SIZE we
3600 rely on is the one sent when the parent frame resizes its children
3601 but here is the problem: if the child already has just the right
3602 size, nothing will happen as both wxWidgets and Windows check for
3603 this and ignore any attempts to change the window size to the size it
3604 already has - so no WM_SIZE would be sent.
3608 // we don't use CW_USEDEFAULT here for several reasons:
3610 // 1. it results in huge frames on modern screens (1000*800 is not
3611 // uncommon on my 1280*1024 screen) which is way too big for a half
3612 // empty frame of most of wxWidgets samples for example)
3614 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3615 // the default is for whatever reason 8*8 which breaks client <->
3616 // window size calculations (it would be nice if it didn't, but it
3617 // does and the simplest way to fix it seemed to change the broken
3618 // default size anyhow)
3620 // 3. there is just no advantage in doing it: with x and y it is
3621 // possible that [future versions of] Windows position the new top
3622 // level window in some smart way which we can't do, but we can
3623 // guess a reasonably good size for a new window just as well
3626 // However, on PocketPC devices, we must use the default
3627 // size if possible.
3629 if (size
.x
== wxDefaultCoord
)
3633 if (size
.y
== wxDefaultCoord
)
3638 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3642 w
= WidthDefault(size
.x
);
3643 h
= HeightDefault(size
.y
);
3646 AdjustForParentClientOrigin(x
, y
);
3651 WXHWND
wxWindowMSW::MSWGetParent() const
3653 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3656 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3657 const wxChar
*title
,
3661 WXDWORD extendedStyle
)
3663 // choose the position/size for the new window
3665 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3667 // controlId is menu handle for the top level windows, so set it to 0
3668 // unless we're creating a child window
3669 int controlId
= style
& WS_CHILD
? GetId() : 0;
3671 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3672 // which is the same but without CS_[HV]REDRAW class styles so using it
3673 // ensures that the window is not fully repainted on each resize
3674 wxString
className(wclass
);
3675 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3677 className
+= wxT("NR");
3680 // do create the window
3681 wxWindowCreationHook
hook(this);
3683 m_hWnd
= (WXHWND
)::CreateWindowEx
3687 title
? title
: m_windowName
.wx_str(),
3690 (HWND
)MSWGetParent(),
3693 NULL
// no extra data
3698 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3703 SubclassWin(m_hWnd
);
3708 // ===========================================================================
3709 // MSW message handlers
3710 // ===========================================================================
3712 // ---------------------------------------------------------------------------
3714 // ---------------------------------------------------------------------------
3716 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3718 #ifndef __WXMICROWIN__
3719 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3720 HWND hWnd
= hdr
->hwndFrom
;
3721 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3723 // if the control is one of our windows, let it handle the message itself
3726 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3729 // VZ: why did we do it? normally this is unnecessary and, besides, it
3730 // breaks the message processing for the toolbars because the tooltip
3731 // notifications were being forwarded to the toolbar child controls
3732 // (if it had any) before being passed to the toolbar itself, so in my
3733 // example the tooltip for the combobox was always shown instead of the
3734 // correct button tooltips
3736 // try all our children
3737 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3740 wxWindow
*child
= node
->GetData();
3741 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3746 node
= node
->GetNext();
3750 // by default, handle it ourselves
3751 return MSWOnNotify(idCtrl
, lParam
, result
);
3752 #else // __WXMICROWIN__
3759 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3761 const wxString
& ttip
)
3763 // I don't know why it happens, but the versions of comctl32.dll starting
3764 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3765 // this message is supposed to be sent to Unicode programs only) -- hence
3766 // we need to handle it as well, otherwise no tooltips will be shown in
3769 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3772 // not a tooltip message or no tooltip to show anyhow
3777 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3779 // We don't want to use the szText buffer because it has a limit of 80
3780 // bytes and this is not enough, especially for Unicode build where it
3781 // limits the tooltip string length to only 40 characters
3783 // The best would be, of course, to not impose any length limitations at
3784 // all but then the buffer would have to be dynamic and someone would have
3785 // to free it and we don't have the tooltip owner object here any more, so
3786 // for now use our own static buffer with a higher fixed max length.
3788 // Note that using a static buffer should not be a problem as only a single
3789 // tooltip can be shown at the same time anyhow.
3791 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3793 // We need to convert tooltip from multi byte to Unicode on the fly.
3794 static wchar_t buf
[513];
3796 // Truncate tooltip length if needed as otherwise we might not have
3797 // enough space for it in the buffer and MultiByteToWideChar() would
3799 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3801 // Convert to WideChar without adding the NULL character. The NULL
3802 // character is added afterwards (this is more efficient).
3803 int len
= ::MultiByteToWideChar
3815 wxLogLastError(_T("MultiByteToWideChar()"));
3819 ttText
->lpszText
= (LPSTR
) buf
;
3821 else // TTN_NEEDTEXTA
3822 #endif // !wxUSE_UNICODE
3824 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3825 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3826 // to copy the string we have into the buffer
3827 static wxChar buf
[513];
3828 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3829 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3830 ttText
->lpszText
= buf
;
3836 #endif // wxUSE_TOOLTIPS
3838 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3840 WXLPARAM
* WXUNUSED(result
))
3845 NMHDR
* hdr
= (NMHDR
*)lParam
;
3846 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3853 wxUnusedVar(lParam
);
3854 #endif // wxUSE_TOOLTIPS
3859 // ---------------------------------------------------------------------------
3860 // end session messages
3861 // ---------------------------------------------------------------------------
3863 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3865 #ifdef ENDSESSION_LOGOFF
3866 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3867 event
.SetEventObject(wxTheApp
);
3868 event
.SetCanVeto(true);
3869 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3871 bool rc
= wxTheApp
->ProcessEvent(event
);
3875 // we may end only if the app didn't veto session closing (double
3877 *mayEnd
= !event
.GetVeto();
3882 wxUnusedVar(logOff
);
3883 wxUnusedVar(mayEnd
);
3888 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3890 #ifdef ENDSESSION_LOGOFF
3891 // do nothing if the session isn't ending
3896 if ( (this != wxTheApp
->GetTopWindow()) )
3899 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3900 event
.SetEventObject(wxTheApp
);
3901 event
.SetCanVeto(false);
3902 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3904 return wxTheApp
->ProcessEvent(event
);
3906 wxUnusedVar(endSession
);
3907 wxUnusedVar(logOff
);
3912 // ---------------------------------------------------------------------------
3913 // window creation/destruction
3914 // ---------------------------------------------------------------------------
3916 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3919 // VZ: why is this commented out for WinCE? If it doesn't support
3920 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3921 // not with multiple #ifdef's!
3923 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3924 EnsureParentHasControlParentStyle(GetParent());
3925 #endif // !__WXWINCE__
3932 bool wxWindowMSW::HandleDestroy()
3936 // delete our drop target if we've got one
3937 #if wxUSE_DRAG_AND_DROP
3938 if ( m_dropTarget
!= NULL
)
3940 m_dropTarget
->Revoke(m_hWnd
);
3942 delete m_dropTarget
;
3943 m_dropTarget
= NULL
;
3945 #endif // wxUSE_DRAG_AND_DROP
3947 // WM_DESTROY handled
3951 // ---------------------------------------------------------------------------
3953 // ---------------------------------------------------------------------------
3955 bool wxWindowMSW::HandleActivate(int state
,
3956 bool WXUNUSED(minimized
),
3957 WXHWND
WXUNUSED(activate
))
3959 wxActivateEvent
event(wxEVT_ACTIVATE
,
3960 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3962 event
.SetEventObject(this);
3964 return HandleWindowEvent(event
);
3967 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3969 // Strangly enough, some controls get set focus events when they are being
3970 // deleted, even if they already had focus before.
3971 if ( m_isBeingDeleted
)
3976 // notify the parent keeping track of focus for the kbd navigation
3977 // purposes that we got it
3978 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3979 (void)HandleWindowEvent(eventFocus
);
3985 m_caret
->OnSetFocus();
3987 #endif // wxUSE_CARET
3990 // If it's a wxTextCtrl don't send the event as it will be done
3991 // after the control gets to process it from EN_FOCUS handler
3992 if ( wxDynamicCastThis(wxTextCtrl
) )
3996 #endif // wxUSE_TEXTCTRL
3998 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3999 event
.SetEventObject(this);
4001 // wxFindWinFromHandle() may return NULL, it is ok
4002 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4004 return HandleWindowEvent(event
);
4007 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4013 m_caret
->OnKillFocus();
4015 #endif // wxUSE_CARET
4018 // If it's a wxTextCtrl don't send the event as it will be done
4019 // after the control gets to process it.
4020 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
4027 // Don't send the event when in the process of being deleted. This can
4028 // only cause problems if the event handler tries to access the object.
4029 if ( m_isBeingDeleted
)
4034 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4035 event
.SetEventObject(this);
4037 // wxFindWinFromHandle() may return NULL, it is ok
4038 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4040 return HandleWindowEvent(event
);
4043 // ---------------------------------------------------------------------------
4045 // ---------------------------------------------------------------------------
4047 void wxWindowMSW::SetLabel( const wxString
& label
)
4049 SetWindowText(GetHwnd(), label
.c_str());
4052 wxString
wxWindowMSW::GetLabel() const
4054 return wxGetWindowText(GetHWND());
4057 // ---------------------------------------------------------------------------
4059 // ---------------------------------------------------------------------------
4061 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4063 wxShowEvent
event(GetId(), show
);
4064 event
.SetEventObject(this);
4066 return HandleWindowEvent(event
);
4069 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4071 wxInitDialogEvent
event(GetId());
4072 event
.SetEventObject(this);
4074 return HandleWindowEvent(event
);
4077 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4079 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4080 wxUnusedVar(wParam
);
4082 #else // __WXMICROWIN__
4083 HDROP hFilesInfo
= (HDROP
) wParam
;
4085 // Get the total number of files dropped
4086 UINT gwFilesDropped
= ::DragQueryFile
4094 wxString
*files
= new wxString
[gwFilesDropped
];
4095 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4097 // first get the needed buffer length (+1 for terminating NUL)
4098 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4100 // and now get the file name
4101 ::DragQueryFile(hFilesInfo
, wIndex
,
4102 wxStringBuffer(files
[wIndex
], len
), len
);
4104 DragFinish (hFilesInfo
);
4106 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4107 event
.SetEventObject(this);
4110 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4111 event
.m_pos
.x
= dropPoint
.x
;
4112 event
.m_pos
.y
= dropPoint
.y
;
4114 return HandleWindowEvent(event
);
4119 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4121 int WXUNUSED(mouseMsg
))
4123 #ifndef __WXMICROWIN__
4124 // the logic is as follows:
4125 // 0. if we're busy, set the busy cursor (even for non client elements)
4126 // 1. don't set custom cursor for non client area of enabled windows
4127 // 2. ask user EVT_SET_CURSOR handler for the cursor
4128 // 3. if still no cursor but we're in a TLW, set the global cursor
4130 HCURSOR hcursor
= 0;
4133 hcursor
= wxGetCurrentBusyCursor();
4137 if ( nHitTest
!= HTCLIENT
)
4140 // first ask the user code - it may wish to set the cursor in some very
4141 // specific way (for example, depending on the current position)
4144 if ( !::GetCursorPosWinCE(&pt
))
4146 if ( !::GetCursorPos(&pt
) )
4149 wxLogLastError(wxT("GetCursorPos"));
4154 ScreenToClient(&x
, &y
);
4155 wxSetCursorEvent
event(x
, y
);
4157 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4158 if ( processedEvtSetCursor
&& event
.HasCursor() )
4160 hcursor
= GetHcursorOf(event
.GetCursor());
4165 // the test for processedEvtSetCursor is here to prevent using
4166 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4167 // nothing from it - this is a way to say that our cursor shouldn't
4168 // be used for this point
4169 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4171 hcursor
= GetHcursorOf(m_cursor
);
4174 if ( !hcursor
&& !GetParent() )
4176 const wxCursor
*cursor
= wxGetGlobalCursor();
4177 if ( cursor
&& cursor
->Ok() )
4179 hcursor
= GetHcursorOf(*cursor
);
4188 ::SetCursor(hcursor
);
4190 // cursor set, stop here
4193 #endif // __WXMICROWIN__
4195 // pass up the window chain
4199 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4200 WXLPARAM
WXUNUSED(lParam
),
4201 bool *WXUNUSED_IN_WINCE(vetoed
))
4207 wxEventType evtType
;
4210 case PBT_APMQUERYSUSPEND
:
4211 evtType
= wxEVT_POWER_SUSPENDING
;
4214 case PBT_APMQUERYSUSPENDFAILED
:
4215 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4218 case PBT_APMSUSPEND
:
4219 evtType
= wxEVT_POWER_SUSPENDED
;
4222 case PBT_APMRESUMESUSPEND
:
4223 #ifdef PBT_APMRESUMEAUTOMATIC
4224 case PBT_APMRESUMEAUTOMATIC
:
4226 evtType
= wxEVT_POWER_RESUME
;
4230 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4233 // these messages are currently not mapped to wx events
4234 case PBT_APMQUERYSTANDBY
:
4235 case PBT_APMQUERYSTANDBYFAILED
:
4236 case PBT_APMSTANDBY
:
4237 case PBT_APMRESUMESTANDBY
:
4238 case PBT_APMBATTERYLOW
:
4239 case PBT_APMPOWERSTATUSCHANGE
:
4240 case PBT_APMOEMEVENT
:
4241 case PBT_APMRESUMECRITICAL
:
4242 evtType
= wxEVT_NULL
;
4246 // don't handle unknown messages
4247 if ( evtType
== wxEVT_NULL
)
4250 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4252 wxPowerEvent
event(evtType
);
4253 if ( !HandleWindowEvent(event
) )
4256 *vetoed
= event
.IsVetoed();
4262 bool wxWindowMSW::IsDoubleBuffered() const
4264 for ( const wxWindowMSW
*wnd
= this;
4265 wnd
&& !wnd
->IsTopLevel(); wnd
=
4268 if ( ::GetWindowLong(GetHwndOf(wnd
), GWL_EXSTYLE
) & WS_EX_COMPOSITED
)
4275 // ---------------------------------------------------------------------------
4276 // owner drawn stuff
4277 // ---------------------------------------------------------------------------
4279 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4280 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4281 #define WXUNUSED_UNLESS_ODRAWN(param) param
4283 #define WXUNUSED_UNLESS_ODRAWN(param)
4287 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4288 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4290 #if wxUSE_OWNER_DRAWN
4292 #if wxUSE_MENUS_NATIVE
4293 // is it a menu item?
4294 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4295 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4297 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4299 // see comment before the same test in MSWOnMeasureItem() below
4303 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4304 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
4306 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4307 // the DC from being released
4308 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4309 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4310 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4311 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4313 return pMenuItem
->OnDrawItem
4317 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4318 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4321 #endif // wxUSE_MENUS_NATIVE
4323 #endif // USE_OWNER_DRAWN
4325 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4327 #if wxUSE_OWNER_DRAWN
4328 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4329 #else // !wxUSE_OWNER_DRAWN
4330 // we may still have owner-drawn buttons internally because we have to make
4331 // them owner-drawn to support colour change
4334 wxDynamicCast(FindItem(id
), wxButton
)
4339 #endif // USE_OWNER_DRAWN
4343 return item
->MSWOnDraw(itemStruct
);
4346 #endif // wxUSE_CONTROLS
4352 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4354 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4355 // is it a menu item?
4356 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4357 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4359 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4361 // according to Carsten Fuchs the pointer may be NULL under XP if an
4362 // MDI child frame is initially maximized, see this for more info:
4363 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4365 // so silently ignore it instead of asserting
4369 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4370 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4373 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4375 pMeasureStruct
->itemWidth
= w
;
4376 pMeasureStruct
->itemHeight
= h
;
4381 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4384 return item
->MSWOnMeasure(itemStruct
);
4388 wxUnusedVar(itemStruct
);
4389 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4394 // ---------------------------------------------------------------------------
4395 // colours and palettes
4396 // ---------------------------------------------------------------------------
4398 bool wxWindowMSW::HandleSysColorChange()
4400 wxSysColourChangedEvent event
;
4401 event
.SetEventObject(this);
4403 (void)HandleWindowEvent(event
);
4405 // always let the system carry on the default processing to allow the
4406 // native controls to react to the colours update
4410 bool wxWindowMSW::HandleDisplayChange()
4412 wxDisplayChangedEvent event
;
4413 event
.SetEventObject(this);
4415 return HandleWindowEvent(event
);
4418 #ifndef __WXMICROWIN__
4420 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4422 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4426 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4429 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4431 #endif // wxUSE_CONTROLS
4434 return *brush
!= NULL
;
4437 #endif // __WXMICROWIN__
4439 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4442 // same as below except we don't respond to our own messages
4443 if ( hWndPalChange
!= GetHWND() )
4445 // check to see if we our our parents have a custom palette
4446 wxWindowMSW
*win
= this;
4447 while ( win
&& !win
->HasCustomPalette() )
4449 win
= win
->GetParent();
4452 if ( win
&& win
->HasCustomPalette() )
4454 // realize the palette to see whether redrawing is needed
4455 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4456 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4457 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4459 int result
= ::RealizePalette(hdc
);
4461 // restore the palette (before releasing the DC)
4462 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4463 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4464 ::RealizePalette(hdc
);
4465 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4467 // now check for the need to redraw
4469 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4473 #endif // wxUSE_PALETTE
4475 wxPaletteChangedEvent
event(GetId());
4476 event
.SetEventObject(this);
4477 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4479 return HandleWindowEvent(event
);
4482 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4484 // notify windows on the capture stack about lost capture
4485 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4486 wxWindowBase::NotifyCaptureLost();
4488 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4489 wxMouseCaptureChangedEvent
event(GetId(), win
);
4490 event
.SetEventObject(this);
4491 return HandleWindowEvent(event
);
4494 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4496 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4497 // we need to send this to child windows (it is only sent to top-level
4498 // windows) so {list,tree}ctrls can adjust their font size if necessary
4499 // this is exactly how explorer does it to enable the font size changes
4501 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4504 // top-level windows already get this message from the system
4505 wxWindow
*win
= node
->GetData();
4506 if ( !win
->IsTopLevel() )
4508 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4511 node
= node
->GetNext();
4514 // let the system handle it
4518 bool wxWindowMSW::HandleQueryNewPalette()
4522 // check to see if we our our parents have a custom palette
4523 wxWindowMSW
*win
= this;
4524 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4525 if (win
->HasCustomPalette()) {
4526 /* realize the palette to see whether redrawing is needed */
4527 HDC hdc
= ::GetDC((HWND
) GetHWND());
4528 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4529 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4531 int result
= ::RealizePalette(hdc
);
4532 /* restore the palette (before releasing the DC) */
4533 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4534 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4535 ::RealizePalette(hdc
);
4536 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4537 /* now check for the need to redraw */
4539 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4541 #endif // wxUSE_PALETTE
4543 wxQueryNewPaletteEvent
event(GetId());
4544 event
.SetEventObject(this);
4546 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4549 // Responds to colour changes: passes event on to children.
4550 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4552 // the top level window also reset the standard colour map as it might have
4553 // changed (there is no need to do it for the non top level windows as we
4554 // only have to do it once)
4558 gs_hasStdCmap
= false;
4560 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4563 // Only propagate to non-top-level windows because Windows already
4564 // sends this event to all top-level ones
4565 wxWindow
*win
= node
->GetData();
4566 if ( !win
->IsTopLevel() )
4568 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4569 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4570 // the standard controls
4571 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4574 node
= node
->GetNext();
4578 extern wxCOLORMAP
*wxGetStdColourMap()
4580 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4581 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4583 if ( !gs_hasStdCmap
)
4585 static bool s_coloursInit
= false;
4587 if ( !s_coloursInit
)
4589 // When a bitmap is loaded, the RGB values can change (apparently
4590 // because Windows adjusts them to care for the old programs always
4591 // using 0xc0c0c0 while the transparent colour for the new Windows
4592 // versions is different). But we do this adjustment ourselves so
4593 // we want to avoid Windows' "help" and for this we need to have a
4594 // reference bitmap which can tell us what the RGB values change
4596 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4597 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4598 if ( stdColourBitmap
.Ok() )
4600 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4601 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4602 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4605 memDC
.SelectObject(stdColourBitmap
);
4608 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4610 memDC
.GetPixel(i
, 0, &colour
);
4611 s_stdColours
[i
] = wxColourToRGB(colour
);
4614 else // wxBITMAP_STD_COLOURS couldn't be loaded
4616 s_stdColours
[0] = RGB(000,000,000); // black
4617 s_stdColours
[1] = RGB(128,128,128); // dark grey
4618 s_stdColours
[2] = RGB(192,192,192); // light grey
4619 s_stdColours
[3] = RGB(255,255,255); // white
4620 //s_stdColours[4] = RGB(000,000,255); // blue
4621 //s_stdColours[5] = RGB(255,000,255); // magenta
4624 s_coloursInit
= true;
4627 gs_hasStdCmap
= true;
4629 // create the colour map
4630 #define INIT_CMAP_ENTRY(col) \
4631 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4632 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4634 INIT_CMAP_ENTRY(BTNTEXT
);
4635 INIT_CMAP_ENTRY(BTNSHADOW
);
4636 INIT_CMAP_ENTRY(BTNFACE
);
4637 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4639 #undef INIT_CMAP_ENTRY
4645 // ---------------------------------------------------------------------------
4647 // ---------------------------------------------------------------------------
4649 bool wxWindowMSW::HandlePaint()
4651 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4653 wxLogLastError(wxT("CreateRectRgn"));
4654 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4655 wxLogLastError(wxT("GetUpdateRgn"));
4657 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4659 wxPaintEvent
event(m_windowId
);
4660 event
.SetEventObject(this);
4662 bool processed
= HandleWindowEvent(event
);
4664 // note that we must generate NC event after the normal one as otherwise
4665 // BeginPaint() will happily overwrite our decorations with the background
4667 wxNcPaintEvent
eventNc(m_windowId
);
4668 eventNc
.SetEventObject(this);
4669 HandleWindowEvent(eventNc
);
4671 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4672 // be called from inside the event handlers called above)
4673 m_updateRegion
.Clear();
4678 // Can be called from an application's OnPaint handler
4679 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4681 #ifdef __WXUNIVERSAL__
4684 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4687 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4692 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4694 wxDCTemp
dc(hdc
, GetClientSize());
4695 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4698 impl
->SetWindow((wxWindow
*)this);
4700 wxEraseEvent
event(m_windowId
, &dc
);
4701 event
.SetEventObject(this);
4702 bool rc
= HandleWindowEvent(event
);
4704 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4705 impl
->SelectOldObjects(hdc
);
4710 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4712 // standard non top level controls (i.e. except the dialogs) always erase
4713 // their background themselves in HandleCtlColor() or have some control-
4714 // specific ways to set the colours (common controls)
4715 if ( IsOfStandardClass() && !IsTopLevel() )
4721 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4723 // don't skip the event here, custom background means that the app
4724 // is drawing it itself in its OnPaint(), so don't draw it at all
4725 // now to avoid flicker
4729 wxDC
*dc
= event
.GetDC();
4731 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
->GetImpl();
4733 // do default background painting
4734 if ( !DoEraseBackground(GetHdcOf(*impl
)) )
4736 // let the system paint the background
4741 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4743 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4747 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4753 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4757 // our background colour applies to:
4758 // 1. this window itself, always
4759 // 2. all children unless the colour is "not inheritable"
4760 // 3. even if it is not inheritable, our immediate transparent
4761 // children should still inherit it -- but not any transparent
4762 // children because it would look wrong if a child of non
4763 // transparent child would show our bg colour when the child itself
4765 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4768 (win
&& win
->HasTransparentBackground() &&
4769 win
->GetParent() == this) )
4771 // draw children with the same colour as the parent
4773 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4775 return (WXHBRUSH
)GetHbrushOf(*brush
);
4782 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4785 hWndToPaint
= GetHWND();
4787 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4789 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4793 // background is not inherited beyond top level windows
4794 if ( win
->IsTopLevel() )
4801 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4803 // we receive this message when DrawThemeParentBackground() is
4804 // called from def window proc of several controls under XP and we
4805 // must draw properly themed background here
4807 // note that naively I'd expect filling the client rect with the
4808 // brush returned by MSWGetBgBrush() work -- but for some reason it
4809 // doesn't and we have to call parents MSWPrintChild() which is
4810 // supposed to call DrawThemeBackground() with appropriate params
4812 // also note that in this case lParam == PRF_CLIENT but we're
4813 // clearly expected to paint the background and nothing else!
4815 if ( IsTopLevel() || InheritsBackgroundColour() )
4818 // sometimes we don't want the parent to handle it at all, instead
4819 // return whatever value this window wants
4820 if ( !MSWShouldPropagatePrintChild() )
4821 return MSWPrintChild(hDC
, (wxWindow
*)this);
4823 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4825 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4828 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4835 // ---------------------------------------------------------------------------
4836 // moving and resizing
4837 // ---------------------------------------------------------------------------
4839 bool wxWindowMSW::HandleMinimize()
4841 wxIconizeEvent
event(m_windowId
);
4842 event
.SetEventObject(this);
4844 return HandleWindowEvent(event
);
4847 bool wxWindowMSW::HandleMaximize()
4849 wxMaximizeEvent
event(m_windowId
);
4850 event
.SetEventObject(this);
4852 return HandleWindowEvent(event
);
4855 bool wxWindowMSW::HandleMove(int x
, int y
)
4858 wxMoveEvent
event(point
, m_windowId
);
4859 event
.SetEventObject(this);
4861 return HandleWindowEvent(event
);
4864 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4866 wxMoveEvent
event(rect
, m_windowId
);
4867 event
.SetEventObject(this);
4869 bool rc
= HandleWindowEvent(event
);
4871 rect
= event
.GetRect();
4875 bool wxWindowMSW::HandleEnterSizeMove()
4877 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4878 event
.SetEventType(wxEVT_MOVE_START
);
4879 event
.SetEventObject(this);
4881 return HandleWindowEvent(event
);
4884 bool wxWindowMSW::HandleExitSizeMove()
4886 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4887 event
.SetEventType(wxEVT_MOVE_END
);
4888 event
.SetEventObject(this);
4890 return HandleWindowEvent(event
);
4893 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4895 #if USE_DEFERRED_SIZING
4896 // when we resize this window, its children are probably going to be
4897 // repositioned as well, prepare to use DeferWindowPos() for them
4898 int numChildren
= 0;
4899 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4901 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4906 // Protect against valid m_hDWP being overwritten
4907 bool useDefer
= false;
4909 if ( numChildren
> 1 )
4913 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4916 wxLogLastError(_T("BeginDeferWindowPos"));
4922 #endif // USE_DEFERRED_SIZING
4924 // update this window size
4925 bool processed
= false;
4929 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4930 // fall through nevertheless
4934 // we're not interested in these messages at all
4937 case SIZE_MINIMIZED
:
4938 processed
= HandleMinimize();
4941 case SIZE_MAXIMIZED
:
4942 /* processed = */ HandleMaximize();
4943 // fall through to send a normal size event as well
4946 // don't use w and h parameters as they specify the client size
4947 // while according to the docs EVT_SIZE handler is supposed to
4948 // receive the total size
4949 wxSizeEvent
event(GetSize(), m_windowId
);
4950 event
.SetEventObject(this);
4952 processed
= HandleWindowEvent(event
);
4955 #if USE_DEFERRED_SIZING
4956 // and finally change the positions of all child windows at once
4957 if ( useDefer
&& m_hDWP
)
4959 // reset m_hDWP to NULL so that child windows don't try to use our
4960 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4961 // happen anyhow normally but who knows what weird flow of control we
4962 // may have depending on what the users EVT_SIZE handler does...)
4963 HDWP hDWP
= (HDWP
)m_hDWP
;
4966 // do put all child controls in place at once
4967 if ( !::EndDeferWindowPos(hDWP
) )
4969 wxLogLastError(_T("EndDeferWindowPos"));
4972 // Reset our children's pending pos/size values.
4973 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4975 node
= node
->GetNext() )
4977 wxWindowMSW
*child
= node
->GetData();
4978 child
->m_pendingPosition
= wxDefaultPosition
;
4979 child
->m_pendingSize
= wxDefaultSize
;
4982 #endif // USE_DEFERRED_SIZING
4987 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4989 wxSizeEvent
event(rect
, m_windowId
);
4990 event
.SetEventObject(this);
4992 bool rc
= HandleWindowEvent(event
);
4994 rect
= event
.GetRect();
4998 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5003 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5007 int minWidth
= GetMinWidth(),
5008 minHeight
= GetMinHeight(),
5009 maxWidth
= GetMaxWidth(),
5010 maxHeight
= GetMaxHeight();
5012 if ( minWidth
!= wxDefaultCoord
)
5014 info
->ptMinTrackSize
.x
= minWidth
;
5018 if ( minHeight
!= wxDefaultCoord
)
5020 info
->ptMinTrackSize
.y
= minHeight
;
5024 if ( maxWidth
!= wxDefaultCoord
)
5026 info
->ptMaxTrackSize
.x
= maxWidth
;
5030 if ( maxHeight
!= wxDefaultCoord
)
5032 info
->ptMaxTrackSize
.y
= maxHeight
;
5040 // ---------------------------------------------------------------------------
5042 // ---------------------------------------------------------------------------
5044 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5046 // sign extend to int from short before comparing with the other int ids
5047 int id
= (signed short)id_
;
5049 #if wxUSE_MENUS_NATIVE
5050 if ( !cmd
&& wxCurrentPopupMenu
)
5052 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5053 wxCurrentPopupMenu
= NULL
;
5055 return popupMenu
->MSWCommand(cmd
, id
);
5057 #endif // wxUSE_MENUS_NATIVE
5059 wxWindow
*win
= NULL
;
5061 // first try to find it from HWND - this works even with the broken
5062 // programs using the same ids for different controls
5065 win
= wxFindWinFromHandle(control
);
5076 return win
->MSWCommand(cmd
, id
);
5079 // the messages sent from the in-place edit control used by the treectrl
5080 // for label editing have id == 0, but they should _not_ be treated as menu
5081 // messages (they are EN_XXX ones, in fact) so don't translate anything
5082 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5085 // If no child window, it may be an accelerator, e.g. for a popup menu
5088 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
5089 event
.SetEventObject(this);
5093 return HandleWindowEvent(event
);
5097 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5098 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5099 // notifications to its parent which we want to reflect back to
5101 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5102 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5104 #endif // wxUSE_SPINCTRL
5106 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5107 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5108 // notifications to its parent which we want to reflect back to
5110 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5111 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5119 // ---------------------------------------------------------------------------
5121 // ---------------------------------------------------------------------------
5123 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5127 // our client coords are not quite the same as Windows ones
5128 wxPoint pt
= GetClientAreaOrigin();
5129 event
.m_x
= x
- pt
.x
;
5130 event
.m_y
= y
- pt
.y
;
5132 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5133 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5134 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5135 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5136 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5137 #ifdef wxHAS_XBUTTON
5138 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5139 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5140 #endif // wxHAS_XBUTTON
5141 event
.m_altDown
= ::wxIsAltDown();
5144 event
.SetTimestamp(::GetMessageTime());
5147 event
.SetEventObject(this);
5148 event
.SetId(GetId());
5150 #if wxUSE_MOUSEEVENT_HACK
5151 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5152 gs_lastMouseEvent
.type
= event
.GetEventType();
5153 #endif // wxUSE_MOUSEEVENT_HACK
5157 // Windows doesn't send the mouse events to the static controls (which are
5158 // transparent in the sense that their WM_NCHITTEST handler returns
5159 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5160 // and so we manually check if we don't have a child window under mouse and if
5161 // we do, send the event to it instead of the window Windows had sent WM_XXX
5164 // Notice that this is not done for the mouse move events because this could
5165 // (would?) be too slow, but only for clicks which means that the static texts
5166 // still don't get move, enter nor leave events.
5167 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5169 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
5171 // first try to find a non transparent child: this allows us to send events
5172 // to a static text which is inside a static box, for example
5173 POINT pt
= { *x
, *y
};
5174 HWND hwnd
= GetHwndOf(win
),
5178 hwndUnderMouse
= ::ChildWindowFromPoint
5184 hwndUnderMouse
= ::ChildWindowFromPointEx
5194 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5196 // now try any child window at all
5197 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5200 // check that we have a child window which is susceptible to receive mouse
5201 // events: for this it must be shown and enabled
5202 if ( hwndUnderMouse
&&
5203 hwndUnderMouse
!= hwnd
&&
5204 ::IsWindowVisible(hwndUnderMouse
) &&
5205 ::IsWindowEnabled(hwndUnderMouse
) )
5207 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
5208 if ( winUnderMouse
)
5210 // translate the mouse coords to the other window coords
5211 win
->ClientToScreen(x
, y
);
5212 winUnderMouse
->ScreenToClient(x
, y
);
5214 win
= winUnderMouse
;
5220 #endif // __WXWINCE__
5222 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5224 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5225 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5226 // from the message id and take the value in the table to get wxWin event
5228 static const wxEventType eventsMouse
[] =
5239 wxEVT_MIDDLE_DCLICK
,
5240 0, // this one is for wxEVT_MOTION which is not used here
5249 #ifdef wxHAS_XBUTTON
5250 // the same messages are used for both auxillary mouse buttons so we need
5251 // to adjust the index manually
5254 case WM_XBUTTONDOWN
:
5256 case WM_XBUTTONDBLCLK
:
5257 if ( flags
& MK_XBUTTON2
)
5258 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5260 #endif // wxHAS_XBUTTON
5262 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5263 InitMouseEvent(event
, x
, y
, flags
);
5265 return HandleWindowEvent(event
);
5268 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5270 if ( !m_mouseInWindow
)
5272 // it would be wrong to assume that just because we get a mouse move
5273 // event that the mouse is inside the window: although this is usually
5274 // true, it is not if we had captured the mouse, so we need to check
5275 // the mouse coordinates here
5276 if ( !HasCapture() || IsMouseInWindow() )
5278 // Generate an ENTER event
5279 m_mouseInWindow
= true;
5281 #ifdef HAVE_TRACKMOUSEEVENT
5282 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5284 static const _TrackMouseEvent_t
5285 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5286 #else // !__WXWINCE__
5287 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5288 static bool s_initDone
= false;
5293 wxDynamicLibrary
dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM
);
5294 if ( dllComCtl32
.IsLoaded() )
5296 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5297 dllComCtl32
.GetSymbol(_T("_TrackMouseEvent"));
5302 // notice that it's ok to unload comctl32.dll here as it won't
5303 // be really unloaded, being still in use because we link to it
5307 if ( s_pfn_TrackMouseEvent
)
5308 #endif // __WXWINCE__/!__WXWINCE__
5310 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5312 trackinfo
.dwFlags
= TME_LEAVE
;
5313 trackinfo
.hwndTrack
= GetHwnd();
5315 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5317 #endif // HAVE_TRACKMOUSEEVENT
5319 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5320 InitMouseEvent(event
, x
, y
, flags
);
5322 (void)HandleWindowEvent(event
);
5325 #ifdef HAVE_TRACKMOUSEEVENT
5326 else // mouse not in window
5328 // Check if we need to send a LEAVE event
5329 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5330 // send it here if we are using native mouse leave tracking
5331 if ( HasCapture() && !IsMouseInWindow() )
5333 GenerateMouseLeave();
5336 #endif // HAVE_TRACKMOUSEEVENT
5338 #if wxUSE_MOUSEEVENT_HACK
5339 // Windows often generates mouse events even if mouse position hasn't
5340 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5342 // Filter this out as it can result in unexpected behaviour compared to
5344 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5345 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5346 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5347 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5349 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5351 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5356 #endif // wxUSE_MOUSEEVENT_HACK
5358 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5362 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5364 #if wxUSE_MOUSEWHEEL
5365 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5366 // forwarded up to the parent by DefWindowProc()) and not in the client
5367 // ones as all the other messages, translate them to the client coords for
5370 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5371 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5372 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5373 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5374 event
.m_wheelDelta
= WHEEL_DELTA
;
5376 static int s_linesPerRotation
= -1;
5377 if ( s_linesPerRotation
== -1 )
5379 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5380 &s_linesPerRotation
, 0))
5382 // this is not supposed to happen
5383 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5385 // the default is 3, so use it if SystemParametersInfo() failed
5386 s_linesPerRotation
= 3;
5390 event
.m_linesPerAction
= s_linesPerRotation
;
5391 return HandleWindowEvent(event
);
5393 #else // !wxUSE_MOUSEWHEEL
5394 wxUnusedVar(wParam
);
5395 wxUnusedVar(lParam
);
5398 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5401 void wxWindowMSW::GenerateMouseLeave()
5403 m_mouseInWindow
= false;
5406 if ( wxIsShiftDown() )
5408 if ( wxIsCtrlDown() )
5409 state
|= MK_CONTROL
;
5411 // Only the high-order bit should be tested
5412 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5413 state
|= MK_LBUTTON
;
5414 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5415 state
|= MK_MBUTTON
;
5416 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5417 state
|= MK_RBUTTON
;
5421 if ( !::GetCursorPosWinCE(&pt
) )
5423 if ( !::GetCursorPos(&pt
) )
5426 wxLogLastError(_T("GetCursorPos"));
5429 // we need to have client coordinates here for symmetry with
5430 // wxEVT_ENTER_WINDOW
5431 RECT rect
= wxGetWindowRect(GetHwnd());
5435 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5436 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5438 (void)HandleWindowEvent(event
);
5441 // ---------------------------------------------------------------------------
5442 // keyboard handling
5443 // ---------------------------------------------------------------------------
5445 // create the key event of the given type for the given key - used by
5446 // HandleChar and HandleKeyDown/Up
5447 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5450 WXWPARAM wParam
) const
5452 wxKeyEvent
event(evType
);
5453 event
.SetId(GetId());
5454 event
.m_shiftDown
= wxIsShiftDown();
5455 event
.m_controlDown
= wxIsCtrlDown();
5456 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5458 event
.SetEventObject((wxWindow
*)this); // const_cast
5459 event
.m_keyCode
= id
;
5461 event
.m_uniChar
= (wxChar
) wParam
;
5463 event
.m_rawCode
= (wxUint32
) wParam
;
5464 event
.m_rawFlags
= (wxUint32
) lParam
;
5466 event
.SetTimestamp(::GetMessageTime());
5469 // translate the position to client coords
5472 GetCursorPosWinCE(&pt
);
5477 GetWindowRect(GetHwnd(),&rect
);
5487 // isASCII is true only when we're called from WM_CHAR handler and not from
5489 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5496 else // we're called from WM_KEYDOWN
5498 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5499 // to get numpad key codes: CHAR events should use the logical keys
5500 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5501 id
= wxCharCodeMSWToWX(wParam
);
5504 // it's ASCII and will be processed here only when called from
5505 // WM_CHAR (i.e. when isASCII = true), don't process it now
5510 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5512 // the alphanumeric keys produced by pressing AltGr+something on European
5513 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5514 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5515 // alphanumeric, so pretend that there are no modifiers at all (the
5516 // KEY_DOWN event would still have the correct modifiers if they're really
5518 if ( event
.m_controlDown
&& event
.m_altDown
&&
5519 (id
>= 32 && id
< 256) )
5521 event
.m_controlDown
=
5522 event
.m_altDown
= false;
5525 return HandleWindowEvent(event
);
5528 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5530 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5534 // normal ASCII char
5538 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5539 return HandleWindowEvent(event
);
5542 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5544 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5548 // normal ASCII char
5552 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5553 return HandleWindowEvent(event
);
5557 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5558 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5560 // FIXME: implement GetMenuItemCount for WinCE, possibly
5561 // in terms of GetMenuItemInfo
5563 const HMENU hmenu
= (HMENU
)lParam
;
5567 mii
.cbSize
= sizeof(MENUITEMINFO
);
5569 // we could use MIIM_FTYPE here as we only need to know if the item is
5570 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5571 // MIIM_FTYPE is not supported under Win95
5572 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5574 // find if we have this letter in any owner drawn item
5575 const int count
= ::GetMenuItemCount(hmenu
);
5576 for ( int i
= 0; i
< count
; i
++ )
5578 // previous loop iteration could modify it, reset it back before
5579 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5582 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5584 if ( mii
.fType
== MFT_OWNERDRAW
)
5586 // dwItemData member of the MENUITEMINFO is a
5587 // pointer to the associated wxMenuItem -- see the
5588 // menu creation code
5589 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5591 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), _T('&'));
5594 if ( *p
== _T('&') )
5596 // this is not the accel char, find the real one
5597 p
= wxStrchr(p
+ 1, _T('&'));
5599 else // got the accel char
5601 // FIXME-UNICODE: this comparison doesn't risk to work
5602 // for non ASCII accelerator characters I'm afraid, but
5604 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5610 // this one doesn't match
5617 else // failed to get the menu text?
5619 // it's not fatal, so don't show error, but still log it
5620 wxLogLastError(_T("GetMenuItemInfo"));
5627 bool wxWindowMSW::HandleClipboardEvent( WXUINT nMsg
)
5629 const wxEventType type
= ( nMsg
== WM_CUT
) ? wxEVT_COMMAND_TEXT_CUT
:
5630 ( nMsg
== WM_COPY
) ? wxEVT_COMMAND_TEXT_COPY
:
5631 /*( nMsg == WM_PASTE ) ? */ wxEVT_COMMAND_TEXT_PASTE
;
5632 wxClipboardTextEvent
evt(type
, GetId());
5634 evt
.SetEventObject(this);
5636 return HandleWindowEvent(evt
);
5638 #endif // wxUSE_MENUS
5640 // ---------------------------------------------------------------------------
5642 // ---------------------------------------------------------------------------
5644 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5648 if ( flags
& JOY_BUTTON1CHG
)
5649 change
= wxJOY_BUTTON1
;
5650 if ( flags
& JOY_BUTTON2CHG
)
5651 change
= wxJOY_BUTTON2
;
5652 if ( flags
& JOY_BUTTON3CHG
)
5653 change
= wxJOY_BUTTON3
;
5654 if ( flags
& JOY_BUTTON4CHG
)
5655 change
= wxJOY_BUTTON4
;
5658 if ( flags
& JOY_BUTTON1
)
5659 buttons
|= wxJOY_BUTTON1
;
5660 if ( flags
& JOY_BUTTON2
)
5661 buttons
|= wxJOY_BUTTON2
;
5662 if ( flags
& JOY_BUTTON3
)
5663 buttons
|= wxJOY_BUTTON3
;
5664 if ( flags
& JOY_BUTTON4
)
5665 buttons
|= wxJOY_BUTTON4
;
5667 // the event ids aren't consecutive so we can't use table based lookup
5669 wxEventType eventType
;
5674 eventType
= wxEVT_JOY_MOVE
;
5679 eventType
= wxEVT_JOY_MOVE
;
5684 eventType
= wxEVT_JOY_ZMOVE
;
5689 eventType
= wxEVT_JOY_ZMOVE
;
5692 case MM_JOY1BUTTONDOWN
:
5694 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5697 case MM_JOY2BUTTONDOWN
:
5699 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5702 case MM_JOY1BUTTONUP
:
5704 eventType
= wxEVT_JOY_BUTTON_UP
;
5707 case MM_JOY2BUTTONUP
:
5709 eventType
= wxEVT_JOY_BUTTON_UP
;
5713 wxFAIL_MSG(wxT("no such joystick event"));
5718 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5719 event
.SetPosition(wxPoint(x
, y
));
5720 event
.SetEventObject(this);
5722 return HandleWindowEvent(event
);
5732 // ---------------------------------------------------------------------------
5734 // ---------------------------------------------------------------------------
5736 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5737 WXWORD pos
, WXHWND control
)
5739 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5741 wxWindow
*child
= wxFindWinFromHandle(control
);
5743 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5746 wxScrollWinEvent event
;
5747 event
.SetPosition(pos
);
5748 event
.SetOrientation(orientation
);
5749 event
.SetEventObject(this);
5754 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5758 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5762 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5766 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5770 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5774 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5777 case SB_THUMBPOSITION
:
5779 // under Win32, the scrollbar range and position are 32 bit integers,
5780 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5781 // explicitly query the scrollbar for the correct position (this must
5782 // be done only for these two SB_ events as they are the only one
5783 // carrying the scrollbar position)
5785 WinStruct
<SCROLLINFO
> scrollInfo
;
5786 scrollInfo
.fMask
= SIF_TRACKPOS
;
5788 if ( !::GetScrollInfo(GetHwnd(),
5789 orientation
== wxHORIZONTAL
? SB_HORZ
5793 // Not necessarily an error, if there are no scrollbars yet.
5794 // wxLogLastError(_T("GetScrollInfo"));
5797 event
.SetPosition(scrollInfo
.nTrackPos
);
5800 event
.SetEventType( wParam
== SB_THUMBPOSITION
5801 ? wxEVT_SCROLLWIN_THUMBRELEASE
5802 : wxEVT_SCROLLWIN_THUMBTRACK
);
5809 return HandleWindowEvent(event
);
5812 // ----------------------------------------------------------------------------
5813 // custom message handlers
5814 // ----------------------------------------------------------------------------
5817 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5819 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5820 false, _T("registering handler for the same message twice") );
5822 gs_messageHandlers
[msg
] = handler
;
5827 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5829 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5830 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5831 _T("unregistering non-registered handler?") );
5833 gs_messageHandlers
.erase(i
);
5836 // ===========================================================================
5838 // ===========================================================================
5840 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5843 HDC dc
= ::GetDC((HWND
) wnd
);
5846 // the_font.UseResource();
5847 // the_font.RealizeResource();
5848 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5850 was
= (HFONT
) SelectObject(dc
,fnt
);
5852 GetTextMetrics(dc
, &tm
);
5855 SelectObject(dc
,was
);
5857 ReleaseDC((HWND
)wnd
, dc
);
5860 *x
= tm
.tmAveCharWidth
;
5862 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5864 // the_font.ReleaseResource();
5867 // use the "extended" bit (24) of lParam to distinguish extended keys
5868 // from normal keys as the same key is sent
5870 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5872 // except that if lParam is 0, it means we don't have real lParam from
5873 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5874 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5875 // non-numpad (hence extended) key as this is a more common case
5876 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5879 // this array contains the Windows virtual key codes which map one to one to
5880 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5882 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5883 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5884 static const struct wxKeyMapping
5888 } gs_specialKeys
[] =
5890 { VK_CANCEL
, WXK_CANCEL
},
5891 { VK_BACK
, WXK_BACK
},
5892 { VK_TAB
, WXK_TAB
},
5893 { VK_CLEAR
, WXK_CLEAR
},
5894 { VK_SHIFT
, WXK_SHIFT
},
5895 { VK_CONTROL
, WXK_CONTROL
},
5896 { VK_MENU
, WXK_ALT
},
5897 { VK_PAUSE
, WXK_PAUSE
},
5898 { VK_CAPITAL
, WXK_CAPITAL
},
5899 { VK_SPACE
, WXK_SPACE
},
5900 { VK_ESCAPE
, WXK_ESCAPE
},
5901 { VK_SELECT
, WXK_SELECT
},
5902 { VK_PRINT
, WXK_PRINT
},
5903 { VK_EXECUTE
, WXK_EXECUTE
},
5904 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5905 { VK_HELP
, WXK_HELP
},
5907 { VK_NUMPAD0
, WXK_NUMPAD0
},
5908 { VK_NUMPAD1
, WXK_NUMPAD1
},
5909 { VK_NUMPAD2
, WXK_NUMPAD2
},
5910 { VK_NUMPAD3
, WXK_NUMPAD3
},
5911 { VK_NUMPAD4
, WXK_NUMPAD4
},
5912 { VK_NUMPAD5
, WXK_NUMPAD5
},
5913 { VK_NUMPAD6
, WXK_NUMPAD6
},
5914 { VK_NUMPAD7
, WXK_NUMPAD7
},
5915 { VK_NUMPAD8
, WXK_NUMPAD8
},
5916 { VK_NUMPAD9
, WXK_NUMPAD9
},
5917 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5918 { VK_ADD
, WXK_NUMPAD_ADD
},
5919 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5920 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5921 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5932 { VK_F10
, WXK_F10
},
5933 { VK_F11
, WXK_F11
},
5934 { VK_F12
, WXK_F12
},
5935 { VK_F13
, WXK_F13
},
5936 { VK_F14
, WXK_F14
},
5937 { VK_F15
, WXK_F15
},
5938 { VK_F16
, WXK_F16
},
5939 { VK_F17
, WXK_F17
},
5940 { VK_F18
, WXK_F18
},
5941 { VK_F19
, WXK_F19
},
5942 { VK_F20
, WXK_F20
},
5943 { VK_F21
, WXK_F21
},
5944 { VK_F22
, WXK_F22
},
5945 { VK_F23
, WXK_F23
},
5946 { VK_F24
, WXK_F24
},
5948 { VK_NUMLOCK
, WXK_NUMLOCK
},
5949 { VK_SCROLL
, WXK_SCROLL
},
5952 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5953 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5954 { VK_APPS
, WXK_WINDOWS_MENU
},
5955 #endif // VK_APPS defined
5958 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5959 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5960 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5962 // check the table first
5963 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5965 if ( gs_specialKeys
[n
].vk
== vk
)
5966 return gs_specialKeys
[n
].wxk
;
5969 // keys requiring special handling
5973 // the mapping for these keys may be incorrect on non-US keyboards so
5974 // maybe we shouldn't map them to ASCII values at all
5975 case VK_OEM_1
: wxk
= ';'; break;
5976 case VK_OEM_PLUS
: wxk
= '+'; break;
5977 case VK_OEM_COMMA
: wxk
= ','; break;
5978 case VK_OEM_MINUS
: wxk
= '-'; break;
5979 case VK_OEM_PERIOD
: wxk
= '.'; break;
5980 case VK_OEM_2
: wxk
= '/'; break;
5981 case VK_OEM_3
: wxk
= '~'; break;
5982 case VK_OEM_4
: wxk
= '['; break;
5983 case VK_OEM_5
: wxk
= '\\'; break;
5984 case VK_OEM_6
: wxk
= ']'; break;
5985 case VK_OEM_7
: wxk
= '\''; break;
5987 // handle extended keys
5989 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5993 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
5997 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6001 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6005 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6009 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6013 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6017 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6021 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6025 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6029 // don't use ChooseNormalOrExtended() here as the keys are reversed
6030 // here: numpad enter is the extended one
6031 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6041 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
6046 // check the table first
6047 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6049 if ( gs_specialKeys
[n
].wxk
== wxk
)
6050 return gs_specialKeys
[n
].vk
;
6053 // and then check for special keys not included in the table
6058 case WXK_NUMPAD_PAGEUP
:
6063 case WXK_NUMPAD_PAGEDOWN
:
6068 case WXK_NUMPAD_END
:
6073 case WXK_NUMPAD_HOME
:
6078 case WXK_NUMPAD_LEFT
:
6088 case WXK_NUMPAD_RIGHT
:
6093 case WXK_NUMPAD_DOWN
:
6098 case WXK_NUMPAD_INSERT
:
6103 case WXK_NUMPAD_DELETE
:
6117 #ifndef SM_SWAPBUTTON
6118 #define SM_SWAPBUTTON 23
6121 // small helper for wxGetKeyState() and wxGetMouseState()
6122 static inline bool wxIsKeyDown(WXWORD vk
)
6127 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_RBUTTON
;
6130 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_LBUTTON
;
6133 // the low order bit indicates whether the key was pressed since the last
6134 // call and the high order one indicates whether it is down right now and
6135 // we only want that one
6136 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6139 bool wxGetKeyState(wxKeyCode key
)
6141 // although this does work under Windows, it is not supported under other
6142 // platforms so don't allow it, you must use wxGetMouseState() instead
6143 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6144 key
!= VK_RBUTTON
&&
6146 wxT("can't use wxGetKeyState() for mouse buttons") );
6148 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6150 // if the requested key is a LED key, return true if the led is pressed
6151 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6153 // low order bit means LED is highlighted and high order one means the
6154 // key is down; for compatibility with the other ports return true if
6155 // either one is set
6156 return GetKeyState(vk
) != 0;
6161 return wxIsKeyDown(vk
);
6166 wxMouseState
wxGetMouseState()
6170 GetCursorPos( &pt
);
6174 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6175 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6176 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6177 #ifdef wxHAS_XBUTTON
6178 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6179 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6180 #endif // wxHAS_XBUTTON
6182 ms
.SetControlDown(wxIsCtrlDown ());
6183 ms
.SetShiftDown (wxIsShiftDown());
6184 ms
.SetAltDown (wxIsAltDown ());
6185 // ms.SetMetaDown();
6191 wxWindow
*wxGetActiveWindow()
6193 HWND hWnd
= GetActiveWindow();
6196 return wxFindWinFromHandle((WXHWND
) hWnd
);
6201 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6203 HWND hwnd
= (HWND
)hWnd
;
6205 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6206 // by code in msw/radiobox.cpp), for all the others we just search up the
6208 wxWindow
*win
= (wxWindow
*)NULL
;
6211 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6215 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6216 // wxWindow class which overrides WM_GETDLGCODE processing to
6217 // do it as well, win would be already non NULL
6218 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6220 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6222 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6223 #endif // wxUSE_RADIOBOX
6225 // spin control text buddy window should be mapped to spin ctrl
6226 // itself so try it too
6227 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6230 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6232 #endif // wxUSE_SPINCTRL
6236 while ( hwnd
&& !win
)
6238 // this is a really ugly hack needed to avoid mistakenly returning the
6239 // parent frame wxWindow for the find/replace modeless dialog HWND -
6240 // this, in turn, is needed to call IsDialogMessage() from
6241 // wxApp::ProcessMessage() as for this we must return NULL from here
6243 // FIXME: this is clearly not the best way to do it but I think we'll
6244 // need to change HWND <-> wxWindow code more heavily than I can
6245 // do it now to fix it
6246 #ifndef __WXMICROWIN__
6247 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6249 // it's a dialog box, don't go upwards
6254 hwnd
= ::GetParent(hwnd
);
6255 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6261 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6263 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6264 // in active frames and dialogs, regardless of where the focus is.
6265 static HHOOK wxTheKeyboardHook
= 0;
6266 static FARPROC wxTheKeyboardHookProc
= 0;
6267 int APIENTRY _EXPORT
6268 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
6270 void wxSetKeyboardHook(bool doIt
)
6274 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
6275 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
6277 GetCurrentThreadId()
6278 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
6283 UnhookWindowsHookEx(wxTheKeyboardHook
);
6287 int APIENTRY _EXPORT
6288 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6290 DWORD hiWord
= HIWORD(lParam
);
6291 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6293 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6296 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6297 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6298 event
.m_altDown
= true;
6300 event
.SetEventObject(NULL
);
6301 event
.m_keyCode
= id
;
6302 event
.m_shiftDown
= wxIsShiftDown();
6303 event
.m_controlDown
= wxIsCtrlDown();
6305 event
.SetTimestamp(::GetMessageTime());
6307 wxWindow
*win
= wxGetActiveWindow();
6308 wxEvtHandler
*handler
;
6311 handler
= win
->GetEventHandler();
6312 event
.SetId(win
->GetId());
6317 event
.SetId(wxID_ANY
);
6320 if ( handler
&& handler
->ProcessEvent(event
) )
6328 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6331 #endif // !__WXMICROWIN__
6334 const wxChar
*wxGetMessageName(int message
)
6338 case 0x0000: return wxT("WM_NULL");
6339 case 0x0001: return wxT("WM_CREATE");
6340 case 0x0002: return wxT("WM_DESTROY");
6341 case 0x0003: return wxT("WM_MOVE");
6342 case 0x0005: return wxT("WM_SIZE");
6343 case 0x0006: return wxT("WM_ACTIVATE");
6344 case 0x0007: return wxT("WM_SETFOCUS");
6345 case 0x0008: return wxT("WM_KILLFOCUS");
6346 case 0x000A: return wxT("WM_ENABLE");
6347 case 0x000B: return wxT("WM_SETREDRAW");
6348 case 0x000C: return wxT("WM_SETTEXT");
6349 case 0x000D: return wxT("WM_GETTEXT");
6350 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6351 case 0x000F: return wxT("WM_PAINT");
6352 case 0x0010: return wxT("WM_CLOSE");
6353 case 0x0011: return wxT("WM_QUERYENDSESSION");
6354 case 0x0012: return wxT("WM_QUIT");
6355 case 0x0013: return wxT("WM_QUERYOPEN");
6356 case 0x0014: return wxT("WM_ERASEBKGND");
6357 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6358 case 0x0016: return wxT("WM_ENDSESSION");
6359 case 0x0017: return wxT("WM_SYSTEMERROR");
6360 case 0x0018: return wxT("WM_SHOWWINDOW");
6361 case 0x0019: return wxT("WM_CTLCOLOR");
6362 case 0x001A: return wxT("WM_WININICHANGE");
6363 case 0x001B: return wxT("WM_DEVMODECHANGE");
6364 case 0x001C: return wxT("WM_ACTIVATEAPP");
6365 case 0x001D: return wxT("WM_FONTCHANGE");
6366 case 0x001E: return wxT("WM_TIMECHANGE");
6367 case 0x001F: return wxT("WM_CANCELMODE");
6368 case 0x0020: return wxT("WM_SETCURSOR");
6369 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6370 case 0x0022: return wxT("WM_CHILDACTIVATE");
6371 case 0x0023: return wxT("WM_QUEUESYNC");
6372 case 0x0024: return wxT("WM_GETMINMAXINFO");
6373 case 0x0026: return wxT("WM_PAINTICON");
6374 case 0x0027: return wxT("WM_ICONERASEBKGND");
6375 case 0x0028: return wxT("WM_NEXTDLGCTL");
6376 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6377 case 0x002B: return wxT("WM_DRAWITEM");
6378 case 0x002C: return wxT("WM_MEASUREITEM");
6379 case 0x002D: return wxT("WM_DELETEITEM");
6380 case 0x002E: return wxT("WM_VKEYTOITEM");
6381 case 0x002F: return wxT("WM_CHARTOITEM");
6382 case 0x0030: return wxT("WM_SETFONT");
6383 case 0x0031: return wxT("WM_GETFONT");
6384 case 0x0037: return wxT("WM_QUERYDRAGICON");
6385 case 0x0039: return wxT("WM_COMPAREITEM");
6386 case 0x0041: return wxT("WM_COMPACTING");
6387 case 0x0044: return wxT("WM_COMMNOTIFY");
6388 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6389 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6390 case 0x0048: return wxT("WM_POWER");
6392 case 0x004A: return wxT("WM_COPYDATA");
6393 case 0x004B: return wxT("WM_CANCELJOURNAL");
6394 case 0x004E: return wxT("WM_NOTIFY");
6395 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6396 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6397 case 0x0052: return wxT("WM_TCARD");
6398 case 0x0053: return wxT("WM_HELP");
6399 case 0x0054: return wxT("WM_USERCHANGED");
6400 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6401 case 0x007B: return wxT("WM_CONTEXTMENU");
6402 case 0x007C: return wxT("WM_STYLECHANGING");
6403 case 0x007D: return wxT("WM_STYLECHANGED");
6404 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6405 case 0x007F: return wxT("WM_GETICON");
6406 case 0x0080: return wxT("WM_SETICON");
6408 case 0x0081: return wxT("WM_NCCREATE");
6409 case 0x0082: return wxT("WM_NCDESTROY");
6410 case 0x0083: return wxT("WM_NCCALCSIZE");
6411 case 0x0084: return wxT("WM_NCHITTEST");
6412 case 0x0085: return wxT("WM_NCPAINT");
6413 case 0x0086: return wxT("WM_NCACTIVATE");
6414 case 0x0087: return wxT("WM_GETDLGCODE");
6415 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6416 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6417 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6418 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6419 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6420 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6421 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6422 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6423 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6424 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6426 case 0x00B0: return wxT("EM_GETSEL");
6427 case 0x00B1: return wxT("EM_SETSEL");
6428 case 0x00B2: return wxT("EM_GETRECT");
6429 case 0x00B3: return wxT("EM_SETRECT");
6430 case 0x00B4: return wxT("EM_SETRECTNP");
6431 case 0x00B5: return wxT("EM_SCROLL");
6432 case 0x00B6: return wxT("EM_LINESCROLL");
6433 case 0x00B7: return wxT("EM_SCROLLCARET");
6434 case 0x00B8: return wxT("EM_GETMODIFY");
6435 case 0x00B9: return wxT("EM_SETMODIFY");
6436 case 0x00BA: return wxT("EM_GETLINECOUNT");
6437 case 0x00BB: return wxT("EM_LINEINDEX");
6438 case 0x00BC: return wxT("EM_SETHANDLE");
6439 case 0x00BD: return wxT("EM_GETHANDLE");
6440 case 0x00BE: return wxT("EM_GETTHUMB");
6441 case 0x00C1: return wxT("EM_LINELENGTH");
6442 case 0x00C2: return wxT("EM_REPLACESEL");
6443 case 0x00C4: return wxT("EM_GETLINE");
6444 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6445 case 0x00C6: return wxT("EM_CANUNDO");
6446 case 0x00C7: return wxT("EM_UNDO");
6447 case 0x00C8: return wxT("EM_FMTLINES");
6448 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6449 case 0x00CB: return wxT("EM_SETTABSTOPS");
6450 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6451 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6452 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6453 case 0x00CF: return wxT("EM_SETREADONLY");
6454 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6455 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6456 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6457 case 0x00D3: return wxT("EM_SETMARGINS");
6458 case 0x00D4: return wxT("EM_GETMARGINS");
6459 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6460 case 0x00D6: return wxT("EM_POSFROMCHAR");
6461 case 0x00D7: return wxT("EM_CHARFROMPOS");
6462 case 0x00D8: return wxT("EM_SETIMESTATUS");
6463 case 0x00D9: return wxT("EM_GETIMESTATUS");
6465 case 0x0100: return wxT("WM_KEYDOWN");
6466 case 0x0101: return wxT("WM_KEYUP");
6467 case 0x0102: return wxT("WM_CHAR");
6468 case 0x0103: return wxT("WM_DEADCHAR");
6469 case 0x0104: return wxT("WM_SYSKEYDOWN");
6470 case 0x0105: return wxT("WM_SYSKEYUP");
6471 case 0x0106: return wxT("WM_SYSCHAR");
6472 case 0x0107: return wxT("WM_SYSDEADCHAR");
6473 case 0x0108: return wxT("WM_KEYLAST");
6475 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6476 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6477 case 0x010F: return wxT("WM_IME_COMPOSITION");
6479 case 0x0110: return wxT("WM_INITDIALOG");
6480 case 0x0111: return wxT("WM_COMMAND");
6481 case 0x0112: return wxT("WM_SYSCOMMAND");
6482 case 0x0113: return wxT("WM_TIMER");
6483 case 0x0114: return wxT("WM_HSCROLL");
6484 case 0x0115: return wxT("WM_VSCROLL");
6485 case 0x0116: return wxT("WM_INITMENU");
6486 case 0x0117: return wxT("WM_INITMENUPOPUP");
6487 case 0x011F: return wxT("WM_MENUSELECT");
6488 case 0x0120: return wxT("WM_MENUCHAR");
6489 case 0x0121: return wxT("WM_ENTERIDLE");
6491 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6492 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6493 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6494 case 0x0135: return wxT("WM_CTLCOLORBTN");
6495 case 0x0136: return wxT("WM_CTLCOLORDLG");
6496 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6497 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6498 case 0x01E1: return wxT("MN_GETHMENU");
6500 case 0x0200: return wxT("WM_MOUSEMOVE");
6501 case 0x0201: return wxT("WM_LBUTTONDOWN");
6502 case 0x0202: return wxT("WM_LBUTTONUP");
6503 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6504 case 0x0204: return wxT("WM_RBUTTONDOWN");
6505 case 0x0205: return wxT("WM_RBUTTONUP");
6506 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6507 case 0x0207: return wxT("WM_MBUTTONDOWN");
6508 case 0x0208: return wxT("WM_MBUTTONUP");
6509 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6510 case 0x020A: return wxT("WM_MOUSEWHEEL");
6511 case 0x020B: return wxT("WM_XBUTTONDOWN");
6512 case 0x020C: return wxT("WM_XBUTTONUP");
6513 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6514 case 0x0210: return wxT("WM_PARENTNOTIFY");
6515 case 0x0211: return wxT("WM_ENTERMENULOOP");
6516 case 0x0212: return wxT("WM_EXITMENULOOP");
6518 case 0x0213: return wxT("WM_NEXTMENU");
6519 case 0x0214: return wxT("WM_SIZING");
6520 case 0x0215: return wxT("WM_CAPTURECHANGED");
6521 case 0x0216: return wxT("WM_MOVING");
6522 case 0x0218: return wxT("WM_POWERBROADCAST");
6523 case 0x0219: return wxT("WM_DEVICECHANGE");
6525 case 0x0220: return wxT("WM_MDICREATE");
6526 case 0x0221: return wxT("WM_MDIDESTROY");
6527 case 0x0222: return wxT("WM_MDIACTIVATE");
6528 case 0x0223: return wxT("WM_MDIRESTORE");
6529 case 0x0224: return wxT("WM_MDINEXT");
6530 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6531 case 0x0226: return wxT("WM_MDITILE");
6532 case 0x0227: return wxT("WM_MDICASCADE");
6533 case 0x0228: return wxT("WM_MDIICONARRANGE");
6534 case 0x0229: return wxT("WM_MDIGETACTIVE");
6535 case 0x0230: return wxT("WM_MDISETMENU");
6536 case 0x0233: return wxT("WM_DROPFILES");
6538 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6539 case 0x0282: return wxT("WM_IME_NOTIFY");
6540 case 0x0283: return wxT("WM_IME_CONTROL");
6541 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6542 case 0x0285: return wxT("WM_IME_SELECT");
6543 case 0x0286: return wxT("WM_IME_CHAR");
6544 case 0x0290: return wxT("WM_IME_KEYDOWN");
6545 case 0x0291: return wxT("WM_IME_KEYUP");
6547 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6548 case 0x02A1: return wxT("WM_MOUSEHOVER");
6549 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6550 case 0x02A3: return wxT("WM_MOUSELEAVE");
6552 case 0x0300: return wxT("WM_CUT");
6553 case 0x0301: return wxT("WM_COPY");
6554 case 0x0302: return wxT("WM_PASTE");
6555 case 0x0303: return wxT("WM_CLEAR");
6556 case 0x0304: return wxT("WM_UNDO");
6557 case 0x0305: return wxT("WM_RENDERFORMAT");
6558 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6559 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6560 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6561 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6562 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6563 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6564 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6565 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6566 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6567 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6568 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6569 case 0x0311: return wxT("WM_PALETTECHANGED");
6570 case 0x0312: return wxT("WM_HOTKEY");
6572 case 0x0317: return wxT("WM_PRINT");
6573 case 0x0318: return wxT("WM_PRINTCLIENT");
6575 // common controls messages - although they're not strictly speaking
6576 // standard, it's nice to decode them nevertheless
6579 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6580 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6581 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6582 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6583 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6584 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6585 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6586 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6587 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6588 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6589 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6590 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6591 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6592 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6593 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6594 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6595 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6596 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6597 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6598 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6599 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6600 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6601 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6602 case 0x1000 + 18: return wxT("LVM_HITTEST");
6603 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6604 case 0x1000 + 20: return wxT("LVM_SCROLL");
6605 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6606 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6607 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6608 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6609 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6610 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6611 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6612 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6613 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6614 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6615 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6616 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6617 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6618 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6619 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6620 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6621 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6622 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6623 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6624 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6625 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6626 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6627 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6628 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6629 case 0x1000 + 42: return wxT("LVM_UPDATE");
6630 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6631 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6632 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6633 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6634 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6635 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6636 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6637 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6638 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6639 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6640 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6641 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6642 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6643 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6644 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6645 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6646 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6647 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6648 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6649 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6650 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6651 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6652 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6653 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6654 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6655 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6658 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6659 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6660 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6661 case 0x1100 + 2: return wxT("TVM_EXPAND");
6662 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6663 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6664 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6665 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6666 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6667 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6668 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6669 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6670 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6671 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6672 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6673 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6674 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6675 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6676 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6677 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6678 case 0x1100 + 17: return wxT("TVM_HITTEST");
6679 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6680 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6681 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6682 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6683 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6684 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6685 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6686 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6687 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6690 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6691 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6692 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6693 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6694 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6695 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6696 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6697 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6698 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6699 case 0x1200 + 6: return wxT("HDM_HITTEST");
6700 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6701 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6702 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6703 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6704 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6705 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6706 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6707 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6710 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6711 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6712 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6713 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6714 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6715 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6716 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6717 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6718 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6719 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6720 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6721 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6722 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6723 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6724 case 0x1300 + 13: return wxT("TCM_HITTEST");
6725 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6726 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6727 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6728 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6729 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6730 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6731 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6732 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6733 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6734 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6735 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6736 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6739 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6740 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6741 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6742 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6743 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6744 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6745 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6746 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6747 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6748 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6749 case WM_USER
+17: return wxT("TB_SETSTATE");
6750 case WM_USER
+18: return wxT("TB_GETSTATE");
6751 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6752 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6753 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6754 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6755 case WM_USER
+23: return wxT("TB_GETBUTTON");
6756 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6757 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6758 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6759 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6760 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6761 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6762 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6763 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6764 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6765 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6766 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6767 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6768 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6769 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6770 case WM_USER
+37: return wxT("TB_SETPARENT");
6771 case WM_USER
+39: return wxT("TB_SETROWS");
6772 case WM_USER
+40: return wxT("TB_GETROWS");
6773 case WM_USER
+42: return wxT("TB_SETCMDID");
6774 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6775 case WM_USER
+44: return wxT("TB_GETBITMAP");
6776 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6777 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6778 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6779 case WM_USER
+47: return wxT("TB_SETINDENT");
6780 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6781 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6782 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6783 case WM_USER
+51: return wxT("TB_GETRECT");
6784 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6785 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6786 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6787 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6788 case WM_USER
+56: return wxT("TB_SETSTYLE");
6789 case WM_USER
+57: return wxT("TB_GETSTYLE");
6790 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6791 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6792 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6793 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6794 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6797 static wxString s_szBuf
;
6798 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6799 return s_szBuf
.c_str();
6802 #endif //__WXDEBUG__
6804 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6808 HWND hwnd
= GetHwndOf(win
);
6809 HDC hdc
= ::GetDC(hwnd
);
6811 #if !wxDIALOG_UNIT_COMPATIBILITY
6812 // and select the current font into it
6813 HFONT hfont
= GetHfontOf(win
->GetFont());
6816 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6820 // finally retrieve the text metrics from it
6821 GetTextMetrics(hdc
, &tm
);
6823 #if !wxDIALOG_UNIT_COMPATIBILITY
6827 (void)::SelectObject(hdc
, hfont
);
6831 ::ReleaseDC(hwnd
, hdc
);
6836 // Find the wxWindow at the current mouse position, returning the mouse
6838 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6840 pt
= wxGetMousePosition();
6841 return wxFindWindowAtPoint(pt
);
6844 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6850 HWND hWnd
= ::WindowFromPoint(pt2
);
6852 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6855 // Get the current mouse position.
6856 wxPoint
wxGetMousePosition()
6860 GetCursorPosWinCE(&pt
);
6862 GetCursorPos( & pt
);
6865 return wxPoint(pt
.x
, pt
.y
);
6870 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6871 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6873 // Register hotkeys for the hardware buttons
6875 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6877 UnregisterFunc1Proc procUnregisterFunc
;
6878 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6881 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6882 if (procUnregisterFunc
)
6883 procUnregisterFunc(modifiers
, id
);
6884 FreeLibrary(hCoreDll
);
6889 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6891 UINT win_modifiers
=0;
6892 if ( modifiers
& wxMOD_ALT
)
6893 win_modifiers
|= MOD_ALT
;
6894 if ( modifiers
& wxMOD_SHIFT
)
6895 win_modifiers
|= MOD_SHIFT
;
6896 if ( modifiers
& wxMOD_CONTROL
)
6897 win_modifiers
|= MOD_CONTROL
;
6898 if ( modifiers
& wxMOD_WIN
)
6899 win_modifiers
|= MOD_WIN
;
6901 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6902 // Required for PPC and Smartphone hardware buttons
6903 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6904 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6907 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6909 wxLogLastError(_T("RegisterHotKey"));
6917 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6919 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6920 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6923 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6925 wxLogLastError(_T("UnregisterHotKey"));
6935 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6937 int hotkeyId
= wParam
;
6938 int virtualKey
= HIWORD(lParam
);
6939 int win_modifiers
= LOWORD(lParam
);
6941 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6942 event
.SetId(hotkeyId
);
6943 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6944 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6945 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6946 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6948 return HandleWindowEvent(event
);
6951 #endif // wxUSE_ACCEL
6953 #endif // wxUSE_HOTKEY
6955 // Not tested under WinCE
6958 // this class installs a message hook which really wakes up our idle processing
6959 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6960 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6961 // being dragged or even inside ::MessageBox()) and so don't control message
6962 // dispatching otherwise
6963 class wxIdleWakeUpModule
: public wxModule
6966 virtual bool OnInit()
6968 ms_hMsgHookProc
= ::SetWindowsHookEx
6971 &wxIdleWakeUpModule::MsgHookProc
,
6973 GetCurrentThreadId()
6976 if ( !ms_hMsgHookProc
)
6978 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6986 virtual void OnExit()
6988 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
6991 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6993 MSG
*msg
= (MSG
*)lParam
;
6995 // only process the message if it is actually going to be removed from
6996 // the message queue, this prevents that the same event from being
6997 // processed multiple times if now someone just called PeekMessage()
6998 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7000 wxTheApp
->ProcessPendingEvents();
7003 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7007 static HHOOK ms_hMsgHookProc
;
7009 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7012 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7014 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7016 #endif // __WXWINCE__
7021 static void wxAdjustZOrder(wxWindow
* parent
)
7023 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7025 // Set the z-order correctly
7026 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7029 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7032 wxWindow
*childWin
= current
->GetData();
7033 wxAdjustZOrder(childWin
);
7034 current
= current
->GetNext();
7039 // We need to adjust the z-order of static boxes in WinCE, to
7040 // make 'contained' controls visible
7041 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7044 wxAdjustZOrder(this);