1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/window.cpp
3 // Purpose: wxWindowMSW
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/window.h"
30 #include "wx/msw/wrapwin.h"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
56 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
60 #include "wx/hashmap.h"
61 #include "wx/evtloop.h"
63 #include "wx/sysopt.h"
65 #if wxUSE_DRAG_AND_DROP
69 #if wxUSE_ACCESSIBILITY
70 #include "wx/access.h"
74 #define WM_GETOBJECT 0x003D
77 #define OBJID_CLIENT 0xFFFFFFFC
81 #include "wx/msw/private.h"
84 #include "wx/tooltip.h"
92 #include "wx/spinctrl.h"
93 #endif // wxUSE_SPINCTRL
95 #include "wx/notebook.h"
96 #include "wx/listctrl.h"
97 #include "wx/dynlib.h"
101 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
102 #include <shellapi.h>
103 #include <mmsystem.h>
107 #include <windowsx.h>
110 #if !defined __WXWINCE__ && !defined NEED_PBT_H
114 #if defined(__WXWINCE__)
115 #include "wx/msw/wince/missing.h"
118 #include <shellapi.h>
120 #include <aygshell.h>
125 #include "wx/msw/uxtheme.h"
126 #define EP_EDITTEXT 1
129 #define ETS_SELECTED 3
130 #define ETS_DISABLED 4
131 #define ETS_FOCUSED 5
132 #define ETS_READONLY 6
136 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
137 #define HAVE_TRACKMOUSEEVENT
138 #endif // everything needed for TrackMouseEvent()
140 // if this is set to 1, we use deferred window sizing to reduce flicker when
141 // resizing complicated window hierarchies, but this can in theory result in
142 // different behaviour than the old code so we keep the possibility to use it
143 // by setting this to 0 (in the future this should be removed completely)
145 #define USE_DEFERRED_SIZING 0
147 #define USE_DEFERRED_SIZING 1
150 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
151 // when mouse position didnd't change
153 #define wxUSE_MOUSEEVENT_HACK 0
155 #define wxUSE_MOUSEEVENT_HACK 1
158 // not all compilers/platforms have X button related declarations (notably
159 // Windows CE doesn't, and probably some old SDKs don't neither)
160 #ifdef WM_XBUTTONDOWN
161 #define wxHAS_XBUTTON
164 // ---------------------------------------------------------------------------
166 // ---------------------------------------------------------------------------
168 #if wxUSE_MENUS_NATIVE
169 wxMenu
*wxCurrentPopupMenu
= NULL
;
170 #endif // wxUSE_MENUS_NATIVE
173 extern wxChar
*wxCanvasClassName
;
175 extern const wxChar
*wxCanvasClassName
;
178 // true if we had already created the std colour map, used by
179 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
180 static bool gs_hasStdCmap
= false;
182 // last mouse event information we need to filter out the duplicates
183 #if wxUSE_MOUSEEVENT_HACK
184 static struct MouseEventInfoDummy
186 // mouse position (in screen coordinates)
189 // last mouse event type
192 #endif // wxUSE_MOUSEEVENT_HACK
194 // hash containing the registered handlers for the custom messages
195 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
196 wxIntegerHash
, wxIntegerEqual
,
199 static MSWMessageHandlers gs_messageHandlers
;
201 // ---------------------------------------------------------------------------
203 // ---------------------------------------------------------------------------
205 // the window proc for all our windows
206 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
207 WPARAM wParam
, LPARAM lParam
);
211 const wxChar
*wxGetMessageName(int message
);
214 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
215 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
216 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
218 // get the text metrics for the current font
219 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
222 // find the window for the mouse event at the specified position
223 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
224 #endif // __WXWINCE__
226 // wrapper around BringWindowToTop() API
227 static inline void wxBringWindowToTop(HWND hwnd
)
229 #ifdef __WXMICROWIN__
230 // It seems that MicroWindows brings the _parent_ of the window to the top,
231 // which can be the wrong one.
233 // activate (set focus to) specified window
237 // raise top level parent to top of z order
238 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
240 wxLogLastError(_T("SetWindowPos"));
246 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
247 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
250 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
251 parent as well as otherwise several Win32 functions using
252 GetNextDlgTabItem() to iterate over all controls such as
253 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
254 all of them iterate over all the controls starting from the currently
255 focused one and stop iterating when they get back to the focus but
256 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
257 get back to the initial (focused) window: as we do have this style,
258 GetNextDlgTabItem() will leave this window and continue in its parent,
259 but if the parent doesn't have it, it wouldn't recurse inside it later
260 on and so wouldn't have a chance of getting back to this window either.
262 while ( parent
&& !parent
->IsTopLevel() )
264 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
265 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
267 // force the parent to have this style
268 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
269 exStyle
| WS_EX_CONTROLPARENT
);
272 parent
= parent
->GetParent();
276 #endif // !__WXWINCE__
279 // On Windows CE, GetCursorPos can return an error, so use this function
281 bool GetCursorPosWinCE(POINT
* pt
)
283 if (!GetCursorPos(pt
))
285 DWORD pos
= GetMessagePos();
293 // ---------------------------------------------------------------------------
295 // ---------------------------------------------------------------------------
297 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
299 #ifdef __WXUNIVERSAL__
300 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
302 #if wxUSE_EXTENDED_RTTI
304 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
305 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
306 // windows with negative ids never can be recreated anyway
308 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
310 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
311 if ( win
&& win
->GetId() < 0 )
316 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
318 // make wxWindowList known before the property is used
320 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
322 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
324 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
327 WX_DEFINE_FLAGS( wxWindowStyle
)
329 wxBEGIN_FLAGS( wxWindowStyle
)
330 // new style border flags, we put them first to
331 // use them for streaming out
333 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
334 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
335 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
336 wxFLAGS_MEMBER(wxBORDER_RAISED
)
337 wxFLAGS_MEMBER(wxBORDER_STATIC
)
338 wxFLAGS_MEMBER(wxBORDER_NONE
)
340 // old style border flags
341 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
342 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
343 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
344 wxFLAGS_MEMBER(wxRAISED_BORDER
)
345 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
346 wxFLAGS_MEMBER(wxBORDER
)
348 // standard window styles
349 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
350 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
351 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
352 wxFLAGS_MEMBER(wxWANTS_CHARS
)
353 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
354 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
355 wxFLAGS_MEMBER(wxVSCROLL
)
356 wxFLAGS_MEMBER(wxHSCROLL
)
358 wxEND_FLAGS( wxWindowStyle
)
360 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
361 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
362 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
363 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
364 // Always constructor Properties first
366 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
367 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
368 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
369 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
370 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
372 // Then all relations of the object graph
374 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
376 // and finally all other properties
378 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
379 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
380 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
381 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
382 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
384 // possible property candidates (not in xrc) or not valid in all subclasses
385 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
386 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
387 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
388 // MaxHeight, Width , MinHeight , Width
389 // TODO switch label to control and title to toplevels
391 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
392 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
393 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
394 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
399 wxEND_PROPERTIES_TABLE()
401 wxBEGIN_HANDLERS_TABLE(wxWindow
)
402 wxEND_HANDLERS_TABLE()
404 wxCONSTRUCTOR_DUMMY(wxWindow
)
407 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
409 #endif // __WXUNIVERSAL__/__WXMSW__
411 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
412 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
413 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
415 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
419 // ===========================================================================
421 // ===========================================================================
423 // ---------------------------------------------------------------------------
424 // wxWindow utility functions
425 // ---------------------------------------------------------------------------
427 // Find an item given the MS Windows id
428 wxWindow
*wxWindowMSW::FindItem(long id
) const
431 wxControl
*item
= wxDynamicCastThis(wxControl
);
434 // is it us or one of our "internal" children?
435 if ( item
->GetId() == id
436 #ifndef __WXUNIVERSAL__
437 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
438 #endif // __WXUNIVERSAL__
444 #endif // wxUSE_CONTROLS
446 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
449 wxWindow
*childWin
= current
->GetData();
451 wxWindow
*wnd
= childWin
->FindItem(id
);
455 current
= current
->GetNext();
461 // Find an item given the MS Windows handle
462 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
464 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
467 wxWindow
*parent
= current
->GetData();
469 // Do a recursive search.
470 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
476 || parent
->IsKindOf(CLASSINFO(wxControl
))
477 #endif // wxUSE_CONTROLS
480 wxWindow
*item
= current
->GetData();
481 if ( item
->GetHWND() == hWnd
)
485 if ( item
->ContainsHWND(hWnd
) )
490 current
= current
->GetNext();
495 // Default command handler
496 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
501 // ----------------------------------------------------------------------------
502 // constructors and such
503 // ----------------------------------------------------------------------------
505 void wxWindowMSW::Init()
508 m_isBeingDeleted
= false;
510 m_mouseInWindow
= false;
511 m_lastKeydownProcessed
= false;
521 m_pendingPosition
= wxDefaultPosition
;
522 m_pendingSize
= wxDefaultSize
;
525 m_contextMenuEnabled
= false;
530 wxWindowMSW::~wxWindowMSW()
532 m_isBeingDeleted
= true;
534 #ifndef __WXUNIVERSAL__
535 // VS: make sure there's no wxFrame with last focus set to us:
536 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
538 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
541 if ( frame
->GetLastFocus() == this )
543 frame
->SetLastFocus(NULL
);
546 // apparently sometimes we can end up with our grand parent
547 // pointing to us as well: this is surely a bug in focus handling
548 // code but it's not clear where it happens so for now just try to
549 // fix it here by not breaking out of the loop
553 #endif // __WXUNIVERSAL__
555 // VS: destroy children first and _then_ detach *this from its parent.
556 // If we did it the other way around, children wouldn't be able
557 // find their parent frame (see above).
562 // VZ: test temp removed to understand what really happens here
563 //if (::IsWindow(GetHwnd()))
565 if ( !::DestroyWindow(GetHwnd()) )
566 wxLogLastError(wxT("DestroyWindow"));
569 // remove hWnd <-> wxWindow association
570 wxRemoveHandleAssociation(this);
575 // real construction (Init() must have been called before!)
576 bool wxWindowMSW::Create(wxWindow
*parent
,
581 const wxString
& name
)
583 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
585 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
588 parent
->AddChild(this);
591 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
593 #ifdef __WXUNIVERSAL__
594 // no borders, we draw them ourselves
595 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
599 msflags
&= ~WS_BORDER
;
600 #endif // wxUniversal
604 msflags
|= WS_VISIBLE
;
607 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
615 // ---------------------------------------------------------------------------
617 // ---------------------------------------------------------------------------
619 void wxWindowMSW::SetFocus()
621 HWND hWnd
= GetHwnd();
622 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
624 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
628 if ( !::SetFocus(hWnd
) )
630 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
631 // was there really an error?
632 DWORD dwRes
= ::GetLastError();
635 HWND hwndFocus
= ::GetFocus();
636 if ( hwndFocus
!= hWnd
)
638 wxLogApiError(_T("SetFocus"), dwRes
);
645 void wxWindowMSW::SetFocusFromKbd()
647 // when the focus is given to the control with DLGC_HASSETSEL style from
648 // keyboard its contents should be entirely selected: this is what
649 // ::IsDialogMessage() does and so we should do it as well to provide the
650 // same LNF as the native programs
651 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
653 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
656 // do this after (maybe) setting the selection as like this when
657 // wxEVT_SET_FOCUS handler is called, the selection would have been already
658 // set correctly -- this may be important
659 wxWindowBase::SetFocusFromKbd();
662 // Get the window with the focus
663 wxWindow
*wxWindowBase::DoFindFocus()
665 HWND hWnd
= ::GetFocus();
668 return wxGetWindowFromHWND((WXHWND
)hWnd
);
674 void wxWindowMSW::DoEnable( bool enable
)
676 HWND hWnd
= GetHwnd();
678 ::EnableWindow(hWnd
, (BOOL
)enable
);
681 bool wxWindowMSW::Show(bool show
)
683 if ( !wxWindowBase::Show(show
) )
686 HWND hWnd
= GetHwnd();
688 // we could be called before the underlying window is created (this is
689 // actually useful to prevent it from being initially shown), e.g.
691 // wxFoo *foo = new wxFoo;
693 // foo->Create(parent, ...);
695 // should work without errors
698 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
704 // Raise the window to the top of the Z order
705 void wxWindowMSW::Raise()
707 wxBringWindowToTop(GetHwnd());
710 // Lower the window to the bottom of the Z order
711 void wxWindowMSW::Lower()
713 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
714 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
717 void wxWindowMSW::DoCaptureMouse()
719 HWND hWnd
= GetHwnd();
726 void wxWindowMSW::DoReleaseMouse()
728 if ( !::ReleaseCapture() )
730 wxLogLastError(_T("ReleaseCapture"));
734 /* static */ wxWindow
*wxWindowBase::GetCapture()
736 HWND hwnd
= ::GetCapture();
737 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
740 bool wxWindowMSW::SetFont(const wxFont
& font
)
742 if ( !wxWindowBase::SetFont(font
) )
748 HWND hWnd
= GetHwnd();
751 WXHANDLE hFont
= m_font
.GetResourceHandle();
753 wxASSERT_MSG( hFont
, wxT("should have valid font") );
755 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
760 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
762 if ( !wxWindowBase::SetCursor(cursor
) )
768 // don't "overwrite" busy cursor
769 if ( m_cursor
.Ok() && !wxIsBusy() )
771 // normally we should change the cursor only if it's over this window
772 // but we should do it always if we capture the mouse currently
773 bool set
= HasCapture();
776 HWND hWnd
= GetHwnd();
780 ::GetCursorPosWinCE(&point
);
782 ::GetCursorPos(&point
);
785 RECT rect
= wxGetWindowRect(hWnd
);
787 set
= ::PtInRect(&rect
, point
) != 0;
792 ::SetCursor(GetHcursorOf(m_cursor
));
794 //else: will be set later when the mouse enters this window
800 void wxWindowMSW::WarpPointer(int x
, int y
)
802 ClientToScreen(&x
, &y
);
804 if ( !::SetCursorPos(x
, y
) )
806 wxLogLastError(_T("SetCursorPos"));
810 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
812 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
813 // to use it on older systems -- and could possibly do some harm
814 static int s_needToUpdate
= -1;
815 if ( s_needToUpdate
== -1 )
818 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
822 if ( s_needToUpdate
)
824 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
825 // won't send WM_UPDATEUISTATE
826 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
830 // ---------------------------------------------------------------------------
832 // ---------------------------------------------------------------------------
834 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
836 #ifdef __WXMICROWIN__
837 return ::GetScrollPosWX(hWnd
, wOrient
);
839 WinStruct
<SCROLLINFO
> scrollInfo
;
840 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
841 scrollInfo
.fMask
= SIF_POS
;
842 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
844 return scrollInfo
.nPos
;
849 int wxWindowMSW::GetScrollPos(int orient
) const
851 HWND hWnd
= GetHwnd();
852 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
854 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
857 // This now returns the whole range, not just the number
858 // of positions that we can scroll.
859 int wxWindowMSW::GetScrollRange(int orient
) const
862 HWND hWnd
= GetHwnd();
866 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
869 WinStruct
<SCROLLINFO
> scrollInfo
;
870 scrollInfo
.fMask
= SIF_RANGE
;
871 if ( !::GetScrollInfo(hWnd
,
872 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
875 // Most of the time this is not really an error, since the return
876 // value can also be zero when there is no scrollbar yet.
877 // wxLogLastError(_T("GetScrollInfo"));
879 maxPos
= scrollInfo
.nMax
;
881 // undo "range - 1" done in SetScrollbar()
885 int wxWindowMSW::GetScrollThumb(int orient
) const
887 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
890 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
892 HWND hWnd
= GetHwnd();
893 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
895 WinStruct
<SCROLLINFO
> info
;
899 info
.fMask
= SIF_POS
;
900 if ( HasFlag(wxALWAYS_SHOW_SB
) )
902 // disable scrollbar instead of removing it then
903 info
.fMask
|= SIF_DISABLENOSCROLL
;
906 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
910 // New function that will replace some of the above.
911 void wxWindowMSW::SetScrollbar(int orient
,
917 WinStruct
<SCROLLINFO
> info
;
918 info
.nPage
= pageSize
;
919 info
.nMin
= 0; // range is nMax - nMin + 1
920 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
922 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
923 if ( HasFlag(wxALWAYS_SHOW_SB
) )
925 // disable scrollbar instead of removing it then
926 info
.fMask
|= SIF_DISABLENOSCROLL
;
929 HWND hWnd
= GetHwnd();
932 // We have to set the variables here to make them valid in events
933 // triggered by ::SetScrollInfo()
934 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
936 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
941 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
947 wxCopyRectToRECT(*prect
, rect
);
957 // FIXME: is this the exact equivalent of the line below?
958 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
960 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
964 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
966 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
969 for ( int n
= 0; n
< count
; n
++ )
971 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
973 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
976 // don't bother to continue, we're already at top/bottom
983 return pos
!= posStart
;
986 bool wxWindowMSW::ScrollLines(int lines
)
988 bool down
= lines
> 0;
990 return ScrollVertically(GetHwnd(),
991 down
? SB_LINEDOWN
: SB_LINEUP
,
992 down
? lines
: -lines
);
995 bool wxWindowMSW::ScrollPages(int pages
)
997 bool down
= pages
> 0;
999 return ScrollVertically(GetHwnd(),
1000 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1001 down
? pages
: -pages
);
1004 // ----------------------------------------------------------------------------
1006 // ----------------------------------------------------------------------------
1008 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1013 const HWND hwnd
= GetHwnd();
1014 wxCHECK_RET( hwnd
, _T("layout direction must be set after window creation") );
1016 LONG styleOld
= ::GetWindowLong(hwnd
, GWL_EXSTYLE
);
1018 LONG styleNew
= styleOld
;
1021 case wxLayout_LeftToRight
:
1022 styleNew
&= ~WS_EX_LAYOUTRTL
;
1025 case wxLayout_RightToLeft
:
1026 styleNew
|= WS_EX_LAYOUTRTL
;
1030 wxFAIL_MSG(_T("unsupported layout direction"));
1034 if ( styleNew
!= styleOld
)
1036 ::SetWindowLong(hwnd
, GWL_EXSTYLE
, styleNew
);
1041 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1044 return wxLayout_Default
;
1046 const HWND hwnd
= GetHwnd();
1047 wxCHECK_MSG( hwnd
, wxLayout_Default
, _T("invalid window") );
1049 return ::GetWindowLong(hwnd
, GWL_EXSTYLE
) & WS_EX_LAYOUTRTL
1050 ? wxLayout_RightToLeft
1051 : wxLayout_LeftToRight
;
1056 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1057 wxCoord
WXUNUSED(width
),
1058 wxCoord
WXUNUSED(widthTotal
)) const
1060 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1061 // redo it ourselves
1065 // ---------------------------------------------------------------------------
1067 // ---------------------------------------------------------------------------
1069 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1071 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1073 HWND hwnd
= (HWND
)hWnd
;
1074 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1076 wxAssociateWinWithHandle(hwnd
, this);
1078 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1080 // we don't need to subclass the window of our own class (in the Windows
1081 // sense of the word)
1082 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1084 wxSetWindowProc(hwnd
, wxWndProc
);
1088 // don't bother restoring it either: this also makes it easy to
1089 // implement IsOfStandardClass() method which returns true for the
1090 // standard controls and false for the wxWidgets own windows as it can
1091 // simply check m_oldWndProc
1092 m_oldWndProc
= NULL
;
1095 // we're officially created now, send the event
1096 wxWindowCreateEvent
event((wxWindow
*)this);
1097 (void)GetEventHandler()->ProcessEvent(event
);
1100 void wxWindowMSW::UnsubclassWin()
1102 wxRemoveHandleAssociation(this);
1104 // Restore old Window proc
1105 HWND hwnd
= GetHwnd();
1110 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1114 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1116 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1119 m_oldWndProc
= NULL
;
1124 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1128 if ( !::DestroyWindow(GetHwnd()) )
1129 wxLogLastError(wxT("DestroyWindow"));
1132 WXHWND wxhwnd
= (WXHWND
)handle
;
1135 SubclassWin(wxhwnd
);
1138 void wxWindowMSW::DissociateHandle()
1140 // this also calls SetHWND(0) for us
1145 bool wxCheckWindowWndProc(WXHWND hWnd
,
1146 WXFARPROC
WXUNUSED(wndProc
))
1148 // TODO: This list of window class names should be factored out so they can be
1149 // managed in one place and then accessed from here and other places, such as
1150 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1153 extern wxChar
*wxCanvasClassName
;
1154 extern wxChar
*wxCanvasClassNameNR
;
1156 extern const wxChar
*wxCanvasClassName
;
1157 extern const wxChar
*wxCanvasClassNameNR
;
1159 extern const wxChar
*wxMDIFrameClassName
;
1160 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1161 extern const wxChar
*wxMDIChildFrameClassName
;
1162 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1163 wxString
str(wxGetWindowClass(hWnd
));
1164 if (str
== wxCanvasClassName
||
1165 str
== wxCanvasClassNameNR
||
1167 str
== _T("wxGLCanvasClass") ||
1168 str
== _T("wxGLCanvasClassNR") ||
1169 #endif // wxUSE_GLCANVAS
1170 str
== wxMDIFrameClassName
||
1171 str
== wxMDIFrameClassNameNoRedraw
||
1172 str
== wxMDIChildFrameClassName
||
1173 str
== wxMDIChildFrameClassNameNoRedraw
||
1174 str
== _T("wxTLWHiddenParent"))
1175 return true; // Effectively means don't subclass
1180 // ----------------------------------------------------------------------------
1182 // ----------------------------------------------------------------------------
1184 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1186 long flagsOld
= GetWindowStyleFlag();
1187 if ( flags
== flagsOld
)
1190 // update the internal variable
1191 wxWindowBase::SetWindowStyleFlag(flags
);
1193 // and the real window flags
1194 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1197 void wxWindowMSW::SetExtraStyle(long exflags
)
1199 long exflagsOld
= GetExtraStyle();
1200 if ( exflags
== exflagsOld
)
1203 // update the internal variable
1204 wxWindowBase::SetExtraStyle(exflags
);
1206 // and the real window flags
1207 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1210 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1212 // now update the Windows style as well if needed - and if the window had
1213 // been already created
1217 // we may need to call SetWindowPos() when we change some styles
1218 bool callSWP
= false;
1221 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1223 // this is quite a horrible hack but we need it because MSWGetStyle()
1224 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1225 // and so we have to modify the window exflags temporarily to get the
1226 // correct exstyleOld
1227 long exflagsNew
= GetExtraStyle();
1228 wxWindowBase::SetExtraStyle(exflagsOld
);
1231 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1233 wxWindowBase::SetExtraStyle(exflagsNew
);
1236 if ( style
!= styleOld
)
1238 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1239 // this function so instead of simply setting the style to the new
1240 // value we clear the bits which were set in styleOld but are set in
1241 // the new one and set the ones which were not set before
1242 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1243 styleReal
&= ~styleOld
;
1246 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1248 // we need to call SetWindowPos() if any of the styles affecting the
1249 // frame appearance have changed
1250 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1259 // and the extended style
1260 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1262 if ( exstyle
!= exstyleOld
)
1264 exstyleReal
&= ~exstyleOld
;
1265 exstyleReal
|= exstyle
;
1267 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1269 // ex style changes don't take effect without calling SetWindowPos
1275 // we must call SetWindowPos() to flush the cached extended style and
1276 // also to make the change to wxSTAY_ON_TOP style take effect: just
1277 // setting the style simply doesn't work
1278 if ( !::SetWindowPos(GetHwnd(),
1279 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1282 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1284 wxLogLastError(_T("SetWindowPos"));
1289 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1291 return wxBORDER_THEME
;
1294 wxBorder
wxWindowMSW::GetDefaultBorder() const
1296 return wxWindowBase::GetDefaultBorder();
1299 // Translate wxBORDER_THEME (and other border styles if necessary to the value
1300 // that makes most sense for this Windows environment
1301 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1303 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1304 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1305 return wxBORDER_SIMPLE
;
1307 return wxBORDER_NONE
;
1310 if (border
== wxBORDER_THEME
)
1312 if (CanApplyThemeBorder())
1314 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1316 return wxBORDER_THEME
;
1327 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1329 // translate common wxWidgets styles to Windows ones
1331 // most of windows are child ones, those which are not (such as
1332 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1333 WXDWORD style
= WS_CHILD
;
1335 // using this flag results in very significant reduction in flicker,
1336 // especially with controls inside the static boxes (as the interior of the
1337 // box is not redrawn twice), but sometimes results in redraw problems, so
1338 // optionally allow the old code to continue to use it provided a special
1339 // system option is turned on
1340 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1341 || (flags
& wxCLIP_CHILDREN
) )
1342 style
|= WS_CLIPCHILDREN
;
1344 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1345 // don't support overlapping windows and it only makes sense for them and,
1346 // presumably, gives the system some extra work (to manage more clipping
1347 // regions), so avoid it alltogether
1350 if ( flags
& wxVSCROLL
)
1351 style
|= WS_VSCROLL
;
1353 if ( flags
& wxHSCROLL
)
1354 style
|= WS_HSCROLL
;
1356 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1358 // After translation, border is now optimized for the specific version of Windows
1359 // and theme engine presence.
1361 // WS_BORDER is only required for wxBORDER_SIMPLE
1362 if ( border
== wxBORDER_SIMPLE
)
1365 // now deal with ext style if the caller wants it
1371 if ( flags
& wxTRANSPARENT_WINDOW
)
1372 *exstyle
|= WS_EX_TRANSPARENT
;
1378 case wxBORDER_DEFAULT
:
1379 wxFAIL_MSG( _T("unknown border style") );
1383 case wxBORDER_SIMPLE
:
1384 case wxBORDER_THEME
:
1387 case wxBORDER_STATIC
:
1388 *exstyle
|= WS_EX_STATICEDGE
;
1391 case wxBORDER_RAISED
:
1392 *exstyle
|= WS_EX_DLGMODALFRAME
;
1395 case wxBORDER_SUNKEN
:
1396 *exstyle
|= WS_EX_CLIENTEDGE
;
1397 style
&= ~WS_BORDER
;
1400 // case wxBORDER_DOUBLE:
1401 // *exstyle |= WS_EX_DLGMODALFRAME;
1405 // wxUniv doesn't use Windows dialog navigation functions at all
1406 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1407 // to make the dialog navigation work with the nested panels we must
1408 // use this style (top level windows such as dialogs don't need it)
1409 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1411 *exstyle
|= WS_EX_CONTROLPARENT
;
1413 #endif // __WXUNIVERSAL__
1419 // Setup background and foreground colours correctly
1420 void wxWindowMSW::SetupColours()
1423 SetBackgroundColour(GetParent()->GetBackgroundColour());
1426 bool wxWindowMSW::IsMouseInWindow() const
1428 // get the mouse position
1431 ::GetCursorPosWinCE(&pt
);
1433 ::GetCursorPos(&pt
);
1436 // find the window which currently has the cursor and go up the window
1437 // chain until we find this window - or exhaust it
1438 HWND hwnd
= ::WindowFromPoint(pt
);
1439 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1440 hwnd
= ::GetParent(hwnd
);
1442 return hwnd
!= NULL
;
1445 void wxWindowMSW::OnInternalIdle()
1447 #ifndef HAVE_TRACKMOUSEEVENT
1448 // Check if we need to send a LEAVE event
1449 if ( m_mouseInWindow
)
1451 // note that we should generate the leave event whether the window has
1452 // or doesn't have mouse capture
1453 if ( !IsMouseInWindow() )
1455 GenerateMouseLeave();
1458 #endif // !HAVE_TRACKMOUSEEVENT
1460 if (wxUpdateUIEvent::CanUpdate(this) && IsShown())
1461 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1464 // Set this window to be the child of 'parent'.
1465 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1467 if ( !wxWindowBase::Reparent(parent
) )
1470 HWND hWndChild
= GetHwnd();
1471 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1473 ::SetParent(hWndChild
, hWndParent
);
1476 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1478 EnsureParentHasControlParentStyle(GetParent());
1480 #endif // !__WXWINCE__
1485 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1487 #ifndef __WXMICROWIN__
1488 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1492 void wxWindowMSW::Freeze()
1494 if ( !m_frozenness
++ )
1497 SendSetRedraw(GetHwnd(), false);
1501 void wxWindowMSW::Thaw()
1503 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1505 if ( --m_frozenness
== 0 )
1509 SendSetRedraw(GetHwnd(), true);
1511 // we need to refresh everything or otherwise the invalidated area
1512 // is not going to be repainted
1518 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1520 HWND hWnd
= GetHwnd();
1527 wxCopyRectToRECT(*rect
, mswRect
);
1535 // RedrawWindow not available on SmartPhone or eVC++ 3
1536 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1537 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1541 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1543 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1548 void wxWindowMSW::Update()
1550 if ( !::UpdateWindow(GetHwnd()) )
1552 wxLogLastError(_T("UpdateWindow"));
1555 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1556 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1557 // handler needs to be really drawn right now
1562 // ---------------------------------------------------------------------------
1564 // ---------------------------------------------------------------------------
1566 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1570 // we need to lower the sibling static boxes so controls contained within can be
1572 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1574 // no sibling static boxes if we have no parent (ie TLW)
1578 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1580 node
= node
->GetNext() )
1582 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1585 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1586 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1591 #else // !wxUSE_STATBOX
1593 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1597 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1599 #endif // drag and drop is used
1601 #if wxUSE_DRAG_AND_DROP
1602 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1604 if ( m_dropTarget
!= 0 ) {
1605 m_dropTarget
->Revoke(m_hWnd
);
1606 delete m_dropTarget
;
1609 m_dropTarget
= pDropTarget
;
1610 if ( m_dropTarget
!= 0 )
1612 AdjustStaticBoxZOrder(GetParent());
1613 m_dropTarget
->Register(m_hWnd
);
1616 #endif // wxUSE_DRAG_AND_DROP
1618 // old-style file manager drag&drop support: we retain the old-style
1619 // DragAcceptFiles in parallel with SetDropTarget.
1620 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1623 HWND hWnd
= GetHwnd();
1626 AdjustStaticBoxZOrder(GetParent());
1627 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1632 // ----------------------------------------------------------------------------
1634 // ----------------------------------------------------------------------------
1638 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1640 wxWindowBase::DoSetToolTip(tooltip
);
1643 m_tooltip
->SetWindow((wxWindow
*)this);
1646 #endif // wxUSE_TOOLTIPS
1648 // ---------------------------------------------------------------------------
1649 // moving and resizing
1650 // ---------------------------------------------------------------------------
1652 bool wxWindowMSW::IsSizeDeferred() const
1654 #if USE_DEFERRED_SIZING
1655 if ( m_pendingPosition
!= wxDefaultPosition
||
1656 m_pendingSize
!= wxDefaultSize
)
1658 #endif // USE_DEFERRED_SIZING
1664 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1666 #if USE_DEFERRED_SIZING
1667 // if SetSize() had been called at wx level but not realized at Windows
1668 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1669 // the new and not the old position to the other wx code
1670 if ( m_pendingSize
!= wxDefaultSize
)
1673 *x
= m_pendingSize
.x
;
1675 *y
= m_pendingSize
.y
;
1677 else // use current size
1678 #endif // USE_DEFERRED_SIZING
1680 RECT rect
= wxGetWindowRect(GetHwnd());
1683 *x
= rect
.right
- rect
.left
;
1685 *y
= rect
.bottom
- rect
.top
;
1689 // Get size *available for subwindows* i.e. excluding menu bar etc.
1690 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1692 #if USE_DEFERRED_SIZING
1693 if ( m_pendingSize
!= wxDefaultSize
)
1695 // we need to calculate the client size corresponding to pending size
1697 rect
.left
= m_pendingPosition
.x
;
1698 rect
.top
= m_pendingPosition
.y
;
1699 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1700 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1702 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1705 *x
= rect
.right
- rect
.left
;
1707 *y
= rect
.bottom
- rect
.top
;
1710 #endif // USE_DEFERRED_SIZING
1712 RECT rect
= wxGetClientRect(GetHwnd());
1721 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1723 wxWindow
* const parent
= GetParent();
1726 if ( m_pendingPosition
!= wxDefaultPosition
)
1728 pos
= m_pendingPosition
;
1730 else // use current position
1732 RECT rect
= wxGetWindowRect(GetHwnd());
1735 point
.x
= rect
.left
;
1738 // we do the adjustments with respect to the parent only for the "real"
1739 // children, not for the dialogs/frames
1740 if ( !IsTopLevel() )
1742 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1744 // In RTL mode, we want the logical left x-coordinate,
1745 // which would be the physical right x-coordinate.
1746 point
.x
= rect
.right
;
1749 // Since we now have the absolute screen coords, if there's a
1750 // parent we must subtract its top left corner
1753 ::ScreenToClient(GetHwndOf(parent
), &point
);
1761 // we also must adjust by the client area offset: a control which is just
1762 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1763 if ( parent
&& !IsTopLevel() )
1765 const wxPoint
pt(parent
->GetClientAreaOrigin());
1776 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1784 ::ScreenToClient(GetHwnd(), &pt
);
1792 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1800 ::ClientToScreen(GetHwnd(), &pt
);
1809 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1811 #if USE_DEFERRED_SIZING
1812 // if our parent had prepared a defer window handle for us, use it (unless
1813 // we are a top level window)
1814 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1816 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1819 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1820 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1823 wxLogLastError(_T("DeferWindowPos"));
1829 // hdwp must be updated as it may have been changed
1830 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1835 // did deferred move, remember new coordinates of the window as they're
1836 // different from what Windows would return for it
1840 // otherwise (or if deferring failed) move the window in place immediately
1841 #endif // USE_DEFERRED_SIZING
1842 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1844 wxLogLastError(wxT("MoveWindow"));
1847 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1848 // ignored otherwise
1852 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1854 // TODO: is this consistent with other platforms?
1855 // Still, negative width or height shouldn't be allowed
1861 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1863 #if USE_DEFERRED_SIZING
1864 m_pendingPosition
= wxPoint(x
, y
);
1865 m_pendingSize
= wxSize(width
, height
);
1866 #endif // USE_DEFERRED_SIZING
1870 // set the size of the window: if the dimensions are positive, just use them,
1871 // but if any of them is equal to -1, it means that we must find the value for
1872 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1873 // which case -1 is a valid value for x and y)
1875 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1876 // the width/height to best suit our contents, otherwise we reuse the current
1878 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1880 // get the current size and position...
1881 int currentX
, currentY
;
1882 int currentW
, currentH
;
1884 GetPosition(¤tX
, ¤tY
);
1885 GetSize(¤tW
, ¤tH
);
1887 // ... and don't do anything (avoiding flicker) if it's already ok unless
1888 // we're forced to resize the window
1889 if ( x
== currentX
&& y
== currentY
&&
1890 width
== currentW
&& height
== currentH
&&
1891 !(sizeFlags
& wxSIZE_FORCE
) )
1896 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1898 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1901 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1903 wxSize size
= wxDefaultSize
;
1904 if ( width
== wxDefaultCoord
)
1906 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1908 size
= DoGetBestSize();
1913 // just take the current one
1918 if ( height
== wxDefaultCoord
)
1920 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1922 if ( size
.x
== wxDefaultCoord
)
1924 size
= DoGetBestSize();
1926 //else: already called DoGetBestSize() above
1932 // just take the current one
1937 DoMoveWindow(x
, y
, width
, height
);
1940 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1942 // setting the client size is less obvious than it could have been
1943 // because in the result of changing the total size the window scrollbar
1944 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
1945 // doesn't take neither into account) and so the client size will not be
1946 // correct as the difference between the total and client size changes --
1947 // so we keep changing it until we get it right
1949 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1950 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1951 // may become 3 if the window had 0 size originally and so we didn't
1952 // calculate the scrollbar correction correctly during the first iteration)
1953 // but just to be on the safe side we check for it instead of making it an
1954 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1955 for ( int i
= 0; i
< 4; i
++ )
1958 ::GetClientRect(GetHwnd(), &rectClient
);
1960 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
1961 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1962 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1967 // Find the difference between the entire window (title bar and all)
1968 // and the client area; add this to the new client size to move the
1971 ::GetWindowRect(GetHwnd(), &rectWin
);
1973 const int widthWin
= rectWin
.right
- rectWin
.left
,
1974 heightWin
= rectWin
.bottom
- rectWin
.top
;
1976 // MoveWindow positions the child windows relative to the parent, so
1977 // adjust if necessary
1978 if ( !IsTopLevel() )
1980 wxWindow
*parent
= GetParent();
1983 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
1987 // don't call DoMoveWindow() because we want to move window immediately
1988 // and not defer it here as otherwise the value returned by
1989 // GetClient/WindowRect() wouldn't change as the window wouldn't be
1991 if ( !::MoveWindow(GetHwnd(),
1994 width
+ widthWin
- rectClient
.right
,
1995 height
+ heightWin
- rectClient
.bottom
,
1998 wxLogLastError(_T("MoveWindow"));
2003 // ---------------------------------------------------------------------------
2005 // ---------------------------------------------------------------------------
2007 int wxWindowMSW::GetCharHeight() const
2009 return wxGetTextMetrics(this).tmHeight
;
2012 int wxWindowMSW::GetCharWidth() const
2014 // +1 is needed because Windows apparently adds it when calculating the
2015 // dialog units size in pixels
2016 #if wxDIALOG_UNIT_COMPATIBILITY
2017 return wxGetTextMetrics(this).tmAveCharWidth
;
2019 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2023 void wxWindowMSW::GetTextExtent(const wxString
& string
,
2025 int *descent
, int *externalLeading
,
2026 const wxFont
*theFont
) const
2028 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
2029 _T("invalid font in GetTextExtent()") );
2033 fontToUse
= *theFont
;
2035 fontToUse
= GetFont();
2037 WindowHDC
hdc(GetHwnd());
2038 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
2042 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2043 GetTextMetrics(hdc
, &tm
);
2050 *descent
= tm
.tmDescent
;
2051 if ( externalLeading
)
2052 *externalLeading
= tm
.tmExternalLeading
;
2055 // ---------------------------------------------------------------------------
2057 // ---------------------------------------------------------------------------
2059 #if wxUSE_MENUS_NATIVE
2061 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2062 // immediately, without waiting for the next event loop iteration
2064 // NB: this function should probably be made public later as it can almost
2065 // surely replace wxYield() elsewhere as well
2066 static void wxYieldForCommandsOnly()
2068 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2069 // want to process it here)
2071 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2073 if ( msg
.message
== WM_QUIT
)
2075 // if we retrieved a WM_QUIT, insert back into the message queue.
2076 ::PostQuitMessage(0);
2080 // luckily (as we don't have access to wxEventLoopImpl method from here
2081 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2083 ::TranslateMessage(&msg
);
2084 ::DispatchMessage(&msg
);
2088 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2090 menu
->SetInvokingWindow(this);
2093 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2095 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2096 x
= mouse
.x
; y
= mouse
.y
;
2099 HWND hWnd
= GetHwnd();
2100 HMENU hMenu
= GetHmenuOf(menu
);
2104 ::ClientToScreen(hWnd
, &point
);
2105 wxCurrentPopupMenu
= menu
;
2106 #if defined(__WXWINCE__)
2107 static const UINT flags
= 0;
2108 #else // !__WXWINCE__
2109 UINT flags
= TPM_RIGHTBUTTON
;
2110 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2111 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2112 // side and not to use it there neither -- modify the test if it does work
2114 if ( wxGetWinVersion() >= wxWinVersion_5
)
2116 // using TPM_RECURSE allows us to show a popup menu while another menu
2117 // is opened which can be useful and is supported by the other
2118 // platforms, so allow it under Windows too
2119 flags
|= TPM_RECURSE
;
2121 #endif // __WXWINCE__/!__WXWINCE__
2123 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2125 // we need to do it right now as otherwise the events are never going to be
2126 // sent to wxCurrentPopupMenu from HandleCommand()
2128 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2129 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2130 // destroyed as soon as we return (it can be a local variable in the caller
2131 // for example) and so we do need to process the event immediately
2132 wxYieldForCommandsOnly();
2134 wxCurrentPopupMenu
= NULL
;
2136 menu
->SetInvokingWindow(NULL
);
2141 #endif // wxUSE_MENUS_NATIVE
2143 // ===========================================================================
2144 // pre/post message processing
2145 // ===========================================================================
2147 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2150 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2152 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2155 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2157 // wxUniversal implements tab traversal itself
2158 #ifndef __WXUNIVERSAL__
2159 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2161 // intercept dialog navigation keys
2162 MSG
*msg
= (MSG
*)pMsg
;
2164 // here we try to do all the job which ::IsDialogMessage() usually does
2166 if ( msg
->message
== WM_KEYDOWN
)
2168 bool bCtrlDown
= wxIsCtrlDown();
2169 bool bShiftDown
= wxIsShiftDown();
2171 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2172 // don't process it if it's the case (except for Ctrl-Tab/Enter
2173 // combinations which are always processed)
2174 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2176 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2177 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2178 // it, of course, implies them
2179 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2181 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2184 bool bForward
= true,
2185 bWindowChange
= false,
2188 // should we process this message specially?
2189 bool bProcess
= true;
2190 switch ( msg
->wParam
)
2193 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2195 // let the control have the TAB
2198 else // use it for navigation
2200 // Ctrl-Tab cycles thru notebook pages
2201 bWindowChange
= bCtrlDown
;
2202 bForward
= !bShiftDown
;
2209 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2217 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2226 // we treat PageUp/Dn as arrows because chances are that
2227 // a control which needs arrows also needs them for
2228 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2229 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2231 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2232 bWindowChange
= true;
2238 // currently active button should get enter press even
2239 // if there is a default button elsewhere so check if
2240 // this window is a button first
2241 wxWindow
*btn
= NULL
;
2242 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2244 // let IsDialogMessage() handle this for all
2245 // buttons except the owner-drawn ones which it
2246 // just seems to ignore
2247 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2248 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2250 // emulate the button click
2251 btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2256 else // not a button itself, do we have default button?
2258 // check if this window or any of its ancestors
2259 // wants the message for itself (we always reserve
2260 // Ctrl-Enter for dialog navigation though)
2261 wxWindow
*win
= this;
2264 // this will contain the dialog code of this
2265 // window and all of its parent windows
2266 LONG lDlgCode2
= lDlgCode
;
2268 while ( win
&& !win
->IsTopLevel() )
2270 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2272 // as it wants to process Enter itself,
2273 // don't call IsDialogMessage() which
2278 lDlgCode2
= ::SendMessage
2286 win
= win
->GetParent();
2291 win
= wxGetTopLevelParent(win
);
2294 wxTopLevelWindow
* const
2295 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2298 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2303 if ( btn
&& btn
->IsEnabled() )
2305 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2309 #endif // wxUSE_BUTTON
2312 // map Enter presses into button presses on PDAs
2313 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2314 event
.SetEventObject(this);
2315 if ( GetEventHandler()->ProcessEvent(event
) )
2317 #endif // __WXWINCE__
2327 wxNavigationKeyEvent event
;
2328 event
.SetDirection(bForward
);
2329 event
.SetWindowChange(bWindowChange
);
2330 event
.SetFromTab(bFromTab
);
2331 event
.SetEventObject(this);
2333 if ( GetEventHandler()->ProcessEvent(event
) )
2335 // as we don't call IsDialogMessage(), which would take of
2336 // this by default, we need to manually send this message
2337 // so that controls can change their UI state if needed
2338 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2345 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2347 // IsDialogMessage() did something...
2351 #endif // __WXUNIVERSAL__
2356 // relay mouse move events to the tooltip control
2357 MSG
*msg
= (MSG
*)pMsg
;
2358 if ( msg
->message
== WM_MOUSEMOVE
)
2359 wxToolTip::RelayEvent(pMsg
);
2361 #endif // wxUSE_TOOLTIPS
2366 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2368 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2369 return m_acceleratorTable
.Translate(this, pMsg
);
2373 #endif // wxUSE_ACCEL
2376 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2378 // all tests below have to deal with various bugs/misfeatures of
2379 // IsDialogMessage(): we have to prevent it from being called from our
2380 // MSWProcessMessage() in some situations
2382 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2383 // message even when there is no cancel button and when the message is
2384 // needed by the control itself: in particular, it prevents the tree in
2385 // place edit control from being closed with Escape in a dialog
2386 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2391 // ::IsDialogMessage() is broken and may sometimes hang the application by
2392 // going into an infinite loop when it tries to find the control to give
2393 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2394 // situations when this may happen and not call it then
2395 if ( msg
->message
!= WM_SYSCHAR
)
2398 // assume we can call it by default
2399 bool canSafelyCallIsDlgMsg
= true;
2401 HWND hwndFocus
= ::GetFocus();
2403 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2404 // ::IsDialogMessage() will also enter an infinite loop, because it will
2405 // recursively check the child windows but not the window itself and so if
2406 // none of the children accepts focus it loops forever (as it only stops
2407 // when it gets back to the window it started from)
2409 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2410 // style has the focus, it can happen. One such possibility is if
2411 // all windows are either toplevel, wxDialog, wxPanel or static
2412 // controls and no window can actually accept keyboard input.
2413 #if !defined(__WXWINCE__)
2414 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2416 // pessimistic by default
2417 canSafelyCallIsDlgMsg
= false;
2418 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2420 node
= node
->GetNext() )
2422 wxWindow
* const win
= node
->GetData();
2423 if ( win
->CanAcceptFocus() &&
2424 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2425 WS_EX_CONTROLPARENT
) )
2427 // it shouldn't hang...
2428 canSafelyCallIsDlgMsg
= true;
2434 #endif // !__WXWINCE__
2436 if ( canSafelyCallIsDlgMsg
)
2438 // ::IsDialogMessage() can enter in an infinite loop when the
2439 // currently focused window is disabled or hidden and its
2440 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2444 if ( !::IsWindowEnabled(hwndFocus
) ||
2445 !::IsWindowVisible(hwndFocus
) )
2447 // it would enter an infinite loop if we do this!
2448 canSafelyCallIsDlgMsg
= false;
2453 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2455 // it's a top level window, don't go further -- e.g. even
2456 // if the parent of a dialog is disabled, this doesn't
2457 // break navigation inside the dialog
2461 hwndFocus
= ::GetParent(hwndFocus
);
2465 return canSafelyCallIsDlgMsg
;
2468 // ---------------------------------------------------------------------------
2469 // message params unpackers
2470 // ---------------------------------------------------------------------------
2472 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2473 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2475 *id
= LOWORD(wParam
);
2476 *hwnd
= (WXHWND
)lParam
;
2477 *cmd
= HIWORD(wParam
);
2480 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2481 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2483 *state
= LOWORD(wParam
);
2484 *minimized
= HIWORD(wParam
);
2485 *hwnd
= (WXHWND
)lParam
;
2488 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2489 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2491 *code
= LOWORD(wParam
);
2492 *pos
= HIWORD(wParam
);
2493 *hwnd
= (WXHWND
)lParam
;
2496 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2497 WXHDC
*hdc
, WXHWND
*hwnd
)
2499 *hwnd
= (WXHWND
)lParam
;
2500 *hdc
= (WXHDC
)wParam
;
2503 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2504 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2506 *item
= (WXWORD
)wParam
;
2507 *flags
= HIWORD(wParam
);
2508 *hmenu
= (WXHMENU
)lParam
;
2511 // ---------------------------------------------------------------------------
2512 // Main wxWidgets window proc and the window proc for wxWindow
2513 // ---------------------------------------------------------------------------
2515 // Hook for new window just as it's being created, when the window isn't yet
2516 // associated with the handle
2517 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2519 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2520 // window being created and insures that it's always unset back later
2521 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2523 gs_winBeingCreated
= winBeingCreated
;
2526 wxWindowCreationHook::~wxWindowCreationHook()
2528 gs_winBeingCreated
= NULL
;
2532 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2534 // trace all messages - useful for the debugging
2536 wxLogTrace(wxTraceMessages
,
2537 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2538 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2539 #endif // __WXDEBUG__
2541 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2543 // when we get the first message for the HWND we just created, we associate
2544 // it with wxWindow stored in gs_winBeingCreated
2545 if ( !wnd
&& gs_winBeingCreated
)
2547 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2548 wnd
= gs_winBeingCreated
;
2549 gs_winBeingCreated
= NULL
;
2550 wnd
->SetHWND((WXHWND
)hWnd
);
2555 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2556 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2558 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2563 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2565 // did we process the message?
2566 bool processed
= false;
2576 // for most messages we should return 0 when we do process the message
2584 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2587 // return 0 to allow window creation
2588 rc
.result
= mayCreate
? 0 : -1;
2594 // never set processed to true and *always* pass WM_DESTROY to
2595 // DefWindowProc() as Windows may do some internal cleanup when
2596 // processing it and failing to pass the message along may cause
2597 // memory and resource leaks!
2598 (void)HandleDestroy();
2602 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2606 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2609 #if !defined(__WXWINCE__)
2612 LPRECT pRect
= (LPRECT
)lParam
;
2614 rc
.SetLeft(pRect
->left
);
2615 rc
.SetTop(pRect
->top
);
2616 rc
.SetRight(pRect
->right
);
2617 rc
.SetBottom(pRect
->bottom
);
2618 processed
= HandleMoving(rc
);
2620 pRect
->left
= rc
.GetLeft();
2621 pRect
->top
= rc
.GetTop();
2622 pRect
->right
= rc
.GetRight();
2623 pRect
->bottom
= rc
.GetBottom();
2628 case WM_ENTERSIZEMOVE
:
2630 processed
= HandleEnterSizeMove();
2634 case WM_EXITSIZEMOVE
:
2636 processed
= HandleExitSizeMove();
2642 LPRECT pRect
= (LPRECT
)lParam
;
2644 rc
.SetLeft(pRect
->left
);
2645 rc
.SetTop(pRect
->top
);
2646 rc
.SetRight(pRect
->right
);
2647 rc
.SetBottom(pRect
->bottom
);
2648 processed
= HandleSizing(rc
);
2650 pRect
->left
= rc
.GetLeft();
2651 pRect
->top
= rc
.GetTop();
2652 pRect
->right
= rc
.GetRight();
2653 pRect
->bottom
= rc
.GetBottom();
2657 #endif // !__WXWINCE__
2659 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2660 case WM_ACTIVATEAPP
:
2661 // This implicitly sends a wxEVT_ACTIVATE_APP event
2662 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2668 WXWORD state
, minimized
;
2670 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2672 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2677 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2681 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2684 case WM_PRINTCLIENT
:
2685 processed
= HandlePrintClient((WXHDC
)wParam
);
2691 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2693 processed
= HandlePaint();
2697 processed
= HandlePaint();
2702 #ifdef __WXUNIVERSAL__
2703 // Universal uses its own wxFrame/wxDialog, so we don't receive
2704 // close events unless we have this.
2706 #endif // __WXUNIVERSAL__
2708 // don't let the DefWindowProc() destroy our window - we'll do it
2709 // ourselves in ~wxWindow
2715 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2719 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2720 GET_Y_LPARAM(lParam
),
2724 #ifdef HAVE_TRACKMOUSEEVENT
2726 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2728 if ( m_mouseInWindow
)
2730 GenerateMouseLeave();
2733 // always pass processed back as false, this allows the window
2734 // manager to process the message too. This is needed to
2735 // ensure windows XP themes work properly as the mouse moves
2736 // over widgets like buttons. So don't set processed to true here.
2738 #endif // HAVE_TRACKMOUSEEVENT
2740 #if wxUSE_MOUSEWHEEL
2742 processed
= HandleMouseWheel(wParam
, lParam
);
2746 case WM_LBUTTONDOWN
:
2748 case WM_LBUTTONDBLCLK
:
2749 case WM_RBUTTONDOWN
:
2751 case WM_RBUTTONDBLCLK
:
2752 case WM_MBUTTONDOWN
:
2754 case WM_MBUTTONDBLCLK
:
2755 #ifdef wxHAS_XBUTTON
2756 case WM_XBUTTONDOWN
:
2758 case WM_XBUTTONDBLCLK
:
2759 #endif // wxHAS_XBUTTON
2761 #ifdef __WXMICROWIN__
2762 // MicroWindows seems to ignore the fact that a window is
2763 // disabled. So catch mouse events and throw them away if
2765 wxWindowMSW
* win
= this;
2768 if (!win
->IsEnabled())
2774 win
= win
->GetParent();
2775 if ( !win
|| win
->IsTopLevel() )
2782 #endif // __WXMICROWIN__
2783 int x
= GET_X_LPARAM(lParam
),
2784 y
= GET_Y_LPARAM(lParam
);
2787 // redirect the event to a static control if necessary by
2788 // finding one under mouse because under CE the static controls
2789 // don't generate mouse events (even with SS_NOTIFY)
2791 if ( GetCapture() == this )
2793 // but don't do it if the mouse is captured by this window
2794 // because then it should really get this event itself
2799 win
= FindWindowForMouseEvent(this, &x
, &y
);
2801 // this should never happen
2802 wxCHECK_MSG( win
, 0,
2803 _T("FindWindowForMouseEvent() returned NULL") );
2806 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2808 SHRGINFO shrgi
= {0};
2810 shrgi
.cbSize
= sizeof(SHRGINFO
);
2811 shrgi
.hwndClient
= (HWND
) GetHWND();
2815 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2816 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2818 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2821 pt
= ClientToScreen(pt
);
2823 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2825 evtCtx
.SetEventObject(this);
2826 if (GetEventHandler()->ProcessEvent(evtCtx
))
2835 #else // !__WXWINCE__
2836 wxWindowMSW
*win
= this;
2837 #endif // __WXWINCE__/!__WXWINCE__
2839 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2841 // if the app didn't eat the event, handle it in the default
2842 // way, that is by giving this window the focus
2845 // for the standard classes their WndProc sets the focus to
2846 // them anyhow and doing it from here results in some weird
2847 // problems, so don't do it for them (unnecessary anyhow)
2848 if ( !win
->IsOfStandardClass() )
2850 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
2862 case MM_JOY1BUTTONDOWN
:
2863 case MM_JOY2BUTTONDOWN
:
2864 case MM_JOY1BUTTONUP
:
2865 case MM_JOY2BUTTONUP
:
2866 processed
= HandleJoystickEvent(message
,
2867 GET_X_LPARAM(lParam
),
2868 GET_Y_LPARAM(lParam
),
2871 #endif // __WXMICROWIN__
2877 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2879 processed
= HandleCommand(id
, cmd
, hwnd
);
2884 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2887 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2888 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2889 // apparently doesn't always behave properly and needs some help
2890 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2891 case WM_NOTIFYFORMAT
:
2892 if ( lParam
== NF_QUERY
)
2895 rc
.result
= NFR_UNICODE
;
2898 #endif // wxUSE_UNICODE_MSLU
2900 // for these messages we must return true if process the message
2903 case WM_MEASUREITEM
:
2905 int idCtrl
= (UINT
)wParam
;
2906 if ( message
== WM_DRAWITEM
)
2908 processed
= MSWOnDrawItem(idCtrl
,
2909 (WXDRAWITEMSTRUCT
*)lParam
);
2913 processed
= MSWOnMeasureItem(idCtrl
,
2914 (WXMEASUREITEMSTRUCT
*)lParam
);
2921 #endif // defined(WM_DRAWITEM)
2924 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
2926 // we always want to get the char events
2927 rc
.result
= DLGC_WANTCHARS
;
2929 if ( HasFlag(wxWANTS_CHARS
) )
2931 // in fact, we want everything
2932 rc
.result
|= DLGC_WANTARROWS
|
2939 //else: get the dlg code from the DefWindowProc()
2944 // If this has been processed by an event handler, return 0 now
2945 // (we've handled it).
2946 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2947 if ( m_lastKeydownProcessed
)
2956 // we consider these messages "not interesting" to OnChar, so
2957 // just don't do anything more with them
2967 // avoid duplicate messages to OnChar for these ASCII keys:
2968 // they will be translated by TranslateMessage() and received
3000 // but set processed to false, not true to still pass them
3001 // to the control's default window proc - otherwise
3002 // built-in keyboard handling won't work
3007 // special case of VK_APPS: treat it the same as right mouse
3008 // click because both usually pop up a context menu
3010 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3015 // do generate a CHAR event
3016 processed
= HandleChar((WORD
)wParam
, lParam
);
3019 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3026 // special case of VK_APPS: treat it the same as right mouse button
3027 if ( wParam
== VK_APPS
)
3029 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3034 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3039 case WM_CHAR
: // Always an ASCII character
3040 if ( m_lastKeydownProcessed
)
3042 // The key was handled in the EVT_KEY_DOWN and handling
3043 // a key in an EVT_KEY_DOWN handler is meant, by
3044 // design, to prevent EVT_CHARs from happening
3045 m_lastKeydownProcessed
= false;
3050 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3056 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3058 #endif // wxUSE_HOTKEY
3065 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3067 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3073 // CTLCOLOR messages are sent by children to query the parent for their
3075 #ifndef __WXMICROWIN__
3076 case WM_CTLCOLORMSGBOX
:
3077 case WM_CTLCOLOREDIT
:
3078 case WM_CTLCOLORLISTBOX
:
3079 case WM_CTLCOLORBTN
:
3080 case WM_CTLCOLORDLG
:
3081 case WM_CTLCOLORSCROLLBAR
:
3082 case WM_CTLCOLORSTATIC
:
3086 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3088 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3091 #endif // !__WXMICROWIN__
3093 case WM_SYSCOLORCHANGE
:
3094 // the return value for this message is ignored
3095 processed
= HandleSysColorChange();
3098 #if !defined(__WXWINCE__)
3099 case WM_DISPLAYCHANGE
:
3100 processed
= HandleDisplayChange();
3104 case WM_PALETTECHANGED
:
3105 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
3108 case WM_CAPTURECHANGED
:
3109 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
3112 case WM_SETTINGCHANGE
:
3113 processed
= HandleSettingChange(wParam
, lParam
);
3116 case WM_QUERYNEWPALETTE
:
3117 processed
= HandleQueryNewPalette();
3121 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
3124 // we processed the message, i.e. erased the background
3129 #if !defined(__WXWINCE__)
3131 processed
= HandleDropFiles(wParam
);
3136 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
3140 // we never set focus from here
3145 #if !defined(__WXWINCE__)
3146 case WM_QUERYENDSESSION
:
3147 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3151 processed
= HandleEndSession(wParam
!= 0, lParam
);
3154 case WM_GETMINMAXINFO
:
3155 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3160 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
3161 LOWORD(lParam
), // hit test
3162 HIWORD(lParam
)); // mouse msg
3166 // returning TRUE stops the DefWindowProc() from further
3167 // processing this message - exactly what we need because we've
3168 // just set the cursor.
3173 #if wxUSE_ACCESSIBILITY
3176 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3177 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3179 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3181 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3187 #if defined(WM_HELP)
3190 // by default, WM_HELP is propagated by DefWindowProc() upwards
3191 // to the window parent but as we do it ourselves already
3192 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3193 // to get the other events if we process this message at all
3196 // WM_HELP doesn't use lParam under CE
3198 HELPINFO
* info
= (HELPINFO
*) lParam
;
3199 if ( info
->iContextType
== HELPINFO_WINDOW
)
3201 #endif // !__WXWINCE__
3202 wxHelpEvent helpEvent
3207 wxGetMousePosition() // what else?
3209 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3213 helpEvent
.SetEventObject(this);
3214 GetEventHandler()->ProcessEvent(helpEvent
);
3217 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3219 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3220 helpEvent
.SetEventObject(this);
3221 GetEventHandler()->ProcessEvent(helpEvent
);
3224 else // unknown help event?
3228 #endif // !__WXWINCE__
3233 #if !defined(__WXWINCE__)
3234 case WM_CONTEXTMENU
:
3236 // we don't convert from screen to client coordinates as
3237 // the event may be handled by a parent window
3238 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3240 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3242 // we could have got an event from our child, reflect it back
3243 // to it if this is the case
3244 wxWindowMSW
*win
= NULL
;
3245 if ( (WXHWND
)wParam
!= m_hWnd
)
3247 win
= FindItemByHWND((WXHWND
)wParam
);
3253 evtCtx
.SetEventObject(win
);
3254 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
3261 // we're only interested in our own menus, not MF_SYSMENU
3262 if ( HIWORD(wParam
) == MF_POPUP
)
3264 // handle menu chars for ownerdrawn menu items
3265 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3266 if ( i
!= wxNOT_FOUND
)
3268 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3273 #endif // wxUSE_MENUS
3276 case WM_POWERBROADCAST
:
3279 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3280 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3283 #endif // __WXWINCE__
3286 // If we want the default themed border then we need to draw it ourselves
3289 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3290 const wxBorder border
= TranslateBorder(GetBorder());
3291 if (theme
&& border
== wxBORDER_THEME
)
3293 // first ask the widget to calculate the border size
3294 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3297 // now alter the client size making room for drawing a themed border
3298 NCCALCSIZE_PARAMS
*csparam
= NULL
;
3302 csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3303 rect
= csparam
->rgrc
[0];
3307 rect
= *((RECT
*)lParam
);
3309 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3310 RECT rcClient
= { 0, 0, 0, 0 };
3311 wxClientDC
dc((wxWindow
*)this);
3313 if (theme
->GetThemeBackgroundContentRect(
3314 hTheme
, GetHdcOf(dc
), EP_EDITTEXT
, ETS_NORMAL
,
3315 &rect
, &rcClient
) == S_OK
)
3317 InflateRect(&rcClient
, -1, -1);
3319 csparam
->rgrc
[0] = rcClient
;
3321 *((RECT
*)lParam
) = rcClient
;
3322 rc
.result
= WVR_REDRAW
;
3330 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3331 const wxBorder border
= TranslateBorder(GetBorder());
3332 if (theme
&& border
== wxBORDER_THEME
)
3334 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3335 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3338 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3339 wxWindowDC
dc((wxWindow
*)this);
3341 // Clip the DC so that you only draw on the non-client area
3343 wxCopyRectToRECT(GetSize(), rcBorder
);
3346 theme
->GetThemeBackgroundContentRect(
3347 hTheme
, GetHdcOf(dc
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3348 InflateRect(&rcClient
, -1, -1);
3350 ::ExcludeClipRect(GetHdcOf(dc
), rcClient
.left
, rcClient
.top
,
3351 rcClient
.right
, rcClient
.bottom
);
3353 // Make sure the background is in a proper state
3354 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3356 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(dc
), &rcBorder
);
3362 nState
= ETS_DISABLED
;
3363 // should we check this?
3364 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3365 // nState = ETS_READONLY;
3367 nState
= ETS_NORMAL
;
3368 theme
->DrawThemeBackground(hTheme
, GetHdcOf(dc
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3373 #endif // wxUSE_UXTHEME
3376 // try a custom message handler
3377 const MSWMessageHandlers::const_iterator
3378 i
= gs_messageHandlers
.find(message
);
3379 if ( i
!= gs_messageHandlers
.end() )
3381 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3388 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3389 wxGetMessageName(message
));
3390 #endif // __WXDEBUG__
3391 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3397 // ----------------------------------------------------------------------------
3398 // wxWindow <-> HWND map
3399 // ----------------------------------------------------------------------------
3401 wxWinHashTable
*wxWinHandleHash
= NULL
;
3403 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3405 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3408 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3410 // adding NULL hWnd is (first) surely a result of an error and
3411 // (secondly) breaks menu command processing
3412 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3413 wxT("attempt to add a NULL hWnd to window list ignored") );
3415 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3417 if ( oldWin
&& (oldWin
!= win
) )
3419 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3420 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3423 #endif // __WXDEBUG__
3426 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3430 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3432 wxWinHandleHash
->Delete((long)win
->GetHWND());
3435 // ----------------------------------------------------------------------------
3436 // various MSW speciic class dependent functions
3437 // ----------------------------------------------------------------------------
3439 // Default destroyer - override if you destroy it in some other way
3440 // (e.g. with MDI child windows)
3441 void wxWindowMSW::MSWDestroyWindow()
3445 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3448 int& w
, int& h
) const
3450 // yes, those are just some arbitrary hardcoded numbers
3451 static const int DEFAULT_Y
= 200;
3453 bool nonDefault
= false;
3455 if ( pos
.x
== wxDefaultCoord
)
3457 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3458 // can just as well set it to CW_USEDEFAULT as well
3464 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3465 // neither because it is not handled as a special value by Windows then
3466 // and so we have to choose some default value for it
3468 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3474 NB: there used to be some code here which set the initial size of the
3475 window to the client size of the parent if no explicit size was
3476 specified. This was wrong because wxWidgets programs often assume
3477 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3478 it. To see why, you should understand that Windows sends WM_SIZE from
3479 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3480 from some base class ctor and so this WM_SIZE is not processed in the
3481 real class' OnSize() (because it's not fully constructed yet and the
3482 event goes to some base class OnSize() instead). So the WM_SIZE we
3483 rely on is the one sent when the parent frame resizes its children
3484 but here is the problem: if the child already has just the right
3485 size, nothing will happen as both wxWidgets and Windows check for
3486 this and ignore any attempts to change the window size to the size it
3487 already has - so no WM_SIZE would be sent.
3491 // we don't use CW_USEDEFAULT here for several reasons:
3493 // 1. it results in huge frames on modern screens (1000*800 is not
3494 // uncommon on my 1280*1024 screen) which is way too big for a half
3495 // empty frame of most of wxWidgets samples for example)
3497 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3498 // the default is for whatever reason 8*8 which breaks client <->
3499 // window size calculations (it would be nice if it didn't, but it
3500 // does and the simplest way to fix it seemed to change the broken
3501 // default size anyhow)
3503 // 3. there is just no advantage in doing it: with x and y it is
3504 // possible that [future versions of] Windows position the new top
3505 // level window in some smart way which we can't do, but we can
3506 // guess a reasonably good size for a new window just as well
3509 // However, on PocketPC devices, we must use the default
3510 // size if possible.
3512 if (size
.x
== wxDefaultCoord
)
3516 if (size
.y
== wxDefaultCoord
)
3521 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3525 w
= WidthDefault(size
.x
);
3526 h
= HeightDefault(size
.y
);
3529 AdjustForParentClientOrigin(x
, y
);
3534 WXHWND
wxWindowMSW::MSWGetParent() const
3536 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3539 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3540 const wxChar
*title
,
3544 WXDWORD extendedStyle
)
3546 // choose the position/size for the new window
3548 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3550 // controlId is menu handle for the top level windows, so set it to 0
3551 // unless we're creating a child window
3552 int controlId
= style
& WS_CHILD
? GetId() : 0;
3554 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3555 // which is the same but without CS_[HV]REDRAW class styles so using it
3556 // ensures that the window is not fully repainted on each resize
3557 wxString
className(wclass
);
3558 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3560 className
+= wxT("NR");
3563 // do create the window
3564 wxWindowCreationHook
hook(this);
3566 m_hWnd
= (WXHWND
)::CreateWindowEx
3570 title
? title
: m_windowName
.wx_str(),
3573 (HWND
)MSWGetParent(),
3576 NULL
// no extra data
3581 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3586 SubclassWin(m_hWnd
);
3591 // ===========================================================================
3592 // MSW message handlers
3593 // ===========================================================================
3595 // ---------------------------------------------------------------------------
3597 // ---------------------------------------------------------------------------
3599 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3601 #ifndef __WXMICROWIN__
3602 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3603 HWND hWnd
= hdr
->hwndFrom
;
3604 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3606 // if the control is one of our windows, let it handle the message itself
3609 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3612 // VZ: why did we do it? normally this is unnecessary and, besides, it
3613 // breaks the message processing for the toolbars because the tooltip
3614 // notifications were being forwarded to the toolbar child controls
3615 // (if it had any) before being passed to the toolbar itself, so in my
3616 // example the tooltip for the combobox was always shown instead of the
3617 // correct button tooltips
3619 // try all our children
3620 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3623 wxWindow
*child
= node
->GetData();
3624 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3629 node
= node
->GetNext();
3633 // by default, handle it ourselves
3634 return MSWOnNotify(idCtrl
, lParam
, result
);
3635 #else // __WXMICROWIN__
3642 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3644 const wxString
& ttip
)
3646 // I don't know why it happens, but the versions of comctl32.dll starting
3647 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3648 // this message is supposed to be sent to Unicode programs only) -- hence
3649 // we need to handle it as well, otherwise no tooltips will be shown in
3652 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3655 // not a tooltip message or no tooltip to show anyhow
3660 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3662 // We don't want to use the szText buffer because it has a limit of 80
3663 // bytes and this is not enough, especially for Unicode build where it
3664 // limits the tooltip string length to only 40 characters
3666 // The best would be, of course, to not impose any length limitations at
3667 // all but then the buffer would have to be dynamic and someone would have
3668 // to free it and we don't have the tooltip owner object here any more, so
3669 // for now use our own static buffer with a higher fixed max length.
3671 // Note that using a static buffer should not be a problem as only a single
3672 // tooltip can be shown at the same time anyhow.
3674 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3676 // We need to convert tooltip from multi byte to Unicode on the fly.
3677 static wchar_t buf
[513];
3679 // Truncate tooltip length if needed as otherwise we might not have
3680 // enough space for it in the buffer and MultiByteToWideChar() would
3682 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3684 // Convert to WideChar without adding the NULL character. The NULL
3685 // character is added afterwards (this is more efficient).
3686 int len
= ::MultiByteToWideChar
3698 wxLogLastError(_T("MultiByteToWideChar()"));
3702 ttText
->lpszText
= (LPSTR
) buf
;
3704 else // TTN_NEEDTEXTA
3705 #endif // !wxUSE_UNICODE
3707 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3708 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3709 // to copy the string we have into the buffer
3710 static wxChar buf
[513];
3711 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3712 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3713 ttText
->lpszText
= buf
;
3719 #endif // wxUSE_TOOLTIPS
3721 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3723 WXLPARAM
* WXUNUSED(result
))
3728 NMHDR
* hdr
= (NMHDR
*)lParam
;
3729 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3736 wxUnusedVar(lParam
);
3737 #endif // wxUSE_TOOLTIPS
3742 // ---------------------------------------------------------------------------
3743 // end session messages
3744 // ---------------------------------------------------------------------------
3746 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3748 #ifdef ENDSESSION_LOGOFF
3749 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3750 event
.SetEventObject(wxTheApp
);
3751 event
.SetCanVeto(true);
3752 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3754 bool rc
= wxTheApp
->ProcessEvent(event
);
3758 // we may end only if the app didn't veto session closing (double
3760 *mayEnd
= !event
.GetVeto();
3765 wxUnusedVar(logOff
);
3766 wxUnusedVar(mayEnd
);
3771 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3773 #ifdef ENDSESSION_LOGOFF
3774 // do nothing if the session isn't ending
3779 if ( (this != wxTheApp
->GetTopWindow()) )
3782 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3783 event
.SetEventObject(wxTheApp
);
3784 event
.SetCanVeto(false);
3785 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3787 return wxTheApp
->ProcessEvent(event
);
3789 wxUnusedVar(endSession
);
3790 wxUnusedVar(logOff
);
3795 // ---------------------------------------------------------------------------
3796 // window creation/destruction
3797 // ---------------------------------------------------------------------------
3799 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3802 // VZ: why is this commented out for WinCE? If it doesn't support
3803 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3804 // not with multiple #ifdef's!
3806 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3807 EnsureParentHasControlParentStyle(GetParent());
3808 #endif // !__WXWINCE__
3815 bool wxWindowMSW::HandleDestroy()
3819 // delete our drop target if we've got one
3820 #if wxUSE_DRAG_AND_DROP
3821 if ( m_dropTarget
!= NULL
)
3823 m_dropTarget
->Revoke(m_hWnd
);
3825 delete m_dropTarget
;
3826 m_dropTarget
= NULL
;
3828 #endif // wxUSE_DRAG_AND_DROP
3830 // WM_DESTROY handled
3834 // ---------------------------------------------------------------------------
3836 // ---------------------------------------------------------------------------
3838 bool wxWindowMSW::HandleActivate(int state
,
3839 bool WXUNUSED(minimized
),
3840 WXHWND
WXUNUSED(activate
))
3842 wxActivateEvent
event(wxEVT_ACTIVATE
,
3843 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3845 event
.SetEventObject(this);
3847 return GetEventHandler()->ProcessEvent(event
);
3850 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3852 // Strangly enough, some controls get set focus events when they are being
3853 // deleted, even if they already had focus before.
3854 if ( m_isBeingDeleted
)
3859 // notify the parent keeping track of focus for the kbd navigation
3860 // purposes that we got it
3861 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3862 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3868 m_caret
->OnSetFocus();
3870 #endif // wxUSE_CARET
3873 // If it's a wxTextCtrl don't send the event as it will be done
3874 // after the control gets to process it from EN_FOCUS handler
3875 if ( wxDynamicCastThis(wxTextCtrl
) )
3879 #endif // wxUSE_TEXTCTRL
3881 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3882 event
.SetEventObject(this);
3884 // wxFindWinFromHandle() may return NULL, it is ok
3885 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3887 return GetEventHandler()->ProcessEvent(event
);
3890 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3896 m_caret
->OnKillFocus();
3898 #endif // wxUSE_CARET
3901 // If it's a wxTextCtrl don't send the event as it will be done
3902 // after the control gets to process it.
3903 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3910 // Don't send the event when in the process of being deleted. This can
3911 // only cause problems if the event handler tries to access the object.
3912 if ( m_isBeingDeleted
)
3917 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3918 event
.SetEventObject(this);
3920 // wxFindWinFromHandle() may return NULL, it is ok
3921 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3923 return GetEventHandler()->ProcessEvent(event
);
3926 // ---------------------------------------------------------------------------
3928 // ---------------------------------------------------------------------------
3930 void wxWindowMSW::SetLabel( const wxString
& label
)
3932 SetWindowText(GetHwnd(), label
.c_str());
3935 wxString
wxWindowMSW::GetLabel() const
3937 return wxGetWindowText(GetHWND());
3940 // ---------------------------------------------------------------------------
3942 // ---------------------------------------------------------------------------
3944 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3946 wxShowEvent
event(GetId(), show
);
3947 event
.SetEventObject(this);
3949 return GetEventHandler()->ProcessEvent(event
);
3952 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3954 wxInitDialogEvent
event(GetId());
3955 event
.SetEventObject(this);
3957 return GetEventHandler()->ProcessEvent(event
);
3960 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3962 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3963 wxUnusedVar(wParam
);
3965 #else // __WXMICROWIN__
3966 HDROP hFilesInfo
= (HDROP
) wParam
;
3968 // Get the total number of files dropped
3969 UINT gwFilesDropped
= ::DragQueryFile
3977 wxString
*files
= new wxString
[gwFilesDropped
];
3978 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3980 // first get the needed buffer length (+1 for terminating NUL)
3981 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3983 // and now get the file name
3984 ::DragQueryFile(hFilesInfo
, wIndex
,
3985 wxStringBuffer(files
[wIndex
], len
), len
);
3987 DragFinish (hFilesInfo
);
3989 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3990 event
.SetEventObject(this);
3993 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3994 event
.m_pos
.x
= dropPoint
.x
;
3995 event
.m_pos
.y
= dropPoint
.y
;
3997 return GetEventHandler()->ProcessEvent(event
);
4002 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4004 int WXUNUSED(mouseMsg
))
4006 #ifndef __WXMICROWIN__
4007 // the logic is as follows:
4008 // 0. if we're busy, set the busy cursor (even for non client elements)
4009 // 1. don't set custom cursor for non client area of enabled windows
4010 // 2. ask user EVT_SET_CURSOR handler for the cursor
4011 // 3. if still no cursor but we're in a TLW, set the global cursor
4013 HCURSOR hcursor
= 0;
4016 hcursor
= wxGetCurrentBusyCursor();
4020 if ( nHitTest
!= HTCLIENT
)
4023 // first ask the user code - it may wish to set the cursor in some very
4024 // specific way (for example, depending on the current position)
4027 if ( !::GetCursorPosWinCE(&pt
))
4029 if ( !::GetCursorPos(&pt
) )
4032 wxLogLastError(wxT("GetCursorPos"));
4037 ScreenToClient(&x
, &y
);
4038 wxSetCursorEvent
event(x
, y
);
4040 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
4041 if ( processedEvtSetCursor
&& event
.HasCursor() )
4043 hcursor
= GetHcursorOf(event
.GetCursor());
4048 // the test for processedEvtSetCursor is here to prevent using
4049 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4050 // nothing from it - this is a way to say that our cursor shouldn't
4051 // be used for this point
4052 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4054 hcursor
= GetHcursorOf(m_cursor
);
4057 if ( !hcursor
&& !GetParent() )
4059 const wxCursor
*cursor
= wxGetGlobalCursor();
4060 if ( cursor
&& cursor
->Ok() )
4062 hcursor
= GetHcursorOf(*cursor
);
4071 ::SetCursor(hcursor
);
4073 // cursor set, stop here
4076 #endif // __WXMICROWIN__
4078 // pass up the window chain
4082 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4083 WXLPARAM
WXUNUSED(lParam
),
4084 bool *WXUNUSED_IN_WINCE(vetoed
))
4090 wxEventType evtType
;
4093 case PBT_APMQUERYSUSPEND
:
4094 evtType
= wxEVT_POWER_SUSPENDING
;
4097 case PBT_APMQUERYSUSPENDFAILED
:
4098 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4101 case PBT_APMSUSPEND
:
4102 evtType
= wxEVT_POWER_SUSPENDED
;
4105 case PBT_APMRESUMESUSPEND
:
4106 #ifdef PBT_APMRESUMEAUTOMATIC
4107 case PBT_APMRESUMEAUTOMATIC
:
4109 evtType
= wxEVT_POWER_RESUME
;
4113 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4116 // these messages are currently not mapped to wx events
4117 case PBT_APMQUERYSTANDBY
:
4118 case PBT_APMQUERYSTANDBYFAILED
:
4119 case PBT_APMSTANDBY
:
4120 case PBT_APMRESUMESTANDBY
:
4121 case PBT_APMBATTERYLOW
:
4122 case PBT_APMPOWERSTATUSCHANGE
:
4123 case PBT_APMOEMEVENT
:
4124 case PBT_APMRESUMECRITICAL
:
4125 evtType
= wxEVT_NULL
;
4129 // don't handle unknown messages
4130 if ( evtType
== wxEVT_NULL
)
4133 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4135 wxPowerEvent
event(evtType
);
4136 if ( !GetEventHandler()->ProcessEvent(event
) )
4139 *vetoed
= event
.IsVetoed();
4145 bool wxWindowMSW::IsDoubleBuffered() const
4147 for ( const wxWindowMSW
*wnd
= this;
4148 wnd
&& !wnd
->IsTopLevel(); wnd
=
4151 if ( ::GetWindowLong(GetHwndOf(wnd
), GWL_EXSTYLE
) & WS_EX_COMPOSITED
)
4158 // ---------------------------------------------------------------------------
4159 // owner drawn stuff
4160 // ---------------------------------------------------------------------------
4162 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4163 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4164 #define WXUNUSED_UNLESS_ODRAWN(param) param
4166 #define WXUNUSED_UNLESS_ODRAWN(param)
4170 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4171 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4173 #if wxUSE_OWNER_DRAWN
4175 #if wxUSE_MENUS_NATIVE
4176 // is it a menu item?
4177 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4178 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4180 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4182 // see comment before the same test in MSWOnMeasureItem() below
4186 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4187 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
4189 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4190 // the DC from being released
4191 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4192 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4193 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4194 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4196 return pMenuItem
->OnDrawItem
4200 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4201 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4204 #endif // wxUSE_MENUS_NATIVE
4206 #endif // USE_OWNER_DRAWN
4208 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4210 #if wxUSE_OWNER_DRAWN
4211 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4212 #else // !wxUSE_OWNER_DRAWN
4213 // we may still have owner-drawn buttons internally because we have to make
4214 // them owner-drawn to support colour change
4217 wxDynamicCast(FindItem(id
), wxButton
)
4222 #endif // USE_OWNER_DRAWN
4226 return item
->MSWOnDraw(itemStruct
);
4229 #endif // wxUSE_CONTROLS
4235 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4237 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4238 // is it a menu item?
4239 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4240 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4242 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4244 // according to Carsten Fuchs the pointer may be NULL under XP if an
4245 // MDI child frame is initially maximized, see this for more info:
4246 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4248 // so silently ignore it instead of asserting
4252 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4253 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4256 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4258 pMeasureStruct
->itemWidth
= w
;
4259 pMeasureStruct
->itemHeight
= h
;
4264 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4267 return item
->MSWOnMeasure(itemStruct
);
4271 wxUnusedVar(itemStruct
);
4272 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4277 // ---------------------------------------------------------------------------
4278 // colours and palettes
4279 // ---------------------------------------------------------------------------
4281 bool wxWindowMSW::HandleSysColorChange()
4283 wxSysColourChangedEvent event
;
4284 event
.SetEventObject(this);
4286 (void)GetEventHandler()->ProcessEvent(event
);
4288 // always let the system carry on the default processing to allow the
4289 // native controls to react to the colours update
4293 bool wxWindowMSW::HandleDisplayChange()
4295 wxDisplayChangedEvent event
;
4296 event
.SetEventObject(this);
4298 return GetEventHandler()->ProcessEvent(event
);
4301 #ifndef __WXMICROWIN__
4303 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4305 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4309 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4312 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4314 #endif // wxUSE_CONTROLS
4317 return *brush
!= NULL
;
4320 #endif // __WXMICROWIN__
4322 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4325 // same as below except we don't respond to our own messages
4326 if ( hWndPalChange
!= GetHWND() )
4328 // check to see if we our our parents have a custom palette
4329 wxWindowMSW
*win
= this;
4330 while ( win
&& !win
->HasCustomPalette() )
4332 win
= win
->GetParent();
4335 if ( win
&& win
->HasCustomPalette() )
4337 // realize the palette to see whether redrawing is needed
4338 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4339 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4340 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4342 int result
= ::RealizePalette(hdc
);
4344 // restore the palette (before releasing the DC)
4345 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4346 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4347 ::RealizePalette(hdc
);
4348 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4350 // now check for the need to redraw
4352 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4356 #endif // wxUSE_PALETTE
4358 wxPaletteChangedEvent
event(GetId());
4359 event
.SetEventObject(this);
4360 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4362 return GetEventHandler()->ProcessEvent(event
);
4365 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4367 // notify windows on the capture stack about lost capture
4368 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4369 wxWindowBase::NotifyCaptureLost();
4371 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4372 wxMouseCaptureChangedEvent
event(GetId(), win
);
4373 event
.SetEventObject(this);
4374 return GetEventHandler()->ProcessEvent(event
);
4377 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4379 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4380 // we need to send this to child windows (it is only sent to top-level
4381 // windows) so {list,tree}ctrls can adjust their font size if necessary
4382 // this is exactly how explorer does it to enable the font size changes
4384 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4387 // top-level windows already get this message from the system
4388 wxWindow
*win
= node
->GetData();
4389 if ( !win
->IsTopLevel() )
4391 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4394 node
= node
->GetNext();
4397 // let the system handle it
4401 bool wxWindowMSW::HandleQueryNewPalette()
4405 // check to see if we our our parents have a custom palette
4406 wxWindowMSW
*win
= this;
4407 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4408 if (win
->HasCustomPalette()) {
4409 /* realize the palette to see whether redrawing is needed */
4410 HDC hdc
= ::GetDC((HWND
) GetHWND());
4411 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4412 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4414 int result
= ::RealizePalette(hdc
);
4415 /* restore the palette (before releasing the DC) */
4416 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4417 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4418 ::RealizePalette(hdc
);
4419 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4420 /* now check for the need to redraw */
4422 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4424 #endif // wxUSE_PALETTE
4426 wxQueryNewPaletteEvent
event(GetId());
4427 event
.SetEventObject(this);
4429 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
4432 // Responds to colour changes: passes event on to children.
4433 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4435 // the top level window also reset the standard colour map as it might have
4436 // changed (there is no need to do it for the non top level windows as we
4437 // only have to do it once)
4441 gs_hasStdCmap
= false;
4443 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4446 // Only propagate to non-top-level windows because Windows already
4447 // sends this event to all top-level ones
4448 wxWindow
*win
= node
->GetData();
4449 if ( !win
->IsTopLevel() )
4451 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4452 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4453 // the standard controls
4454 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4457 node
= node
->GetNext();
4461 extern wxCOLORMAP
*wxGetStdColourMap()
4463 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4464 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4466 if ( !gs_hasStdCmap
)
4468 static bool s_coloursInit
= false;
4470 if ( !s_coloursInit
)
4472 // When a bitmap is loaded, the RGB values can change (apparently
4473 // because Windows adjusts them to care for the old programs always
4474 // using 0xc0c0c0 while the transparent colour for the new Windows
4475 // versions is different). But we do this adjustment ourselves so
4476 // we want to avoid Windows' "help" and for this we need to have a
4477 // reference bitmap which can tell us what the RGB values change
4479 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4480 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4481 if ( stdColourBitmap
.Ok() )
4483 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4484 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4485 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4488 memDC
.SelectObject(stdColourBitmap
);
4491 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4493 memDC
.GetPixel(i
, 0, &colour
);
4494 s_stdColours
[i
] = wxColourToRGB(colour
);
4497 else // wxBITMAP_STD_COLOURS couldn't be loaded
4499 s_stdColours
[0] = RGB(000,000,000); // black
4500 s_stdColours
[1] = RGB(128,128,128); // dark grey
4501 s_stdColours
[2] = RGB(192,192,192); // light grey
4502 s_stdColours
[3] = RGB(255,255,255); // white
4503 //s_stdColours[4] = RGB(000,000,255); // blue
4504 //s_stdColours[5] = RGB(255,000,255); // magenta
4507 s_coloursInit
= true;
4510 gs_hasStdCmap
= true;
4512 // create the colour map
4513 #define INIT_CMAP_ENTRY(col) \
4514 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4515 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4517 INIT_CMAP_ENTRY(BTNTEXT
);
4518 INIT_CMAP_ENTRY(BTNSHADOW
);
4519 INIT_CMAP_ENTRY(BTNFACE
);
4520 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4522 #undef INIT_CMAP_ENTRY
4528 // ---------------------------------------------------------------------------
4530 // ---------------------------------------------------------------------------
4532 bool wxWindowMSW::HandlePaint()
4534 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4536 wxLogLastError(wxT("CreateRectRgn"));
4537 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4538 wxLogLastError(wxT("GetUpdateRgn"));
4540 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4542 wxPaintEvent
event(m_windowId
);
4543 event
.SetEventObject(this);
4545 bool processed
= GetEventHandler()->ProcessEvent(event
);
4547 // note that we must generate NC event after the normal one as otherwise
4548 // BeginPaint() will happily overwrite our decorations with the background
4550 wxNcPaintEvent
eventNc(m_windowId
);
4551 eventNc
.SetEventObject(this);
4552 GetEventHandler()->ProcessEvent(eventNc
);
4554 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4555 // be called from inside the event handlers called above)
4556 m_updateRegion
.Clear();
4561 // Can be called from an application's OnPaint handler
4562 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4564 #ifdef __WXUNIVERSAL__
4567 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
4570 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4575 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4577 wxDCTemp
dc(hdc
, GetClientSize());
4580 dc
.SetWindow((wxWindow
*)this);
4582 wxEraseEvent
event(m_windowId
, &dc
);
4583 event
.SetEventObject(this);
4584 bool rc
= GetEventHandler()->ProcessEvent(event
);
4586 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4587 dc
.SelectOldObjects(hdc
);
4592 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4594 // standard non top level controls (i.e. except the dialogs) always erase
4595 // their background themselves in HandleCtlColor() or have some control-
4596 // specific ways to set the colours (common controls)
4597 if ( IsOfStandardClass() && !IsTopLevel() )
4603 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4605 // don't skip the event here, custom background means that the app
4606 // is drawing it itself in its OnPaint(), so don't draw it at all
4607 // now to avoid flicker
4612 // do default background painting
4613 if ( !DoEraseBackground(GetHdcOf(*event
.GetDC())) )
4615 // let the system paint the background
4620 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4622 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4626 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4632 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4636 // our background colour applies to:
4637 // 1. this window itself, always
4638 // 2. all children unless the colour is "not inheritable"
4639 // 3. even if it is not inheritable, our immediate transparent
4640 // children should still inherit it -- but not any transparent
4641 // children because it would look wrong if a child of non
4642 // transparent child would show our bg colour when the child itself
4644 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4647 (win
&& win
->HasTransparentBackground() &&
4648 win
->GetParent() == this) )
4650 // draw children with the same colour as the parent
4652 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4654 return (WXHBRUSH
)GetHbrushOf(*brush
);
4661 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4664 hWndToPaint
= GetHWND();
4666 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4668 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4672 // background is not inherited beyond top level windows
4673 if ( win
->IsTopLevel() )
4680 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4682 // we receive this message when DrawThemeParentBackground() is
4683 // called from def window proc of several controls under XP and we
4684 // must draw properly themed background here
4686 // note that naively I'd expect filling the client rect with the
4687 // brush returned by MSWGetBgBrush() work -- but for some reason it
4688 // doesn't and we have to call parents MSWPrintChild() which is
4689 // supposed to call DrawThemeBackground() with appropriate params
4691 // also note that in this case lParam == PRF_CLIENT but we're
4692 // clearly expected to paint the background and nothing else!
4694 if ( IsTopLevel() || InheritsBackgroundColour() )
4697 // sometimes we don't want the parent to handle it at all, instead
4698 // return whatever value this window wants
4699 if ( !MSWShouldPropagatePrintChild() )
4700 return MSWPrintChild(hDC
, (wxWindow
*)this);
4702 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4704 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4707 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4714 // ---------------------------------------------------------------------------
4715 // moving and resizing
4716 // ---------------------------------------------------------------------------
4718 bool wxWindowMSW::HandleMinimize()
4720 wxIconizeEvent
event(m_windowId
);
4721 event
.SetEventObject(this);
4723 return GetEventHandler()->ProcessEvent(event
);
4726 bool wxWindowMSW::HandleMaximize()
4728 wxMaximizeEvent
event(m_windowId
);
4729 event
.SetEventObject(this);
4731 return GetEventHandler()->ProcessEvent(event
);
4734 bool wxWindowMSW::HandleMove(int x
, int y
)
4737 wxMoveEvent
event(point
, m_windowId
);
4738 event
.SetEventObject(this);
4740 return GetEventHandler()->ProcessEvent(event
);
4743 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4745 wxMoveEvent
event(rect
, m_windowId
);
4746 event
.SetEventObject(this);
4748 bool rc
= GetEventHandler()->ProcessEvent(event
);
4750 rect
= event
.GetRect();
4754 bool wxWindowMSW::HandleEnterSizeMove()
4756 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4757 event
.SetEventType(wxEVT_MOVE_START
);
4758 event
.SetEventObject(this);
4760 return GetEventHandler()->ProcessEvent(event
);
4763 bool wxWindowMSW::HandleExitSizeMove()
4765 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4766 event
.SetEventType(wxEVT_MOVE_END
);
4767 event
.SetEventObject(this);
4769 return GetEventHandler()->ProcessEvent(event
);
4772 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4774 #if USE_DEFERRED_SIZING
4775 // when we resize this window, its children are probably going to be
4776 // repositioned as well, prepare to use DeferWindowPos() for them
4777 int numChildren
= 0;
4778 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4780 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4785 // Protect against valid m_hDWP being overwritten
4786 bool useDefer
= false;
4788 if ( numChildren
> 1 )
4792 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4795 wxLogLastError(_T("BeginDeferWindowPos"));
4801 #endif // USE_DEFERRED_SIZING
4803 // update this window size
4804 bool processed
= false;
4808 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4809 // fall through nevertheless
4813 // we're not interested in these messages at all
4816 case SIZE_MINIMIZED
:
4817 processed
= HandleMinimize();
4820 case SIZE_MAXIMIZED
:
4821 /* processed = */ HandleMaximize();
4822 // fall through to send a normal size event as well
4825 // don't use w and h parameters as they specify the client size
4826 // while according to the docs EVT_SIZE handler is supposed to
4827 // receive the total size
4828 wxSizeEvent
event(GetSize(), m_windowId
);
4829 event
.SetEventObject(this);
4831 processed
= GetEventHandler()->ProcessEvent(event
);
4834 #if USE_DEFERRED_SIZING
4835 // and finally change the positions of all child windows at once
4836 if ( useDefer
&& m_hDWP
)
4838 // reset m_hDWP to NULL so that child windows don't try to use our
4839 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4840 // happen anyhow normally but who knows what weird flow of control we
4841 // may have depending on what the users EVT_SIZE handler does...)
4842 HDWP hDWP
= (HDWP
)m_hDWP
;
4845 // do put all child controls in place at once
4846 if ( !::EndDeferWindowPos(hDWP
) )
4848 wxLogLastError(_T("EndDeferWindowPos"));
4851 // Reset our children's pending pos/size values.
4852 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4854 node
= node
->GetNext() )
4856 wxWindowMSW
*child
= node
->GetData();
4857 child
->m_pendingPosition
= wxDefaultPosition
;
4858 child
->m_pendingSize
= wxDefaultSize
;
4861 #endif // USE_DEFERRED_SIZING
4866 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4868 wxSizeEvent
event(rect
, m_windowId
);
4869 event
.SetEventObject(this);
4871 bool rc
= GetEventHandler()->ProcessEvent(event
);
4873 rect
= event
.GetRect();
4877 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4882 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4886 int minWidth
= GetMinWidth(),
4887 minHeight
= GetMinHeight(),
4888 maxWidth
= GetMaxWidth(),
4889 maxHeight
= GetMaxHeight();
4891 if ( minWidth
!= wxDefaultCoord
)
4893 info
->ptMinTrackSize
.x
= minWidth
;
4897 if ( minHeight
!= wxDefaultCoord
)
4899 info
->ptMinTrackSize
.y
= minHeight
;
4903 if ( maxWidth
!= wxDefaultCoord
)
4905 info
->ptMaxTrackSize
.x
= maxWidth
;
4909 if ( maxHeight
!= wxDefaultCoord
)
4911 info
->ptMaxTrackSize
.y
= maxHeight
;
4919 // ---------------------------------------------------------------------------
4921 // ---------------------------------------------------------------------------
4923 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
4925 // sign extend to int from short before comparing with the other int ids
4926 int id
= (signed short)id_
;
4928 #if wxUSE_MENUS_NATIVE
4929 if ( !cmd
&& wxCurrentPopupMenu
)
4931 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4932 wxCurrentPopupMenu
= NULL
;
4934 return popupMenu
->MSWCommand(cmd
, id
);
4936 #endif // wxUSE_MENUS_NATIVE
4938 wxWindow
*win
= NULL
;
4940 // first try to find it from HWND - this works even with the broken
4941 // programs using the same ids for different controls
4944 win
= wxFindWinFromHandle(control
);
4955 return win
->MSWCommand(cmd
, id
);
4958 // the messages sent from the in-place edit control used by the treectrl
4959 // for label editing have id == 0, but they should _not_ be treated as menu
4960 // messages (they are EN_XXX ones, in fact) so don't translate anything
4961 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4964 // If no child window, it may be an accelerator, e.g. for a popup menu
4967 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4968 event
.SetEventObject(this);
4972 return GetEventHandler()->ProcessEvent(event
);
4976 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4977 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4978 // notifications to its parent which we want to reflect back to
4980 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4981 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4983 #endif // wxUSE_SPINCTRL
4985 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
4986 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
4987 // notifications to its parent which we want to reflect back to
4989 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
4990 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
4998 // ---------------------------------------------------------------------------
5000 // ---------------------------------------------------------------------------
5002 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5006 // our client coords are not quite the same as Windows ones
5007 wxPoint pt
= GetClientAreaOrigin();
5008 event
.m_x
= x
- pt
.x
;
5009 event
.m_y
= y
- pt
.y
;
5011 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5012 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5013 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5014 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5015 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5016 #ifdef wxHAS_XBUTTON
5017 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5018 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5019 #endif // wxHAS_XBUTTON
5020 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
5023 event
.SetTimestamp(::GetMessageTime());
5026 event
.SetEventObject(this);
5027 event
.SetId(GetId());
5029 #if wxUSE_MOUSEEVENT_HACK
5030 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5031 gs_lastMouseEvent
.type
= event
.GetEventType();
5032 #endif // wxUSE_MOUSEEVENT_HACK
5036 // Windows doesn't send the mouse events to the static controls (which are
5037 // transparent in the sense that their WM_NCHITTEST handler returns
5038 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5039 // and so we manually check if we don't have a child window under mouse and if
5040 // we do, send the event to it instead of the window Windows had sent WM_XXX
5043 // Notice that this is not done for the mouse move events because this could
5044 // (would?) be too slow, but only for clicks which means that the static texts
5045 // still don't get move, enter nor leave events.
5046 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5048 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
5050 // first try to find a non transparent child: this allows us to send events
5051 // to a static text which is inside a static box, for example
5052 POINT pt
= { *x
, *y
};
5053 HWND hwnd
= GetHwndOf(win
),
5057 hwndUnderMouse
= ::ChildWindowFromPoint
5063 hwndUnderMouse
= ::ChildWindowFromPointEx
5073 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5075 // now try any child window at all
5076 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5079 // check that we have a child window which is susceptible to receive mouse
5080 // events: for this it must be shown and enabled
5081 if ( hwndUnderMouse
&&
5082 hwndUnderMouse
!= hwnd
&&
5083 ::IsWindowVisible(hwndUnderMouse
) &&
5084 ::IsWindowEnabled(hwndUnderMouse
) )
5086 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
5087 if ( winUnderMouse
)
5089 // translate the mouse coords to the other window coords
5090 win
->ClientToScreen(x
, y
);
5091 winUnderMouse
->ScreenToClient(x
, y
);
5093 win
= winUnderMouse
;
5099 #endif // __WXWINCE__
5101 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5103 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5104 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5105 // from the message id and take the value in the table to get wxWin event
5107 static const wxEventType eventsMouse
[] =
5118 wxEVT_MIDDLE_DCLICK
,
5119 0, // this one is for wxEVT_MOTION which is not used here
5128 #ifdef wxHAS_XBUTTON
5129 // the same messages are used for both auxillary mouse buttons so we need
5130 // to adjust the index manually
5133 case WM_XBUTTONDOWN
:
5135 case WM_XBUTTONDBLCLK
:
5136 if ( flags
& MK_XBUTTON2
)
5137 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5139 #endif // wxHAS_XBUTTON
5141 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5142 InitMouseEvent(event
, x
, y
, flags
);
5144 return GetEventHandler()->ProcessEvent(event
);
5147 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5149 if ( !m_mouseInWindow
)
5151 // it would be wrong to assume that just because we get a mouse move
5152 // event that the mouse is inside the window: although this is usually
5153 // true, it is not if we had captured the mouse, so we need to check
5154 // the mouse coordinates here
5155 if ( !HasCapture() || IsMouseInWindow() )
5157 // Generate an ENTER event
5158 m_mouseInWindow
= true;
5160 #ifdef HAVE_TRACKMOUSEEVENT
5161 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5163 static const _TrackMouseEvent_t
5164 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5165 #else // !__WXWINCE__
5166 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5167 static bool s_initDone
= false;
5172 wxDynamicLibrary
dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM
);
5173 if ( dllComCtl32
.IsLoaded() )
5175 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5176 dllComCtl32
.GetSymbol(_T("_TrackMouseEvent"));
5181 // notice that it's ok to unload comctl32.dll here as it won't
5182 // be really unloaded, being still in use because we link to it
5186 if ( s_pfn_TrackMouseEvent
)
5187 #endif // __WXWINCE__/!__WXWINCE__
5189 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5191 trackinfo
.dwFlags
= TME_LEAVE
;
5192 trackinfo
.hwndTrack
= GetHwnd();
5194 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5196 #endif // HAVE_TRACKMOUSEEVENT
5198 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5199 InitMouseEvent(event
, x
, y
, flags
);
5201 (void)GetEventHandler()->ProcessEvent(event
);
5204 #ifdef HAVE_TRACKMOUSEEVENT
5205 else // mouse not in window
5207 // Check if we need to send a LEAVE event
5208 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5209 // send it here if we are using native mouse leave tracking
5210 if ( HasCapture() && !IsMouseInWindow() )
5212 GenerateMouseLeave();
5215 #endif // HAVE_TRACKMOUSEEVENT
5217 #if wxUSE_MOUSEEVENT_HACK
5218 // Windows often generates mouse events even if mouse position hasn't
5219 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5221 // Filter this out as it can result in unexpected behaviour compared to
5223 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5224 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5225 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5226 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5228 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5230 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5235 #endif // wxUSE_MOUSEEVENT_HACK
5237 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5241 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5243 #if wxUSE_MOUSEWHEEL
5244 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5245 // forwarded up to the parent by DefWindowProc()) and not in the client
5246 // ones as all the other messages, translate them to the client coords for
5249 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5250 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5251 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5252 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5253 event
.m_wheelDelta
= WHEEL_DELTA
;
5255 static int s_linesPerRotation
= -1;
5256 if ( s_linesPerRotation
== -1 )
5258 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5259 &s_linesPerRotation
, 0))
5261 // this is not supposed to happen
5262 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5264 // the default is 3, so use it if SystemParametersInfo() failed
5265 s_linesPerRotation
= 3;
5269 event
.m_linesPerAction
= s_linesPerRotation
;
5270 return GetEventHandler()->ProcessEvent(event
);
5272 #else // !wxUSE_MOUSEWHEEL
5273 wxUnusedVar(wParam
);
5274 wxUnusedVar(lParam
);
5277 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5280 void wxWindowMSW::GenerateMouseLeave()
5282 m_mouseInWindow
= false;
5285 if ( wxIsShiftDown() )
5287 if ( wxIsCtrlDown() )
5288 state
|= MK_CONTROL
;
5290 // Only the high-order bit should be tested
5291 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5292 state
|= MK_LBUTTON
;
5293 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5294 state
|= MK_MBUTTON
;
5295 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5296 state
|= MK_RBUTTON
;
5300 if ( !::GetCursorPosWinCE(&pt
) )
5302 if ( !::GetCursorPos(&pt
) )
5305 wxLogLastError(_T("GetCursorPos"));
5308 // we need to have client coordinates here for symmetry with
5309 // wxEVT_ENTER_WINDOW
5310 RECT rect
= wxGetWindowRect(GetHwnd());
5314 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5315 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5317 (void)GetEventHandler()->ProcessEvent(event
);
5320 // ---------------------------------------------------------------------------
5321 // keyboard handling
5322 // ---------------------------------------------------------------------------
5324 // create the key event of the given type for the given key - used by
5325 // HandleChar and HandleKeyDown/Up
5326 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5329 WXWPARAM wParam
) const
5331 wxKeyEvent
event(evType
);
5332 event
.SetId(GetId());
5333 event
.m_shiftDown
= wxIsShiftDown();
5334 event
.m_controlDown
= wxIsCtrlDown();
5335 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5337 event
.SetEventObject((wxWindow
*)this); // const_cast
5338 event
.m_keyCode
= id
;
5340 event
.m_uniChar
= (wxChar
) wParam
;
5342 event
.m_rawCode
= (wxUint32
) wParam
;
5343 event
.m_rawFlags
= (wxUint32
) lParam
;
5345 event
.SetTimestamp(::GetMessageTime());
5348 // translate the position to client coords
5351 GetCursorPosWinCE(&pt
);
5356 GetWindowRect(GetHwnd(),&rect
);
5366 // isASCII is true only when we're called from WM_CHAR handler and not from
5368 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5375 else // we're called from WM_KEYDOWN
5377 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5378 // to get numpad key codes: CHAR events should use the logical keys
5379 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5380 id
= wxCharCodeMSWToWX(wParam
);
5383 // it's ASCII and will be processed here only when called from
5384 // WM_CHAR (i.e. when isASCII = true), don't process it now
5389 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5391 // the alphanumeric keys produced by pressing AltGr+something on European
5392 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5393 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5394 // alphanumeric, so pretend that there are no modifiers at all (the
5395 // KEY_DOWN event would still have the correct modifiers if they're really
5397 if ( event
.m_controlDown
&& event
.m_altDown
&&
5398 (id
>= 32 && id
< 256) )
5400 event
.m_controlDown
=
5401 event
.m_altDown
= false;
5404 return GetEventHandler()->ProcessEvent(event
);
5407 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5409 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5413 // normal ASCII char
5417 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5418 return GetEventHandler()->ProcessEvent(event
);
5421 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5423 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5427 // normal ASCII char
5431 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5432 return GetEventHandler()->ProcessEvent(event
);
5436 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5437 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5439 // FIXME: implement GetMenuItemCount for WinCE, possibly
5440 // in terms of GetMenuItemInfo
5442 const HMENU hmenu
= (HMENU
)lParam
;
5446 mii
.cbSize
= sizeof(MENUITEMINFO
);
5448 // we could use MIIM_FTYPE here as we only need to know if the item is
5449 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5450 // MIIM_FTYPE is not supported under Win95
5451 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5453 // find if we have this letter in any owner drawn item
5454 const int count
= ::GetMenuItemCount(hmenu
);
5455 for ( int i
= 0; i
< count
; i
++ )
5457 // previous loop iteration could modify it, reset it back before
5458 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5461 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5463 if ( mii
.fType
== MFT_OWNERDRAW
)
5465 // dwItemData member of the MENUITEMINFO is a
5466 // pointer to the associated wxMenuItem -- see the
5467 // menu creation code
5468 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5470 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), _T('&'));
5473 if ( *p
== _T('&') )
5475 // this is not the accel char, find the real one
5476 p
= wxStrchr(p
+ 1, _T('&'));
5478 else // got the accel char
5480 // FIXME-UNICODE: this comparison doesn't risk to work
5481 // for non ASCII accelerator characters I'm afraid, but
5483 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5489 // this one doesn't match
5496 else // failed to get the menu text?
5498 // it's not fatal, so don't show error, but still log it
5499 wxLogLastError(_T("GetMenuItemInfo"));
5506 bool wxWindowMSW::HandleClipboardEvent( WXUINT nMsg
)
5508 const wxEventType type
= ( nMsg
== WM_CUT
) ? wxEVT_COMMAND_TEXT_CUT
:
5509 ( nMsg
== WM_COPY
) ? wxEVT_COMMAND_TEXT_COPY
:
5510 /*( nMsg == WM_PASTE ) ? */ wxEVT_COMMAND_TEXT_PASTE
;
5511 wxClipboardTextEvent
evt(type
, GetId());
5513 evt
.SetEventObject(this);
5515 return GetEventHandler()->ProcessEvent(evt
);
5517 #endif // wxUSE_MENUS
5519 // ---------------------------------------------------------------------------
5521 // ---------------------------------------------------------------------------
5523 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5527 if ( flags
& JOY_BUTTON1CHG
)
5528 change
= wxJOY_BUTTON1
;
5529 if ( flags
& JOY_BUTTON2CHG
)
5530 change
= wxJOY_BUTTON2
;
5531 if ( flags
& JOY_BUTTON3CHG
)
5532 change
= wxJOY_BUTTON3
;
5533 if ( flags
& JOY_BUTTON4CHG
)
5534 change
= wxJOY_BUTTON4
;
5537 if ( flags
& JOY_BUTTON1
)
5538 buttons
|= wxJOY_BUTTON1
;
5539 if ( flags
& JOY_BUTTON2
)
5540 buttons
|= wxJOY_BUTTON2
;
5541 if ( flags
& JOY_BUTTON3
)
5542 buttons
|= wxJOY_BUTTON3
;
5543 if ( flags
& JOY_BUTTON4
)
5544 buttons
|= wxJOY_BUTTON4
;
5546 // the event ids aren't consecutive so we can't use table based lookup
5548 wxEventType eventType
;
5553 eventType
= wxEVT_JOY_MOVE
;
5558 eventType
= wxEVT_JOY_MOVE
;
5563 eventType
= wxEVT_JOY_ZMOVE
;
5568 eventType
= wxEVT_JOY_ZMOVE
;
5571 case MM_JOY1BUTTONDOWN
:
5573 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5576 case MM_JOY2BUTTONDOWN
:
5578 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5581 case MM_JOY1BUTTONUP
:
5583 eventType
= wxEVT_JOY_BUTTON_UP
;
5586 case MM_JOY2BUTTONUP
:
5588 eventType
= wxEVT_JOY_BUTTON_UP
;
5592 wxFAIL_MSG(wxT("no such joystick event"));
5597 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5598 event
.SetPosition(wxPoint(x
, y
));
5599 event
.SetEventObject(this);
5601 return GetEventHandler()->ProcessEvent(event
);
5611 // ---------------------------------------------------------------------------
5613 // ---------------------------------------------------------------------------
5615 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5616 WXWORD pos
, WXHWND control
)
5618 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5620 wxWindow
*child
= wxFindWinFromHandle(control
);
5622 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5625 wxScrollWinEvent event
;
5626 event
.SetPosition(pos
);
5627 event
.SetOrientation(orientation
);
5628 event
.SetEventObject(this);
5633 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5637 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5641 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5645 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5649 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5653 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5656 case SB_THUMBPOSITION
:
5658 // under Win32, the scrollbar range and position are 32 bit integers,
5659 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5660 // explicitly query the scrollbar for the correct position (this must
5661 // be done only for these two SB_ events as they are the only one
5662 // carrying the scrollbar position)
5664 WinStruct
<SCROLLINFO
> scrollInfo
;
5665 scrollInfo
.fMask
= SIF_TRACKPOS
;
5667 if ( !::GetScrollInfo(GetHwnd(),
5668 orientation
== wxHORIZONTAL
? SB_HORZ
5672 // Not necessarily an error, if there are no scrollbars yet.
5673 // wxLogLastError(_T("GetScrollInfo"));
5676 event
.SetPosition(scrollInfo
.nTrackPos
);
5679 event
.SetEventType( wParam
== SB_THUMBPOSITION
5680 ? wxEVT_SCROLLWIN_THUMBRELEASE
5681 : wxEVT_SCROLLWIN_THUMBTRACK
);
5688 return GetEventHandler()->ProcessEvent(event
);
5691 // ----------------------------------------------------------------------------
5692 // custom message handlers
5693 // ----------------------------------------------------------------------------
5696 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5698 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5699 false, _T("registering handler for the same message twice") );
5701 gs_messageHandlers
[msg
] = handler
;
5706 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5708 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5709 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5710 _T("unregistering non-registered handler?") );
5712 gs_messageHandlers
.erase(i
);
5715 // ===========================================================================
5717 // ===========================================================================
5719 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5722 HDC dc
= ::GetDC((HWND
) wnd
);
5725 // the_font.UseResource();
5726 // the_font.RealizeResource();
5727 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5729 was
= (HFONT
) SelectObject(dc
,fnt
);
5731 GetTextMetrics(dc
, &tm
);
5734 SelectObject(dc
,was
);
5736 ReleaseDC((HWND
)wnd
, dc
);
5739 *x
= tm
.tmAveCharWidth
;
5741 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5743 // the_font.ReleaseResource();
5746 // use the "extended" bit (24) of lParam to distinguish extended keys
5747 // from normal keys as the same key is sent
5749 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5751 // except that if lParam is 0, it means we don't have real lParam from
5752 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5753 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5754 // non-numpad (hence extended) key as this is a more common case
5755 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5758 // this array contains the Windows virtual key codes which map one to one to
5759 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5761 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5762 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5763 static const struct wxKeyMapping
5767 } gs_specialKeys
[] =
5769 { VK_CANCEL
, WXK_CANCEL
},
5770 { VK_BACK
, WXK_BACK
},
5771 { VK_TAB
, WXK_TAB
},
5772 { VK_CLEAR
, WXK_CLEAR
},
5773 { VK_SHIFT
, WXK_SHIFT
},
5774 { VK_CONTROL
, WXK_CONTROL
},
5775 { VK_MENU
, WXK_ALT
},
5776 { VK_PAUSE
, WXK_PAUSE
},
5777 { VK_CAPITAL
, WXK_CAPITAL
},
5778 { VK_SPACE
, WXK_SPACE
},
5779 { VK_ESCAPE
, WXK_ESCAPE
},
5780 { VK_SELECT
, WXK_SELECT
},
5781 { VK_PRINT
, WXK_PRINT
},
5782 { VK_EXECUTE
, WXK_EXECUTE
},
5783 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5784 { VK_HELP
, WXK_HELP
},
5786 { VK_NUMPAD0
, WXK_NUMPAD0
},
5787 { VK_NUMPAD1
, WXK_NUMPAD1
},
5788 { VK_NUMPAD2
, WXK_NUMPAD2
},
5789 { VK_NUMPAD3
, WXK_NUMPAD3
},
5790 { VK_NUMPAD4
, WXK_NUMPAD4
},
5791 { VK_NUMPAD5
, WXK_NUMPAD5
},
5792 { VK_NUMPAD6
, WXK_NUMPAD6
},
5793 { VK_NUMPAD7
, WXK_NUMPAD7
},
5794 { VK_NUMPAD8
, WXK_NUMPAD8
},
5795 { VK_NUMPAD9
, WXK_NUMPAD9
},
5796 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5797 { VK_ADD
, WXK_NUMPAD_ADD
},
5798 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5799 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5800 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5811 { VK_F10
, WXK_F10
},
5812 { VK_F11
, WXK_F11
},
5813 { VK_F12
, WXK_F12
},
5814 { VK_F13
, WXK_F13
},
5815 { VK_F14
, WXK_F14
},
5816 { VK_F15
, WXK_F15
},
5817 { VK_F16
, WXK_F16
},
5818 { VK_F17
, WXK_F17
},
5819 { VK_F18
, WXK_F18
},
5820 { VK_F19
, WXK_F19
},
5821 { VK_F20
, WXK_F20
},
5822 { VK_F21
, WXK_F21
},
5823 { VK_F22
, WXK_F22
},
5824 { VK_F23
, WXK_F23
},
5825 { VK_F24
, WXK_F24
},
5827 { VK_NUMLOCK
, WXK_NUMLOCK
},
5828 { VK_SCROLL
, WXK_SCROLL
},
5831 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5832 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5833 { VK_APPS
, WXK_WINDOWS_MENU
},
5834 #endif // VK_APPS defined
5837 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5838 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5839 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5841 // check the table first
5842 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5844 if ( gs_specialKeys
[n
].vk
== vk
)
5845 return gs_specialKeys
[n
].wxk
;
5848 // keys requiring special handling
5852 // the mapping for these keys may be incorrect on non-US keyboards so
5853 // maybe we shouldn't map them to ASCII values at all
5854 case VK_OEM_1
: wxk
= ';'; break;
5855 case VK_OEM_PLUS
: wxk
= '+'; break;
5856 case VK_OEM_COMMA
: wxk
= ','; break;
5857 case VK_OEM_MINUS
: wxk
= '-'; break;
5858 case VK_OEM_PERIOD
: wxk
= '.'; break;
5859 case VK_OEM_2
: wxk
= '/'; break;
5860 case VK_OEM_3
: wxk
= '~'; break;
5861 case VK_OEM_4
: wxk
= '['; break;
5862 case VK_OEM_5
: wxk
= '\\'; break;
5863 case VK_OEM_6
: wxk
= ']'; break;
5864 case VK_OEM_7
: wxk
= '\''; break;
5866 // handle extended keys
5868 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5872 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
5876 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
5880 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
5884 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
5888 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
5892 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
5896 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
5900 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
5904 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
5908 // don't use ChooseNormalOrExtended() here as the keys are reversed
5909 // here: numpad enter is the extended one
5910 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5920 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
5925 // check the table first
5926 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5928 if ( gs_specialKeys
[n
].wxk
== wxk
)
5929 return gs_specialKeys
[n
].vk
;
5932 // and then check for special keys not included in the table
5937 case WXK_NUMPAD_PAGEUP
:
5942 case WXK_NUMPAD_PAGEDOWN
:
5947 case WXK_NUMPAD_END
:
5952 case WXK_NUMPAD_HOME
:
5957 case WXK_NUMPAD_LEFT
:
5967 case WXK_NUMPAD_RIGHT
:
5972 case WXK_NUMPAD_DOWN
:
5977 case WXK_NUMPAD_INSERT
:
5982 case WXK_NUMPAD_DELETE
:
5996 #ifndef SM_SWAPBUTTON
5997 #define SM_SWAPBUTTON 23
6000 // small helper for wxGetKeyState() and wxGetMouseState()
6001 static inline bool wxIsKeyDown(WXWORD vk
)
6006 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_RBUTTON
;
6009 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_LBUTTON
;
6012 // the low order bit indicates whether the key was pressed since the last
6013 // call and the high order one indicates whether it is down right now and
6014 // we only want that one
6015 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6018 bool wxGetKeyState(wxKeyCode key
)
6020 // although this does work under Windows, it is not supported under other
6021 // platforms so don't allow it, you must use wxGetMouseState() instead
6022 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6023 key
!= VK_RBUTTON
&&
6025 wxT("can't use wxGetKeyState() for mouse buttons") );
6027 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6029 // if the requested key is a LED key, return true if the led is pressed
6030 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6032 // low order bit means LED is highlighted and high order one means the
6033 // key is down; for compatibility with the other ports return true if
6034 // either one is set
6035 return GetKeyState(vk
) != 0;
6040 return wxIsKeyDown(vk
);
6045 wxMouseState
wxGetMouseState()
6049 GetCursorPos( &pt
);
6053 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6054 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6055 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6056 #ifdef wxHAS_XBUTTON
6057 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6058 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6059 #endif // wxHAS_XBUTTON
6061 ms
.SetControlDown(wxIsKeyDown(VK_CONTROL
));
6062 ms
.SetShiftDown(wxIsKeyDown(VK_SHIFT
));
6063 ms
.SetAltDown(wxIsKeyDown(VK_MENU
));
6064 // ms.SetMetaDown();
6070 wxWindow
*wxGetActiveWindow()
6072 HWND hWnd
= GetActiveWindow();
6075 return wxFindWinFromHandle((WXHWND
) hWnd
);
6080 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6082 HWND hwnd
= (HWND
)hWnd
;
6084 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6085 // by code in msw/radiobox.cpp), for all the others we just search up the
6087 wxWindow
*win
= (wxWindow
*)NULL
;
6090 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6094 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6095 // wxWindow class which overrides WM_GETDLGCODE processing to
6096 // do it as well, win would be already non NULL
6097 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6099 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6101 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6102 #endif // wxUSE_RADIOBOX
6104 // spin control text buddy window should be mapped to spin ctrl
6105 // itself so try it too
6106 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6109 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6111 #endif // wxUSE_SPINCTRL
6115 while ( hwnd
&& !win
)
6117 // this is a really ugly hack needed to avoid mistakenly returning the
6118 // parent frame wxWindow for the find/replace modeless dialog HWND -
6119 // this, in turn, is needed to call IsDialogMessage() from
6120 // wxApp::ProcessMessage() as for this we must return NULL from here
6122 // FIXME: this is clearly not the best way to do it but I think we'll
6123 // need to change HWND <-> wxWindow code more heavily than I can
6124 // do it now to fix it
6125 #ifndef __WXMICROWIN__
6126 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6128 // it's a dialog box, don't go upwards
6133 hwnd
= ::GetParent(hwnd
);
6134 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6140 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6142 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6143 // in active frames and dialogs, regardless of where the focus is.
6144 static HHOOK wxTheKeyboardHook
= 0;
6145 static FARPROC wxTheKeyboardHookProc
= 0;
6146 int APIENTRY _EXPORT
6147 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
6149 void wxSetKeyboardHook(bool doIt
)
6153 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
6154 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
6156 GetCurrentThreadId()
6157 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
6162 UnhookWindowsHookEx(wxTheKeyboardHook
);
6166 int APIENTRY _EXPORT
6167 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6169 DWORD hiWord
= HIWORD(lParam
);
6170 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6172 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6175 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6176 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6177 event
.m_altDown
= true;
6179 event
.SetEventObject(NULL
);
6180 event
.m_keyCode
= id
;
6181 event
.m_shiftDown
= wxIsShiftDown();
6182 event
.m_controlDown
= wxIsCtrlDown();
6184 event
.SetTimestamp(::GetMessageTime());
6186 wxWindow
*win
= wxGetActiveWindow();
6187 wxEvtHandler
*handler
;
6190 handler
= win
->GetEventHandler();
6191 event
.SetId(win
->GetId());
6196 event
.SetId(wxID_ANY
);
6199 if ( handler
&& handler
->ProcessEvent(event
) )
6207 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6210 #endif // !__WXMICROWIN__
6213 const wxChar
*wxGetMessageName(int message
)
6217 case 0x0000: return wxT("WM_NULL");
6218 case 0x0001: return wxT("WM_CREATE");
6219 case 0x0002: return wxT("WM_DESTROY");
6220 case 0x0003: return wxT("WM_MOVE");
6221 case 0x0005: return wxT("WM_SIZE");
6222 case 0x0006: return wxT("WM_ACTIVATE");
6223 case 0x0007: return wxT("WM_SETFOCUS");
6224 case 0x0008: return wxT("WM_KILLFOCUS");
6225 case 0x000A: return wxT("WM_ENABLE");
6226 case 0x000B: return wxT("WM_SETREDRAW");
6227 case 0x000C: return wxT("WM_SETTEXT");
6228 case 0x000D: return wxT("WM_GETTEXT");
6229 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6230 case 0x000F: return wxT("WM_PAINT");
6231 case 0x0010: return wxT("WM_CLOSE");
6232 case 0x0011: return wxT("WM_QUERYENDSESSION");
6233 case 0x0012: return wxT("WM_QUIT");
6234 case 0x0013: return wxT("WM_QUERYOPEN");
6235 case 0x0014: return wxT("WM_ERASEBKGND");
6236 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6237 case 0x0016: return wxT("WM_ENDSESSION");
6238 case 0x0017: return wxT("WM_SYSTEMERROR");
6239 case 0x0018: return wxT("WM_SHOWWINDOW");
6240 case 0x0019: return wxT("WM_CTLCOLOR");
6241 case 0x001A: return wxT("WM_WININICHANGE");
6242 case 0x001B: return wxT("WM_DEVMODECHANGE");
6243 case 0x001C: return wxT("WM_ACTIVATEAPP");
6244 case 0x001D: return wxT("WM_FONTCHANGE");
6245 case 0x001E: return wxT("WM_TIMECHANGE");
6246 case 0x001F: return wxT("WM_CANCELMODE");
6247 case 0x0020: return wxT("WM_SETCURSOR");
6248 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6249 case 0x0022: return wxT("WM_CHILDACTIVATE");
6250 case 0x0023: return wxT("WM_QUEUESYNC");
6251 case 0x0024: return wxT("WM_GETMINMAXINFO");
6252 case 0x0026: return wxT("WM_PAINTICON");
6253 case 0x0027: return wxT("WM_ICONERASEBKGND");
6254 case 0x0028: return wxT("WM_NEXTDLGCTL");
6255 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6256 case 0x002B: return wxT("WM_DRAWITEM");
6257 case 0x002C: return wxT("WM_MEASUREITEM");
6258 case 0x002D: return wxT("WM_DELETEITEM");
6259 case 0x002E: return wxT("WM_VKEYTOITEM");
6260 case 0x002F: return wxT("WM_CHARTOITEM");
6261 case 0x0030: return wxT("WM_SETFONT");
6262 case 0x0031: return wxT("WM_GETFONT");
6263 case 0x0037: return wxT("WM_QUERYDRAGICON");
6264 case 0x0039: return wxT("WM_COMPAREITEM");
6265 case 0x0041: return wxT("WM_COMPACTING");
6266 case 0x0044: return wxT("WM_COMMNOTIFY");
6267 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6268 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6269 case 0x0048: return wxT("WM_POWER");
6271 case 0x004A: return wxT("WM_COPYDATA");
6272 case 0x004B: return wxT("WM_CANCELJOURNAL");
6273 case 0x004E: return wxT("WM_NOTIFY");
6274 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6275 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6276 case 0x0052: return wxT("WM_TCARD");
6277 case 0x0053: return wxT("WM_HELP");
6278 case 0x0054: return wxT("WM_USERCHANGED");
6279 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6280 case 0x007B: return wxT("WM_CONTEXTMENU");
6281 case 0x007C: return wxT("WM_STYLECHANGING");
6282 case 0x007D: return wxT("WM_STYLECHANGED");
6283 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6284 case 0x007F: return wxT("WM_GETICON");
6285 case 0x0080: return wxT("WM_SETICON");
6287 case 0x0081: return wxT("WM_NCCREATE");
6288 case 0x0082: return wxT("WM_NCDESTROY");
6289 case 0x0083: return wxT("WM_NCCALCSIZE");
6290 case 0x0084: return wxT("WM_NCHITTEST");
6291 case 0x0085: return wxT("WM_NCPAINT");
6292 case 0x0086: return wxT("WM_NCACTIVATE");
6293 case 0x0087: return wxT("WM_GETDLGCODE");
6294 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6295 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6296 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6297 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6298 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6299 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6300 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6301 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6302 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6303 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6305 case 0x00B0: return wxT("EM_GETSEL");
6306 case 0x00B1: return wxT("EM_SETSEL");
6307 case 0x00B2: return wxT("EM_GETRECT");
6308 case 0x00B3: return wxT("EM_SETRECT");
6309 case 0x00B4: return wxT("EM_SETRECTNP");
6310 case 0x00B5: return wxT("EM_SCROLL");
6311 case 0x00B6: return wxT("EM_LINESCROLL");
6312 case 0x00B7: return wxT("EM_SCROLLCARET");
6313 case 0x00B8: return wxT("EM_GETMODIFY");
6314 case 0x00B9: return wxT("EM_SETMODIFY");
6315 case 0x00BA: return wxT("EM_GETLINECOUNT");
6316 case 0x00BB: return wxT("EM_LINEINDEX");
6317 case 0x00BC: return wxT("EM_SETHANDLE");
6318 case 0x00BD: return wxT("EM_GETHANDLE");
6319 case 0x00BE: return wxT("EM_GETTHUMB");
6320 case 0x00C1: return wxT("EM_LINELENGTH");
6321 case 0x00C2: return wxT("EM_REPLACESEL");
6322 case 0x00C4: return wxT("EM_GETLINE");
6323 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6324 case 0x00C6: return wxT("EM_CANUNDO");
6325 case 0x00C7: return wxT("EM_UNDO");
6326 case 0x00C8: return wxT("EM_FMTLINES");
6327 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6328 case 0x00CB: return wxT("EM_SETTABSTOPS");
6329 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6330 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6331 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6332 case 0x00CF: return wxT("EM_SETREADONLY");
6333 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6334 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6335 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6336 case 0x00D3: return wxT("EM_SETMARGINS");
6337 case 0x00D4: return wxT("EM_GETMARGINS");
6338 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6339 case 0x00D6: return wxT("EM_POSFROMCHAR");
6340 case 0x00D7: return wxT("EM_CHARFROMPOS");
6341 case 0x00D8: return wxT("EM_SETIMESTATUS");
6342 case 0x00D9: return wxT("EM_GETIMESTATUS");
6344 case 0x0100: return wxT("WM_KEYDOWN");
6345 case 0x0101: return wxT("WM_KEYUP");
6346 case 0x0102: return wxT("WM_CHAR");
6347 case 0x0103: return wxT("WM_DEADCHAR");
6348 case 0x0104: return wxT("WM_SYSKEYDOWN");
6349 case 0x0105: return wxT("WM_SYSKEYUP");
6350 case 0x0106: return wxT("WM_SYSCHAR");
6351 case 0x0107: return wxT("WM_SYSDEADCHAR");
6352 case 0x0108: return wxT("WM_KEYLAST");
6354 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6355 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6356 case 0x010F: return wxT("WM_IME_COMPOSITION");
6358 case 0x0110: return wxT("WM_INITDIALOG");
6359 case 0x0111: return wxT("WM_COMMAND");
6360 case 0x0112: return wxT("WM_SYSCOMMAND");
6361 case 0x0113: return wxT("WM_TIMER");
6362 case 0x0114: return wxT("WM_HSCROLL");
6363 case 0x0115: return wxT("WM_VSCROLL");
6364 case 0x0116: return wxT("WM_INITMENU");
6365 case 0x0117: return wxT("WM_INITMENUPOPUP");
6366 case 0x011F: return wxT("WM_MENUSELECT");
6367 case 0x0120: return wxT("WM_MENUCHAR");
6368 case 0x0121: return wxT("WM_ENTERIDLE");
6370 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6371 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6372 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6373 case 0x0135: return wxT("WM_CTLCOLORBTN");
6374 case 0x0136: return wxT("WM_CTLCOLORDLG");
6375 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6376 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6377 case 0x01E1: return wxT("MN_GETHMENU");
6379 case 0x0200: return wxT("WM_MOUSEMOVE");
6380 case 0x0201: return wxT("WM_LBUTTONDOWN");
6381 case 0x0202: return wxT("WM_LBUTTONUP");
6382 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6383 case 0x0204: return wxT("WM_RBUTTONDOWN");
6384 case 0x0205: return wxT("WM_RBUTTONUP");
6385 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6386 case 0x0207: return wxT("WM_MBUTTONDOWN");
6387 case 0x0208: return wxT("WM_MBUTTONUP");
6388 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6389 case 0x020A: return wxT("WM_MOUSEWHEEL");
6390 case 0x020B: return wxT("WM_XBUTTONDOWN");
6391 case 0x020C: return wxT("WM_XBUTTONUP");
6392 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6393 case 0x0210: return wxT("WM_PARENTNOTIFY");
6394 case 0x0211: return wxT("WM_ENTERMENULOOP");
6395 case 0x0212: return wxT("WM_EXITMENULOOP");
6397 case 0x0213: return wxT("WM_NEXTMENU");
6398 case 0x0214: return wxT("WM_SIZING");
6399 case 0x0215: return wxT("WM_CAPTURECHANGED");
6400 case 0x0216: return wxT("WM_MOVING");
6401 case 0x0218: return wxT("WM_POWERBROADCAST");
6402 case 0x0219: return wxT("WM_DEVICECHANGE");
6404 case 0x0220: return wxT("WM_MDICREATE");
6405 case 0x0221: return wxT("WM_MDIDESTROY");
6406 case 0x0222: return wxT("WM_MDIACTIVATE");
6407 case 0x0223: return wxT("WM_MDIRESTORE");
6408 case 0x0224: return wxT("WM_MDINEXT");
6409 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6410 case 0x0226: return wxT("WM_MDITILE");
6411 case 0x0227: return wxT("WM_MDICASCADE");
6412 case 0x0228: return wxT("WM_MDIICONARRANGE");
6413 case 0x0229: return wxT("WM_MDIGETACTIVE");
6414 case 0x0230: return wxT("WM_MDISETMENU");
6415 case 0x0233: return wxT("WM_DROPFILES");
6417 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6418 case 0x0282: return wxT("WM_IME_NOTIFY");
6419 case 0x0283: return wxT("WM_IME_CONTROL");
6420 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6421 case 0x0285: return wxT("WM_IME_SELECT");
6422 case 0x0286: return wxT("WM_IME_CHAR");
6423 case 0x0290: return wxT("WM_IME_KEYDOWN");
6424 case 0x0291: return wxT("WM_IME_KEYUP");
6426 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6427 case 0x02A1: return wxT("WM_MOUSEHOVER");
6428 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6429 case 0x02A3: return wxT("WM_MOUSELEAVE");
6431 case 0x0300: return wxT("WM_CUT");
6432 case 0x0301: return wxT("WM_COPY");
6433 case 0x0302: return wxT("WM_PASTE");
6434 case 0x0303: return wxT("WM_CLEAR");
6435 case 0x0304: return wxT("WM_UNDO");
6436 case 0x0305: return wxT("WM_RENDERFORMAT");
6437 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6438 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6439 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6440 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6441 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6442 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6443 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6444 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6445 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6446 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6447 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6448 case 0x0311: return wxT("WM_PALETTECHANGED");
6449 case 0x0312: return wxT("WM_HOTKEY");
6451 case 0x0317: return wxT("WM_PRINT");
6452 case 0x0318: return wxT("WM_PRINTCLIENT");
6454 // common controls messages - although they're not strictly speaking
6455 // standard, it's nice to decode them nevertheless
6458 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6459 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6460 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6461 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6462 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6463 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6464 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6465 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6466 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6467 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6468 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6469 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6470 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6471 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6472 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6473 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6474 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6475 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6476 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6477 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6478 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6479 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6480 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6481 case 0x1000 + 18: return wxT("LVM_HITTEST");
6482 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6483 case 0x1000 + 20: return wxT("LVM_SCROLL");
6484 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6485 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6486 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6487 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6488 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6489 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6490 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6491 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6492 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6493 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6494 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6495 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6496 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6497 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6498 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6499 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6500 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6501 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6502 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6503 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6504 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6505 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6506 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6507 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6508 case 0x1000 + 42: return wxT("LVM_UPDATE");
6509 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6510 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6511 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6512 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6513 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6514 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6515 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6516 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6517 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6518 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6519 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6520 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6521 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6522 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6523 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6524 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6525 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6526 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6527 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6528 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6529 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6530 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6531 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6532 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6533 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6534 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6537 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6538 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6539 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6540 case 0x1100 + 2: return wxT("TVM_EXPAND");
6541 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6542 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6543 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6544 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6545 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6546 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6547 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6548 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6549 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6550 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6551 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6552 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6553 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6554 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6555 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6556 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6557 case 0x1100 + 17: return wxT("TVM_HITTEST");
6558 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6559 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6560 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6561 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6562 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6563 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6564 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6565 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6566 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6569 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6570 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6571 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6572 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6573 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6574 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6575 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6576 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6577 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6578 case 0x1200 + 6: return wxT("HDM_HITTEST");
6579 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6580 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6581 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6582 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6583 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6584 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6585 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6586 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6589 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6590 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6591 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6592 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6593 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6594 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6595 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6596 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6597 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6598 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6599 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6600 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6601 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6602 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6603 case 0x1300 + 13: return wxT("TCM_HITTEST");
6604 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6605 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6606 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6607 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6608 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6609 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6610 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6611 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6612 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6613 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6614 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6615 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6618 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6619 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6620 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6621 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6622 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6623 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6624 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6625 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6626 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6627 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6628 case WM_USER
+17: return wxT("TB_SETSTATE");
6629 case WM_USER
+18: return wxT("TB_GETSTATE");
6630 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6631 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6632 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6633 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6634 case WM_USER
+23: return wxT("TB_GETBUTTON");
6635 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6636 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6637 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6638 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6639 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6640 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6641 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6642 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6643 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6644 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6645 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6646 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6647 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6648 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6649 case WM_USER
+37: return wxT("TB_SETPARENT");
6650 case WM_USER
+39: return wxT("TB_SETROWS");
6651 case WM_USER
+40: return wxT("TB_GETROWS");
6652 case WM_USER
+42: return wxT("TB_SETCMDID");
6653 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6654 case WM_USER
+44: return wxT("TB_GETBITMAP");
6655 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6656 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6657 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6658 case WM_USER
+47: return wxT("TB_SETINDENT");
6659 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6660 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6661 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6662 case WM_USER
+51: return wxT("TB_GETRECT");
6663 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6664 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6665 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6666 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6667 case WM_USER
+56: return wxT("TB_SETSTYLE");
6668 case WM_USER
+57: return wxT("TB_GETSTYLE");
6669 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6670 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6671 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6672 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6673 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6676 static wxString s_szBuf
;
6677 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6678 return s_szBuf
.c_str();
6681 #endif //__WXDEBUG__
6683 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6687 HWND hwnd
= GetHwndOf(win
);
6688 HDC hdc
= ::GetDC(hwnd
);
6690 #if !wxDIALOG_UNIT_COMPATIBILITY
6691 // and select the current font into it
6692 HFONT hfont
= GetHfontOf(win
->GetFont());
6695 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6699 // finally retrieve the text metrics from it
6700 GetTextMetrics(hdc
, &tm
);
6702 #if !wxDIALOG_UNIT_COMPATIBILITY
6706 (void)::SelectObject(hdc
, hfont
);
6710 ::ReleaseDC(hwnd
, hdc
);
6715 // Find the wxWindow at the current mouse position, returning the mouse
6717 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6719 pt
= wxGetMousePosition();
6720 return wxFindWindowAtPoint(pt
);
6723 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6729 HWND hWnd
= ::WindowFromPoint(pt2
);
6731 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6734 // Get the current mouse position.
6735 wxPoint
wxGetMousePosition()
6739 GetCursorPosWinCE(&pt
);
6741 GetCursorPos( & pt
);
6744 return wxPoint(pt
.x
, pt
.y
);
6749 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6750 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6752 // Register hotkeys for the hardware buttons
6754 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6756 UnregisterFunc1Proc procUnregisterFunc
;
6757 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6760 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6761 if (procUnregisterFunc
)
6762 procUnregisterFunc(modifiers
, id
);
6763 FreeLibrary(hCoreDll
);
6768 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6770 UINT win_modifiers
=0;
6771 if ( modifiers
& wxMOD_ALT
)
6772 win_modifiers
|= MOD_ALT
;
6773 if ( modifiers
& wxMOD_SHIFT
)
6774 win_modifiers
|= MOD_SHIFT
;
6775 if ( modifiers
& wxMOD_CONTROL
)
6776 win_modifiers
|= MOD_CONTROL
;
6777 if ( modifiers
& wxMOD_WIN
)
6778 win_modifiers
|= MOD_WIN
;
6780 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6781 // Required for PPC and Smartphone hardware buttons
6782 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6783 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6786 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6788 wxLogLastError(_T("RegisterHotKey"));
6796 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6798 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6799 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6802 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6804 wxLogLastError(_T("UnregisterHotKey"));
6814 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6816 int hotkeyId
= wParam
;
6817 int virtualKey
= HIWORD(lParam
);
6818 int win_modifiers
= LOWORD(lParam
);
6820 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6821 event
.SetId(hotkeyId
);
6822 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6823 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6824 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6825 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6827 return GetEventHandler()->ProcessEvent(event
);
6830 #endif // wxUSE_ACCEL
6832 #endif // wxUSE_HOTKEY
6834 // Not tested under WinCE
6837 // this class installs a message hook which really wakes up our idle processing
6838 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6839 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6840 // being dragged or even inside ::MessageBox()) and so don't control message
6841 // dispatching otherwise
6842 class wxIdleWakeUpModule
: public wxModule
6845 virtual bool OnInit()
6847 ms_hMsgHookProc
= ::SetWindowsHookEx
6850 &wxIdleWakeUpModule::MsgHookProc
,
6852 GetCurrentThreadId()
6855 if ( !ms_hMsgHookProc
)
6857 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6865 virtual void OnExit()
6867 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
6870 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6872 MSG
*msg
= (MSG
*)lParam
;
6874 // only process the message if it is actually going to be removed from
6875 // the message queue, this prevents that the same event from being
6876 // processed multiple times if now someone just called PeekMessage()
6877 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
6879 wxTheApp
->ProcessPendingEvents();
6882 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
6886 static HHOOK ms_hMsgHookProc
;
6888 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
6891 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
6893 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
6895 #endif // __WXWINCE__
6900 static void wxAdjustZOrder(wxWindow
* parent
)
6902 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
6904 // Set the z-order correctly
6905 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
6908 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
6911 wxWindow
*childWin
= current
->GetData();
6912 wxAdjustZOrder(childWin
);
6913 current
= current
->GetNext();
6918 // We need to adjust the z-order of static boxes in WinCE, to
6919 // make 'contained' controls visible
6920 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
6923 wxAdjustZOrder(this);