1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/window.cpp
3 // Purpose: wxWindowMSW
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/window.h"
30 #include "wx/msw/wrapwin.h"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
56 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
60 #include "wx/hashmap.h"
61 #include "wx/evtloop.h"
63 #include "wx/sysopt.h"
65 #if wxUSE_DRAG_AND_DROP
69 #if wxUSE_ACCESSIBILITY
70 #include "wx/access.h"
74 #define WM_GETOBJECT 0x003D
77 #define OBJID_CLIENT 0xFFFFFFFC
81 #include "wx/msw/private.h"
82 #include "wx/msw/dcclient.h"
85 #include "wx/tooltip.h"
93 #include "wx/spinctrl.h"
94 #endif // wxUSE_SPINCTRL
96 #include "wx/notebook.h"
97 #include "wx/listctrl.h"
98 #include "wx/dynlib.h"
102 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
103 #include <shellapi.h>
104 #include <mmsystem.h>
108 #include <windowsx.h>
111 #if !defined __WXWINCE__ && !defined NEED_PBT_H
115 #if defined(__WXWINCE__)
116 #include "wx/msw/wince/missing.h"
119 #include <shellapi.h>
121 #include <aygshell.h>
126 #include "wx/msw/uxtheme.h"
127 #define EP_EDITTEXT 1
130 #define ETS_SELECTED 3
131 #define ETS_DISABLED 4
132 #define ETS_FOCUSED 5
133 #define ETS_READONLY 6
137 // define the constants used by AnimateWindow() if our SDK doesn't have them
139 #define AW_HOR_POSITIVE 0x00000001
140 #define AW_HOR_NEGATIVE 0x00000002
141 #define AW_VER_POSITIVE 0x00000004
142 #define AW_VER_NEGATIVE 0x00000008
143 #define AW_CENTER 0x00000010
144 #define AW_HIDE 0x00010000
145 #define AW_ACTIVATE 0x00020000
146 #define AW_SLIDE 0x00040000
147 #define AW_BLEND 0x00080000
150 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
151 #define HAVE_TRACKMOUSEEVENT
152 #endif // everything needed for TrackMouseEvent()
154 // if this is set to 1, we use deferred window sizing to reduce flicker when
155 // resizing complicated window hierarchies, but this can in theory result in
156 // different behaviour than the old code so we keep the possibility to use it
157 // by setting this to 0 (in the future this should be removed completely)
159 #define USE_DEFERRED_SIZING 0
161 #define USE_DEFERRED_SIZING 1
164 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
165 // when mouse position didnd't change
167 #define wxUSE_MOUSEEVENT_HACK 0
169 #define wxUSE_MOUSEEVENT_HACK 1
172 // not all compilers/platforms have X button related declarations (notably
173 // Windows CE doesn't, and probably some old SDKs don't neither)
174 #ifdef WM_XBUTTONDOWN
175 #define wxHAS_XBUTTON
178 // ---------------------------------------------------------------------------
180 // ---------------------------------------------------------------------------
182 #if wxUSE_MENUS_NATIVE
183 extern wxMenu
*wxCurrentPopupMenu
;
186 // true if we had already created the std colour map, used by
187 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
188 static bool gs_hasStdCmap
= false;
190 // last mouse event information we need to filter out the duplicates
191 #if wxUSE_MOUSEEVENT_HACK
192 static struct MouseEventInfoDummy
194 // mouse position (in screen coordinates)
197 // last mouse event type
200 #endif // wxUSE_MOUSEEVENT_HACK
202 // hash containing the registered handlers for the custom messages
203 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
204 wxIntegerHash
, wxIntegerEqual
,
207 static MSWMessageHandlers gs_messageHandlers
;
209 // hash containing all our windows, it uses HWND keys and wxWindow* values
210 WX_DECLARE_HASH_MAP(HWND
, wxWindow
*,
211 wxPointerHash
, wxPointerEqual
,
214 static WindowHandles gs_windowHandles
;
216 // ---------------------------------------------------------------------------
218 // ---------------------------------------------------------------------------
220 // the window proc for all our windows
221 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
222 WPARAM wParam
, LPARAM lParam
);
226 const wxChar
*wxGetMessageName(int message
);
229 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
230 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
232 // get the text metrics for the current font
233 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
236 // find the window for the mouse event at the specified position
237 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
238 #endif // __WXWINCE__
240 // wrapper around BringWindowToTop() API
241 static inline void wxBringWindowToTop(HWND hwnd
)
243 #ifdef __WXMICROWIN__
244 // It seems that MicroWindows brings the _parent_ of the window to the top,
245 // which can be the wrong one.
247 // activate (set focus to) specified window
251 // raise top level parent to top of z order
252 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
254 wxLogLastError(_T("SetWindowPos"));
260 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
261 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
264 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
265 parent as well as otherwise several Win32 functions using
266 GetNextDlgTabItem() to iterate over all controls such as
267 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
268 all of them iterate over all the controls starting from the currently
269 focused one and stop iterating when they get back to the focus but
270 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
271 get back to the initial (focused) window: as we do have this style,
272 GetNextDlgTabItem() will leave this window and continue in its parent,
273 but if the parent doesn't have it, it wouldn't recurse inside it later
274 on and so wouldn't have a chance of getting back to this window either.
276 while ( parent
&& !parent
->IsTopLevel() )
278 LONG exStyle
= wxGetWindowExStyle(parent
);
279 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
281 // force the parent to have this style
282 wxSetWindowExStyle(parent
, exStyle
| WS_EX_CONTROLPARENT
);
285 parent
= parent
->GetParent();
289 #endif // !__WXWINCE__
292 // On Windows CE, GetCursorPos can return an error, so use this function
294 bool GetCursorPosWinCE(POINT
* pt
)
296 if (!GetCursorPos(pt
))
298 DWORD pos
= GetMessagePos();
306 // ---------------------------------------------------------------------------
308 // ---------------------------------------------------------------------------
310 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
312 #ifdef __WXUNIVERSAL__
313 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
315 #if wxUSE_EXTENDED_RTTI
317 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
318 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
319 // windows with negative ids never can be recreated anyway
321 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
323 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
324 if ( win
&& win
->GetId() < 0 )
329 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
331 // make wxWindowList known before the property is used
333 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
335 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
337 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
340 WX_DEFINE_FLAGS( wxWindowStyle
)
342 wxBEGIN_FLAGS( wxWindowStyle
)
343 // new style border flags, we put them first to
344 // use them for streaming out
346 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
347 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
348 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
349 wxFLAGS_MEMBER(wxBORDER_RAISED
)
350 wxFLAGS_MEMBER(wxBORDER_STATIC
)
351 wxFLAGS_MEMBER(wxBORDER_NONE
)
353 // old style border flags
354 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
355 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
356 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
357 wxFLAGS_MEMBER(wxRAISED_BORDER
)
358 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
359 wxFLAGS_MEMBER(wxBORDER
)
361 // standard window styles
362 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
363 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
364 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
365 wxFLAGS_MEMBER(wxWANTS_CHARS
)
366 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
367 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
368 wxFLAGS_MEMBER(wxVSCROLL
)
369 wxFLAGS_MEMBER(wxHSCROLL
)
371 wxEND_FLAGS( wxWindowStyle
)
373 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
374 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
375 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
376 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
377 // Always constructor Properties first
379 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
380 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
381 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
382 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
383 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
385 // Then all relations of the object graph
387 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
389 // and finally all other properties
391 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
392 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
393 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
394 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
395 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
397 // possible property candidates (not in xrc) or not valid in all subclasses
398 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
399 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
400 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
401 // MaxHeight, Width , MinHeight , Width
402 // TODO switch label to control and title to toplevels
404 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
405 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
406 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
407 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
412 wxEND_PROPERTIES_TABLE()
414 wxBEGIN_HANDLERS_TABLE(wxWindow
)
415 wxEND_HANDLERS_TABLE()
417 wxCONSTRUCTOR_DUMMY(wxWindow
)
420 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
422 #endif // __WXUNIVERSAL__/__WXMSW__
424 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
425 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
426 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
428 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
432 // ===========================================================================
434 // ===========================================================================
436 // ---------------------------------------------------------------------------
437 // wxWindow utility functions
438 // ---------------------------------------------------------------------------
440 // Find an item given the MS Windows id
441 wxWindow
*wxWindowMSW::FindItem(long id
) const
444 wxControl
*item
= wxDynamicCastThis(wxControl
);
447 // is it us or one of our "internal" children?
448 if ( item
->GetId() == id
449 #ifndef __WXUNIVERSAL__
450 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
451 #endif // __WXUNIVERSAL__
457 #endif // wxUSE_CONTROLS
459 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
462 wxWindow
*childWin
= current
->GetData();
464 wxWindow
*wnd
= childWin
->FindItem(id
);
468 current
= current
->GetNext();
474 // Find an item given the MS Windows handle
475 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
477 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
480 wxWindow
*parent
= current
->GetData();
482 // Do a recursive search.
483 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
489 || parent
->IsKindOf(CLASSINFO(wxControl
))
490 #endif // wxUSE_CONTROLS
493 wxWindow
*item
= current
->GetData();
494 if ( item
->GetHWND() == hWnd
)
498 if ( item
->ContainsHWND(hWnd
) )
503 current
= current
->GetNext();
508 // Default command handler
509 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
514 // ----------------------------------------------------------------------------
515 // constructors and such
516 // ----------------------------------------------------------------------------
518 void wxWindowMSW::Init()
521 m_isBeingDeleted
= false;
523 m_mouseInWindow
= false;
524 m_lastKeydownProcessed
= false;
532 m_pendingPosition
= wxDefaultPosition
;
533 m_pendingSize
= wxDefaultSize
;
536 m_contextMenuEnabled
= false;
541 wxWindowMSW::~wxWindowMSW()
543 m_isBeingDeleted
= true;
545 #ifndef __WXUNIVERSAL__
546 // VS: make sure there's no wxFrame with last focus set to us:
547 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
549 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
552 if ( frame
->GetLastFocus() == this )
554 frame
->SetLastFocus(NULL
);
557 // apparently sometimes we can end up with our grand parent
558 // pointing to us as well: this is surely a bug in focus handling
559 // code but it's not clear where it happens so for now just try to
560 // fix it here by not breaking out of the loop
564 #endif // __WXUNIVERSAL__
566 // VS: destroy children first and _then_ detach *this from its parent.
567 // If we did it the other way around, children wouldn't be able
568 // find their parent frame (see above).
573 // VZ: test temp removed to understand what really happens here
574 //if (::IsWindow(GetHwnd()))
576 if ( !::DestroyWindow(GetHwnd()) )
577 wxLogLastError(wxT("DestroyWindow"));
580 // remove hWnd <-> wxWindow association
581 wxRemoveHandleAssociation(this);
587 const wxChar
*wxWindowMSW::MSWGetRegisteredClassName()
589 return wxApp::GetRegisteredClassName(_T("wxWindow"), COLOR_BTNFACE
);
592 // real construction (Init() must have been called before!)
593 bool wxWindowMSW::Create(wxWindow
*parent
,
598 const wxString
& name
)
600 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
602 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
605 parent
->AddChild(this);
608 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
610 #ifdef __WXUNIVERSAL__
611 // no borders, we draw them ourselves
612 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
616 msflags
&= ~WS_BORDER
;
617 #endif // wxUniversal
621 msflags
|= WS_VISIBLE
;
624 if ( !MSWCreate(MSWGetRegisteredClassName(),
625 NULL
, pos
, size
, msflags
, exstyle
) )
633 // ---------------------------------------------------------------------------
635 // ---------------------------------------------------------------------------
637 void wxWindowMSW::SetFocus()
639 HWND hWnd
= GetHwnd();
640 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
642 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
646 if ( !::SetFocus(hWnd
) )
648 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
649 // was there really an error?
650 DWORD dwRes
= ::GetLastError();
653 HWND hwndFocus
= ::GetFocus();
654 if ( hwndFocus
!= hWnd
)
656 wxLogApiError(_T("SetFocus"), dwRes
);
663 void wxWindowMSW::SetFocusFromKbd()
665 // when the focus is given to the control with DLGC_HASSETSEL style from
666 // keyboard its contents should be entirely selected: this is what
667 // ::IsDialogMessage() does and so we should do it as well to provide the
668 // same LNF as the native programs
669 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
671 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
674 // do this after (maybe) setting the selection as like this when
675 // wxEVT_SET_FOCUS handler is called, the selection would have been already
676 // set correctly -- this may be important
677 wxWindowBase::SetFocusFromKbd();
680 // Get the window with the focus
681 wxWindow
*wxWindowBase::DoFindFocus()
683 HWND hWnd
= ::GetFocus();
686 return wxGetWindowFromHWND((WXHWND
)hWnd
);
692 void wxWindowMSW::DoEnable( bool enable
)
694 HWND hWnd
= GetHwnd();
696 ::EnableWindow(hWnd
, (BOOL
)enable
);
699 bool wxWindowMSW::Show(bool show
)
701 if ( !wxWindowBase::Show(show
) )
704 HWND hWnd
= GetHwnd();
706 // we could be called before the underlying window is created (this is
707 // actually useful to prevent it from being initially shown), e.g.
709 // wxFoo *foo = new wxFoo;
711 // foo->Create(parent, ...);
713 // should work without errors
716 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
721 // DoFreeze/DoThaw don't do anything if the window is not shown, so
722 // we have to call them from here now
733 wxWindowMSW::MSWShowWithEffect(bool show
,
737 if ( !wxWindowBase::Show(show
) )
740 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
742 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
743 static bool s_initDone
= false;
746 wxDynamicLibrary
dllUser32(_T("user32.dll"), wxDL_VERBATIM
| wxDL_QUIET
);
747 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
751 // notice that it's ok to unload user32.dll here as it won't be really
752 // unloaded, being still in use because we link to it statically too
755 if ( !s_pfnAnimateWindow
)
758 // Show() has a side effect of sending a WM_SIZE to the window, which helps
759 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
760 // this so send the event ourselves
763 // prepare to use AnimateWindow()
766 timeout
= 200; // this is the default animation timeout, per MSDN
768 DWORD dwFlags
= show
? 0 : AW_HIDE
;
772 case wxSHOW_EFFECT_ROLL_TO_LEFT
:
773 dwFlags
|= AW_HOR_NEGATIVE
;
776 case wxSHOW_EFFECT_ROLL_TO_RIGHT
:
777 dwFlags
|= AW_HOR_POSITIVE
;
780 case wxSHOW_EFFECT_ROLL_TO_TOP
:
781 dwFlags
|= AW_VER_NEGATIVE
;
784 case wxSHOW_EFFECT_ROLL_TO_BOTTOM
:
785 dwFlags
|= AW_VER_POSITIVE
;
788 case wxSHOW_EFFECT_SLIDE_TO_LEFT
:
789 dwFlags
|= AW_SLIDE
| AW_HOR_NEGATIVE
;
792 case wxSHOW_EFFECT_SLIDE_TO_RIGHT
:
793 dwFlags
|= AW_SLIDE
| AW_HOR_POSITIVE
;
796 case wxSHOW_EFFECT_SLIDE_TO_TOP
:
797 dwFlags
|= AW_SLIDE
| AW_VER_NEGATIVE
;
800 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM
:
801 dwFlags
|= AW_SLIDE
| AW_VER_POSITIVE
;
804 case wxSHOW_EFFECT_BLEND
:
808 case wxSHOW_EFFECT_EXPAND
:
809 dwFlags
|= AW_CENTER
;
813 case wxSHOW_EFFECT_MAX
:
814 wxFAIL_MSG( _T("invalid window show effect") );
818 wxFAIL_MSG( _T("unknown window show effect") );
822 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
824 wxLogLastError(_T("AnimateWindow"));
832 // Raise the window to the top of the Z order
833 void wxWindowMSW::Raise()
835 wxBringWindowToTop(GetHwnd());
838 // Lower the window to the bottom of the Z order
839 void wxWindowMSW::Lower()
841 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
842 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
845 void wxWindowMSW::DoCaptureMouse()
847 HWND hWnd
= GetHwnd();
854 void wxWindowMSW::DoReleaseMouse()
856 if ( !::ReleaseCapture() )
858 wxLogLastError(_T("ReleaseCapture"));
862 /* static */ wxWindow
*wxWindowBase::GetCapture()
864 HWND hwnd
= ::GetCapture();
865 return hwnd
? wxFindWinFromHandle(hwnd
) : NULL
;
868 bool wxWindowMSW::SetFont(const wxFont
& font
)
870 if ( !wxWindowBase::SetFont(font
) )
876 HWND hWnd
= GetHwnd();
879 // note the use of GetFont() instead of m_font: our own font could have
880 // just been reset and in this case we need to change the font used by
881 // the native window to the default for this class, i.e. exactly what
883 WXHANDLE hFont
= GetFont().GetResourceHandle();
885 wxASSERT_MSG( hFont
, wxT("should have valid font") );
887 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
892 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
894 if ( !wxWindowBase::SetCursor(cursor
) )
900 // don't "overwrite" busy cursor
901 if ( m_cursor
.Ok() && !wxIsBusy() )
903 // normally we should change the cursor only if it's over this window
904 // but we should do it always if we capture the mouse currently
905 bool set
= HasCapture();
908 HWND hWnd
= GetHwnd();
912 ::GetCursorPosWinCE(&point
);
914 ::GetCursorPos(&point
);
917 RECT rect
= wxGetWindowRect(hWnd
);
919 set
= ::PtInRect(&rect
, point
) != 0;
924 ::SetCursor(GetHcursorOf(m_cursor
));
926 //else: will be set later when the mouse enters this window
932 void wxWindowMSW::WarpPointer(int x
, int y
)
934 ClientToScreen(&x
, &y
);
936 if ( !::SetCursorPos(x
, y
) )
938 wxLogLastError(_T("SetCursorPos"));
942 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
944 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
945 // to use it on older systems -- and could possibly do some harm
946 static int s_needToUpdate
= -1;
947 if ( s_needToUpdate
== -1 )
950 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
954 if ( s_needToUpdate
)
956 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
957 // won't send WM_UPDATEUISTATE
958 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
962 // ---------------------------------------------------------------------------
964 // ---------------------------------------------------------------------------
966 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
968 #ifdef __WXMICROWIN__
969 return ::GetScrollPosWX(hWnd
, wOrient
);
971 WinStruct
<SCROLLINFO
> scrollInfo
;
972 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
973 scrollInfo
.fMask
= SIF_POS
;
974 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
976 return scrollInfo
.nPos
;
981 int wxWindowMSW::GetScrollPos(int orient
) const
983 HWND hWnd
= GetHwnd();
984 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
986 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
989 // This now returns the whole range, not just the number
990 // of positions that we can scroll.
991 int wxWindowMSW::GetScrollRange(int orient
) const
994 HWND hWnd
= GetHwnd();
998 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1001 WinStruct
<SCROLLINFO
> scrollInfo
;
1002 scrollInfo
.fMask
= SIF_RANGE
;
1003 if ( !::GetScrollInfo(hWnd
,
1004 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1007 // Most of the time this is not really an error, since the return
1008 // value can also be zero when there is no scrollbar yet.
1009 // wxLogLastError(_T("GetScrollInfo"));
1011 maxPos
= scrollInfo
.nMax
;
1013 // undo "range - 1" done in SetScrollbar()
1017 int wxWindowMSW::GetScrollThumb(int orient
) const
1019 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
1022 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
1024 HWND hWnd
= GetHwnd();
1025 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
1027 WinStruct
<SCROLLINFO
> info
;
1031 info
.fMask
= SIF_POS
;
1032 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1034 // disable scrollbar instead of removing it then
1035 info
.fMask
|= SIF_DISABLENOSCROLL
;
1038 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1042 // New function that will replace some of the above.
1043 void wxWindowMSW::SetScrollbar(int orient
,
1049 WinStruct
<SCROLLINFO
> info
;
1050 info
.nPage
= pageSize
;
1051 info
.nMin
= 0; // range is nMax - nMin + 1
1052 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1054 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1055 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1057 // disable scrollbar instead of removing it then
1058 info
.fMask
|= SIF_DISABLENOSCROLL
;
1061 HWND hWnd
= GetHwnd();
1064 // We have to set the variables here to make them valid in events
1065 // triggered by ::SetScrollInfo()
1066 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1068 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1073 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1079 wxCopyRectToRECT(*prect
, rect
);
1089 // FIXME: is this the exact equivalent of the line below?
1090 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1092 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1096 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1098 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1101 for ( int n
= 0; n
< count
; n
++ )
1103 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1105 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1106 if ( posNew
== pos
)
1108 // don't bother to continue, we're already at top/bottom
1115 return pos
!= posStart
;
1118 bool wxWindowMSW::ScrollLines(int lines
)
1120 bool down
= lines
> 0;
1122 return ScrollVertically(GetHwnd(),
1123 down
? SB_LINEDOWN
: SB_LINEUP
,
1124 down
? lines
: -lines
);
1127 bool wxWindowMSW::ScrollPages(int pages
)
1129 bool down
= pages
> 0;
1131 return ScrollVertically(GetHwnd(),
1132 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1133 down
? pages
: -pages
);
1136 // ----------------------------------------------------------------------------
1138 // ----------------------------------------------------------------------------
1140 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1145 wxCHECK_RET( GetHwnd(),
1146 _T("layout direction must be set after window creation") );
1148 LONG styleOld
= wxGetWindowExStyle(this);
1150 LONG styleNew
= styleOld
;
1153 case wxLayout_LeftToRight
:
1154 styleNew
&= ~WS_EX_LAYOUTRTL
;
1157 case wxLayout_RightToLeft
:
1158 styleNew
|= WS_EX_LAYOUTRTL
;
1162 wxFAIL_MSG(_T("unsupported layout direction"));
1166 if ( styleNew
!= styleOld
)
1168 wxSetWindowExStyle(this, styleNew
);
1173 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1176 return wxLayout_Default
;
1178 wxCHECK_MSG( GetHwnd(), wxLayout_Default
, _T("invalid window") );
1180 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL
) ? wxLayout_RightToLeft
1181 : wxLayout_LeftToRight
;
1186 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1187 wxCoord
WXUNUSED(width
),
1188 wxCoord
WXUNUSED(widthTotal
)) const
1190 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1191 // redo it ourselves
1195 // ---------------------------------------------------------------------------
1197 // ---------------------------------------------------------------------------
1199 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1201 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1203 HWND hwnd
= (HWND
)hWnd
;
1204 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1208 wxAssociateWinWithHandle(hwnd
, this);
1210 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1212 // we don't need to subclass the window of our own class (in the Windows
1213 // sense of the word)
1214 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1216 wxSetWindowProc(hwnd
, wxWndProc
);
1220 // don't bother restoring it either: this also makes it easy to
1221 // implement IsOfStandardClass() method which returns true for the
1222 // standard controls and false for the wxWidgets own windows as it can
1223 // simply check m_oldWndProc
1224 m_oldWndProc
= NULL
;
1227 // we're officially created now, send the event
1228 wxWindowCreateEvent
event((wxWindow
*)this);
1229 (void)HandleWindowEvent(event
);
1232 void wxWindowMSW::UnsubclassWin()
1234 wxRemoveHandleAssociation(this);
1236 // Restore old Window proc
1237 HWND hwnd
= GetHwnd();
1242 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1246 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1248 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1251 m_oldWndProc
= NULL
;
1256 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1260 if ( !::DestroyWindow(GetHwnd()) )
1261 wxLogLastError(wxT("DestroyWindow"));
1264 WXHWND wxhwnd
= (WXHWND
)handle
;
1266 // this also calls SetHWND(wxhwnd)
1267 SubclassWin(wxhwnd
);
1270 void wxWindowMSW::DissociateHandle()
1272 // this also calls SetHWND(0) for us
1277 bool wxCheckWindowWndProc(WXHWND hWnd
,
1278 WXFARPROC
WXUNUSED(wndProc
))
1280 const wxString
str(wxGetWindowClass(hWnd
));
1282 // TODO: get rid of wxTLWHiddenParent special case (currently it's not
1283 // registered by wxApp but using ad hoc code in msw/toplevel.cpp);
1284 // there is also a hidden window class used by sockets &c
1285 return wxApp::IsRegisteredClassName(str
) || str
== _T("wxTLWHiddenParent");
1288 // ----------------------------------------------------------------------------
1290 // ----------------------------------------------------------------------------
1292 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1294 long flagsOld
= GetWindowStyleFlag();
1295 if ( flags
== flagsOld
)
1298 // update the internal variable
1299 wxWindowBase::SetWindowStyleFlag(flags
);
1301 // and the real window flags
1302 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1305 void wxWindowMSW::SetExtraStyle(long exflags
)
1307 long exflagsOld
= GetExtraStyle();
1308 if ( exflags
== exflagsOld
)
1311 // update the internal variable
1312 wxWindowBase::SetExtraStyle(exflags
);
1314 // and the real window flags
1315 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1318 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1320 // now update the Windows style as well if needed - and if the window had
1321 // been already created
1325 // we may need to call SetWindowPos() when we change some styles
1326 bool callSWP
= false;
1329 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1331 // this is quite a horrible hack but we need it because MSWGetStyle()
1332 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1333 // and so we have to modify the window exflags temporarily to get the
1334 // correct exstyleOld
1335 long exflagsNew
= GetExtraStyle();
1336 wxWindowBase::SetExtraStyle(exflagsOld
);
1339 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1341 wxWindowBase::SetExtraStyle(exflagsNew
);
1344 if ( style
!= styleOld
)
1346 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1347 // this function so instead of simply setting the style to the new
1348 // value we clear the bits which were set in styleOld but are set in
1349 // the new one and set the ones which were not set before
1350 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1351 styleReal
&= ~styleOld
;
1354 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1356 // we need to call SetWindowPos() if any of the styles affecting the
1357 // frame appearance have changed
1358 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1367 // and the extended style
1368 long exstyleReal
= wxGetWindowExStyle(this);
1370 if ( exstyle
!= exstyleOld
)
1372 exstyleReal
&= ~exstyleOld
;
1373 exstyleReal
|= exstyle
;
1375 wxSetWindowExStyle(this, exstyleReal
);
1377 // ex style changes don't take effect without calling SetWindowPos
1383 // we must call SetWindowPos() to flush the cached extended style and
1384 // also to make the change to wxSTAY_ON_TOP style take effect: just
1385 // setting the style simply doesn't work
1386 if ( !::SetWindowPos(GetHwnd(),
1387 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1390 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1392 wxLogLastError(_T("SetWindowPos"));
1397 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1399 return wxBORDER_THEME
;
1402 wxBorder
wxWindowMSW::GetDefaultBorder() const
1404 return wxWindowBase::GetDefaultBorder();
1407 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1408 // that makes most sense for this Windows environment
1409 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1411 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1412 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1413 return wxBORDER_SIMPLE
;
1415 return wxBORDER_NONE
;
1418 if (border
== wxBORDER_THEME
)
1420 if (CanApplyThemeBorder())
1422 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1424 return wxBORDER_THEME
;
1426 return wxBORDER_SUNKEN
;
1434 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1436 // translate common wxWidgets styles to Windows ones
1438 // most of windows are child ones, those which are not (such as
1439 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1440 WXDWORD style
= WS_CHILD
;
1442 // using this flag results in very significant reduction in flicker,
1443 // especially with controls inside the static boxes (as the interior of the
1444 // box is not redrawn twice), but sometimes results in redraw problems, so
1445 // optionally allow the old code to continue to use it provided a special
1446 // system option is turned on
1447 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1448 || (flags
& wxCLIP_CHILDREN
) )
1449 style
|= WS_CLIPCHILDREN
;
1451 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1452 // don't support overlapping windows and it only makes sense for them and,
1453 // presumably, gives the system some extra work (to manage more clipping
1454 // regions), so avoid it alltogether
1457 if ( flags
& wxVSCROLL
)
1458 style
|= WS_VSCROLL
;
1460 if ( flags
& wxHSCROLL
)
1461 style
|= WS_HSCROLL
;
1463 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1465 // After translation, border is now optimized for the specific version of Windows
1466 // and theme engine presence.
1468 // WS_BORDER is only required for wxBORDER_SIMPLE
1469 if ( border
== wxBORDER_SIMPLE
)
1472 // now deal with ext style if the caller wants it
1478 if ( flags
& wxTRANSPARENT_WINDOW
)
1479 *exstyle
|= WS_EX_TRANSPARENT
;
1485 case wxBORDER_DEFAULT
:
1486 wxFAIL_MSG( _T("unknown border style") );
1490 case wxBORDER_SIMPLE
:
1491 case wxBORDER_THEME
:
1494 case wxBORDER_STATIC
:
1495 *exstyle
|= WS_EX_STATICEDGE
;
1498 case wxBORDER_RAISED
:
1499 *exstyle
|= WS_EX_DLGMODALFRAME
;
1502 case wxBORDER_SUNKEN
:
1503 *exstyle
|= WS_EX_CLIENTEDGE
;
1504 style
&= ~WS_BORDER
;
1507 // case wxBORDER_DOUBLE:
1508 // *exstyle |= WS_EX_DLGMODALFRAME;
1512 // wxUniv doesn't use Windows dialog navigation functions at all
1513 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1514 // to make the dialog navigation work with the nested panels we must
1515 // use this style (top level windows such as dialogs don't need it)
1516 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1518 *exstyle
|= WS_EX_CONTROLPARENT
;
1520 #endif // __WXUNIVERSAL__
1526 // Setup background and foreground colours correctly
1527 void wxWindowMSW::SetupColours()
1530 SetBackgroundColour(GetParent()->GetBackgroundColour());
1533 bool wxWindowMSW::IsMouseInWindow() const
1535 // get the mouse position
1538 ::GetCursorPosWinCE(&pt
);
1540 ::GetCursorPos(&pt
);
1543 // find the window which currently has the cursor and go up the window
1544 // chain until we find this window - or exhaust it
1545 HWND hwnd
= ::WindowFromPoint(pt
);
1546 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1547 hwnd
= ::GetParent(hwnd
);
1549 return hwnd
!= NULL
;
1552 void wxWindowMSW::OnInternalIdle()
1554 #ifndef HAVE_TRACKMOUSEEVENT
1555 // Check if we need to send a LEAVE event
1556 if ( m_mouseInWindow
)
1558 // note that we should generate the leave event whether the window has
1559 // or doesn't have mouse capture
1560 if ( !IsMouseInWindow() )
1562 GenerateMouseLeave();
1565 #endif // !HAVE_TRACKMOUSEEVENT
1567 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1568 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1571 // Set this window to be the child of 'parent'.
1572 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1574 if ( !wxWindowBase::Reparent(parent
) )
1577 HWND hWndChild
= GetHwnd();
1578 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1580 ::SetParent(hWndChild
, hWndParent
);
1583 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT
) )
1585 EnsureParentHasControlParentStyle(GetParent());
1587 #endif // !__WXWINCE__
1592 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1594 #ifndef __WXMICROWIN__
1595 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1599 void wxWindowMSW::DoFreeze()
1602 return; // no point in freezing hidden window
1604 SendSetRedraw(GetHwnd(), false);
1607 void wxWindowMSW::DoThaw()
1610 return; // hidden windows aren't frozen by DoFreeze
1612 SendSetRedraw(GetHwnd(), true);
1614 // we need to refresh everything or otherwise the invalidated area
1615 // is not going to be repainted
1619 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1621 HWND hWnd
= GetHwnd();
1628 wxCopyRectToRECT(*rect
, mswRect
);
1636 // RedrawWindow not available on SmartPhone or eVC++ 3
1637 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1638 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1642 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1644 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1649 void wxWindowMSW::Update()
1651 if ( !::UpdateWindow(GetHwnd()) )
1653 wxLogLastError(_T("UpdateWindow"));
1656 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1657 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1658 // handler needs to be really drawn right now
1663 // ---------------------------------------------------------------------------
1665 // ---------------------------------------------------------------------------
1667 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1671 // we need to lower the sibling static boxes so controls contained within can be
1673 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1675 // no sibling static boxes if we have no parent (ie TLW)
1679 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1681 node
= node
->GetNext() )
1683 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1686 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1687 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1692 #else // !wxUSE_STATBOX
1694 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1698 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1700 #endif // drag and drop is used
1702 #if wxUSE_DRAG_AND_DROP
1703 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1705 if ( m_dropTarget
!= 0 ) {
1706 m_dropTarget
->Revoke(m_hWnd
);
1707 delete m_dropTarget
;
1710 m_dropTarget
= pDropTarget
;
1711 if ( m_dropTarget
!= 0 )
1713 AdjustStaticBoxZOrder(GetParent());
1714 m_dropTarget
->Register(m_hWnd
);
1717 #endif // wxUSE_DRAG_AND_DROP
1719 // old-style file manager drag&drop support: we retain the old-style
1720 // DragAcceptFiles in parallel with SetDropTarget.
1721 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1724 HWND hWnd
= GetHwnd();
1727 AdjustStaticBoxZOrder(GetParent());
1728 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1733 // ----------------------------------------------------------------------------
1735 // ----------------------------------------------------------------------------
1739 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1741 wxWindowBase::DoSetToolTip(tooltip
);
1744 m_tooltip
->SetWindow((wxWindow
*)this);
1747 #endif // wxUSE_TOOLTIPS
1749 // ---------------------------------------------------------------------------
1750 // moving and resizing
1751 // ---------------------------------------------------------------------------
1753 bool wxWindowMSW::IsSizeDeferred() const
1755 #if USE_DEFERRED_SIZING
1756 if ( m_pendingPosition
!= wxDefaultPosition
||
1757 m_pendingSize
!= wxDefaultSize
)
1759 #endif // USE_DEFERRED_SIZING
1765 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1767 #if USE_DEFERRED_SIZING
1768 // if SetSize() had been called at wx level but not realized at Windows
1769 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1770 // the new and not the old position to the other wx code
1771 if ( m_pendingSize
!= wxDefaultSize
)
1774 *x
= m_pendingSize
.x
;
1776 *y
= m_pendingSize
.y
;
1778 else // use current size
1779 #endif // USE_DEFERRED_SIZING
1781 RECT rect
= wxGetWindowRect(GetHwnd());
1784 *x
= rect
.right
- rect
.left
;
1786 *y
= rect
.bottom
- rect
.top
;
1790 // Get size *available for subwindows* i.e. excluding menu bar etc.
1791 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1793 #if USE_DEFERRED_SIZING
1794 if ( m_pendingSize
!= wxDefaultSize
)
1796 // we need to calculate the client size corresponding to pending size
1798 rect
.left
= m_pendingPosition
.x
;
1799 rect
.top
= m_pendingPosition
.y
;
1800 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1801 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1803 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1806 *x
= rect
.right
- rect
.left
;
1808 *y
= rect
.bottom
- rect
.top
;
1811 #endif // USE_DEFERRED_SIZING
1813 RECT rect
= wxGetClientRect(GetHwnd());
1822 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1824 wxWindow
* const parent
= GetParent();
1827 if ( m_pendingPosition
!= wxDefaultPosition
)
1829 pos
= m_pendingPosition
;
1831 else // use current position
1833 RECT rect
= wxGetWindowRect(GetHwnd());
1836 point
.x
= rect
.left
;
1839 // we do the adjustments with respect to the parent only for the "real"
1840 // children, not for the dialogs/frames
1841 if ( !IsTopLevel() )
1843 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1845 // In RTL mode, we want the logical left x-coordinate,
1846 // which would be the physical right x-coordinate.
1847 point
.x
= rect
.right
;
1850 // Since we now have the absolute screen coords, if there's a
1851 // parent we must subtract its top left corner
1854 ::ScreenToClient(GetHwndOf(parent
), &point
);
1862 // we also must adjust by the client area offset: a control which is just
1863 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1864 if ( parent
&& !IsTopLevel() )
1866 const wxPoint
pt(parent
->GetClientAreaOrigin());
1877 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1885 ::ScreenToClient(GetHwnd(), &pt
);
1893 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1901 ::ClientToScreen(GetHwnd(), &pt
);
1910 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1912 #if USE_DEFERRED_SIZING
1913 // if our parent had prepared a defer window handle for us, use it (unless
1914 // we are a top level window)
1915 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1917 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1920 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1921 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1924 wxLogLastError(_T("DeferWindowPos"));
1930 // hdwp must be updated as it may have been changed
1931 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1936 // did deferred move, remember new coordinates of the window as they're
1937 // different from what Windows would return for it
1941 // otherwise (or if deferring failed) move the window in place immediately
1942 #endif // USE_DEFERRED_SIZING
1943 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1945 wxLogLastError(wxT("MoveWindow"));
1948 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1949 // ignored otherwise
1953 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1955 // TODO: is this consistent with other platforms?
1956 // Still, negative width or height shouldn't be allowed
1962 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1964 #if USE_DEFERRED_SIZING
1965 m_pendingPosition
= wxPoint(x
, y
);
1966 m_pendingSize
= wxSize(width
, height
);
1968 else // window was moved immediately, without deferring it
1970 m_pendingPosition
= wxDefaultPosition
;
1971 m_pendingSize
= wxDefaultSize
;
1972 #endif // USE_DEFERRED_SIZING
1976 // set the size of the window: if the dimensions are positive, just use them,
1977 // but if any of them is equal to -1, it means that we must find the value for
1978 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1979 // which case -1 is a valid value for x and y)
1981 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1982 // the width/height to best suit our contents, otherwise we reuse the current
1984 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1986 // get the current size and position...
1987 int currentX
, currentY
;
1988 int currentW
, currentH
;
1990 GetPosition(¤tX
, ¤tY
);
1991 GetSize(¤tW
, ¤tH
);
1993 // ... and don't do anything (avoiding flicker) if it's already ok unless
1994 // we're forced to resize the window
1995 if ( x
== currentX
&& y
== currentY
&&
1996 width
== currentW
&& height
== currentH
&&
1997 !(sizeFlags
& wxSIZE_FORCE
) )
2002 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2004 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2007 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2009 wxSize size
= wxDefaultSize
;
2010 if ( width
== wxDefaultCoord
)
2012 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2014 size
= DoGetBestSize();
2019 // just take the current one
2024 if ( height
== wxDefaultCoord
)
2026 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2028 if ( size
.x
== wxDefaultCoord
)
2030 size
= DoGetBestSize();
2032 //else: already called DoGetBestSize() above
2038 // just take the current one
2043 DoMoveWindow(x
, y
, width
, height
);
2046 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2048 // setting the client size is less obvious than it could have been
2049 // because in the result of changing the total size the window scrollbar
2050 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2051 // doesn't take neither into account) and so the client size will not be
2052 // correct as the difference between the total and client size changes --
2053 // so we keep changing it until we get it right
2055 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2056 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2057 // may become 3 if the window had 0 size originally and so we didn't
2058 // calculate the scrollbar correction correctly during the first iteration)
2059 // but just to be on the safe side we check for it instead of making it an
2060 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2061 for ( int i
= 0; i
< 4; i
++ )
2064 ::GetClientRect(GetHwnd(), &rectClient
);
2066 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2067 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2068 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2073 // Find the difference between the entire window (title bar and all)
2074 // and the client area; add this to the new client size to move the
2077 ::GetWindowRect(GetHwnd(), &rectWin
);
2079 const int widthWin
= rectWin
.right
- rectWin
.left
,
2080 heightWin
= rectWin
.bottom
- rectWin
.top
;
2082 // MoveWindow positions the child windows relative to the parent, so
2083 // adjust if necessary
2084 if ( !IsTopLevel() )
2086 wxWindow
*parent
= GetParent();
2089 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2093 // don't call DoMoveWindow() because we want to move window immediately
2094 // and not defer it here as otherwise the value returned by
2095 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2097 if ( !::MoveWindow(GetHwnd(),
2100 width
+ widthWin
- rectClient
.right
,
2101 height
+ heightWin
- rectClient
.bottom
,
2104 wxLogLastError(_T("MoveWindow"));
2109 // ---------------------------------------------------------------------------
2111 // ---------------------------------------------------------------------------
2113 int wxWindowMSW::GetCharHeight() const
2115 return wxGetTextMetrics(this).tmHeight
;
2118 int wxWindowMSW::GetCharWidth() const
2120 // +1 is needed because Windows apparently adds it when calculating the
2121 // dialog units size in pixels
2122 #if wxDIALOG_UNIT_COMPATIBILITY
2123 return wxGetTextMetrics(this).tmAveCharWidth
;
2125 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2129 void wxWindowMSW::GetTextExtent(const wxString
& string
,
2131 int *descent
, int *externalLeading
,
2132 const wxFont
*fontToUse
) const
2134 wxASSERT_MSG( !fontToUse
|| fontToUse
->Ok(),
2135 _T("invalid font in GetTextExtent()") );
2139 hfontToUse
= GetHfontOf(*fontToUse
);
2141 hfontToUse
= GetHfontOf(GetFont());
2143 WindowHDC
hdc(GetHwnd());
2144 SelectInHDC
selectFont(hdc
, hfontToUse
);
2148 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2149 GetTextMetrics(hdc
, &tm
);
2156 *descent
= tm
.tmDescent
;
2157 if ( externalLeading
)
2158 *externalLeading
= tm
.tmExternalLeading
;
2161 // ---------------------------------------------------------------------------
2163 // ---------------------------------------------------------------------------
2165 #if wxUSE_MENUS_NATIVE
2167 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2168 // immediately, without waiting for the next event loop iteration
2170 // NB: this function should probably be made public later as it can almost
2171 // surely replace wxYield() elsewhere as well
2172 static void wxYieldForCommandsOnly()
2174 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2175 // want to process it here)
2177 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2179 if ( msg
.message
== WM_QUIT
)
2181 // if we retrieved a WM_QUIT, insert back into the message queue.
2182 ::PostQuitMessage(0);
2186 // luckily (as we don't have access to wxEventLoopImpl method from here
2187 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2189 ::TranslateMessage(&msg
);
2190 ::DispatchMessage(&msg
);
2194 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2196 menu
->SetInvokingWindow(this);
2199 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2201 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2202 x
= mouse
.x
; y
= mouse
.y
;
2205 HWND hWnd
= GetHwnd();
2206 HMENU hMenu
= GetHmenuOf(menu
);
2210 ::ClientToScreen(hWnd
, &point
);
2211 #if defined(__WXWINCE__)
2212 static const UINT flags
= 0;
2213 #else // !__WXWINCE__
2214 UINT flags
= TPM_RIGHTBUTTON
;
2215 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2216 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2217 // side and not to use it there neither -- modify the test if it does work
2219 if ( wxGetWinVersion() >= wxWinVersion_5
)
2221 // using TPM_RECURSE allows us to show a popup menu while another menu
2222 // is opened which can be useful and is supported by the other
2223 // platforms, so allow it under Windows too
2224 flags
|= TPM_RECURSE
;
2226 #endif // __WXWINCE__/!__WXWINCE__
2228 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2230 // we need to do it right now as otherwise the events are never going to be
2231 // sent to wxCurrentPopupMenu from HandleCommand()
2233 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2234 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2235 // destroyed as soon as we return (it can be a local variable in the caller
2236 // for example) and so we do need to process the event immediately
2237 wxYieldForCommandsOnly();
2239 menu
->SetInvokingWindow(NULL
);
2244 #endif // wxUSE_MENUS_NATIVE
2246 // ===========================================================================
2247 // pre/post message processing
2248 // ===========================================================================
2250 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2253 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2255 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2258 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2260 // wxUniversal implements tab traversal itself
2261 #ifndef __WXUNIVERSAL__
2262 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2264 // intercept dialog navigation keys
2265 MSG
*msg
= (MSG
*)pMsg
;
2267 // here we try to do all the job which ::IsDialogMessage() usually does
2269 if ( msg
->message
== WM_KEYDOWN
)
2271 bool bCtrlDown
= wxIsCtrlDown();
2272 bool bShiftDown
= wxIsShiftDown();
2274 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2275 // don't process it if it's the case (except for Ctrl-Tab/Enter
2276 // combinations which are always processed)
2277 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2279 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2280 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2281 // it, of course, implies them
2282 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2284 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2287 bool bForward
= true,
2288 bWindowChange
= false,
2291 // should we process this message specially?
2292 bool bProcess
= true;
2293 switch ( msg
->wParam
)
2296 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2298 // let the control have the TAB
2301 else // use it for navigation
2303 // Ctrl-Tab cycles thru notebook pages
2304 bWindowChange
= bCtrlDown
;
2305 bForward
= !bShiftDown
;
2312 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2320 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2329 // we treat PageUp/Dn as arrows because chances are that
2330 // a control which needs arrows also needs them for
2331 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2332 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2334 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2335 bWindowChange
= true;
2341 // currently active button should get enter press even
2342 // if there is a default button elsewhere so check if
2343 // this window is a button first
2344 wxWindow
*btn
= NULL
;
2345 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2347 // let IsDialogMessage() handle this for all
2348 // buttons except the owner-drawn ones which it
2349 // just seems to ignore
2350 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2351 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2353 // emulate the button click
2354 btn
= wxFindWinFromHandle(msg
->hwnd
);
2359 else // not a button itself, do we have default button?
2361 // check if this window or any of its ancestors
2362 // wants the message for itself (we always reserve
2363 // Ctrl-Enter for dialog navigation though)
2364 wxWindow
*win
= this;
2367 // this will contain the dialog code of this
2368 // window and all of its parent windows in turn
2369 LONG lDlgCode2
= lDlgCode
;
2373 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2375 // as it wants to process Enter itself,
2376 // don't call IsDialogMessage() which
2381 // don't propagate keyboard messages beyond
2382 // the first top level window parent
2383 if ( win
->IsTopLevel() )
2386 win
= win
->GetParent();
2388 lDlgCode2
= ::SendMessage
2399 win
= wxGetTopLevelParent(win
);
2402 wxTopLevelWindow
* const
2403 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2406 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2411 if ( btn
&& btn
->IsEnabled() )
2413 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2417 #endif // wxUSE_BUTTON
2420 // map Enter presses into button presses on PDAs
2421 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2422 event
.SetEventObject(this);
2423 if ( HandleWindowEvent(event
) )
2425 #endif // __WXWINCE__
2435 wxNavigationKeyEvent event
;
2436 event
.SetDirection(bForward
);
2437 event
.SetWindowChange(bWindowChange
);
2438 event
.SetFromTab(bFromTab
);
2439 event
.SetEventObject(this);
2441 if ( HandleWindowEvent(event
) )
2443 // as we don't call IsDialogMessage(), which would take of
2444 // this by default, we need to manually send this message
2445 // so that controls can change their UI state if needed
2446 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2453 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2455 // IsDialogMessage() did something...
2459 #endif // __WXUNIVERSAL__
2464 // relay mouse move events to the tooltip control
2465 MSG
*msg
= (MSG
*)pMsg
;
2466 if ( msg
->message
== WM_MOUSEMOVE
)
2467 wxToolTip::RelayEvent(pMsg
);
2469 #endif // wxUSE_TOOLTIPS
2474 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2476 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2477 return m_acceleratorTable
.Translate(this, pMsg
);
2481 #endif // wxUSE_ACCEL
2484 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2486 // all tests below have to deal with various bugs/misfeatures of
2487 // IsDialogMessage(): we have to prevent it from being called from our
2488 // MSWProcessMessage() in some situations
2490 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2491 // message even when there is no cancel button and when the message is
2492 // needed by the control itself: in particular, it prevents the tree in
2493 // place edit control from being closed with Escape in a dialog
2494 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2499 // ::IsDialogMessage() is broken and may sometimes hang the application by
2500 // going into an infinite loop when it tries to find the control to give
2501 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2502 // situations when this may happen and not call it then
2503 if ( msg
->message
!= WM_SYSCHAR
)
2506 // assume we can call it by default
2507 bool canSafelyCallIsDlgMsg
= true;
2509 HWND hwndFocus
= ::GetFocus();
2511 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2512 // ::IsDialogMessage() will also enter an infinite loop, because it will
2513 // recursively check the child windows but not the window itself and so if
2514 // none of the children accepts focus it loops forever (as it only stops
2515 // when it gets back to the window it started from)
2517 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2518 // style has the focus, it can happen. One such possibility is if
2519 // all windows are either toplevel, wxDialog, wxPanel or static
2520 // controls and no window can actually accept keyboard input.
2521 #if !defined(__WXWINCE__)
2522 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2524 // pessimistic by default
2525 canSafelyCallIsDlgMsg
= false;
2526 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2528 node
= node
->GetNext() )
2530 wxWindow
* const win
= node
->GetData();
2531 if ( win
->CanAcceptFocus() &&
2532 !wxHasWindowExStyle(win
, WS_EX_CONTROLPARENT
) )
2534 // it shouldn't hang...
2535 canSafelyCallIsDlgMsg
= true;
2541 #endif // !__WXWINCE__
2543 if ( canSafelyCallIsDlgMsg
)
2545 // ::IsDialogMessage() can enter in an infinite loop when the
2546 // currently focused window is disabled or hidden and its
2547 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2551 if ( !::IsWindowEnabled(hwndFocus
) ||
2552 !::IsWindowVisible(hwndFocus
) )
2554 // it would enter an infinite loop if we do this!
2555 canSafelyCallIsDlgMsg
= false;
2560 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2562 // it's a top level window, don't go further -- e.g. even
2563 // if the parent of a dialog is disabled, this doesn't
2564 // break navigation inside the dialog
2568 hwndFocus
= ::GetParent(hwndFocus
);
2572 return canSafelyCallIsDlgMsg
;
2575 // ---------------------------------------------------------------------------
2576 // message params unpackers
2577 // ---------------------------------------------------------------------------
2579 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2580 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2582 *id
= LOWORD(wParam
);
2583 *hwnd
= (WXHWND
)lParam
;
2584 *cmd
= HIWORD(wParam
);
2587 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2588 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2590 *state
= LOWORD(wParam
);
2591 *minimized
= HIWORD(wParam
);
2592 *hwnd
= (WXHWND
)lParam
;
2595 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2596 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2598 *code
= LOWORD(wParam
);
2599 *pos
= HIWORD(wParam
);
2600 *hwnd
= (WXHWND
)lParam
;
2603 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2604 WXHDC
*hdc
, WXHWND
*hwnd
)
2606 *hwnd
= (WXHWND
)lParam
;
2607 *hdc
= (WXHDC
)wParam
;
2610 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2611 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2613 *item
= (WXWORD
)wParam
;
2614 *flags
= HIWORD(wParam
);
2615 *hmenu
= (WXHMENU
)lParam
;
2618 // ---------------------------------------------------------------------------
2619 // Main wxWidgets window proc and the window proc for wxWindow
2620 // ---------------------------------------------------------------------------
2622 // Hook for new window just as it's being created, when the window isn't yet
2623 // associated with the handle
2624 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2626 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2627 // window being created and insures that it's always unset back later
2628 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2630 gs_winBeingCreated
= winBeingCreated
;
2633 wxWindowCreationHook::~wxWindowCreationHook()
2635 gs_winBeingCreated
= NULL
;
2639 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2641 // trace all messages - useful for the debugging
2643 wxLogTrace(wxTraceMessages
,
2644 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2645 wxGetMessageName(message
), hWnd
, (long)wParam
, lParam
);
2646 #endif // __WXDEBUG__
2648 wxWindowMSW
*wnd
= wxFindWinFromHandle(hWnd
);
2650 // when we get the first message for the HWND we just created, we associate
2651 // it with wxWindow stored in gs_winBeingCreated
2652 if ( !wnd
&& gs_winBeingCreated
)
2654 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2655 wnd
= gs_winBeingCreated
;
2656 gs_winBeingCreated
= NULL
;
2657 wnd
->SetHWND((WXHWND
)hWnd
);
2662 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2663 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2665 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2670 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2672 // did we process the message?
2673 bool processed
= false;
2683 // for most messages we should return 0 when we do process the message
2691 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2694 // return 0 to allow window creation
2695 rc
.result
= mayCreate
? 0 : -1;
2701 // never set processed to true and *always* pass WM_DESTROY to
2702 // DefWindowProc() as Windows may do some internal cleanup when
2703 // processing it and failing to pass the message along may cause
2704 // memory and resource leaks!
2705 (void)HandleDestroy();
2709 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2713 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2716 #if !defined(__WXWINCE__)
2719 LPRECT pRect
= (LPRECT
)lParam
;
2721 rc
.SetLeft(pRect
->left
);
2722 rc
.SetTop(pRect
->top
);
2723 rc
.SetRight(pRect
->right
);
2724 rc
.SetBottom(pRect
->bottom
);
2725 processed
= HandleMoving(rc
);
2727 pRect
->left
= rc
.GetLeft();
2728 pRect
->top
= rc
.GetTop();
2729 pRect
->right
= rc
.GetRight();
2730 pRect
->bottom
= rc
.GetBottom();
2735 case WM_ENTERSIZEMOVE
:
2737 processed
= HandleEnterSizeMove();
2741 case WM_EXITSIZEMOVE
:
2743 processed
= HandleExitSizeMove();
2749 LPRECT pRect
= (LPRECT
)lParam
;
2751 rc
.SetLeft(pRect
->left
);
2752 rc
.SetTop(pRect
->top
);
2753 rc
.SetRight(pRect
->right
);
2754 rc
.SetBottom(pRect
->bottom
);
2755 processed
= HandleSizing(rc
);
2757 pRect
->left
= rc
.GetLeft();
2758 pRect
->top
= rc
.GetTop();
2759 pRect
->right
= rc
.GetRight();
2760 pRect
->bottom
= rc
.GetBottom();
2764 #endif // !__WXWINCE__
2766 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2767 case WM_ACTIVATEAPP
:
2768 // This implicitly sends a wxEVT_ACTIVATE_APP event
2769 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2775 WXWORD state
, minimized
;
2777 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2779 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2784 processed
= HandleSetFocus((WXHWND
)wParam
);
2788 processed
= HandleKillFocus((WXHWND
)wParam
);
2791 case WM_PRINTCLIENT
:
2792 processed
= HandlePrintClient((WXHDC
)wParam
);
2798 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2800 processed
= HandlePaint();
2804 processed
= HandlePaint();
2809 #ifdef __WXUNIVERSAL__
2810 // Universal uses its own wxFrame/wxDialog, so we don't receive
2811 // close events unless we have this.
2813 #endif // __WXUNIVERSAL__
2815 // don't let the DefWindowProc() destroy our window - we'll do it
2816 // ourselves in ~wxWindow
2822 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2826 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2827 GET_Y_LPARAM(lParam
),
2831 #ifdef HAVE_TRACKMOUSEEVENT
2833 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2835 if ( m_mouseInWindow
)
2837 GenerateMouseLeave();
2840 // always pass processed back as false, this allows the window
2841 // manager to process the message too. This is needed to
2842 // ensure windows XP themes work properly as the mouse moves
2843 // over widgets like buttons. So don't set processed to true here.
2845 #endif // HAVE_TRACKMOUSEEVENT
2847 #if wxUSE_MOUSEWHEEL
2849 processed
= HandleMouseWheel(wParam
, lParam
);
2853 case WM_LBUTTONDOWN
:
2855 case WM_LBUTTONDBLCLK
:
2856 case WM_RBUTTONDOWN
:
2858 case WM_RBUTTONDBLCLK
:
2859 case WM_MBUTTONDOWN
:
2861 case WM_MBUTTONDBLCLK
:
2862 #ifdef wxHAS_XBUTTON
2863 case WM_XBUTTONDOWN
:
2865 case WM_XBUTTONDBLCLK
:
2866 #endif // wxHAS_XBUTTON
2868 #ifdef __WXMICROWIN__
2869 // MicroWindows seems to ignore the fact that a window is
2870 // disabled. So catch mouse events and throw them away if
2872 wxWindowMSW
* win
= this;
2875 if (!win
->IsEnabled())
2881 win
= win
->GetParent();
2882 if ( !win
|| win
->IsTopLevel() )
2889 #endif // __WXMICROWIN__
2890 int x
= GET_X_LPARAM(lParam
),
2891 y
= GET_Y_LPARAM(lParam
);
2894 // redirect the event to a static control if necessary by
2895 // finding one under mouse because under CE the static controls
2896 // don't generate mouse events (even with SS_NOTIFY)
2898 if ( GetCapture() == this )
2900 // but don't do it if the mouse is captured by this window
2901 // because then it should really get this event itself
2906 win
= FindWindowForMouseEvent(this, &x
, &y
);
2908 // this should never happen
2909 wxCHECK_MSG( win
, 0,
2910 _T("FindWindowForMouseEvent() returned NULL") );
2913 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2915 SHRGINFO shrgi
= {0};
2917 shrgi
.cbSize
= sizeof(SHRGINFO
);
2918 shrgi
.hwndClient
= (HWND
) GetHWND();
2922 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2923 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2925 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2928 pt
= ClientToScreen(pt
);
2930 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2932 evtCtx
.SetEventObject(this);
2933 if (HandleWindowEvent(evtCtx
))
2942 #else // !__WXWINCE__
2943 wxWindowMSW
*win
= this;
2944 #endif // __WXWINCE__/!__WXWINCE__
2946 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2948 // if the app didn't eat the event, handle it in the default
2949 // way, that is by giving this window the focus
2952 // for the standard classes their WndProc sets the focus to
2953 // them anyhow and doing it from here results in some weird
2954 // problems, so don't do it for them (unnecessary anyhow)
2955 if ( !win
->IsOfStandardClass() )
2957 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
2969 case MM_JOY1BUTTONDOWN
:
2970 case MM_JOY2BUTTONDOWN
:
2971 case MM_JOY1BUTTONUP
:
2972 case MM_JOY2BUTTONUP
:
2973 processed
= HandleJoystickEvent(message
,
2974 GET_X_LPARAM(lParam
),
2975 GET_Y_LPARAM(lParam
),
2978 #endif // __WXMICROWIN__
2984 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2986 processed
= HandleCommand(id
, cmd
, hwnd
);
2991 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2994 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2995 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2996 // apparently doesn't always behave properly and needs some help
2997 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2998 case WM_NOTIFYFORMAT
:
2999 if ( lParam
== NF_QUERY
)
3002 rc
.result
= NFR_UNICODE
;
3005 #endif // wxUSE_UNICODE_MSLU
3007 // for these messages we must return true if process the message
3010 processed
= MSWOnDrawItem(wParam
, (WXDRAWITEMSTRUCT
*)lParam
);
3015 case WM_MEASUREITEM
:
3016 processed
= MSWOnMeasureItem(wParam
, (WXMEASUREITEMSTRUCT
*)lParam
);
3020 #endif // defined(WM_DRAWITEM)
3023 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3025 // we always want to get the char events
3026 rc
.result
= DLGC_WANTCHARS
;
3028 if ( HasFlag(wxWANTS_CHARS
) )
3030 // in fact, we want everything
3031 rc
.result
|= DLGC_WANTARROWS
|
3038 //else: get the dlg code from the DefWindowProc()
3043 // If this has been processed by an event handler, return 0 now
3044 // (we've handled it).
3045 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3046 if ( m_lastKeydownProcessed
)
3055 // we consider these messages "not interesting" to OnChar, so
3056 // just don't do anything more with them
3066 // avoid duplicate messages to OnChar for these ASCII keys:
3067 // they will be translated by TranslateMessage() and received
3099 // but set processed to false, not true to still pass them
3100 // to the control's default window proc - otherwise
3101 // built-in keyboard handling won't work
3106 // special case of VK_APPS: treat it the same as right mouse
3107 // click because both usually pop up a context menu
3109 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3114 // do generate a CHAR event
3115 processed
= HandleChar((WORD
)wParam
, lParam
);
3118 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3125 // special case of VK_APPS: treat it the same as right mouse button
3126 if ( wParam
== VK_APPS
)
3128 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3133 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3138 case WM_CHAR
: // Always an ASCII character
3139 if ( m_lastKeydownProcessed
)
3141 // The key was handled in the EVT_KEY_DOWN and handling
3142 // a key in an EVT_KEY_DOWN handler is meant, by
3143 // design, to prevent EVT_CHARs from happening
3144 m_lastKeydownProcessed
= false;
3149 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3155 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3157 #endif // wxUSE_HOTKEY
3162 processed
= HandleClipboardEvent(message
);
3170 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3172 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3178 // CTLCOLOR messages are sent by children to query the parent for their
3180 #ifndef __WXMICROWIN__
3181 case WM_CTLCOLORMSGBOX
:
3182 case WM_CTLCOLOREDIT
:
3183 case WM_CTLCOLORLISTBOX
:
3184 case WM_CTLCOLORBTN
:
3185 case WM_CTLCOLORDLG
:
3186 case WM_CTLCOLORSCROLLBAR
:
3187 case WM_CTLCOLORSTATIC
:
3191 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3193 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3196 #endif // !__WXMICROWIN__
3198 case WM_SYSCOLORCHANGE
:
3199 // the return value for this message is ignored
3200 processed
= HandleSysColorChange();
3203 #if !defined(__WXWINCE__)
3204 case WM_DISPLAYCHANGE
:
3205 processed
= HandleDisplayChange();
3209 case WM_PALETTECHANGED
:
3210 processed
= HandlePaletteChanged((WXHWND
)wParam
);
3213 case WM_CAPTURECHANGED
:
3214 processed
= HandleCaptureChanged((WXHWND
)lParam
);
3217 case WM_SETTINGCHANGE
:
3218 processed
= HandleSettingChange(wParam
, lParam
);
3221 case WM_QUERYNEWPALETTE
:
3222 processed
= HandleQueryNewPalette();
3226 processed
= HandleEraseBkgnd((WXHDC
)wParam
);
3229 // we processed the message, i.e. erased the background
3234 #if !defined(__WXWINCE__)
3236 processed
= HandleDropFiles(wParam
);
3241 processed
= HandleInitDialog((WXHWND
)wParam
);
3245 // we never set focus from here
3250 #if !defined(__WXWINCE__)
3251 case WM_QUERYENDSESSION
:
3252 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3256 processed
= HandleEndSession(wParam
!= 0, lParam
);
3259 case WM_GETMINMAXINFO
:
3260 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3265 processed
= HandleSetCursor((WXHWND
)wParam
,
3266 LOWORD(lParam
), // hit test
3267 HIWORD(lParam
)); // mouse msg
3271 // returning TRUE stops the DefWindowProc() from further
3272 // processing this message - exactly what we need because we've
3273 // just set the cursor.
3278 #if wxUSE_ACCESSIBILITY
3281 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3282 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3284 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3286 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3292 #if defined(WM_HELP)
3295 // by default, WM_HELP is propagated by DefWindowProc() upwards
3296 // to the window parent but as we do it ourselves already
3297 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3298 // to get the other events if we process this message at all
3301 // WM_HELP doesn't use lParam under CE
3303 HELPINFO
* info
= (HELPINFO
*) lParam
;
3304 if ( info
->iContextType
== HELPINFO_WINDOW
)
3306 #endif // !__WXWINCE__
3307 wxHelpEvent helpEvent
3312 wxGetMousePosition() // what else?
3314 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3318 helpEvent
.SetEventObject(this);
3319 HandleWindowEvent(helpEvent
);
3322 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3324 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3325 helpEvent
.SetEventObject(this);
3326 HandleWindowEvent(helpEvent
);
3329 else // unknown help event?
3333 #endif // !__WXWINCE__
3338 #if !defined(__WXWINCE__)
3339 case WM_CONTEXTMENU
:
3341 // we don't convert from screen to client coordinates as
3342 // the event may be handled by a parent window
3343 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3345 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3347 // we could have got an event from our child, reflect it back
3348 // to it if this is the case
3349 wxWindowMSW
*win
= NULL
;
3350 WXHWND hWnd
= (WXHWND
)wParam
;
3351 if ( hWnd
!= m_hWnd
)
3353 win
= FindItemByHWND(hWnd
);
3359 evtCtx
.SetEventObject(win
);
3360 processed
= win
->HandleWindowEvent(evtCtx
);
3367 // we're only interested in our own menus, not MF_SYSMENU
3368 if ( HIWORD(wParam
) == MF_POPUP
)
3370 // handle menu chars for ownerdrawn menu items
3371 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3372 if ( i
!= wxNOT_FOUND
)
3374 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3379 #endif // wxUSE_MENUS
3382 case WM_POWERBROADCAST
:
3385 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3386 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3389 #endif // __WXWINCE__
3392 // If we want the default themed border then we need to draw it ourselves
3395 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3396 const wxBorder border
= TranslateBorder(GetBorder());
3397 if (theme
&& border
== wxBORDER_THEME
)
3399 // first ask the widget to calculate the border size
3400 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3403 // now alter the client size making room for drawing a
3408 NCCALCSIZE_PARAMS
*csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3409 rect
= &csparam
->rgrc
[0];
3413 rect
= (RECT
*)lParam
;
3416 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3417 RECT rcClient
= { 0, 0, 0, 0 };
3418 wxClientDC
dc((wxWindow
*)this);
3419 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3421 if ( theme
->GetThemeBackgroundContentRect
3428 &rcClient
) == S_OK
)
3430 InflateRect(&rcClient
, -1, -1);
3432 rc
.result
= WVR_REDRAW
;
3440 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3441 const wxBorder border
= TranslateBorder(GetBorder());
3442 if (theme
&& border
== wxBORDER_THEME
)
3444 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3445 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3448 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3449 wxWindowDC
dc((wxWindow
*)this);
3450 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3452 // Clip the DC so that you only draw on the non-client area
3454 wxCopyRectToRECT(GetSize(), rcBorder
);
3457 theme
->GetThemeBackgroundContentRect(
3458 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3459 InflateRect(&rcClient
, -1, -1);
3461 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3462 rcClient
.right
, rcClient
.bottom
);
3464 // Make sure the background is in a proper state
3465 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3467 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3473 nState
= ETS_DISABLED
;
3474 // should we check this?
3475 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3476 // nState = ETS_READONLY;
3478 nState
= ETS_NORMAL
;
3479 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3484 #endif // wxUSE_UXTHEME
3487 // try a custom message handler
3488 const MSWMessageHandlers::const_iterator
3489 i
= gs_messageHandlers
.find(message
);
3490 if ( i
!= gs_messageHandlers
.end() )
3492 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3499 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3500 wxGetMessageName(message
));
3501 #endif // __WXDEBUG__
3502 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3508 // ----------------------------------------------------------------------------
3509 // wxWindow <-> HWND map
3510 // ----------------------------------------------------------------------------
3512 wxWindow
*wxFindWinFromHandle(HWND hwnd
)
3514 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3515 return i
== gs_windowHandles
.end() ? NULL
: i
->second
;
3518 void wxAssociateWinWithHandle(HWND hwnd
, wxWindowMSW
*win
)
3520 // adding NULL hwnd is (first) surely a result of an error and
3521 // (secondly) breaks menu command processing
3522 wxCHECK_RET( hwnd
!= (HWND
)NULL
,
3523 wxT("attempt to add a NULL hwnd to window list ignored") );
3526 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3527 if ( i
!= gs_windowHandles
.end() )
3529 if ( i
->second
!= win
)
3531 wxLogDebug(wxT("HWND %p already associated with another window (%s)"),
3532 hwnd
, win
->GetClassInfo()->GetClassName());
3534 //else: this actually happens currently because we associate the window
3535 // with its HWND during creation (if we create it) and also when
3536 // SubclassWin() is called later, this is ok
3538 #endif // __WXDEBUG__
3540 gs_windowHandles
[hwnd
] = (wxWindow
*)win
;
3543 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3545 gs_windowHandles
.erase(GetHwndOf(win
));
3548 // ----------------------------------------------------------------------------
3549 // various MSW speciic class dependent functions
3550 // ----------------------------------------------------------------------------
3552 // Default destroyer - override if you destroy it in some other way
3553 // (e.g. with MDI child windows)
3554 void wxWindowMSW::MSWDestroyWindow()
3558 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3561 int& w
, int& h
) const
3563 // yes, those are just some arbitrary hardcoded numbers
3564 static const int DEFAULT_Y
= 200;
3566 bool nonDefault
= false;
3568 if ( pos
.x
== wxDefaultCoord
)
3570 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3571 // can just as well set it to CW_USEDEFAULT as well
3577 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3578 // neither because it is not handled as a special value by Windows then
3579 // and so we have to choose some default value for it
3581 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3587 NB: there used to be some code here which set the initial size of the
3588 window to the client size of the parent if no explicit size was
3589 specified. This was wrong because wxWidgets programs often assume
3590 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3591 it. To see why, you should understand that Windows sends WM_SIZE from
3592 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3593 from some base class ctor and so this WM_SIZE is not processed in the
3594 real class' OnSize() (because it's not fully constructed yet and the
3595 event goes to some base class OnSize() instead). So the WM_SIZE we
3596 rely on is the one sent when the parent frame resizes its children
3597 but here is the problem: if the child already has just the right
3598 size, nothing will happen as both wxWidgets and Windows check for
3599 this and ignore any attempts to change the window size to the size it
3600 already has - so no WM_SIZE would be sent.
3604 // we don't use CW_USEDEFAULT here for several reasons:
3606 // 1. it results in huge frames on modern screens (1000*800 is not
3607 // uncommon on my 1280*1024 screen) which is way too big for a half
3608 // empty frame of most of wxWidgets samples for example)
3610 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3611 // the default is for whatever reason 8*8 which breaks client <->
3612 // window size calculations (it would be nice if it didn't, but it
3613 // does and the simplest way to fix it seemed to change the broken
3614 // default size anyhow)
3616 // 3. there is just no advantage in doing it: with x and y it is
3617 // possible that [future versions of] Windows position the new top
3618 // level window in some smart way which we can't do, but we can
3619 // guess a reasonably good size for a new window just as well
3622 // However, on PocketPC devices, we must use the default
3623 // size if possible.
3625 if (size
.x
== wxDefaultCoord
)
3629 if (size
.y
== wxDefaultCoord
)
3634 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3638 w
= WidthDefault(size
.x
);
3639 h
= HeightDefault(size
.y
);
3642 AdjustForParentClientOrigin(x
, y
);
3647 WXHWND
wxWindowMSW::MSWGetParent() const
3649 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3652 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3653 const wxChar
*title
,
3657 WXDWORD extendedStyle
)
3659 // check a common bug in the user code: if the window is created with a
3660 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3661 // single wxWindow object and this results in all sorts of trouble,
3662 // especially for wxTLWs
3663 wxCHECK_MSG( !m_hWnd
, true, "window can't be recreated" );
3665 // this can happen if this function is called using the return value of
3666 // wxApp::GetRegisteredClassName() which failed
3667 wxCHECK_MSG( wclass
, false, "failed to register window class?" );
3670 // choose the position/size for the new window
3672 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3674 // controlId is menu handle for the top level windows, so set it to 0
3675 // unless we're creating a child window
3676 int controlId
= style
& WS_CHILD
? GetId() : 0;
3678 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3679 // which is the same but without CS_[HV]REDRAW class styles so using it
3680 // ensures that the window is not fully repainted on each resize
3681 wxString
className(wclass
);
3682 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3684 className
+= wxApp::GetNoRedrawClassSuffix();
3687 // do create the window
3688 wxWindowCreationHook
hook(this);
3690 m_hWnd
= (WXHWND
)::CreateWindowEx
3694 title
? title
: m_windowName
.wx_str(),
3697 (HWND
)MSWGetParent(),
3698 (HMENU
)wxUIntToPtr(controlId
),
3700 NULL
// no extra data
3705 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3710 SubclassWin(m_hWnd
);
3715 // ===========================================================================
3716 // MSW message handlers
3717 // ===========================================================================
3719 // ---------------------------------------------------------------------------
3721 // ---------------------------------------------------------------------------
3723 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3725 #ifndef __WXMICROWIN__
3726 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3727 HWND hWnd
= hdr
->hwndFrom
;
3728 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
3730 // if the control is one of our windows, let it handle the message itself
3733 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3736 // VZ: why did we do it? normally this is unnecessary and, besides, it
3737 // breaks the message processing for the toolbars because the tooltip
3738 // notifications were being forwarded to the toolbar child controls
3739 // (if it had any) before being passed to the toolbar itself, so in my
3740 // example the tooltip for the combobox was always shown instead of the
3741 // correct button tooltips
3743 // try all our children
3744 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3747 wxWindow
*child
= node
->GetData();
3748 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3753 node
= node
->GetNext();
3757 // by default, handle it ourselves
3758 return MSWOnNotify(idCtrl
, lParam
, result
);
3759 #else // __WXMICROWIN__
3766 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3768 const wxString
& ttip
)
3770 // I don't know why it happens, but the versions of comctl32.dll starting
3771 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3772 // this message is supposed to be sent to Unicode programs only) -- hence
3773 // we need to handle it as well, otherwise no tooltips will be shown in
3776 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3779 // not a tooltip message or no tooltip to show anyhow
3784 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3786 // We don't want to use the szText buffer because it has a limit of 80
3787 // bytes and this is not enough, especially for Unicode build where it
3788 // limits the tooltip string length to only 40 characters
3790 // The best would be, of course, to not impose any length limitations at
3791 // all but then the buffer would have to be dynamic and someone would have
3792 // to free it and we don't have the tooltip owner object here any more, so
3793 // for now use our own static buffer with a higher fixed max length.
3795 // Note that using a static buffer should not be a problem as only a single
3796 // tooltip can be shown at the same time anyhow.
3798 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3800 // We need to convert tooltip from multi byte to Unicode on the fly.
3801 static wchar_t buf
[513];
3803 // Truncate tooltip length if needed as otherwise we might not have
3804 // enough space for it in the buffer and MultiByteToWideChar() would
3806 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3808 // Convert to WideChar without adding the NULL character. The NULL
3809 // character is added afterwards (this is more efficient).
3810 int len
= ::MultiByteToWideChar
3822 wxLogLastError(_T("MultiByteToWideChar()"));
3826 ttText
->lpszText
= (LPSTR
) buf
;
3828 else // TTN_NEEDTEXTA
3829 #endif // !wxUSE_UNICODE
3831 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3832 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3833 // to copy the string we have into the buffer
3834 static wxChar buf
[513];
3835 wxStrlcpy(buf
, ttip
.c_str(), WXSIZEOF(buf
));
3836 ttText
->lpszText
= buf
;
3842 #endif // wxUSE_TOOLTIPS
3844 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3846 WXLPARAM
* WXUNUSED(result
))
3851 NMHDR
* hdr
= (NMHDR
*)lParam
;
3852 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3859 wxUnusedVar(lParam
);
3860 #endif // wxUSE_TOOLTIPS
3865 // ---------------------------------------------------------------------------
3866 // end session messages
3867 // ---------------------------------------------------------------------------
3869 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3871 #ifdef ENDSESSION_LOGOFF
3872 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3873 event
.SetEventObject(wxTheApp
);
3874 event
.SetCanVeto(true);
3875 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3877 bool rc
= wxTheApp
->ProcessEvent(event
);
3881 // we may end only if the app didn't veto session closing (double
3883 *mayEnd
= !event
.GetVeto();
3888 wxUnusedVar(logOff
);
3889 wxUnusedVar(mayEnd
);
3894 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3896 #ifdef ENDSESSION_LOGOFF
3897 // do nothing if the session isn't ending
3902 if ( (this != wxTheApp
->GetTopWindow()) )
3905 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3906 event
.SetEventObject(wxTheApp
);
3907 event
.SetCanVeto(false);
3908 event
.SetLoggingOff((logOff
& ENDSESSION_LOGOFF
) != 0);
3910 return wxTheApp
->ProcessEvent(event
);
3912 wxUnusedVar(endSession
);
3913 wxUnusedVar(logOff
);
3918 // ---------------------------------------------------------------------------
3919 // window creation/destruction
3920 // ---------------------------------------------------------------------------
3922 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3925 // VZ: why is this commented out for WinCE? If it doesn't support
3926 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3927 // not with multiple #ifdef's!
3929 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3930 EnsureParentHasControlParentStyle(GetParent());
3931 #endif // !__WXWINCE__
3938 bool wxWindowMSW::HandleDestroy()
3942 // delete our drop target if we've got one
3943 #if wxUSE_DRAG_AND_DROP
3944 if ( m_dropTarget
!= NULL
)
3946 m_dropTarget
->Revoke(m_hWnd
);
3948 delete m_dropTarget
;
3949 m_dropTarget
= NULL
;
3951 #endif // wxUSE_DRAG_AND_DROP
3953 // WM_DESTROY handled
3957 // ---------------------------------------------------------------------------
3959 // ---------------------------------------------------------------------------
3961 bool wxWindowMSW::HandleActivate(int state
,
3962 bool WXUNUSED(minimized
),
3963 WXHWND
WXUNUSED(activate
))
3965 wxActivateEvent
event(wxEVT_ACTIVATE
,
3966 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3968 event
.SetEventObject(this);
3970 return HandleWindowEvent(event
);
3973 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3975 // Strangly enough, some controls get set focus events when they are being
3976 // deleted, even if they already had focus before.
3977 if ( m_isBeingDeleted
)
3982 // notify the parent keeping track of focus for the kbd navigation
3983 // purposes that we got it
3984 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3985 (void)HandleWindowEvent(eventFocus
);
3991 m_caret
->OnSetFocus();
3993 #endif // wxUSE_CARET
3995 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3996 event
.SetEventObject(this);
3998 // wxFindWinFromHandle() may return NULL, it is ok
3999 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4001 return HandleWindowEvent(event
);
4004 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4010 m_caret
->OnKillFocus();
4012 #endif // wxUSE_CARET
4014 // Don't send the event when in the process of being deleted. This can
4015 // only cause problems if the event handler tries to access the object.
4016 if ( m_isBeingDeleted
)
4021 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4022 event
.SetEventObject(this);
4024 // wxFindWinFromHandle() may return NULL, it is ok
4025 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4027 return HandleWindowEvent(event
);
4030 // ---------------------------------------------------------------------------
4032 // ---------------------------------------------------------------------------
4034 void wxWindowMSW::SetLabel( const wxString
& label
)
4036 SetWindowText(GetHwnd(), label
.c_str());
4039 wxString
wxWindowMSW::GetLabel() const
4041 return wxGetWindowText(GetHWND());
4044 // ---------------------------------------------------------------------------
4046 // ---------------------------------------------------------------------------
4048 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4050 wxShowEvent
event(GetId(), show
);
4051 event
.SetEventObject(this);
4053 return HandleWindowEvent(event
);
4056 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4058 wxInitDialogEvent
event(GetId());
4059 event
.SetEventObject(this);
4061 return HandleWindowEvent(event
);
4064 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4066 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4067 wxUnusedVar(wParam
);
4069 #else // __WXMICROWIN__
4070 HDROP hFilesInfo
= (HDROP
) wParam
;
4072 // Get the total number of files dropped
4073 UINT gwFilesDropped
= ::DragQueryFile
4081 wxString
*files
= new wxString
[gwFilesDropped
];
4082 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4084 // first get the needed buffer length (+1 for terminating NUL)
4085 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4087 // and now get the file name
4088 ::DragQueryFile(hFilesInfo
, wIndex
,
4089 wxStringBuffer(files
[wIndex
], len
), len
);
4092 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4093 event
.SetEventObject(this);
4096 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4097 event
.m_pos
.x
= dropPoint
.x
;
4098 event
.m_pos
.y
= dropPoint
.y
;
4100 DragFinish(hFilesInfo
);
4102 return HandleWindowEvent(event
);
4107 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4109 int WXUNUSED(mouseMsg
))
4111 #ifndef __WXMICROWIN__
4112 // the logic is as follows:
4113 // 0. if we're busy, set the busy cursor (even for non client elements)
4114 // 1. don't set custom cursor for non client area of enabled windows
4115 // 2. ask user EVT_SET_CURSOR handler for the cursor
4116 // 3. if still no cursor but we're in a TLW, set the global cursor
4118 HCURSOR hcursor
= 0;
4121 hcursor
= wxGetCurrentBusyCursor();
4125 if ( nHitTest
!= HTCLIENT
)
4128 // first ask the user code - it may wish to set the cursor in some very
4129 // specific way (for example, depending on the current position)
4132 if ( !::GetCursorPosWinCE(&pt
))
4134 if ( !::GetCursorPos(&pt
) )
4137 wxLogLastError(wxT("GetCursorPos"));
4142 ScreenToClient(&x
, &y
);
4143 wxSetCursorEvent
event(x
, y
);
4145 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4146 if ( processedEvtSetCursor
&& event
.HasCursor() )
4148 hcursor
= GetHcursorOf(event
.GetCursor());
4153 // the test for processedEvtSetCursor is here to prevent using
4154 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4155 // nothing from it - this is a way to say that our cursor shouldn't
4156 // be used for this point
4157 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4159 hcursor
= GetHcursorOf(m_cursor
);
4162 if ( !hcursor
&& !GetParent() )
4164 const wxCursor
*cursor
= wxGetGlobalCursor();
4165 if ( cursor
&& cursor
->Ok() )
4167 hcursor
= GetHcursorOf(*cursor
);
4176 ::SetCursor(hcursor
);
4178 // cursor set, stop here
4181 #endif // __WXMICROWIN__
4183 // pass up the window chain
4187 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4188 WXLPARAM
WXUNUSED(lParam
),
4189 bool *WXUNUSED_IN_WINCE(vetoed
))
4195 wxEventType evtType
;
4198 case PBT_APMQUERYSUSPEND
:
4199 evtType
= wxEVT_POWER_SUSPENDING
;
4202 case PBT_APMQUERYSUSPENDFAILED
:
4203 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4206 case PBT_APMSUSPEND
:
4207 evtType
= wxEVT_POWER_SUSPENDED
;
4210 case PBT_APMRESUMESUSPEND
:
4211 evtType
= wxEVT_POWER_RESUME
;
4215 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4218 // these messages are currently not mapped to wx events
4219 case PBT_APMQUERYSTANDBY
:
4220 case PBT_APMQUERYSTANDBYFAILED
:
4221 case PBT_APMSTANDBY
:
4222 case PBT_APMRESUMESTANDBY
:
4223 case PBT_APMBATTERYLOW
:
4224 case PBT_APMPOWERSTATUSCHANGE
:
4225 case PBT_APMOEMEVENT
:
4226 case PBT_APMRESUMECRITICAL
:
4227 #ifdef PBT_APMRESUMEAUTOMATIC
4228 case PBT_APMRESUMEAUTOMATIC
:
4230 evtType
= wxEVT_NULL
;
4234 // don't handle unknown messages
4235 if ( evtType
== wxEVT_NULL
)
4238 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4240 wxPowerEvent
event(evtType
);
4241 if ( !HandleWindowEvent(event
) )
4244 *vetoed
= event
.IsVetoed();
4250 bool wxWindowMSW::IsDoubleBuffered() const
4252 for ( const wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4254 if ( wxHasWindowExStyle(win
, WS_EX_COMPOSITED
) )
4257 if ( win
->IsTopLevel() )
4264 void wxWindowMSW::SetDoubleBuffered(bool on
)
4266 // Get the current extended style bits
4267 long exstyle
= wxGetWindowExStyle(this);
4269 // Twiddle the bit as needed
4271 exstyle
|= WS_EX_COMPOSITED
;
4273 exstyle
&= ~WS_EX_COMPOSITED
;
4276 wxSetWindowExStyle(this, exstyle
);
4279 // ---------------------------------------------------------------------------
4280 // owner drawn stuff
4281 // ---------------------------------------------------------------------------
4283 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4284 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4285 #define WXUNUSED_UNLESS_ODRAWN(param) param
4287 #define WXUNUSED_UNLESS_ODRAWN(param)
4291 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4292 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4294 #if wxUSE_OWNER_DRAWN
4296 #if wxUSE_MENUS_NATIVE
4297 // is it a menu item?
4298 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4299 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4301 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4303 // see comment before the same test in MSWOnMeasureItem() below
4307 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4308 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
4310 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4311 // the DC from being released
4312 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4313 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4314 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4315 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4317 return pMenuItem
->OnDrawItem
4321 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4322 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4325 #endif // wxUSE_MENUS_NATIVE
4327 #endif // USE_OWNER_DRAWN
4329 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4331 #if wxUSE_OWNER_DRAWN
4332 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4333 #else // !wxUSE_OWNER_DRAWN
4334 // we may still have owner-drawn buttons internally because we have to make
4335 // them owner-drawn to support colour change
4338 wxDynamicCast(FindItem(id
), wxButton
)
4343 #endif // USE_OWNER_DRAWN
4347 return item
->MSWOnDraw(itemStruct
);
4350 #endif // wxUSE_CONTROLS
4356 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4358 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4359 // is it a menu item?
4360 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4361 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4363 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4365 // according to Carsten Fuchs the pointer may be NULL under XP if an
4366 // MDI child frame is initially maximized, see this for more info:
4367 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4369 // so silently ignore it instead of asserting
4373 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4374 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4377 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4379 pMeasureStruct
->itemWidth
= w
;
4380 pMeasureStruct
->itemHeight
= h
;
4385 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4388 return item
->MSWOnMeasure(itemStruct
);
4392 wxUnusedVar(itemStruct
);
4393 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4398 // ---------------------------------------------------------------------------
4399 // colours and palettes
4400 // ---------------------------------------------------------------------------
4402 bool wxWindowMSW::HandleSysColorChange()
4404 wxSysColourChangedEvent event
;
4405 event
.SetEventObject(this);
4407 (void)HandleWindowEvent(event
);
4409 // always let the system carry on the default processing to allow the
4410 // native controls to react to the colours update
4414 bool wxWindowMSW::HandleDisplayChange()
4416 wxDisplayChangedEvent event
;
4417 event
.SetEventObject(this);
4419 return HandleWindowEvent(event
);
4422 #ifndef __WXMICROWIN__
4424 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4426 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4430 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4433 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4435 #endif // wxUSE_CONTROLS
4438 return *brush
!= NULL
;
4441 #endif // __WXMICROWIN__
4443 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4446 // same as below except we don't respond to our own messages
4447 if ( hWndPalChange
!= GetHWND() )
4449 // check to see if we our our parents have a custom palette
4450 wxWindowMSW
*win
= this;
4451 while ( win
&& !win
->HasCustomPalette() )
4453 win
= win
->GetParent();
4456 if ( win
&& win
->HasCustomPalette() )
4458 // realize the palette to see whether redrawing is needed
4459 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4460 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4461 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4463 int result
= ::RealizePalette(hdc
);
4465 // restore the palette (before releasing the DC)
4466 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4467 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4468 ::RealizePalette(hdc
);
4469 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4471 // now check for the need to redraw
4473 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4477 #endif // wxUSE_PALETTE
4479 wxPaletteChangedEvent
event(GetId());
4480 event
.SetEventObject(this);
4481 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4483 return HandleWindowEvent(event
);
4486 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4488 // notify windows on the capture stack about lost capture
4489 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4490 wxWindowBase::NotifyCaptureLost();
4492 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4493 wxMouseCaptureChangedEvent
event(GetId(), win
);
4494 event
.SetEventObject(this);
4495 return HandleWindowEvent(event
);
4498 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4500 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4501 // we need to send this to child windows (it is only sent to top-level
4502 // windows) so {list,tree}ctrls can adjust their font size if necessary
4503 // this is exactly how explorer does it to enable the font size changes
4505 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4508 // top-level windows already get this message from the system
4509 wxWindow
*win
= node
->GetData();
4510 if ( !win
->IsTopLevel() )
4512 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4515 node
= node
->GetNext();
4518 // let the system handle it
4522 bool wxWindowMSW::HandleQueryNewPalette()
4526 // check to see if we our our parents have a custom palette
4527 wxWindowMSW
*win
= this;
4528 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4529 if (win
->HasCustomPalette()) {
4530 /* realize the palette to see whether redrawing is needed */
4531 HDC hdc
= ::GetDC((HWND
) GetHWND());
4532 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4533 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4535 int result
= ::RealizePalette(hdc
);
4536 /* restore the palette (before releasing the DC) */
4537 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4538 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4539 ::RealizePalette(hdc
);
4540 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4541 /* now check for the need to redraw */
4543 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4545 #endif // wxUSE_PALETTE
4547 wxQueryNewPaletteEvent
event(GetId());
4548 event
.SetEventObject(this);
4550 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4553 // Responds to colour changes: passes event on to children.
4554 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4556 // the top level window also reset the standard colour map as it might have
4557 // changed (there is no need to do it for the non top level windows as we
4558 // only have to do it once)
4562 gs_hasStdCmap
= false;
4564 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4567 // Only propagate to non-top-level windows because Windows already
4568 // sends this event to all top-level ones
4569 wxWindow
*win
= node
->GetData();
4570 if ( !win
->IsTopLevel() )
4572 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4573 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4574 // the standard controls
4575 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4578 node
= node
->GetNext();
4582 extern wxCOLORMAP
*wxGetStdColourMap()
4584 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4585 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4587 if ( !gs_hasStdCmap
)
4589 static bool s_coloursInit
= false;
4591 if ( !s_coloursInit
)
4593 // When a bitmap is loaded, the RGB values can change (apparently
4594 // because Windows adjusts them to care for the old programs always
4595 // using 0xc0c0c0 while the transparent colour for the new Windows
4596 // versions is different). But we do this adjustment ourselves so
4597 // we want to avoid Windows' "help" and for this we need to have a
4598 // reference bitmap which can tell us what the RGB values change
4600 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4601 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4602 if ( stdColourBitmap
.Ok() )
4604 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4605 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4606 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4609 memDC
.SelectObject(stdColourBitmap
);
4612 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4614 memDC
.GetPixel(i
, 0, &colour
);
4615 s_stdColours
[i
] = wxColourToRGB(colour
);
4618 else // wxBITMAP_STD_COLOURS couldn't be loaded
4620 s_stdColours
[0] = RGB(000,000,000); // black
4621 s_stdColours
[1] = RGB(128,128,128); // dark grey
4622 s_stdColours
[2] = RGB(192,192,192); // light grey
4623 s_stdColours
[3] = RGB(255,255,255); // white
4624 //s_stdColours[4] = RGB(000,000,255); // blue
4625 //s_stdColours[5] = RGB(255,000,255); // magenta
4628 s_coloursInit
= true;
4631 gs_hasStdCmap
= true;
4633 // create the colour map
4634 #define INIT_CMAP_ENTRY(col) \
4635 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4636 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4638 INIT_CMAP_ENTRY(BTNTEXT
);
4639 INIT_CMAP_ENTRY(BTNSHADOW
);
4640 INIT_CMAP_ENTRY(BTNFACE
);
4641 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4643 #undef INIT_CMAP_ENTRY
4649 // ---------------------------------------------------------------------------
4651 // ---------------------------------------------------------------------------
4653 bool wxWindowMSW::HandlePaint()
4655 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4657 wxLogLastError(wxT("CreateRectRgn"));
4658 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4659 wxLogLastError(wxT("GetUpdateRgn"));
4661 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4663 wxPaintEvent
event(m_windowId
);
4664 event
.SetEventObject(this);
4666 bool processed
= HandleWindowEvent(event
);
4668 // note that we must generate NC event after the normal one as otherwise
4669 // BeginPaint() will happily overwrite our decorations with the background
4671 wxNcPaintEvent
eventNc(m_windowId
);
4672 eventNc
.SetEventObject(this);
4673 HandleWindowEvent(eventNc
);
4675 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4676 // be called from inside the event handlers called above)
4677 m_updateRegion
.Clear();
4682 // Can be called from an application's OnPaint handler
4683 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4685 #ifdef __WXUNIVERSAL__
4688 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4691 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4696 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4698 wxDCTemp
dc(hdc
, GetClientSize());
4699 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4702 impl
->SetWindow((wxWindow
*)this);
4704 wxEraseEvent
event(m_windowId
, &dc
);
4705 event
.SetEventObject(this);
4706 bool rc
= HandleWindowEvent(event
);
4708 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4709 impl
->SelectOldObjects(hdc
);
4714 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4716 // standard non top level controls (i.e. except the dialogs) always erase
4717 // their background themselves in HandleCtlColor() or have some control-
4718 // specific ways to set the colours (common controls)
4719 if ( IsOfStandardClass() && !IsTopLevel() )
4725 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4727 // don't skip the event here, custom background means that the app
4728 // is drawing it itself in its OnPaint(), so don't draw it at all
4729 // now to avoid flicker
4733 wxDC
*dc
= event
.GetDC();
4735 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
->GetImpl();
4737 // do default background painting
4738 if ( !DoEraseBackground(GetHdcOf(*impl
)) )
4740 // let the system paint the background
4745 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4747 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4751 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4757 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4761 // our background colour applies to:
4762 // 1. this window itself, always
4763 // 2. all children unless the colour is "not inheritable"
4764 // 3. even if it is not inheritable, our immediate transparent
4765 // children should still inherit it -- but not any transparent
4766 // children because it would look wrong if a child of non
4767 // transparent child would show our bg colour when the child itself
4769 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4772 (win
&& win
->HasTransparentBackground() &&
4773 win
->GetParent() == this) )
4775 // draw children with the same colour as the parent
4777 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4779 return (WXHBRUSH
)GetHbrushOf(*brush
);
4786 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4789 hWndToPaint
= GetHWND();
4791 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4793 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4797 // background is not inherited beyond top level windows
4798 if ( win
->IsTopLevel() )
4805 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4807 // we receive this message when DrawThemeParentBackground() is
4808 // called from def window proc of several controls under XP and we
4809 // must draw properly themed background here
4811 // note that naively I'd expect filling the client rect with the
4812 // brush returned by MSWGetBgBrush() work -- but for some reason it
4813 // doesn't and we have to call parents MSWPrintChild() which is
4814 // supposed to call DrawThemeBackground() with appropriate params
4816 // also note that in this case lParam == PRF_CLIENT but we're
4817 // clearly expected to paint the background and nothing else!
4819 if ( IsTopLevel() || InheritsBackgroundColour() )
4822 // sometimes we don't want the parent to handle it at all, instead
4823 // return whatever value this window wants
4824 if ( !MSWShouldPropagatePrintChild() )
4825 return MSWPrintChild(hDC
, (wxWindow
*)this);
4827 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4829 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4832 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4839 // ---------------------------------------------------------------------------
4840 // moving and resizing
4841 // ---------------------------------------------------------------------------
4843 bool wxWindowMSW::HandleMinimize()
4845 wxIconizeEvent
event(m_windowId
);
4846 event
.SetEventObject(this);
4848 return HandleWindowEvent(event
);
4851 bool wxWindowMSW::HandleMaximize()
4853 wxMaximizeEvent
event(m_windowId
);
4854 event
.SetEventObject(this);
4856 return HandleWindowEvent(event
);
4859 bool wxWindowMSW::HandleMove(int x
, int y
)
4862 wxMoveEvent
event(point
, m_windowId
);
4863 event
.SetEventObject(this);
4865 return HandleWindowEvent(event
);
4868 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4870 wxMoveEvent
event(rect
, m_windowId
);
4871 event
.SetEventObject(this);
4873 bool rc
= HandleWindowEvent(event
);
4875 rect
= event
.GetRect();
4879 bool wxWindowMSW::HandleEnterSizeMove()
4881 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4882 event
.SetEventType(wxEVT_MOVE_START
);
4883 event
.SetEventObject(this);
4885 return HandleWindowEvent(event
);
4888 bool wxWindowMSW::HandleExitSizeMove()
4890 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4891 event
.SetEventType(wxEVT_MOVE_END
);
4892 event
.SetEventObject(this);
4894 return HandleWindowEvent(event
);
4897 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4899 #if USE_DEFERRED_SIZING
4900 // when we resize this window, its children are probably going to be
4901 // repositioned as well, prepare to use DeferWindowPos() for them
4902 int numChildren
= 0;
4903 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4905 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4910 // Protect against valid m_hDWP being overwritten
4911 bool useDefer
= false;
4913 if ( numChildren
> 1 )
4917 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4920 wxLogLastError(_T("BeginDeferWindowPos"));
4926 #endif // USE_DEFERRED_SIZING
4928 // update this window size
4929 bool processed
= false;
4933 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4934 // fall through nevertheless
4938 // we're not interested in these messages at all
4941 case SIZE_MINIMIZED
:
4942 processed
= HandleMinimize();
4945 case SIZE_MAXIMIZED
:
4946 /* processed = */ HandleMaximize();
4947 // fall through to send a normal size event as well
4950 // don't use w and h parameters as they specify the client size
4951 // while according to the docs EVT_SIZE handler is supposed to
4952 // receive the total size
4953 wxSizeEvent
event(GetSize(), m_windowId
);
4954 event
.SetEventObject(this);
4956 processed
= HandleWindowEvent(event
);
4959 #if USE_DEFERRED_SIZING
4960 // and finally change the positions of all child windows at once
4961 if ( useDefer
&& m_hDWP
)
4963 // reset m_hDWP to NULL so that child windows don't try to use our
4964 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4965 // happen anyhow normally but who knows what weird flow of control we
4966 // may have depending on what the users EVT_SIZE handler does...)
4967 HDWP hDWP
= (HDWP
)m_hDWP
;
4970 // do put all child controls in place at once
4971 if ( !::EndDeferWindowPos(hDWP
) )
4973 wxLogLastError(_T("EndDeferWindowPos"));
4976 // Reset our children's pending pos/size values.
4977 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4979 node
= node
->GetNext() )
4981 wxWindowMSW
*child
= node
->GetData();
4982 child
->m_pendingPosition
= wxDefaultPosition
;
4983 child
->m_pendingSize
= wxDefaultSize
;
4986 #endif // USE_DEFERRED_SIZING
4991 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4993 wxSizeEvent
event(rect
, m_windowId
);
4994 event
.SetEventObject(this);
4996 bool rc
= HandleWindowEvent(event
);
4998 rect
= event
.GetRect();
5002 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5007 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5011 int minWidth
= GetMinWidth(),
5012 minHeight
= GetMinHeight(),
5013 maxWidth
= GetMaxWidth(),
5014 maxHeight
= GetMaxHeight();
5016 if ( minWidth
!= wxDefaultCoord
)
5018 info
->ptMinTrackSize
.x
= minWidth
;
5022 if ( minHeight
!= wxDefaultCoord
)
5024 info
->ptMinTrackSize
.y
= minHeight
;
5028 if ( maxWidth
!= wxDefaultCoord
)
5030 info
->ptMaxTrackSize
.x
= maxWidth
;
5034 if ( maxHeight
!= wxDefaultCoord
)
5036 info
->ptMaxTrackSize
.y
= maxHeight
;
5044 // ---------------------------------------------------------------------------
5046 // ---------------------------------------------------------------------------
5048 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5050 // sign extend to int from short before comparing with the other int ids
5051 int id
= (signed short)id_
;
5053 #if wxUSE_MENUS_NATIVE
5054 if ( !cmd
&& wxCurrentPopupMenu
)
5056 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5057 wxCurrentPopupMenu
= NULL
;
5059 return popupMenu
->MSWCommand(cmd
, id
);
5061 #endif // wxUSE_MENUS_NATIVE
5063 wxWindow
*win
= NULL
;
5065 // first try to find it from HWND - this works even with the broken
5066 // programs using the same ids for different controls
5069 win
= wxFindWinFromHandle(control
);
5080 return win
->MSWCommand(cmd
, id
);
5083 // the messages sent from the in-place edit control used by the treectrl
5084 // for label editing have id == 0, but they should _not_ be treated as menu
5085 // messages (they are EN_XXX ones, in fact) so don't translate anything
5086 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5089 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, id
);
5090 event
.SetEventObject(this);
5093 return HandleWindowEvent(event
);
5097 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5098 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5099 // notifications to its parent which we want to reflect back to
5101 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5102 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5104 #endif // wxUSE_SPINCTRL
5106 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5107 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5108 // notifications to its parent which we want to reflect back to
5110 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5111 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5119 // ---------------------------------------------------------------------------
5121 // ---------------------------------------------------------------------------
5123 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5127 // our client coords are not quite the same as Windows ones
5128 wxPoint pt
= GetClientAreaOrigin();
5129 event
.m_x
= x
- pt
.x
;
5130 event
.m_y
= y
- pt
.y
;
5132 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5133 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5134 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5135 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5136 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5137 #ifdef wxHAS_XBUTTON
5138 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5139 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5140 #endif // wxHAS_XBUTTON
5141 event
.m_altDown
= ::wxIsAltDown();
5144 event
.SetTimestamp(::GetMessageTime());
5147 event
.SetEventObject(this);
5148 event
.SetId(GetId());
5150 #if wxUSE_MOUSEEVENT_HACK
5151 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5152 gs_lastMouseEvent
.type
= event
.GetEventType();
5153 #endif // wxUSE_MOUSEEVENT_HACK
5157 // Windows doesn't send the mouse events to the static controls (which are
5158 // transparent in the sense that their WM_NCHITTEST handler returns
5159 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5160 // and so we manually check if we don't have a child window under mouse and if
5161 // we do, send the event to it instead of the window Windows had sent WM_XXX
5164 // Notice that this is not done for the mouse move events because this could
5165 // (would?) be too slow, but only for clicks which means that the static texts
5166 // still don't get move, enter nor leave events.
5167 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5169 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
5171 // first try to find a non transparent child: this allows us to send events
5172 // to a static text which is inside a static box, for example
5173 POINT pt
= { *x
, *y
};
5174 HWND hwnd
= GetHwndOf(win
),
5178 hwndUnderMouse
= ::ChildWindowFromPoint
5184 hwndUnderMouse
= ::ChildWindowFromPointEx
5194 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5196 // now try any child window at all
5197 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5200 // check that we have a child window which is susceptible to receive mouse
5201 // events: for this it must be shown and enabled
5202 if ( hwndUnderMouse
&&
5203 hwndUnderMouse
!= hwnd
&&
5204 ::IsWindowVisible(hwndUnderMouse
) &&
5205 ::IsWindowEnabled(hwndUnderMouse
) )
5207 wxWindow
*winUnderMouse
= wxFindWinFromHandle(hwndUnderMouse
);
5208 if ( winUnderMouse
)
5210 // translate the mouse coords to the other window coords
5211 win
->ClientToScreen(x
, y
);
5212 winUnderMouse
->ScreenToClient(x
, y
);
5214 win
= winUnderMouse
;
5220 #endif // __WXWINCE__
5222 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5224 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5225 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5226 // from the message id and take the value in the table to get wxWin event
5228 static const wxEventType eventsMouse
[] =
5239 wxEVT_MIDDLE_DCLICK
,
5240 0, // this one is for wxEVT_MOTION which is not used here
5249 #ifdef wxHAS_XBUTTON
5250 // the same messages are used for both auxillary mouse buttons so we need
5251 // to adjust the index manually
5254 case WM_XBUTTONDOWN
:
5256 case WM_XBUTTONDBLCLK
:
5257 if ( flags
& MK_XBUTTON2
)
5258 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5260 #endif // wxHAS_XBUTTON
5262 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5263 InitMouseEvent(event
, x
, y
, flags
);
5265 return HandleWindowEvent(event
);
5268 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5270 if ( !m_mouseInWindow
)
5272 // it would be wrong to assume that just because we get a mouse move
5273 // event that the mouse is inside the window: although this is usually
5274 // true, it is not if we had captured the mouse, so we need to check
5275 // the mouse coordinates here
5276 if ( !HasCapture() || IsMouseInWindow() )
5278 // Generate an ENTER event
5279 m_mouseInWindow
= true;
5281 #ifdef HAVE_TRACKMOUSEEVENT
5282 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5284 static const _TrackMouseEvent_t
5285 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5286 #else // !__WXWINCE__
5287 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5288 static bool s_initDone
= false;
5291 // see comment in wxApp::GetComCtl32Version() explaining the
5292 // use of wxDL_GET_LOADED
5293 wxDynamicLibrary
dllComCtl32(_T("comctl32.dll"),
5297 if ( dllComCtl32
.IsLoaded() )
5299 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5300 dllComCtl32
.RawGetSymbol(_T("_TrackMouseEvent"));
5305 // we shouldn't unload comctl32.dll here as we didn't really
5307 dllComCtl32
.Detach();
5310 if ( s_pfn_TrackMouseEvent
)
5311 #endif // __WXWINCE__/!__WXWINCE__
5313 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5315 trackinfo
.dwFlags
= TME_LEAVE
;
5316 trackinfo
.hwndTrack
= GetHwnd();
5318 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5320 #endif // HAVE_TRACKMOUSEEVENT
5322 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5323 InitMouseEvent(event
, x
, y
, flags
);
5325 (void)HandleWindowEvent(event
);
5328 #ifdef HAVE_TRACKMOUSEEVENT
5329 else // mouse not in window
5331 // Check if we need to send a LEAVE event
5332 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5333 // send it here if we are using native mouse leave tracking
5334 if ( HasCapture() && !IsMouseInWindow() )
5336 GenerateMouseLeave();
5339 #endif // HAVE_TRACKMOUSEEVENT
5341 #if wxUSE_MOUSEEVENT_HACK
5342 // Windows often generates mouse events even if mouse position hasn't
5343 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5345 // Filter this out as it can result in unexpected behaviour compared to
5347 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5348 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5349 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5350 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5352 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5354 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5359 #endif // wxUSE_MOUSEEVENT_HACK
5361 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5365 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5367 #if wxUSE_MOUSEWHEEL
5368 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5369 // forwarded up to the parent by DefWindowProc()) and not in the client
5370 // ones as all the other messages, translate them to the client coords for
5373 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5374 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5375 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5376 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5377 event
.m_wheelDelta
= WHEEL_DELTA
;
5379 static int s_linesPerRotation
= -1;
5380 if ( s_linesPerRotation
== -1 )
5382 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5383 &s_linesPerRotation
, 0))
5385 // this is not supposed to happen
5386 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5388 // the default is 3, so use it if SystemParametersInfo() failed
5389 s_linesPerRotation
= 3;
5393 event
.m_linesPerAction
= s_linesPerRotation
;
5394 return HandleWindowEvent(event
);
5396 #else // !wxUSE_MOUSEWHEEL
5397 wxUnusedVar(wParam
);
5398 wxUnusedVar(lParam
);
5401 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5404 void wxWindowMSW::GenerateMouseLeave()
5406 m_mouseInWindow
= false;
5409 if ( wxIsShiftDown() )
5411 if ( wxIsCtrlDown() )
5412 state
|= MK_CONTROL
;
5414 // Only the high-order bit should be tested
5415 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5416 state
|= MK_LBUTTON
;
5417 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5418 state
|= MK_MBUTTON
;
5419 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5420 state
|= MK_RBUTTON
;
5424 if ( !::GetCursorPosWinCE(&pt
) )
5426 if ( !::GetCursorPos(&pt
) )
5429 wxLogLastError(_T("GetCursorPos"));
5432 // we need to have client coordinates here for symmetry with
5433 // wxEVT_ENTER_WINDOW
5434 RECT rect
= wxGetWindowRect(GetHwnd());
5438 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5439 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5441 (void)HandleWindowEvent(event
);
5444 // ---------------------------------------------------------------------------
5445 // keyboard handling
5446 // ---------------------------------------------------------------------------
5448 // create the key event of the given type for the given key - used by
5449 // HandleChar and HandleKeyDown/Up
5450 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5453 WXWPARAM wParam
) const
5455 wxKeyEvent
event(evType
);
5456 event
.SetId(GetId());
5457 event
.m_shiftDown
= wxIsShiftDown();
5458 event
.m_controlDown
= wxIsCtrlDown();
5459 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5461 event
.SetEventObject((wxWindow
*)this); // const_cast
5462 event
.m_keyCode
= id
;
5464 event
.m_uniChar
= (wxChar
) wParam
;
5466 event
.m_rawCode
= (wxUint32
) wParam
;
5467 event
.m_rawFlags
= (wxUint32
) lParam
;
5469 event
.SetTimestamp(::GetMessageTime());
5472 // translate the position to client coords
5475 GetCursorPosWinCE(&pt
);
5480 GetWindowRect(GetHwnd(),&rect
);
5490 // isASCII is true only when we're called from WM_CHAR handler and not from
5492 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5499 else // we're called from WM_KEYDOWN
5501 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5502 // to get numpad key codes: CHAR events should use the logical keys
5503 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5504 id
= wxCharCodeMSWToWX(wParam
);
5507 // it's ASCII and will be processed here only when called from
5508 // WM_CHAR (i.e. when isASCII = true), don't process it now
5513 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5515 // the alphanumeric keys produced by pressing AltGr+something on European
5516 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5517 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5518 // alphanumeric, so pretend that there are no modifiers at all (the
5519 // KEY_DOWN event would still have the correct modifiers if they're really
5521 if ( event
.m_controlDown
&& event
.m_altDown
&&
5522 (id
>= 32 && id
< 256) )
5524 event
.m_controlDown
=
5525 event
.m_altDown
= false;
5528 return HandleWindowEvent(event
);
5531 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5533 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5537 // normal ASCII char
5541 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5542 return HandleWindowEvent(event
);
5545 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5547 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5551 // normal ASCII char
5555 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5556 return HandleWindowEvent(event
);
5560 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5561 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5563 // FIXME: implement GetMenuItemCount for WinCE, possibly
5564 // in terms of GetMenuItemInfo
5566 const HMENU hmenu
= (HMENU
)lParam
;
5570 mii
.cbSize
= sizeof(MENUITEMINFO
);
5572 // we could use MIIM_FTYPE here as we only need to know if the item is
5573 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5574 // MIIM_FTYPE is not supported under Win95
5575 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5577 // find if we have this letter in any owner drawn item
5578 const int count
= ::GetMenuItemCount(hmenu
);
5579 for ( int i
= 0; i
< count
; i
++ )
5581 // previous loop iteration could modify it, reset it back before
5582 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5585 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5587 if ( mii
.fType
== MFT_OWNERDRAW
)
5589 // dwItemData member of the MENUITEMINFO is a
5590 // pointer to the associated wxMenuItem -- see the
5591 // menu creation code
5592 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5594 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), _T('&'));
5597 if ( *p
== _T('&') )
5599 // this is not the accel char, find the real one
5600 p
= wxStrchr(p
+ 1, _T('&'));
5602 else // got the accel char
5604 // FIXME-UNICODE: this comparison doesn't risk to work
5605 // for non ASCII accelerator characters I'm afraid, but
5607 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5613 // this one doesn't match
5620 else // failed to get the menu text?
5622 // it's not fatal, so don't show error, but still log it
5623 wxLogLastError(_T("GetMenuItemInfo"));
5630 #endif // wxUSE_MENUS
5632 bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg
)
5634 const wxEventType type
= nMsg
== WM_CUT
? wxEVT_COMMAND_TEXT_CUT
5635 : nMsg
== WM_COPY
? wxEVT_COMMAND_TEXT_COPY
5636 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE
;
5637 wxClipboardTextEvent
evt(type
, GetId());
5639 evt
.SetEventObject(this);
5641 return HandleWindowEvent(evt
);
5644 // ---------------------------------------------------------------------------
5646 // ---------------------------------------------------------------------------
5648 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5652 if ( flags
& JOY_BUTTON1CHG
)
5653 change
= wxJOY_BUTTON1
;
5654 if ( flags
& JOY_BUTTON2CHG
)
5655 change
= wxJOY_BUTTON2
;
5656 if ( flags
& JOY_BUTTON3CHG
)
5657 change
= wxJOY_BUTTON3
;
5658 if ( flags
& JOY_BUTTON4CHG
)
5659 change
= wxJOY_BUTTON4
;
5662 if ( flags
& JOY_BUTTON1
)
5663 buttons
|= wxJOY_BUTTON1
;
5664 if ( flags
& JOY_BUTTON2
)
5665 buttons
|= wxJOY_BUTTON2
;
5666 if ( flags
& JOY_BUTTON3
)
5667 buttons
|= wxJOY_BUTTON3
;
5668 if ( flags
& JOY_BUTTON4
)
5669 buttons
|= wxJOY_BUTTON4
;
5671 // the event ids aren't consecutive so we can't use table based lookup
5673 wxEventType eventType
;
5678 eventType
= wxEVT_JOY_MOVE
;
5683 eventType
= wxEVT_JOY_MOVE
;
5688 eventType
= wxEVT_JOY_ZMOVE
;
5693 eventType
= wxEVT_JOY_ZMOVE
;
5696 case MM_JOY1BUTTONDOWN
:
5698 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5701 case MM_JOY2BUTTONDOWN
:
5703 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5706 case MM_JOY1BUTTONUP
:
5708 eventType
= wxEVT_JOY_BUTTON_UP
;
5711 case MM_JOY2BUTTONUP
:
5713 eventType
= wxEVT_JOY_BUTTON_UP
;
5717 wxFAIL_MSG(wxT("no such joystick event"));
5722 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5723 event
.SetPosition(wxPoint(x
, y
));
5724 event
.SetEventObject(this);
5726 return HandleWindowEvent(event
);
5736 // ---------------------------------------------------------------------------
5738 // ---------------------------------------------------------------------------
5740 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5741 WXWORD pos
, WXHWND control
)
5743 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5745 wxWindow
*child
= wxFindWinFromHandle(control
);
5747 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5750 wxScrollWinEvent event
;
5751 event
.SetPosition(pos
);
5752 event
.SetOrientation(orientation
);
5753 event
.SetEventObject(this);
5758 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5762 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5766 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5770 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5774 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5778 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5781 case SB_THUMBPOSITION
:
5783 // under Win32, the scrollbar range and position are 32 bit integers,
5784 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5785 // explicitly query the scrollbar for the correct position (this must
5786 // be done only for these two SB_ events as they are the only one
5787 // carrying the scrollbar position)
5789 WinStruct
<SCROLLINFO
> scrollInfo
;
5790 scrollInfo
.fMask
= SIF_TRACKPOS
;
5792 if ( !::GetScrollInfo(GetHwnd(),
5793 orientation
== wxHORIZONTAL
? SB_HORZ
5797 // Not necessarily an error, if there are no scrollbars yet.
5798 // wxLogLastError(_T("GetScrollInfo"));
5801 event
.SetPosition(scrollInfo
.nTrackPos
);
5804 event
.SetEventType( wParam
== SB_THUMBPOSITION
5805 ? wxEVT_SCROLLWIN_THUMBRELEASE
5806 : wxEVT_SCROLLWIN_THUMBTRACK
);
5813 return HandleWindowEvent(event
);
5816 // ----------------------------------------------------------------------------
5817 // custom message handlers
5818 // ----------------------------------------------------------------------------
5821 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5823 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5824 false, _T("registering handler for the same message twice") );
5826 gs_messageHandlers
[msg
] = handler
;
5831 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5833 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5834 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5835 _T("unregistering non-registered handler?") );
5837 gs_messageHandlers
.erase(i
);
5840 // ===========================================================================
5842 // ===========================================================================
5844 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5847 HDC dc
= ::GetDC((HWND
) wnd
);
5850 // the_font.UseResource();
5851 // the_font.RealizeResource();
5852 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5854 was
= (HFONT
) SelectObject(dc
,fnt
);
5856 GetTextMetrics(dc
, &tm
);
5859 SelectObject(dc
,was
);
5861 ReleaseDC((HWND
)wnd
, dc
);
5864 *x
= tm
.tmAveCharWidth
;
5866 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5868 // the_font.ReleaseResource();
5871 // use the "extended" bit (24) of lParam to distinguish extended keys
5872 // from normal keys as the same key is sent
5874 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5876 // except that if lParam is 0, it means we don't have real lParam from
5877 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5878 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5879 // non-numpad (hence extended) key as this is a more common case
5880 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5883 // this array contains the Windows virtual key codes which map one to one to
5884 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5886 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5887 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5888 static const struct wxKeyMapping
5892 } gs_specialKeys
[] =
5894 { VK_CANCEL
, WXK_CANCEL
},
5895 { VK_BACK
, WXK_BACK
},
5896 { VK_TAB
, WXK_TAB
},
5897 { VK_CLEAR
, WXK_CLEAR
},
5898 { VK_SHIFT
, WXK_SHIFT
},
5899 { VK_CONTROL
, WXK_CONTROL
},
5900 { VK_MENU
, WXK_ALT
},
5901 { VK_PAUSE
, WXK_PAUSE
},
5902 { VK_CAPITAL
, WXK_CAPITAL
},
5903 { VK_SPACE
, WXK_SPACE
},
5904 { VK_ESCAPE
, WXK_ESCAPE
},
5905 { VK_SELECT
, WXK_SELECT
},
5906 { VK_PRINT
, WXK_PRINT
},
5907 { VK_EXECUTE
, WXK_EXECUTE
},
5908 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5909 { VK_HELP
, WXK_HELP
},
5911 { VK_NUMPAD0
, WXK_NUMPAD0
},
5912 { VK_NUMPAD1
, WXK_NUMPAD1
},
5913 { VK_NUMPAD2
, WXK_NUMPAD2
},
5914 { VK_NUMPAD3
, WXK_NUMPAD3
},
5915 { VK_NUMPAD4
, WXK_NUMPAD4
},
5916 { VK_NUMPAD5
, WXK_NUMPAD5
},
5917 { VK_NUMPAD6
, WXK_NUMPAD6
},
5918 { VK_NUMPAD7
, WXK_NUMPAD7
},
5919 { VK_NUMPAD8
, WXK_NUMPAD8
},
5920 { VK_NUMPAD9
, WXK_NUMPAD9
},
5921 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5922 { VK_ADD
, WXK_NUMPAD_ADD
},
5923 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5924 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5925 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5936 { VK_F10
, WXK_F10
},
5937 { VK_F11
, WXK_F11
},
5938 { VK_F12
, WXK_F12
},
5939 { VK_F13
, WXK_F13
},
5940 { VK_F14
, WXK_F14
},
5941 { VK_F15
, WXK_F15
},
5942 { VK_F16
, WXK_F16
},
5943 { VK_F17
, WXK_F17
},
5944 { VK_F18
, WXK_F18
},
5945 { VK_F19
, WXK_F19
},
5946 { VK_F20
, WXK_F20
},
5947 { VK_F21
, WXK_F21
},
5948 { VK_F22
, WXK_F22
},
5949 { VK_F23
, WXK_F23
},
5950 { VK_F24
, WXK_F24
},
5952 { VK_NUMLOCK
, WXK_NUMLOCK
},
5953 { VK_SCROLL
, WXK_SCROLL
},
5956 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5957 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5958 { VK_APPS
, WXK_WINDOWS_MENU
},
5959 #endif // VK_APPS defined
5962 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5963 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5964 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5966 // check the table first
5967 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5969 if ( gs_specialKeys
[n
].vk
== vk
)
5970 return gs_specialKeys
[n
].wxk
;
5973 // keys requiring special handling
5977 // the mapping for these keys may be incorrect on non-US keyboards so
5978 // maybe we shouldn't map them to ASCII values at all
5979 case VK_OEM_1
: wxk
= ';'; break;
5980 case VK_OEM_PLUS
: wxk
= '+'; break;
5981 case VK_OEM_COMMA
: wxk
= ','; break;
5982 case VK_OEM_MINUS
: wxk
= '-'; break;
5983 case VK_OEM_PERIOD
: wxk
= '.'; break;
5984 case VK_OEM_2
: wxk
= '/'; break;
5985 case VK_OEM_3
: wxk
= '~'; break;
5986 case VK_OEM_4
: wxk
= '['; break;
5987 case VK_OEM_5
: wxk
= '\\'; break;
5988 case VK_OEM_6
: wxk
= ']'; break;
5989 case VK_OEM_7
: wxk
= '\''; break;
5991 // handle extended keys
5993 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5997 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
6001 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6005 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6009 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6013 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6017 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6021 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6025 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6029 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6033 // don't use ChooseNormalOrExtended() here as the keys are reversed
6034 // here: numpad enter is the extended one
6035 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6045 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
6050 // check the table first
6051 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6053 if ( gs_specialKeys
[n
].wxk
== wxk
)
6054 return gs_specialKeys
[n
].vk
;
6057 // and then check for special keys not included in the table
6062 case WXK_NUMPAD_PAGEUP
:
6067 case WXK_NUMPAD_PAGEDOWN
:
6072 case WXK_NUMPAD_END
:
6077 case WXK_NUMPAD_HOME
:
6082 case WXK_NUMPAD_LEFT
:
6092 case WXK_NUMPAD_RIGHT
:
6097 case WXK_NUMPAD_DOWN
:
6102 case WXK_NUMPAD_INSERT
:
6107 case WXK_NUMPAD_DELETE
:
6112 // no VkKeyScan() under CE unfortunately, we need to test how does
6113 // it handle OEM keys
6115 // check to see if its one of the OEM key codes.
6116 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6122 #endif // !__WXWINCE__
6133 // small helper for wxGetKeyState() and wxGetMouseState()
6134 static inline bool wxIsKeyDown(WXWORD vk
)
6136 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6137 #ifdef SM_SWAPBUTTON
6138 if ( vk
== VK_LBUTTON
|| vk
== VK_RBUTTON
)
6140 if ( ::GetSystemMetrics(SM_SWAPBUTTON
) )
6142 if ( vk
== VK_LBUTTON
)
6144 else // vk == VK_RBUTTON
6148 #endif // SM_SWAPBUTTON
6150 // the low order bit indicates whether the key was pressed since the last
6151 // call and the high order one indicates whether it is down right now and
6152 // we only want that one
6153 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6156 bool wxGetKeyState(wxKeyCode key
)
6158 // although this does work under Windows, it is not supported under other
6159 // platforms so don't allow it, you must use wxGetMouseState() instead
6160 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6161 key
!= VK_RBUTTON
&&
6163 wxT("can't use wxGetKeyState() for mouse buttons") );
6165 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6167 // if the requested key is a LED key, return true if the led is pressed
6168 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6170 // low order bit means LED is highlighted and high order one means the
6171 // key is down; for compatibility with the other ports return true if
6172 // either one is set
6173 return GetKeyState(vk
) != 0;
6178 return wxIsKeyDown(vk
);
6183 wxMouseState
wxGetMouseState()
6187 GetCursorPos( &pt
);
6191 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6192 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6193 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6194 #ifdef wxHAS_XBUTTON
6195 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6196 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6197 #endif // wxHAS_XBUTTON
6199 ms
.SetControlDown(wxIsCtrlDown ());
6200 ms
.SetShiftDown (wxIsShiftDown());
6201 ms
.SetAltDown (wxIsAltDown ());
6202 // ms.SetMetaDown();
6208 wxWindow
*wxGetActiveWindow()
6210 HWND hWnd
= GetActiveWindow();
6213 return wxFindWinFromHandle(hWnd
);
6218 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6220 HWND hwnd
= (HWND
)hWnd
;
6222 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6223 // by code in msw/radiobox.cpp), for all the others we just search up the
6225 wxWindow
*win
= (wxWindow
*)NULL
;
6228 win
= wxFindWinFromHandle(hwnd
);
6232 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6233 // wxWindow class which overrides WM_GETDLGCODE processing to
6234 // do it as well, win would be already non NULL
6235 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6237 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6239 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6240 #endif // wxUSE_RADIOBOX
6242 // spin control text buddy window should be mapped to spin ctrl
6243 // itself so try it too
6244 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6247 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6249 #endif // wxUSE_SPINCTRL
6253 while ( hwnd
&& !win
)
6255 // this is a really ugly hack needed to avoid mistakenly returning the
6256 // parent frame wxWindow for the find/replace modeless dialog HWND -
6257 // this, in turn, is needed to call IsDialogMessage() from
6258 // wxApp::ProcessMessage() as for this we must return NULL from here
6260 // FIXME: this is clearly not the best way to do it but I think we'll
6261 // need to change HWND <-> wxWindow code more heavily than I can
6262 // do it now to fix it
6263 #ifndef __WXMICROWIN__
6264 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6266 // it's a dialog box, don't go upwards
6271 hwnd
= ::GetParent(hwnd
);
6272 win
= wxFindWinFromHandle(hwnd
);
6278 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6280 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6281 // in active frames and dialogs, regardless of where the focus is.
6282 static HHOOK wxTheKeyboardHook
= 0;
6283 static FARPROC wxTheKeyboardHookProc
= 0;
6284 int APIENTRY _EXPORT
6285 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
6287 void wxSetKeyboardHook(bool doIt
)
6291 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
6292 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
6294 GetCurrentThreadId()
6295 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
6300 UnhookWindowsHookEx(wxTheKeyboardHook
);
6304 int APIENTRY _EXPORT
6305 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6307 DWORD hiWord
= HIWORD(lParam
);
6308 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6310 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6313 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6314 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6315 event
.m_altDown
= true;
6317 event
.SetEventObject(NULL
);
6318 event
.m_keyCode
= id
;
6319 event
.m_shiftDown
= wxIsShiftDown();
6320 event
.m_controlDown
= wxIsCtrlDown();
6322 event
.SetTimestamp(::GetMessageTime());
6324 wxWindow
*win
= wxGetActiveWindow();
6325 wxEvtHandler
*handler
;
6328 handler
= win
->GetEventHandler();
6329 event
.SetId(win
->GetId());
6334 event
.SetId(wxID_ANY
);
6337 if ( handler
&& handler
->ProcessEvent(event
) )
6345 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6348 #endif // !__WXMICROWIN__
6351 const wxChar
*wxGetMessageName(int message
)
6355 case 0x0000: return wxT("WM_NULL");
6356 case 0x0001: return wxT("WM_CREATE");
6357 case 0x0002: return wxT("WM_DESTROY");
6358 case 0x0003: return wxT("WM_MOVE");
6359 case 0x0005: return wxT("WM_SIZE");
6360 case 0x0006: return wxT("WM_ACTIVATE");
6361 case 0x0007: return wxT("WM_SETFOCUS");
6362 case 0x0008: return wxT("WM_KILLFOCUS");
6363 case 0x000A: return wxT("WM_ENABLE");
6364 case 0x000B: return wxT("WM_SETREDRAW");
6365 case 0x000C: return wxT("WM_SETTEXT");
6366 case 0x000D: return wxT("WM_GETTEXT");
6367 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6368 case 0x000F: return wxT("WM_PAINT");
6369 case 0x0010: return wxT("WM_CLOSE");
6370 case 0x0011: return wxT("WM_QUERYENDSESSION");
6371 case 0x0012: return wxT("WM_QUIT");
6372 case 0x0013: return wxT("WM_QUERYOPEN");
6373 case 0x0014: return wxT("WM_ERASEBKGND");
6374 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6375 case 0x0016: return wxT("WM_ENDSESSION");
6376 case 0x0017: return wxT("WM_SYSTEMERROR");
6377 case 0x0018: return wxT("WM_SHOWWINDOW");
6378 case 0x0019: return wxT("WM_CTLCOLOR");
6379 case 0x001A: return wxT("WM_WININICHANGE");
6380 case 0x001B: return wxT("WM_DEVMODECHANGE");
6381 case 0x001C: return wxT("WM_ACTIVATEAPP");
6382 case 0x001D: return wxT("WM_FONTCHANGE");
6383 case 0x001E: return wxT("WM_TIMECHANGE");
6384 case 0x001F: return wxT("WM_CANCELMODE");
6385 case 0x0020: return wxT("WM_SETCURSOR");
6386 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6387 case 0x0022: return wxT("WM_CHILDACTIVATE");
6388 case 0x0023: return wxT("WM_QUEUESYNC");
6389 case 0x0024: return wxT("WM_GETMINMAXINFO");
6390 case 0x0026: return wxT("WM_PAINTICON");
6391 case 0x0027: return wxT("WM_ICONERASEBKGND");
6392 case 0x0028: return wxT("WM_NEXTDLGCTL");
6393 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6394 case 0x002B: return wxT("WM_DRAWITEM");
6395 case 0x002C: return wxT("WM_MEASUREITEM");
6396 case 0x002D: return wxT("WM_DELETEITEM");
6397 case 0x002E: return wxT("WM_VKEYTOITEM");
6398 case 0x002F: return wxT("WM_CHARTOITEM");
6399 case 0x0030: return wxT("WM_SETFONT");
6400 case 0x0031: return wxT("WM_GETFONT");
6401 case 0x0037: return wxT("WM_QUERYDRAGICON");
6402 case 0x0039: return wxT("WM_COMPAREITEM");
6403 case 0x0041: return wxT("WM_COMPACTING");
6404 case 0x0044: return wxT("WM_COMMNOTIFY");
6405 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6406 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6407 case 0x0048: return wxT("WM_POWER");
6409 case 0x004A: return wxT("WM_COPYDATA");
6410 case 0x004B: return wxT("WM_CANCELJOURNAL");
6411 case 0x004E: return wxT("WM_NOTIFY");
6412 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6413 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6414 case 0x0052: return wxT("WM_TCARD");
6415 case 0x0053: return wxT("WM_HELP");
6416 case 0x0054: return wxT("WM_USERCHANGED");
6417 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6418 case 0x007B: return wxT("WM_CONTEXTMENU");
6419 case 0x007C: return wxT("WM_STYLECHANGING");
6420 case 0x007D: return wxT("WM_STYLECHANGED");
6421 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6422 case 0x007F: return wxT("WM_GETICON");
6423 case 0x0080: return wxT("WM_SETICON");
6425 case 0x0081: return wxT("WM_NCCREATE");
6426 case 0x0082: return wxT("WM_NCDESTROY");
6427 case 0x0083: return wxT("WM_NCCALCSIZE");
6428 case 0x0084: return wxT("WM_NCHITTEST");
6429 case 0x0085: return wxT("WM_NCPAINT");
6430 case 0x0086: return wxT("WM_NCACTIVATE");
6431 case 0x0087: return wxT("WM_GETDLGCODE");
6432 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6433 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6434 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6435 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6436 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6437 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6438 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6439 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6440 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6441 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6443 case 0x00B0: return wxT("EM_GETSEL");
6444 case 0x00B1: return wxT("EM_SETSEL");
6445 case 0x00B2: return wxT("EM_GETRECT");
6446 case 0x00B3: return wxT("EM_SETRECT");
6447 case 0x00B4: return wxT("EM_SETRECTNP");
6448 case 0x00B5: return wxT("EM_SCROLL");
6449 case 0x00B6: return wxT("EM_LINESCROLL");
6450 case 0x00B7: return wxT("EM_SCROLLCARET");
6451 case 0x00B8: return wxT("EM_GETMODIFY");
6452 case 0x00B9: return wxT("EM_SETMODIFY");
6453 case 0x00BA: return wxT("EM_GETLINECOUNT");
6454 case 0x00BB: return wxT("EM_LINEINDEX");
6455 case 0x00BC: return wxT("EM_SETHANDLE");
6456 case 0x00BD: return wxT("EM_GETHANDLE");
6457 case 0x00BE: return wxT("EM_GETTHUMB");
6458 case 0x00C1: return wxT("EM_LINELENGTH");
6459 case 0x00C2: return wxT("EM_REPLACESEL");
6460 case 0x00C4: return wxT("EM_GETLINE");
6461 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6462 case 0x00C6: return wxT("EM_CANUNDO");
6463 case 0x00C7: return wxT("EM_UNDO");
6464 case 0x00C8: return wxT("EM_FMTLINES");
6465 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6466 case 0x00CB: return wxT("EM_SETTABSTOPS");
6467 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6468 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6469 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6470 case 0x00CF: return wxT("EM_SETREADONLY");
6471 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6472 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6473 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6474 case 0x00D3: return wxT("EM_SETMARGINS");
6475 case 0x00D4: return wxT("EM_GETMARGINS");
6476 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6477 case 0x00D6: return wxT("EM_POSFROMCHAR");
6478 case 0x00D7: return wxT("EM_CHARFROMPOS");
6479 case 0x00D8: return wxT("EM_SETIMESTATUS");
6480 case 0x00D9: return wxT("EM_GETIMESTATUS");
6482 case 0x0100: return wxT("WM_KEYDOWN");
6483 case 0x0101: return wxT("WM_KEYUP");
6484 case 0x0102: return wxT("WM_CHAR");
6485 case 0x0103: return wxT("WM_DEADCHAR");
6486 case 0x0104: return wxT("WM_SYSKEYDOWN");
6487 case 0x0105: return wxT("WM_SYSKEYUP");
6488 case 0x0106: return wxT("WM_SYSCHAR");
6489 case 0x0107: return wxT("WM_SYSDEADCHAR");
6490 case 0x0108: return wxT("WM_KEYLAST");
6492 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6493 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6494 case 0x010F: return wxT("WM_IME_COMPOSITION");
6496 case 0x0110: return wxT("WM_INITDIALOG");
6497 case 0x0111: return wxT("WM_COMMAND");
6498 case 0x0112: return wxT("WM_SYSCOMMAND");
6499 case 0x0113: return wxT("WM_TIMER");
6500 case 0x0114: return wxT("WM_HSCROLL");
6501 case 0x0115: return wxT("WM_VSCROLL");
6502 case 0x0116: return wxT("WM_INITMENU");
6503 case 0x0117: return wxT("WM_INITMENUPOPUP");
6504 case 0x011F: return wxT("WM_MENUSELECT");
6505 case 0x0120: return wxT("WM_MENUCHAR");
6506 case 0x0121: return wxT("WM_ENTERIDLE");
6508 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6509 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6510 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6511 case 0x0135: return wxT("WM_CTLCOLORBTN");
6512 case 0x0136: return wxT("WM_CTLCOLORDLG");
6513 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6514 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6515 case 0x01E1: return wxT("MN_GETHMENU");
6517 case 0x0200: return wxT("WM_MOUSEMOVE");
6518 case 0x0201: return wxT("WM_LBUTTONDOWN");
6519 case 0x0202: return wxT("WM_LBUTTONUP");
6520 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6521 case 0x0204: return wxT("WM_RBUTTONDOWN");
6522 case 0x0205: return wxT("WM_RBUTTONUP");
6523 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6524 case 0x0207: return wxT("WM_MBUTTONDOWN");
6525 case 0x0208: return wxT("WM_MBUTTONUP");
6526 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6527 case 0x020A: return wxT("WM_MOUSEWHEEL");
6528 case 0x020B: return wxT("WM_XBUTTONDOWN");
6529 case 0x020C: return wxT("WM_XBUTTONUP");
6530 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6531 case 0x0210: return wxT("WM_PARENTNOTIFY");
6532 case 0x0211: return wxT("WM_ENTERMENULOOP");
6533 case 0x0212: return wxT("WM_EXITMENULOOP");
6535 case 0x0213: return wxT("WM_NEXTMENU");
6536 case 0x0214: return wxT("WM_SIZING");
6537 case 0x0215: return wxT("WM_CAPTURECHANGED");
6538 case 0x0216: return wxT("WM_MOVING");
6539 case 0x0218: return wxT("WM_POWERBROADCAST");
6540 case 0x0219: return wxT("WM_DEVICECHANGE");
6542 case 0x0220: return wxT("WM_MDICREATE");
6543 case 0x0221: return wxT("WM_MDIDESTROY");
6544 case 0x0222: return wxT("WM_MDIACTIVATE");
6545 case 0x0223: return wxT("WM_MDIRESTORE");
6546 case 0x0224: return wxT("WM_MDINEXT");
6547 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6548 case 0x0226: return wxT("WM_MDITILE");
6549 case 0x0227: return wxT("WM_MDICASCADE");
6550 case 0x0228: return wxT("WM_MDIICONARRANGE");
6551 case 0x0229: return wxT("WM_MDIGETACTIVE");
6552 case 0x0230: return wxT("WM_MDISETMENU");
6553 case 0x0233: return wxT("WM_DROPFILES");
6555 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6556 case 0x0282: return wxT("WM_IME_NOTIFY");
6557 case 0x0283: return wxT("WM_IME_CONTROL");
6558 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6559 case 0x0285: return wxT("WM_IME_SELECT");
6560 case 0x0286: return wxT("WM_IME_CHAR");
6561 case 0x0290: return wxT("WM_IME_KEYDOWN");
6562 case 0x0291: return wxT("WM_IME_KEYUP");
6564 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6565 case 0x02A1: return wxT("WM_MOUSEHOVER");
6566 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6567 case 0x02A3: return wxT("WM_MOUSELEAVE");
6569 case 0x0300: return wxT("WM_CUT");
6570 case 0x0301: return wxT("WM_COPY");
6571 case 0x0302: return wxT("WM_PASTE");
6572 case 0x0303: return wxT("WM_CLEAR");
6573 case 0x0304: return wxT("WM_UNDO");
6574 case 0x0305: return wxT("WM_RENDERFORMAT");
6575 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6576 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6577 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6578 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6579 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6580 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6581 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6582 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6583 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6584 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6585 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6586 case 0x0311: return wxT("WM_PALETTECHANGED");
6587 case 0x0312: return wxT("WM_HOTKEY");
6589 case 0x0317: return wxT("WM_PRINT");
6590 case 0x0318: return wxT("WM_PRINTCLIENT");
6592 // common controls messages - although they're not strictly speaking
6593 // standard, it's nice to decode them nevertheless
6596 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6597 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6598 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6599 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6600 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6601 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6602 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6603 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6604 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6605 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6606 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6607 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6608 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6609 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6610 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6611 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6612 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6613 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6614 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6615 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6616 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6617 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6618 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6619 case 0x1000 + 18: return wxT("LVM_HITTEST");
6620 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6621 case 0x1000 + 20: return wxT("LVM_SCROLL");
6622 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6623 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6624 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6625 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6626 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6627 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6628 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6629 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6630 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6631 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6632 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6633 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6634 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6635 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6636 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6637 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6638 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6639 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6640 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6641 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6642 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6643 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6644 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6645 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6646 case 0x1000 + 42: return wxT("LVM_UPDATE");
6647 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6648 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6649 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6650 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6651 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6652 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6653 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6654 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6655 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6656 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6657 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6658 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6659 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6660 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6661 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6662 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6663 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6664 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6665 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6666 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6667 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6668 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6669 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6670 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6671 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6672 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6675 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6676 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6677 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6678 case 0x1100 + 2: return wxT("TVM_EXPAND");
6679 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6680 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6681 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6682 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6683 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6684 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6685 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6686 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6687 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6688 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6689 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6690 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6691 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6692 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6693 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6694 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6695 case 0x1100 + 17: return wxT("TVM_HITTEST");
6696 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6697 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6698 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6699 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6700 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6701 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6702 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6703 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6704 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6707 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6708 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6709 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6710 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6711 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6712 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6713 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6714 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6715 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6716 case 0x1200 + 6: return wxT("HDM_HITTEST");
6717 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6718 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6719 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6720 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6721 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6722 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6723 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6724 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6727 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6728 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6729 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6730 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6731 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6732 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6733 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6734 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6735 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6736 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6737 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6738 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6739 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6740 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6741 case 0x1300 + 13: return wxT("TCM_HITTEST");
6742 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6743 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6744 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6745 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6746 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6747 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6748 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6749 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6750 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6751 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6752 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6753 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6756 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6757 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6758 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6759 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6760 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6761 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6762 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6763 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6764 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6765 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6766 case WM_USER
+17: return wxT("TB_SETSTATE");
6767 case WM_USER
+18: return wxT("TB_GETSTATE");
6768 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6769 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6770 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6771 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6772 case WM_USER
+23: return wxT("TB_GETBUTTON");
6773 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6774 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6775 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6776 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6777 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6778 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6779 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6780 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6781 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6782 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6783 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6784 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6785 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6786 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6787 case WM_USER
+37: return wxT("TB_SETPARENT");
6788 case WM_USER
+39: return wxT("TB_SETROWS");
6789 case WM_USER
+40: return wxT("TB_GETROWS");
6790 case WM_USER
+42: return wxT("TB_SETCMDID");
6791 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6792 case WM_USER
+44: return wxT("TB_GETBITMAP");
6793 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6794 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6795 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6796 case WM_USER
+47: return wxT("TB_SETINDENT");
6797 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6798 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6799 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6800 case WM_USER
+51: return wxT("TB_GETRECT");
6801 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6802 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6803 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6804 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6805 case WM_USER
+56: return wxT("TB_SETSTYLE");
6806 case WM_USER
+57: return wxT("TB_GETSTYLE");
6807 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6808 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6809 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6810 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6811 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6814 static wxString s_szBuf
;
6815 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6816 return s_szBuf
.c_str();
6819 #endif //__WXDEBUG__
6821 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6825 HWND hwnd
= GetHwndOf(win
);
6826 HDC hdc
= ::GetDC(hwnd
);
6828 #if !wxDIALOG_UNIT_COMPATIBILITY
6829 // and select the current font into it
6830 HFONT hfont
= GetHfontOf(win
->GetFont());
6833 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6837 // finally retrieve the text metrics from it
6838 GetTextMetrics(hdc
, &tm
);
6840 #if !wxDIALOG_UNIT_COMPATIBILITY
6844 (void)::SelectObject(hdc
, hfont
);
6848 ::ReleaseDC(hwnd
, hdc
);
6853 // Find the wxWindow at the current mouse position, returning the mouse
6855 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6857 pt
= wxGetMousePosition();
6858 return wxFindWindowAtPoint(pt
);
6861 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6867 HWND hWnd
= ::WindowFromPoint(pt2
);
6869 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6872 // Get the current mouse position.
6873 wxPoint
wxGetMousePosition()
6877 GetCursorPosWinCE(&pt
);
6879 GetCursorPos( & pt
);
6882 return wxPoint(pt
.x
, pt
.y
);
6887 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6888 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6890 // Register hotkeys for the hardware buttons
6892 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6894 UnregisterFunc1Proc procUnregisterFunc
;
6895 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6898 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6899 if (procUnregisterFunc
)
6900 procUnregisterFunc(modifiers
, id
);
6901 FreeLibrary(hCoreDll
);
6906 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6908 UINT win_modifiers
=0;
6909 if ( modifiers
& wxMOD_ALT
)
6910 win_modifiers
|= MOD_ALT
;
6911 if ( modifiers
& wxMOD_SHIFT
)
6912 win_modifiers
|= MOD_SHIFT
;
6913 if ( modifiers
& wxMOD_CONTROL
)
6914 win_modifiers
|= MOD_CONTROL
;
6915 if ( modifiers
& wxMOD_WIN
)
6916 win_modifiers
|= MOD_WIN
;
6918 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6919 // Required for PPC and Smartphone hardware buttons
6920 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6921 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6924 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6926 wxLogLastError(_T("RegisterHotKey"));
6934 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6936 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6937 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6940 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6942 wxLogLastError(_T("UnregisterHotKey"));
6952 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6954 int hotkeyId
= wParam
;
6955 int virtualKey
= HIWORD(lParam
);
6956 int win_modifiers
= LOWORD(lParam
);
6958 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6959 event
.SetId(hotkeyId
);
6960 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6961 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6962 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6963 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6965 return HandleWindowEvent(event
);
6968 #endif // wxUSE_ACCEL
6970 #endif // wxUSE_HOTKEY
6972 // Not tested under WinCE
6975 // this class installs a message hook which really wakes up our idle processing
6976 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6977 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6978 // being dragged or even inside ::MessageBox()) and so don't control message
6979 // dispatching otherwise
6980 class wxIdleWakeUpModule
: public wxModule
6983 virtual bool OnInit()
6985 ms_hMsgHookProc
= ::SetWindowsHookEx
6988 &wxIdleWakeUpModule::MsgHookProc
,
6990 GetCurrentThreadId()
6993 if ( !ms_hMsgHookProc
)
6995 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
7003 virtual void OnExit()
7005 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
7008 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
7010 MSG
*msg
= (MSG
*)lParam
;
7012 // only process the message if it is actually going to be removed from
7013 // the message queue, this prevents that the same event from being
7014 // processed multiple times if now someone just called PeekMessage()
7015 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7017 wxTheApp
->ProcessPendingEvents();
7020 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7024 static HHOOK ms_hMsgHookProc
;
7026 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7029 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7031 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7033 #endif // __WXWINCE__
7038 static void wxAdjustZOrder(wxWindow
* parent
)
7040 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7042 // Set the z-order correctly
7043 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7046 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7049 wxWindow
*childWin
= current
->GetData();
7050 wxAdjustZOrder(childWin
);
7051 current
= current
->GetNext();
7056 // We need to adjust the z-order of static boxes in WinCE, to
7057 // make 'contained' controls visible
7058 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7061 wxAdjustZOrder(this);