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
;
187 extern wxChar
*wxCanvasClassName
;
189 extern const wxChar
*wxCanvasClassName
;
192 // true if we had already created the std colour map, used by
193 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
194 static bool gs_hasStdCmap
= false;
196 // last mouse event information we need to filter out the duplicates
197 #if wxUSE_MOUSEEVENT_HACK
198 static struct MouseEventInfoDummy
200 // mouse position (in screen coordinates)
203 // last mouse event type
206 #endif // wxUSE_MOUSEEVENT_HACK
208 // hash containing the registered handlers for the custom messages
209 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
210 wxIntegerHash
, wxIntegerEqual
,
213 static MSWMessageHandlers gs_messageHandlers
;
215 // hash containing all our windows, it uses HWND keys and wxWindow* values
216 WX_DECLARE_HASH_MAP(HWND
, wxWindow
*,
217 wxPointerHash
, wxPointerEqual
,
220 static WindowHandles gs_windowHandles
;
222 // ---------------------------------------------------------------------------
224 // ---------------------------------------------------------------------------
226 // the window proc for all our windows
227 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
228 WPARAM wParam
, LPARAM lParam
);
232 const wxChar
*wxGetMessageName(int message
);
235 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
236 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
238 // get the text metrics for the current font
239 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
242 // find the window for the mouse event at the specified position
243 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
244 #endif // __WXWINCE__
246 // wrapper around BringWindowToTop() API
247 static inline void wxBringWindowToTop(HWND hwnd
)
249 #ifdef __WXMICROWIN__
250 // It seems that MicroWindows brings the _parent_ of the window to the top,
251 // which can be the wrong one.
253 // activate (set focus to) specified window
257 // raise top level parent to top of z order
258 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
260 wxLogLastError(_T("SetWindowPos"));
266 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
267 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
270 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
271 parent as well as otherwise several Win32 functions using
272 GetNextDlgTabItem() to iterate over all controls such as
273 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
274 all of them iterate over all the controls starting from the currently
275 focused one and stop iterating when they get back to the focus but
276 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
277 get back to the initial (focused) window: as we do have this style,
278 GetNextDlgTabItem() will leave this window and continue in its parent,
279 but if the parent doesn't have it, it wouldn't recurse inside it later
280 on and so wouldn't have a chance of getting back to this window either.
282 while ( parent
&& !parent
->IsTopLevel() )
284 LONG exStyle
= wxGetWindowExStyle(parent
);
285 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
287 // force the parent to have this style
288 wxSetWindowExStyle(parent
, exStyle
| WS_EX_CONTROLPARENT
);
291 parent
= parent
->GetParent();
295 #endif // !__WXWINCE__
298 // On Windows CE, GetCursorPos can return an error, so use this function
300 bool GetCursorPosWinCE(POINT
* pt
)
302 if (!GetCursorPos(pt
))
304 DWORD pos
= GetMessagePos();
312 // ---------------------------------------------------------------------------
314 // ---------------------------------------------------------------------------
316 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
318 #ifdef __WXUNIVERSAL__
319 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
321 #if wxUSE_EXTENDED_RTTI
323 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
324 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
325 // windows with negative ids never can be recreated anyway
327 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
329 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
330 if ( win
&& win
->GetId() < 0 )
335 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
337 // make wxWindowList known before the property is used
339 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
341 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
343 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
346 WX_DEFINE_FLAGS( wxWindowStyle
)
348 wxBEGIN_FLAGS( wxWindowStyle
)
349 // new style border flags, we put them first to
350 // use them for streaming out
352 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
353 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
354 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
355 wxFLAGS_MEMBER(wxBORDER_RAISED
)
356 wxFLAGS_MEMBER(wxBORDER_STATIC
)
357 wxFLAGS_MEMBER(wxBORDER_NONE
)
359 // old style border flags
360 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
361 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
362 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
363 wxFLAGS_MEMBER(wxRAISED_BORDER
)
364 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
365 wxFLAGS_MEMBER(wxBORDER
)
367 // standard window styles
368 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
369 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
370 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
371 wxFLAGS_MEMBER(wxWANTS_CHARS
)
372 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
373 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
374 wxFLAGS_MEMBER(wxVSCROLL
)
375 wxFLAGS_MEMBER(wxHSCROLL
)
377 wxEND_FLAGS( wxWindowStyle
)
379 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
380 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
381 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
382 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
383 // Always constructor Properties first
385 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
386 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
387 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
388 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
389 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
391 // Then all relations of the object graph
393 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
395 // and finally all other properties
397 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
398 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
399 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
400 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
401 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
403 // possible property candidates (not in xrc) or not valid in all subclasses
404 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
405 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
406 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
407 // MaxHeight, Width , MinHeight , Width
408 // TODO switch label to control and title to toplevels
410 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
411 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
412 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
413 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
418 wxEND_PROPERTIES_TABLE()
420 wxBEGIN_HANDLERS_TABLE(wxWindow
)
421 wxEND_HANDLERS_TABLE()
423 wxCONSTRUCTOR_DUMMY(wxWindow
)
426 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
428 #endif // __WXUNIVERSAL__/__WXMSW__
430 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
431 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
432 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
434 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
438 // ===========================================================================
440 // ===========================================================================
442 // ---------------------------------------------------------------------------
443 // wxWindow utility functions
444 // ---------------------------------------------------------------------------
446 // Find an item given the MS Windows id
447 wxWindow
*wxWindowMSW::FindItem(long id
) const
450 wxControl
*item
= wxDynamicCastThis(wxControl
);
453 // is it us or one of our "internal" children?
454 if ( item
->GetId() == id
455 #ifndef __WXUNIVERSAL__
456 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
457 #endif // __WXUNIVERSAL__
463 #endif // wxUSE_CONTROLS
465 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
468 wxWindow
*childWin
= current
->GetData();
470 wxWindow
*wnd
= childWin
->FindItem(id
);
474 current
= current
->GetNext();
480 // Find an item given the MS Windows handle
481 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
483 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
486 wxWindow
*parent
= current
->GetData();
488 // Do a recursive search.
489 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
495 || parent
->IsKindOf(CLASSINFO(wxControl
))
496 #endif // wxUSE_CONTROLS
499 wxWindow
*item
= current
->GetData();
500 if ( item
->GetHWND() == hWnd
)
504 if ( item
->ContainsHWND(hWnd
) )
509 current
= current
->GetNext();
514 // Default command handler
515 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
520 // ----------------------------------------------------------------------------
521 // constructors and such
522 // ----------------------------------------------------------------------------
524 void wxWindowMSW::Init()
527 m_isBeingDeleted
= false;
529 m_mouseInWindow
= false;
530 m_lastKeydownProcessed
= false;
538 m_pendingPosition
= wxDefaultPosition
;
539 m_pendingSize
= wxDefaultSize
;
542 m_contextMenuEnabled
= false;
547 wxWindowMSW::~wxWindowMSW()
549 m_isBeingDeleted
= true;
551 #ifndef __WXUNIVERSAL__
552 // VS: make sure there's no wxFrame with last focus set to us:
553 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
555 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
558 if ( frame
->GetLastFocus() == this )
560 frame
->SetLastFocus(NULL
);
563 // apparently sometimes we can end up with our grand parent
564 // pointing to us as well: this is surely a bug in focus handling
565 // code but it's not clear where it happens so for now just try to
566 // fix it here by not breaking out of the loop
570 #endif // __WXUNIVERSAL__
572 // VS: destroy children first and _then_ detach *this from its parent.
573 // If we did it the other way around, children wouldn't be able
574 // find their parent frame (see above).
579 // VZ: test temp removed to understand what really happens here
580 //if (::IsWindow(GetHwnd()))
582 if ( !::DestroyWindow(GetHwnd()) )
583 wxLogLastError(wxT("DestroyWindow"));
586 // remove hWnd <-> wxWindow association
587 wxRemoveHandleAssociation(this);
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(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
632 // ---------------------------------------------------------------------------
634 // ---------------------------------------------------------------------------
636 void wxWindowMSW::SetFocus()
638 HWND hWnd
= GetHwnd();
639 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
641 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
645 if ( !::SetFocus(hWnd
) )
647 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
648 // was there really an error?
649 DWORD dwRes
= ::GetLastError();
652 HWND hwndFocus
= ::GetFocus();
653 if ( hwndFocus
!= hWnd
)
655 wxLogApiError(_T("SetFocus"), dwRes
);
662 void wxWindowMSW::SetFocusFromKbd()
664 // when the focus is given to the control with DLGC_HASSETSEL style from
665 // keyboard its contents should be entirely selected: this is what
666 // ::IsDialogMessage() does and so we should do it as well to provide the
667 // same LNF as the native programs
668 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
670 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
673 // do this after (maybe) setting the selection as like this when
674 // wxEVT_SET_FOCUS handler is called, the selection would have been already
675 // set correctly -- this may be important
676 wxWindowBase::SetFocusFromKbd();
679 // Get the window with the focus
680 wxWindow
*wxWindowBase::DoFindFocus()
682 HWND hWnd
= ::GetFocus();
685 return wxGetWindowFromHWND((WXHWND
)hWnd
);
691 void wxWindowMSW::DoEnable( bool enable
)
693 HWND hWnd
= GetHwnd();
695 ::EnableWindow(hWnd
, (BOOL
)enable
);
698 bool wxWindowMSW::Show(bool show
)
700 if ( !wxWindowBase::Show(show
) )
703 HWND hWnd
= GetHwnd();
705 // we could be called before the underlying window is created (this is
706 // actually useful to prevent it from being initially shown), e.g.
708 // wxFoo *foo = new wxFoo;
710 // foo->Create(parent, ...);
712 // should work without errors
715 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
720 // DoFreeze/DoThaw don't do anything if the window is not shown, so
721 // we have to call them from here now
732 wxWindowMSW::MSWShowWithEffect(bool show
,
736 if ( !wxWindowBase::Show(show
) )
739 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
741 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
742 static bool s_initDone
= false;
745 wxDynamicLibrary
dllUser32(_T("user32.dll"), wxDL_VERBATIM
| wxDL_QUIET
);
746 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
750 // notice that it's ok to unload user32.dll here as it won't be really
751 // unloaded, being still in use because we link to it statically too
754 if ( !s_pfnAnimateWindow
)
757 // Show() has a side effect of sending a WM_SIZE to the window, which helps
758 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
759 // this so send the event ourselves
762 // prepare to use AnimateWindow()
765 timeout
= 200; // this is the default animation timeout, per MSDN
767 DWORD dwFlags
= show
? 0 : AW_HIDE
;
771 case wxSHOW_EFFECT_ROLL_TO_LEFT
:
772 dwFlags
|= AW_HOR_NEGATIVE
;
775 case wxSHOW_EFFECT_ROLL_TO_RIGHT
:
776 dwFlags
|= AW_HOR_POSITIVE
;
779 case wxSHOW_EFFECT_ROLL_TO_TOP
:
780 dwFlags
|= AW_VER_NEGATIVE
;
783 case wxSHOW_EFFECT_ROLL_TO_BOTTOM
:
784 dwFlags
|= AW_VER_POSITIVE
;
787 case wxSHOW_EFFECT_SLIDE_TO_LEFT
:
788 dwFlags
|= AW_SLIDE
| AW_HOR_NEGATIVE
;
791 case wxSHOW_EFFECT_SLIDE_TO_RIGHT
:
792 dwFlags
|= AW_SLIDE
| AW_HOR_POSITIVE
;
795 case wxSHOW_EFFECT_SLIDE_TO_TOP
:
796 dwFlags
|= AW_SLIDE
| AW_VER_NEGATIVE
;
799 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM
:
800 dwFlags
|= AW_SLIDE
| AW_VER_POSITIVE
;
803 case wxSHOW_EFFECT_BLEND
:
807 case wxSHOW_EFFECT_EXPAND
:
808 dwFlags
|= AW_CENTER
;
812 case wxSHOW_EFFECT_MAX
:
813 wxFAIL_MSG( _T("invalid window show effect") );
817 wxFAIL_MSG( _T("unknown window show effect") );
821 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
823 wxLogLastError(_T("AnimateWindow"));
831 // Raise the window to the top of the Z order
832 void wxWindowMSW::Raise()
834 wxBringWindowToTop(GetHwnd());
837 // Lower the window to the bottom of the Z order
838 void wxWindowMSW::Lower()
840 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
841 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
844 void wxWindowMSW::DoCaptureMouse()
846 HWND hWnd
= GetHwnd();
853 void wxWindowMSW::DoReleaseMouse()
855 if ( !::ReleaseCapture() )
857 wxLogLastError(_T("ReleaseCapture"));
861 /* static */ wxWindow
*wxWindowBase::GetCapture()
863 HWND hwnd
= ::GetCapture();
864 return hwnd
? wxFindWinFromHandle(hwnd
) : NULL
;
867 bool wxWindowMSW::SetFont(const wxFont
& font
)
869 if ( !wxWindowBase::SetFont(font
) )
875 HWND hWnd
= GetHwnd();
878 // note the use of GetFont() instead of m_font: our own font could have
879 // just been reset and in this case we need to change the font used by
880 // the native window to the default for this class, i.e. exactly what
882 WXHANDLE hFont
= GetFont().GetResourceHandle();
884 wxASSERT_MSG( hFont
, wxT("should have valid font") );
886 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
891 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
893 if ( !wxWindowBase::SetCursor(cursor
) )
899 // don't "overwrite" busy cursor
900 if ( m_cursor
.Ok() && !wxIsBusy() )
902 // normally we should change the cursor only if it's over this window
903 // but we should do it always if we capture the mouse currently
904 bool set
= HasCapture();
907 HWND hWnd
= GetHwnd();
911 ::GetCursorPosWinCE(&point
);
913 ::GetCursorPos(&point
);
916 RECT rect
= wxGetWindowRect(hWnd
);
918 set
= ::PtInRect(&rect
, point
) != 0;
923 ::SetCursor(GetHcursorOf(m_cursor
));
925 //else: will be set later when the mouse enters this window
931 void wxWindowMSW::WarpPointer(int x
, int y
)
933 ClientToScreen(&x
, &y
);
935 if ( !::SetCursorPos(x
, y
) )
937 wxLogLastError(_T("SetCursorPos"));
941 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
943 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
944 // to use it on older systems -- and could possibly do some harm
945 static int s_needToUpdate
= -1;
946 if ( s_needToUpdate
== -1 )
949 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
953 if ( s_needToUpdate
)
955 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
956 // won't send WM_UPDATEUISTATE
957 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
961 // ---------------------------------------------------------------------------
963 // ---------------------------------------------------------------------------
965 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
967 #ifdef __WXMICROWIN__
968 return ::GetScrollPosWX(hWnd
, wOrient
);
970 WinStruct
<SCROLLINFO
> scrollInfo
;
971 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
972 scrollInfo
.fMask
= SIF_POS
;
973 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
975 return scrollInfo
.nPos
;
980 int wxWindowMSW::GetScrollPos(int orient
) const
982 HWND hWnd
= GetHwnd();
983 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
985 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
988 // This now returns the whole range, not just the number
989 // of positions that we can scroll.
990 int wxWindowMSW::GetScrollRange(int orient
) const
993 HWND hWnd
= GetHwnd();
997 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1000 WinStruct
<SCROLLINFO
> scrollInfo
;
1001 scrollInfo
.fMask
= SIF_RANGE
;
1002 if ( !::GetScrollInfo(hWnd
,
1003 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1006 // Most of the time this is not really an error, since the return
1007 // value can also be zero when there is no scrollbar yet.
1008 // wxLogLastError(_T("GetScrollInfo"));
1010 maxPos
= scrollInfo
.nMax
;
1012 // undo "range - 1" done in SetScrollbar()
1016 int wxWindowMSW::GetScrollThumb(int orient
) const
1018 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
1021 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
1023 HWND hWnd
= GetHwnd();
1024 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
1026 WinStruct
<SCROLLINFO
> info
;
1030 info
.fMask
= SIF_POS
;
1031 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1033 // disable scrollbar instead of removing it then
1034 info
.fMask
|= SIF_DISABLENOSCROLL
;
1037 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1041 // New function that will replace some of the above.
1042 void wxWindowMSW::SetScrollbar(int orient
,
1048 WinStruct
<SCROLLINFO
> info
;
1049 info
.nPage
= pageSize
;
1050 info
.nMin
= 0; // range is nMax - nMin + 1
1051 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1053 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1054 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1056 // disable scrollbar instead of removing it then
1057 info
.fMask
|= SIF_DISABLENOSCROLL
;
1060 HWND hWnd
= GetHwnd();
1063 // We have to set the variables here to make them valid in events
1064 // triggered by ::SetScrollInfo()
1065 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1067 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1072 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1078 wxCopyRectToRECT(*prect
, rect
);
1088 // FIXME: is this the exact equivalent of the line below?
1089 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1091 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1095 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1097 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1100 for ( int n
= 0; n
< count
; n
++ )
1102 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1104 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1105 if ( posNew
== pos
)
1107 // don't bother to continue, we're already at top/bottom
1114 return pos
!= posStart
;
1117 bool wxWindowMSW::ScrollLines(int lines
)
1119 bool down
= lines
> 0;
1121 return ScrollVertically(GetHwnd(),
1122 down
? SB_LINEDOWN
: SB_LINEUP
,
1123 down
? lines
: -lines
);
1126 bool wxWindowMSW::ScrollPages(int pages
)
1128 bool down
= pages
> 0;
1130 return ScrollVertically(GetHwnd(),
1131 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1132 down
? pages
: -pages
);
1135 // ----------------------------------------------------------------------------
1137 // ----------------------------------------------------------------------------
1139 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1144 wxCHECK_RET( GetHwnd(),
1145 _T("layout direction must be set after window creation") );
1147 LONG styleOld
= wxGetWindowExStyle(this);
1149 LONG styleNew
= styleOld
;
1152 case wxLayout_LeftToRight
:
1153 styleNew
&= ~WS_EX_LAYOUTRTL
;
1156 case wxLayout_RightToLeft
:
1157 styleNew
|= WS_EX_LAYOUTRTL
;
1161 wxFAIL_MSG(_T("unsupported layout direction"));
1165 if ( styleNew
!= styleOld
)
1167 wxSetWindowExStyle(this, styleNew
);
1172 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1175 return wxLayout_Default
;
1177 wxCHECK_MSG( GetHwnd(), wxLayout_Default
, _T("invalid window") );
1179 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL
) ? wxLayout_RightToLeft
1180 : wxLayout_LeftToRight
;
1185 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1186 wxCoord
WXUNUSED(width
),
1187 wxCoord
WXUNUSED(widthTotal
)) const
1189 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1190 // redo it ourselves
1194 // ---------------------------------------------------------------------------
1196 // ---------------------------------------------------------------------------
1198 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1200 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1202 HWND hwnd
= (HWND
)hWnd
;
1203 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1207 wxAssociateWinWithHandle(hwnd
, this);
1209 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1211 // we don't need to subclass the window of our own class (in the Windows
1212 // sense of the word)
1213 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1215 wxSetWindowProc(hwnd
, wxWndProc
);
1219 // don't bother restoring it either: this also makes it easy to
1220 // implement IsOfStandardClass() method which returns true for the
1221 // standard controls and false for the wxWidgets own windows as it can
1222 // simply check m_oldWndProc
1223 m_oldWndProc
= NULL
;
1226 // we're officially created now, send the event
1227 wxWindowCreateEvent
event((wxWindow
*)this);
1228 (void)HandleWindowEvent(event
);
1231 void wxWindowMSW::UnsubclassWin()
1233 wxRemoveHandleAssociation(this);
1235 // Restore old Window proc
1236 HWND hwnd
= GetHwnd();
1241 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1245 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1247 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1250 m_oldWndProc
= NULL
;
1255 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1259 if ( !::DestroyWindow(GetHwnd()) )
1260 wxLogLastError(wxT("DestroyWindow"));
1263 WXHWND wxhwnd
= (WXHWND
)handle
;
1265 // this also calls SetHWND(wxhwnd)
1266 SubclassWin(wxhwnd
);
1269 void wxWindowMSW::DissociateHandle()
1271 // this also calls SetHWND(0) for us
1276 bool wxCheckWindowWndProc(WXHWND hWnd
,
1277 WXFARPROC
WXUNUSED(wndProc
))
1279 // TODO: This list of window class names should be factored out so they can be
1280 // managed in one place and then accessed from here and other places, such as
1281 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1284 extern wxChar
*wxCanvasClassName
;
1285 extern wxChar
*wxCanvasClassNameNR
;
1287 extern const wxChar
*wxCanvasClassName
;
1288 extern const wxChar
*wxCanvasClassNameNR
;
1290 extern const wxChar
*wxMDIFrameClassName
;
1291 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1292 extern const wxChar
*wxMDIChildFrameClassName
;
1293 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1294 wxString
str(wxGetWindowClass(hWnd
));
1295 if (str
== wxCanvasClassName
||
1296 str
== wxCanvasClassNameNR
||
1298 str
== _T("wxGLCanvasClass") ||
1299 str
== _T("wxGLCanvasClassNR") ||
1300 #endif // wxUSE_GLCANVAS
1301 str
== wxMDIFrameClassName
||
1302 str
== wxMDIFrameClassNameNoRedraw
||
1303 str
== wxMDIChildFrameClassName
||
1304 str
== wxMDIChildFrameClassNameNoRedraw
||
1305 str
== _T("wxTLWHiddenParent"))
1306 return true; // Effectively means don't subclass
1311 // ----------------------------------------------------------------------------
1313 // ----------------------------------------------------------------------------
1315 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1317 long flagsOld
= GetWindowStyleFlag();
1318 if ( flags
== flagsOld
)
1321 // update the internal variable
1322 wxWindowBase::SetWindowStyleFlag(flags
);
1324 // and the real window flags
1325 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1328 void wxWindowMSW::SetExtraStyle(long exflags
)
1330 long exflagsOld
= GetExtraStyle();
1331 if ( exflags
== exflagsOld
)
1334 // update the internal variable
1335 wxWindowBase::SetExtraStyle(exflags
);
1337 // and the real window flags
1338 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1341 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1343 // now update the Windows style as well if needed - and if the window had
1344 // been already created
1348 // we may need to call SetWindowPos() when we change some styles
1349 bool callSWP
= false;
1352 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1354 // this is quite a horrible hack but we need it because MSWGetStyle()
1355 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1356 // and so we have to modify the window exflags temporarily to get the
1357 // correct exstyleOld
1358 long exflagsNew
= GetExtraStyle();
1359 wxWindowBase::SetExtraStyle(exflagsOld
);
1362 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1364 wxWindowBase::SetExtraStyle(exflagsNew
);
1367 if ( style
!= styleOld
)
1369 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1370 // this function so instead of simply setting the style to the new
1371 // value we clear the bits which were set in styleOld but are set in
1372 // the new one and set the ones which were not set before
1373 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1374 styleReal
&= ~styleOld
;
1377 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1379 // we need to call SetWindowPos() if any of the styles affecting the
1380 // frame appearance have changed
1381 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1390 // and the extended style
1391 long exstyleReal
= wxGetWindowExStyle(this);
1393 if ( exstyle
!= exstyleOld
)
1395 exstyleReal
&= ~exstyleOld
;
1396 exstyleReal
|= exstyle
;
1398 wxSetWindowExStyle(this, exstyleReal
);
1400 // ex style changes don't take effect without calling SetWindowPos
1406 // we must call SetWindowPos() to flush the cached extended style and
1407 // also to make the change to wxSTAY_ON_TOP style take effect: just
1408 // setting the style simply doesn't work
1409 if ( !::SetWindowPos(GetHwnd(),
1410 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1413 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1415 wxLogLastError(_T("SetWindowPos"));
1420 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1422 return wxBORDER_THEME
;
1425 wxBorder
wxWindowMSW::GetDefaultBorder() const
1427 return wxWindowBase::GetDefaultBorder();
1430 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1431 // that makes most sense for this Windows environment
1432 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1434 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1435 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1436 return wxBORDER_SIMPLE
;
1438 return wxBORDER_NONE
;
1441 if (border
== wxBORDER_THEME
)
1443 if (CanApplyThemeBorder())
1445 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1447 return wxBORDER_THEME
;
1449 return wxBORDER_SUNKEN
;
1457 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1459 // translate common wxWidgets styles to Windows ones
1461 // most of windows are child ones, those which are not (such as
1462 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1463 WXDWORD style
= WS_CHILD
;
1465 // using this flag results in very significant reduction in flicker,
1466 // especially with controls inside the static boxes (as the interior of the
1467 // box is not redrawn twice), but sometimes results in redraw problems, so
1468 // optionally allow the old code to continue to use it provided a special
1469 // system option is turned on
1470 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1471 || (flags
& wxCLIP_CHILDREN
) )
1472 style
|= WS_CLIPCHILDREN
;
1474 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1475 // don't support overlapping windows and it only makes sense for them and,
1476 // presumably, gives the system some extra work (to manage more clipping
1477 // regions), so avoid it alltogether
1480 if ( flags
& wxVSCROLL
)
1481 style
|= WS_VSCROLL
;
1483 if ( flags
& wxHSCROLL
)
1484 style
|= WS_HSCROLL
;
1486 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1488 // After translation, border is now optimized for the specific version of Windows
1489 // and theme engine presence.
1491 // WS_BORDER is only required for wxBORDER_SIMPLE
1492 if ( border
== wxBORDER_SIMPLE
)
1495 // now deal with ext style if the caller wants it
1501 if ( flags
& wxTRANSPARENT_WINDOW
)
1502 *exstyle
|= WS_EX_TRANSPARENT
;
1508 case wxBORDER_DEFAULT
:
1509 wxFAIL_MSG( _T("unknown border style") );
1513 case wxBORDER_SIMPLE
:
1514 case wxBORDER_THEME
:
1517 case wxBORDER_STATIC
:
1518 *exstyle
|= WS_EX_STATICEDGE
;
1521 case wxBORDER_RAISED
:
1522 *exstyle
|= WS_EX_DLGMODALFRAME
;
1525 case wxBORDER_SUNKEN
:
1526 *exstyle
|= WS_EX_CLIENTEDGE
;
1527 style
&= ~WS_BORDER
;
1530 // case wxBORDER_DOUBLE:
1531 // *exstyle |= WS_EX_DLGMODALFRAME;
1535 // wxUniv doesn't use Windows dialog navigation functions at all
1536 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1537 // to make the dialog navigation work with the nested panels we must
1538 // use this style (top level windows such as dialogs don't need it)
1539 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1541 *exstyle
|= WS_EX_CONTROLPARENT
;
1543 #endif // __WXUNIVERSAL__
1549 // Setup background and foreground colours correctly
1550 void wxWindowMSW::SetupColours()
1553 SetBackgroundColour(GetParent()->GetBackgroundColour());
1556 bool wxWindowMSW::IsMouseInWindow() const
1558 // get the mouse position
1561 ::GetCursorPosWinCE(&pt
);
1563 ::GetCursorPos(&pt
);
1566 // find the window which currently has the cursor and go up the window
1567 // chain until we find this window - or exhaust it
1568 HWND hwnd
= ::WindowFromPoint(pt
);
1569 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1570 hwnd
= ::GetParent(hwnd
);
1572 return hwnd
!= NULL
;
1575 void wxWindowMSW::OnInternalIdle()
1577 #ifndef HAVE_TRACKMOUSEEVENT
1578 // Check if we need to send a LEAVE event
1579 if ( m_mouseInWindow
)
1581 // note that we should generate the leave event whether the window has
1582 // or doesn't have mouse capture
1583 if ( !IsMouseInWindow() )
1585 GenerateMouseLeave();
1588 #endif // !HAVE_TRACKMOUSEEVENT
1590 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1591 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1594 // Set this window to be the child of 'parent'.
1595 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1597 if ( !wxWindowBase::Reparent(parent
) )
1600 HWND hWndChild
= GetHwnd();
1601 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1603 ::SetParent(hWndChild
, hWndParent
);
1606 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT
) )
1608 EnsureParentHasControlParentStyle(GetParent());
1610 #endif // !__WXWINCE__
1615 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1617 #ifndef __WXMICROWIN__
1618 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1622 void wxWindowMSW::DoFreeze()
1625 return; // no point in freezing hidden window
1627 SendSetRedraw(GetHwnd(), false);
1630 void wxWindowMSW::DoThaw()
1633 return; // hidden windows aren't frozen by DoFreeze
1635 SendSetRedraw(GetHwnd(), true);
1637 // we need to refresh everything or otherwise the invalidated area
1638 // is not going to be repainted
1642 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1644 HWND hWnd
= GetHwnd();
1651 wxCopyRectToRECT(*rect
, mswRect
);
1659 // RedrawWindow not available on SmartPhone or eVC++ 3
1660 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1661 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1665 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1667 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1672 void wxWindowMSW::Update()
1674 if ( !::UpdateWindow(GetHwnd()) )
1676 wxLogLastError(_T("UpdateWindow"));
1679 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1680 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1681 // handler needs to be really drawn right now
1686 // ---------------------------------------------------------------------------
1688 // ---------------------------------------------------------------------------
1690 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1694 // we need to lower the sibling static boxes so controls contained within can be
1696 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1698 // no sibling static boxes if we have no parent (ie TLW)
1702 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1704 node
= node
->GetNext() )
1706 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1709 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1710 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1715 #else // !wxUSE_STATBOX
1717 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1721 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1723 #endif // drag and drop is used
1725 #if wxUSE_DRAG_AND_DROP
1726 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1728 if ( m_dropTarget
!= 0 ) {
1729 m_dropTarget
->Revoke(m_hWnd
);
1730 delete m_dropTarget
;
1733 m_dropTarget
= pDropTarget
;
1734 if ( m_dropTarget
!= 0 )
1736 AdjustStaticBoxZOrder(GetParent());
1737 m_dropTarget
->Register(m_hWnd
);
1740 #endif // wxUSE_DRAG_AND_DROP
1742 // old-style file manager drag&drop support: we retain the old-style
1743 // DragAcceptFiles in parallel with SetDropTarget.
1744 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1747 HWND hWnd
= GetHwnd();
1750 AdjustStaticBoxZOrder(GetParent());
1751 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1756 // ----------------------------------------------------------------------------
1758 // ----------------------------------------------------------------------------
1762 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1764 wxWindowBase::DoSetToolTip(tooltip
);
1767 m_tooltip
->SetWindow((wxWindow
*)this);
1770 #endif // wxUSE_TOOLTIPS
1772 // ---------------------------------------------------------------------------
1773 // moving and resizing
1774 // ---------------------------------------------------------------------------
1776 bool wxWindowMSW::IsSizeDeferred() const
1778 #if USE_DEFERRED_SIZING
1779 if ( m_pendingPosition
!= wxDefaultPosition
||
1780 m_pendingSize
!= wxDefaultSize
)
1782 #endif // USE_DEFERRED_SIZING
1788 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1790 #if USE_DEFERRED_SIZING
1791 // if SetSize() had been called at wx level but not realized at Windows
1792 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1793 // the new and not the old position to the other wx code
1794 if ( m_pendingSize
!= wxDefaultSize
)
1797 *x
= m_pendingSize
.x
;
1799 *y
= m_pendingSize
.y
;
1801 else // use current size
1802 #endif // USE_DEFERRED_SIZING
1804 RECT rect
= wxGetWindowRect(GetHwnd());
1807 *x
= rect
.right
- rect
.left
;
1809 *y
= rect
.bottom
- rect
.top
;
1813 // Get size *available for subwindows* i.e. excluding menu bar etc.
1814 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1816 #if USE_DEFERRED_SIZING
1817 if ( m_pendingSize
!= wxDefaultSize
)
1819 // we need to calculate the client size corresponding to pending size
1821 rect
.left
= m_pendingPosition
.x
;
1822 rect
.top
= m_pendingPosition
.y
;
1823 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1824 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1826 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1829 *x
= rect
.right
- rect
.left
;
1831 *y
= rect
.bottom
- rect
.top
;
1834 #endif // USE_DEFERRED_SIZING
1836 RECT rect
= wxGetClientRect(GetHwnd());
1845 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1847 wxWindow
* const parent
= GetParent();
1850 if ( m_pendingPosition
!= wxDefaultPosition
)
1852 pos
= m_pendingPosition
;
1854 else // use current position
1856 RECT rect
= wxGetWindowRect(GetHwnd());
1859 point
.x
= rect
.left
;
1862 // we do the adjustments with respect to the parent only for the "real"
1863 // children, not for the dialogs/frames
1864 if ( !IsTopLevel() )
1866 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1868 // In RTL mode, we want the logical left x-coordinate,
1869 // which would be the physical right x-coordinate.
1870 point
.x
= rect
.right
;
1873 // Since we now have the absolute screen coords, if there's a
1874 // parent we must subtract its top left corner
1877 ::ScreenToClient(GetHwndOf(parent
), &point
);
1885 // we also must adjust by the client area offset: a control which is just
1886 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1887 if ( parent
&& !IsTopLevel() )
1889 const wxPoint
pt(parent
->GetClientAreaOrigin());
1900 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1908 ::ScreenToClient(GetHwnd(), &pt
);
1916 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1924 ::ClientToScreen(GetHwnd(), &pt
);
1933 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1935 #if USE_DEFERRED_SIZING
1936 // if our parent had prepared a defer window handle for us, use it (unless
1937 // we are a top level window)
1938 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1940 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1943 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1944 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1947 wxLogLastError(_T("DeferWindowPos"));
1953 // hdwp must be updated as it may have been changed
1954 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1959 // did deferred move, remember new coordinates of the window as they're
1960 // different from what Windows would return for it
1964 // otherwise (or if deferring failed) move the window in place immediately
1965 #endif // USE_DEFERRED_SIZING
1966 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1968 wxLogLastError(wxT("MoveWindow"));
1971 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1972 // ignored otherwise
1976 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1978 // TODO: is this consistent with other platforms?
1979 // Still, negative width or height shouldn't be allowed
1985 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1987 #if USE_DEFERRED_SIZING
1988 m_pendingPosition
= wxPoint(x
, y
);
1989 m_pendingSize
= wxSize(width
, height
);
1991 else // window was moved immediately, without deferring it
1993 m_pendingPosition
= wxDefaultPosition
;
1994 m_pendingSize
= wxDefaultSize
;
1995 #endif // USE_DEFERRED_SIZING
1999 // set the size of the window: if the dimensions are positive, just use them,
2000 // but if any of them is equal to -1, it means that we must find the value for
2001 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
2002 // which case -1 is a valid value for x and y)
2004 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
2005 // the width/height to best suit our contents, otherwise we reuse the current
2007 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
2009 // get the current size and position...
2010 int currentX
, currentY
;
2011 int currentW
, currentH
;
2013 GetPosition(¤tX
, ¤tY
);
2014 GetSize(¤tW
, ¤tH
);
2016 // ... and don't do anything (avoiding flicker) if it's already ok unless
2017 // we're forced to resize the window
2018 if ( x
== currentX
&& y
== currentY
&&
2019 width
== currentW
&& height
== currentH
&&
2020 !(sizeFlags
& wxSIZE_FORCE
) )
2025 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2027 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2030 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2032 wxSize size
= wxDefaultSize
;
2033 if ( width
== wxDefaultCoord
)
2035 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2037 size
= DoGetBestSize();
2042 // just take the current one
2047 if ( height
== wxDefaultCoord
)
2049 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2051 if ( size
.x
== wxDefaultCoord
)
2053 size
= DoGetBestSize();
2055 //else: already called DoGetBestSize() above
2061 // just take the current one
2066 DoMoveWindow(x
, y
, width
, height
);
2069 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2071 // setting the client size is less obvious than it could have been
2072 // because in the result of changing the total size the window scrollbar
2073 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2074 // doesn't take neither into account) and so the client size will not be
2075 // correct as the difference between the total and client size changes --
2076 // so we keep changing it until we get it right
2078 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2079 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2080 // may become 3 if the window had 0 size originally and so we didn't
2081 // calculate the scrollbar correction correctly during the first iteration)
2082 // but just to be on the safe side we check for it instead of making it an
2083 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2084 for ( int i
= 0; i
< 4; i
++ )
2087 ::GetClientRect(GetHwnd(), &rectClient
);
2089 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2090 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2091 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2096 // Find the difference between the entire window (title bar and all)
2097 // and the client area; add this to the new client size to move the
2100 ::GetWindowRect(GetHwnd(), &rectWin
);
2102 const int widthWin
= rectWin
.right
- rectWin
.left
,
2103 heightWin
= rectWin
.bottom
- rectWin
.top
;
2105 // MoveWindow positions the child windows relative to the parent, so
2106 // adjust if necessary
2107 if ( !IsTopLevel() )
2109 wxWindow
*parent
= GetParent();
2112 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2116 // don't call DoMoveWindow() because we want to move window immediately
2117 // and not defer it here as otherwise the value returned by
2118 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2120 if ( !::MoveWindow(GetHwnd(),
2123 width
+ widthWin
- rectClient
.right
,
2124 height
+ heightWin
- rectClient
.bottom
,
2127 wxLogLastError(_T("MoveWindow"));
2132 // ---------------------------------------------------------------------------
2134 // ---------------------------------------------------------------------------
2136 int wxWindowMSW::GetCharHeight() const
2138 return wxGetTextMetrics(this).tmHeight
;
2141 int wxWindowMSW::GetCharWidth() const
2143 // +1 is needed because Windows apparently adds it when calculating the
2144 // dialog units size in pixels
2145 #if wxDIALOG_UNIT_COMPATIBILITY
2146 return wxGetTextMetrics(this).tmAveCharWidth
;
2148 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2152 void wxWindowMSW::GetTextExtent(const wxString
& string
,
2154 int *descent
, int *externalLeading
,
2155 const wxFont
*fontToUse
) const
2157 wxASSERT_MSG( !fontToUse
|| fontToUse
->Ok(),
2158 _T("invalid font in GetTextExtent()") );
2162 hfontToUse
= GetHfontOf(*fontToUse
);
2164 hfontToUse
= GetHfontOf(GetFont());
2166 WindowHDC
hdc(GetHwnd());
2167 SelectInHDC
selectFont(hdc
, hfontToUse
);
2171 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2172 GetTextMetrics(hdc
, &tm
);
2179 *descent
= tm
.tmDescent
;
2180 if ( externalLeading
)
2181 *externalLeading
= tm
.tmExternalLeading
;
2184 // ---------------------------------------------------------------------------
2186 // ---------------------------------------------------------------------------
2188 #if wxUSE_MENUS_NATIVE
2190 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2191 // immediately, without waiting for the next event loop iteration
2193 // NB: this function should probably be made public later as it can almost
2194 // surely replace wxYield() elsewhere as well
2195 static void wxYieldForCommandsOnly()
2197 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2198 // want to process it here)
2200 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2202 if ( msg
.message
== WM_QUIT
)
2204 // if we retrieved a WM_QUIT, insert back into the message queue.
2205 ::PostQuitMessage(0);
2209 // luckily (as we don't have access to wxEventLoopImpl method from here
2210 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2212 ::TranslateMessage(&msg
);
2213 ::DispatchMessage(&msg
);
2217 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2219 menu
->SetInvokingWindow(this);
2222 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2224 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2225 x
= mouse
.x
; y
= mouse
.y
;
2228 HWND hWnd
= GetHwnd();
2229 HMENU hMenu
= GetHmenuOf(menu
);
2233 ::ClientToScreen(hWnd
, &point
);
2234 #if defined(__WXWINCE__)
2235 static const UINT flags
= 0;
2236 #else // !__WXWINCE__
2237 UINT flags
= TPM_RIGHTBUTTON
;
2238 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2239 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2240 // side and not to use it there neither -- modify the test if it does work
2242 if ( wxGetWinVersion() >= wxWinVersion_5
)
2244 // using TPM_RECURSE allows us to show a popup menu while another menu
2245 // is opened which can be useful and is supported by the other
2246 // platforms, so allow it under Windows too
2247 flags
|= TPM_RECURSE
;
2249 #endif // __WXWINCE__/!__WXWINCE__
2251 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2253 // we need to do it right now as otherwise the events are never going to be
2254 // sent to wxCurrentPopupMenu from HandleCommand()
2256 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2257 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2258 // destroyed as soon as we return (it can be a local variable in the caller
2259 // for example) and so we do need to process the event immediately
2260 wxYieldForCommandsOnly();
2262 menu
->SetInvokingWindow(NULL
);
2267 #endif // wxUSE_MENUS_NATIVE
2269 // ===========================================================================
2270 // pre/post message processing
2271 // ===========================================================================
2273 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2276 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2278 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2281 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2283 // wxUniversal implements tab traversal itself
2284 #ifndef __WXUNIVERSAL__
2285 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2287 // intercept dialog navigation keys
2288 MSG
*msg
= (MSG
*)pMsg
;
2290 // here we try to do all the job which ::IsDialogMessage() usually does
2292 if ( msg
->message
== WM_KEYDOWN
)
2294 bool bCtrlDown
= wxIsCtrlDown();
2295 bool bShiftDown
= wxIsShiftDown();
2297 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2298 // don't process it if it's the case (except for Ctrl-Tab/Enter
2299 // combinations which are always processed)
2300 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2302 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2303 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2304 // it, of course, implies them
2305 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2307 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2310 bool bForward
= true,
2311 bWindowChange
= false,
2314 // should we process this message specially?
2315 bool bProcess
= true;
2316 switch ( msg
->wParam
)
2319 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2321 // let the control have the TAB
2324 else // use it for navigation
2326 // Ctrl-Tab cycles thru notebook pages
2327 bWindowChange
= bCtrlDown
;
2328 bForward
= !bShiftDown
;
2335 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2343 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2352 // we treat PageUp/Dn as arrows because chances are that
2353 // a control which needs arrows also needs them for
2354 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2355 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2357 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2358 bWindowChange
= true;
2364 // currently active button should get enter press even
2365 // if there is a default button elsewhere so check if
2366 // this window is a button first
2367 wxWindow
*btn
= NULL
;
2368 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2370 // let IsDialogMessage() handle this for all
2371 // buttons except the owner-drawn ones which it
2372 // just seems to ignore
2373 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2374 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2376 // emulate the button click
2377 btn
= wxFindWinFromHandle(msg
->hwnd
);
2382 else // not a button itself, do we have default button?
2384 // check if this window or any of its ancestors
2385 // wants the message for itself (we always reserve
2386 // Ctrl-Enter for dialog navigation though)
2387 wxWindow
*win
= this;
2390 // this will contain the dialog code of this
2391 // window and all of its parent windows in turn
2392 LONG lDlgCode2
= lDlgCode
;
2396 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2398 // as it wants to process Enter itself,
2399 // don't call IsDialogMessage() which
2404 // don't propagate keyboard messages beyond
2405 // the first top level window parent
2406 if ( win
->IsTopLevel() )
2409 win
= win
->GetParent();
2411 lDlgCode2
= ::SendMessage
2422 win
= wxGetTopLevelParent(win
);
2425 wxTopLevelWindow
* const
2426 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2429 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2434 if ( btn
&& btn
->IsEnabled() )
2436 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2440 #endif // wxUSE_BUTTON
2443 // map Enter presses into button presses on PDAs
2444 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2445 event
.SetEventObject(this);
2446 if ( HandleWindowEvent(event
) )
2448 #endif // __WXWINCE__
2458 wxNavigationKeyEvent event
;
2459 event
.SetDirection(bForward
);
2460 event
.SetWindowChange(bWindowChange
);
2461 event
.SetFromTab(bFromTab
);
2462 event
.SetEventObject(this);
2464 if ( HandleWindowEvent(event
) )
2466 // as we don't call IsDialogMessage(), which would take of
2467 // this by default, we need to manually send this message
2468 // so that controls can change their UI state if needed
2469 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2476 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2478 // IsDialogMessage() did something...
2482 #endif // __WXUNIVERSAL__
2487 // relay mouse move events to the tooltip control
2488 MSG
*msg
= (MSG
*)pMsg
;
2489 if ( msg
->message
== WM_MOUSEMOVE
)
2490 wxToolTip::RelayEvent(pMsg
);
2492 #endif // wxUSE_TOOLTIPS
2497 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2499 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2500 return m_acceleratorTable
.Translate(this, pMsg
);
2504 #endif // wxUSE_ACCEL
2507 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2509 // all tests below have to deal with various bugs/misfeatures of
2510 // IsDialogMessage(): we have to prevent it from being called from our
2511 // MSWProcessMessage() in some situations
2513 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2514 // message even when there is no cancel button and when the message is
2515 // needed by the control itself: in particular, it prevents the tree in
2516 // place edit control from being closed with Escape in a dialog
2517 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2522 // ::IsDialogMessage() is broken and may sometimes hang the application by
2523 // going into an infinite loop when it tries to find the control to give
2524 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2525 // situations when this may happen and not call it then
2526 if ( msg
->message
!= WM_SYSCHAR
)
2529 // assume we can call it by default
2530 bool canSafelyCallIsDlgMsg
= true;
2532 HWND hwndFocus
= ::GetFocus();
2534 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2535 // ::IsDialogMessage() will also enter an infinite loop, because it will
2536 // recursively check the child windows but not the window itself and so if
2537 // none of the children accepts focus it loops forever (as it only stops
2538 // when it gets back to the window it started from)
2540 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2541 // style has the focus, it can happen. One such possibility is if
2542 // all windows are either toplevel, wxDialog, wxPanel or static
2543 // controls and no window can actually accept keyboard input.
2544 #if !defined(__WXWINCE__)
2545 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2547 // pessimistic by default
2548 canSafelyCallIsDlgMsg
= false;
2549 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2551 node
= node
->GetNext() )
2553 wxWindow
* const win
= node
->GetData();
2554 if ( win
->CanAcceptFocus() &&
2555 !wxHasWindowExStyle(win
, WS_EX_CONTROLPARENT
) )
2557 // it shouldn't hang...
2558 canSafelyCallIsDlgMsg
= true;
2564 #endif // !__WXWINCE__
2566 if ( canSafelyCallIsDlgMsg
)
2568 // ::IsDialogMessage() can enter in an infinite loop when the
2569 // currently focused window is disabled or hidden and its
2570 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2574 if ( !::IsWindowEnabled(hwndFocus
) ||
2575 !::IsWindowVisible(hwndFocus
) )
2577 // it would enter an infinite loop if we do this!
2578 canSafelyCallIsDlgMsg
= false;
2583 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2585 // it's a top level window, don't go further -- e.g. even
2586 // if the parent of a dialog is disabled, this doesn't
2587 // break navigation inside the dialog
2591 hwndFocus
= ::GetParent(hwndFocus
);
2595 return canSafelyCallIsDlgMsg
;
2598 // ---------------------------------------------------------------------------
2599 // message params unpackers
2600 // ---------------------------------------------------------------------------
2602 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2603 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2605 *id
= LOWORD(wParam
);
2606 *hwnd
= (WXHWND
)lParam
;
2607 *cmd
= HIWORD(wParam
);
2610 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2611 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2613 *state
= LOWORD(wParam
);
2614 *minimized
= HIWORD(wParam
);
2615 *hwnd
= (WXHWND
)lParam
;
2618 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2619 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2621 *code
= LOWORD(wParam
);
2622 *pos
= HIWORD(wParam
);
2623 *hwnd
= (WXHWND
)lParam
;
2626 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2627 WXHDC
*hdc
, WXHWND
*hwnd
)
2629 *hwnd
= (WXHWND
)lParam
;
2630 *hdc
= (WXHDC
)wParam
;
2633 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2634 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2636 *item
= (WXWORD
)wParam
;
2637 *flags
= HIWORD(wParam
);
2638 *hmenu
= (WXHMENU
)lParam
;
2641 // ---------------------------------------------------------------------------
2642 // Main wxWidgets window proc and the window proc for wxWindow
2643 // ---------------------------------------------------------------------------
2645 // Hook for new window just as it's being created, when the window isn't yet
2646 // associated with the handle
2647 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2649 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2650 // window being created and insures that it's always unset back later
2651 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2653 gs_winBeingCreated
= winBeingCreated
;
2656 wxWindowCreationHook::~wxWindowCreationHook()
2658 gs_winBeingCreated
= NULL
;
2662 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2664 // trace all messages - useful for the debugging
2666 wxLogTrace(wxTraceMessages
,
2667 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2668 wxGetMessageName(message
), hWnd
, (long)wParam
, lParam
);
2669 #endif // __WXDEBUG__
2671 wxWindowMSW
*wnd
= wxFindWinFromHandle(hWnd
);
2673 // when we get the first message for the HWND we just created, we associate
2674 // it with wxWindow stored in gs_winBeingCreated
2675 if ( !wnd
&& gs_winBeingCreated
)
2677 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2678 wnd
= gs_winBeingCreated
;
2679 gs_winBeingCreated
= NULL
;
2680 wnd
->SetHWND((WXHWND
)hWnd
);
2685 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2686 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2688 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2693 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2695 // did we process the message?
2696 bool processed
= false;
2706 // for most messages we should return 0 when we do process the message
2714 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2717 // return 0 to allow window creation
2718 rc
.result
= mayCreate
? 0 : -1;
2724 // never set processed to true and *always* pass WM_DESTROY to
2725 // DefWindowProc() as Windows may do some internal cleanup when
2726 // processing it and failing to pass the message along may cause
2727 // memory and resource leaks!
2728 (void)HandleDestroy();
2732 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2736 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2739 #if !defined(__WXWINCE__)
2742 LPRECT pRect
= (LPRECT
)lParam
;
2744 rc
.SetLeft(pRect
->left
);
2745 rc
.SetTop(pRect
->top
);
2746 rc
.SetRight(pRect
->right
);
2747 rc
.SetBottom(pRect
->bottom
);
2748 processed
= HandleMoving(rc
);
2750 pRect
->left
= rc
.GetLeft();
2751 pRect
->top
= rc
.GetTop();
2752 pRect
->right
= rc
.GetRight();
2753 pRect
->bottom
= rc
.GetBottom();
2758 case WM_ENTERSIZEMOVE
:
2760 processed
= HandleEnterSizeMove();
2764 case WM_EXITSIZEMOVE
:
2766 processed
= HandleExitSizeMove();
2772 LPRECT pRect
= (LPRECT
)lParam
;
2774 rc
.SetLeft(pRect
->left
);
2775 rc
.SetTop(pRect
->top
);
2776 rc
.SetRight(pRect
->right
);
2777 rc
.SetBottom(pRect
->bottom
);
2778 processed
= HandleSizing(rc
);
2780 pRect
->left
= rc
.GetLeft();
2781 pRect
->top
= rc
.GetTop();
2782 pRect
->right
= rc
.GetRight();
2783 pRect
->bottom
= rc
.GetBottom();
2787 #endif // !__WXWINCE__
2789 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2790 case WM_ACTIVATEAPP
:
2791 // This implicitly sends a wxEVT_ACTIVATE_APP event
2792 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2798 WXWORD state
, minimized
;
2800 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2802 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2807 processed
= HandleSetFocus((WXHWND
)wParam
);
2811 processed
= HandleKillFocus((WXHWND
)wParam
);
2814 case WM_PRINTCLIENT
:
2815 processed
= HandlePrintClient((WXHDC
)wParam
);
2821 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2823 processed
= HandlePaint();
2827 processed
= HandlePaint();
2832 #ifdef __WXUNIVERSAL__
2833 // Universal uses its own wxFrame/wxDialog, so we don't receive
2834 // close events unless we have this.
2836 #endif // __WXUNIVERSAL__
2838 // don't let the DefWindowProc() destroy our window - we'll do it
2839 // ourselves in ~wxWindow
2845 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2849 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2850 GET_Y_LPARAM(lParam
),
2854 #ifdef HAVE_TRACKMOUSEEVENT
2856 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2858 if ( m_mouseInWindow
)
2860 GenerateMouseLeave();
2863 // always pass processed back as false, this allows the window
2864 // manager to process the message too. This is needed to
2865 // ensure windows XP themes work properly as the mouse moves
2866 // over widgets like buttons. So don't set processed to true here.
2868 #endif // HAVE_TRACKMOUSEEVENT
2870 #if wxUSE_MOUSEWHEEL
2872 processed
= HandleMouseWheel(wParam
, lParam
);
2876 case WM_LBUTTONDOWN
:
2878 case WM_LBUTTONDBLCLK
:
2879 case WM_RBUTTONDOWN
:
2881 case WM_RBUTTONDBLCLK
:
2882 case WM_MBUTTONDOWN
:
2884 case WM_MBUTTONDBLCLK
:
2885 #ifdef wxHAS_XBUTTON
2886 case WM_XBUTTONDOWN
:
2888 case WM_XBUTTONDBLCLK
:
2889 #endif // wxHAS_XBUTTON
2891 #ifdef __WXMICROWIN__
2892 // MicroWindows seems to ignore the fact that a window is
2893 // disabled. So catch mouse events and throw them away if
2895 wxWindowMSW
* win
= this;
2898 if (!win
->IsEnabled())
2904 win
= win
->GetParent();
2905 if ( !win
|| win
->IsTopLevel() )
2912 #endif // __WXMICROWIN__
2913 int x
= GET_X_LPARAM(lParam
),
2914 y
= GET_Y_LPARAM(lParam
);
2917 // redirect the event to a static control if necessary by
2918 // finding one under mouse because under CE the static controls
2919 // don't generate mouse events (even with SS_NOTIFY)
2921 if ( GetCapture() == this )
2923 // but don't do it if the mouse is captured by this window
2924 // because then it should really get this event itself
2929 win
= FindWindowForMouseEvent(this, &x
, &y
);
2931 // this should never happen
2932 wxCHECK_MSG( win
, 0,
2933 _T("FindWindowForMouseEvent() returned NULL") );
2936 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2938 SHRGINFO shrgi
= {0};
2940 shrgi
.cbSize
= sizeof(SHRGINFO
);
2941 shrgi
.hwndClient
= (HWND
) GetHWND();
2945 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2946 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2948 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2951 pt
= ClientToScreen(pt
);
2953 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2955 evtCtx
.SetEventObject(this);
2956 if (HandleWindowEvent(evtCtx
))
2965 #else // !__WXWINCE__
2966 wxWindowMSW
*win
= this;
2967 #endif // __WXWINCE__/!__WXWINCE__
2969 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2971 // if the app didn't eat the event, handle it in the default
2972 // way, that is by giving this window the focus
2975 // for the standard classes their WndProc sets the focus to
2976 // them anyhow and doing it from here results in some weird
2977 // problems, so don't do it for them (unnecessary anyhow)
2978 if ( !win
->IsOfStandardClass() )
2980 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
2992 case MM_JOY1BUTTONDOWN
:
2993 case MM_JOY2BUTTONDOWN
:
2994 case MM_JOY1BUTTONUP
:
2995 case MM_JOY2BUTTONUP
:
2996 processed
= HandleJoystickEvent(message
,
2997 GET_X_LPARAM(lParam
),
2998 GET_Y_LPARAM(lParam
),
3001 #endif // __WXMICROWIN__
3007 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
3009 processed
= HandleCommand(id
, cmd
, hwnd
);
3014 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
3017 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3018 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3019 // apparently doesn't always behave properly and needs some help
3020 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3021 case WM_NOTIFYFORMAT
:
3022 if ( lParam
== NF_QUERY
)
3025 rc
.result
= NFR_UNICODE
;
3028 #endif // wxUSE_UNICODE_MSLU
3030 // for these messages we must return true if process the message
3033 processed
= MSWOnDrawItem(wParam
, (WXDRAWITEMSTRUCT
*)lParam
);
3038 case WM_MEASUREITEM
:
3039 processed
= MSWOnMeasureItem(wParam
, (WXMEASUREITEMSTRUCT
*)lParam
);
3043 #endif // defined(WM_DRAWITEM)
3046 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3048 // we always want to get the char events
3049 rc
.result
= DLGC_WANTCHARS
;
3051 if ( HasFlag(wxWANTS_CHARS
) )
3053 // in fact, we want everything
3054 rc
.result
|= DLGC_WANTARROWS
|
3061 //else: get the dlg code from the DefWindowProc()
3066 // If this has been processed by an event handler, return 0 now
3067 // (we've handled it).
3068 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3069 if ( m_lastKeydownProcessed
)
3078 // we consider these messages "not interesting" to OnChar, so
3079 // just don't do anything more with them
3089 // avoid duplicate messages to OnChar for these ASCII keys:
3090 // they will be translated by TranslateMessage() and received
3122 // but set processed to false, not true to still pass them
3123 // to the control's default window proc - otherwise
3124 // built-in keyboard handling won't work
3129 // special case of VK_APPS: treat it the same as right mouse
3130 // click because both usually pop up a context menu
3132 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3137 // do generate a CHAR event
3138 processed
= HandleChar((WORD
)wParam
, lParam
);
3141 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3148 // special case of VK_APPS: treat it the same as right mouse button
3149 if ( wParam
== VK_APPS
)
3151 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3156 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3161 case WM_CHAR
: // Always an ASCII character
3162 if ( m_lastKeydownProcessed
)
3164 // The key was handled in the EVT_KEY_DOWN and handling
3165 // a key in an EVT_KEY_DOWN handler is meant, by
3166 // design, to prevent EVT_CHARs from happening
3167 m_lastKeydownProcessed
= false;
3172 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3178 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3180 #endif // wxUSE_HOTKEY
3185 processed
= HandleClipboardEvent(message
);
3193 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3195 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3201 // CTLCOLOR messages are sent by children to query the parent for their
3203 #ifndef __WXMICROWIN__
3204 case WM_CTLCOLORMSGBOX
:
3205 case WM_CTLCOLOREDIT
:
3206 case WM_CTLCOLORLISTBOX
:
3207 case WM_CTLCOLORBTN
:
3208 case WM_CTLCOLORDLG
:
3209 case WM_CTLCOLORSCROLLBAR
:
3210 case WM_CTLCOLORSTATIC
:
3214 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3216 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3219 #endif // !__WXMICROWIN__
3221 case WM_SYSCOLORCHANGE
:
3222 // the return value for this message is ignored
3223 processed
= HandleSysColorChange();
3226 #if !defined(__WXWINCE__)
3227 case WM_DISPLAYCHANGE
:
3228 processed
= HandleDisplayChange();
3232 case WM_PALETTECHANGED
:
3233 processed
= HandlePaletteChanged((WXHWND
)wParam
);
3236 case WM_CAPTURECHANGED
:
3237 processed
= HandleCaptureChanged((WXHWND
)lParam
);
3240 case WM_SETTINGCHANGE
:
3241 processed
= HandleSettingChange(wParam
, lParam
);
3244 case WM_QUERYNEWPALETTE
:
3245 processed
= HandleQueryNewPalette();
3249 processed
= HandleEraseBkgnd((WXHDC
)wParam
);
3252 // we processed the message, i.e. erased the background
3257 #if !defined(__WXWINCE__)
3259 processed
= HandleDropFiles(wParam
);
3264 processed
= HandleInitDialog((WXHWND
)wParam
);
3268 // we never set focus from here
3273 #if !defined(__WXWINCE__)
3274 case WM_QUERYENDSESSION
:
3275 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3279 processed
= HandleEndSession(wParam
!= 0, lParam
);
3282 case WM_GETMINMAXINFO
:
3283 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3288 processed
= HandleSetCursor((WXHWND
)wParam
,
3289 LOWORD(lParam
), // hit test
3290 HIWORD(lParam
)); // mouse msg
3294 // returning TRUE stops the DefWindowProc() from further
3295 // processing this message - exactly what we need because we've
3296 // just set the cursor.
3301 #if wxUSE_ACCESSIBILITY
3304 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3305 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3307 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3309 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3315 #if defined(WM_HELP)
3318 // by default, WM_HELP is propagated by DefWindowProc() upwards
3319 // to the window parent but as we do it ourselves already
3320 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3321 // to get the other events if we process this message at all
3324 // WM_HELP doesn't use lParam under CE
3326 HELPINFO
* info
= (HELPINFO
*) lParam
;
3327 if ( info
->iContextType
== HELPINFO_WINDOW
)
3329 #endif // !__WXWINCE__
3330 wxHelpEvent helpEvent
3335 wxGetMousePosition() // what else?
3337 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3341 helpEvent
.SetEventObject(this);
3342 HandleWindowEvent(helpEvent
);
3345 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3347 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3348 helpEvent
.SetEventObject(this);
3349 HandleWindowEvent(helpEvent
);
3352 else // unknown help event?
3356 #endif // !__WXWINCE__
3361 #if !defined(__WXWINCE__)
3362 case WM_CONTEXTMENU
:
3364 // we don't convert from screen to client coordinates as
3365 // the event may be handled by a parent window
3366 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3368 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3370 // we could have got an event from our child, reflect it back
3371 // to it if this is the case
3372 wxWindowMSW
*win
= NULL
;
3373 WXHWND hWnd
= (WXHWND
)wParam
;
3374 if ( hWnd
!= m_hWnd
)
3376 win
= FindItemByHWND(hWnd
);
3382 evtCtx
.SetEventObject(win
);
3383 processed
= win
->HandleWindowEvent(evtCtx
);
3390 // we're only interested in our own menus, not MF_SYSMENU
3391 if ( HIWORD(wParam
) == MF_POPUP
)
3393 // handle menu chars for ownerdrawn menu items
3394 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3395 if ( i
!= wxNOT_FOUND
)
3397 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3402 #endif // wxUSE_MENUS
3405 case WM_POWERBROADCAST
:
3408 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3409 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3412 #endif // __WXWINCE__
3415 // If we want the default themed border then we need to draw it ourselves
3418 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3419 const wxBorder border
= TranslateBorder(GetBorder());
3420 if (theme
&& border
== wxBORDER_THEME
)
3422 // first ask the widget to calculate the border size
3423 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3426 // now alter the client size making room for drawing a
3431 NCCALCSIZE_PARAMS
*csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3432 rect
= &csparam
->rgrc
[0];
3436 rect
= (RECT
*)lParam
;
3439 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3440 RECT rcClient
= { 0, 0, 0, 0 };
3441 wxClientDC
dc((wxWindow
*)this);
3442 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3444 if ( theme
->GetThemeBackgroundContentRect
3451 &rcClient
) == S_OK
)
3453 InflateRect(&rcClient
, -1, -1);
3455 rc
.result
= WVR_REDRAW
;
3463 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3464 const wxBorder border
= TranslateBorder(GetBorder());
3465 if (theme
&& border
== wxBORDER_THEME
)
3467 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3468 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3471 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3472 wxWindowDC
dc((wxWindow
*)this);
3473 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3475 // Clip the DC so that you only draw on the non-client area
3477 wxCopyRectToRECT(GetSize(), rcBorder
);
3480 theme
->GetThemeBackgroundContentRect(
3481 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3482 InflateRect(&rcClient
, -1, -1);
3484 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3485 rcClient
.right
, rcClient
.bottom
);
3487 // Make sure the background is in a proper state
3488 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3490 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3496 nState
= ETS_DISABLED
;
3497 // should we check this?
3498 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3499 // nState = ETS_READONLY;
3501 nState
= ETS_NORMAL
;
3502 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3507 #endif // wxUSE_UXTHEME
3510 // try a custom message handler
3511 const MSWMessageHandlers::const_iterator
3512 i
= gs_messageHandlers
.find(message
);
3513 if ( i
!= gs_messageHandlers
.end() )
3515 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3522 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3523 wxGetMessageName(message
));
3524 #endif // __WXDEBUG__
3525 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3531 // ----------------------------------------------------------------------------
3532 // wxWindow <-> HWND map
3533 // ----------------------------------------------------------------------------
3535 wxWindow
*wxFindWinFromHandle(HWND hwnd
)
3537 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3538 return i
== gs_windowHandles
.end() ? NULL
: i
->second
;
3541 void wxAssociateWinWithHandle(HWND hwnd
, wxWindowMSW
*win
)
3543 // adding NULL hwnd is (first) surely a result of an error and
3544 // (secondly) breaks menu command processing
3545 wxCHECK_RET( hwnd
!= (HWND
)NULL
,
3546 wxT("attempt to add a NULL hwnd to window list ignored") );
3549 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3550 if ( i
!= gs_windowHandles
.end() )
3552 if ( i
->second
!= win
)
3554 wxLogDebug(wxT("HWND %p already associated with another window (%s)"),
3555 hwnd
, win
->GetClassInfo()->GetClassName());
3557 //else: this actually happens currently because we associate the window
3558 // with its HWND during creation (if we create it) and also when
3559 // SubclassWin() is called later, this is ok
3561 #endif // __WXDEBUG__
3563 gs_windowHandles
[hwnd
] = (wxWindow
*)win
;
3566 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3568 gs_windowHandles
.erase(GetHwndOf(win
));
3571 // ----------------------------------------------------------------------------
3572 // various MSW speciic class dependent functions
3573 // ----------------------------------------------------------------------------
3575 // Default destroyer - override if you destroy it in some other way
3576 // (e.g. with MDI child windows)
3577 void wxWindowMSW::MSWDestroyWindow()
3581 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3584 int& w
, int& h
) const
3586 // yes, those are just some arbitrary hardcoded numbers
3587 static const int DEFAULT_Y
= 200;
3589 bool nonDefault
= false;
3591 if ( pos
.x
== wxDefaultCoord
)
3593 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3594 // can just as well set it to CW_USEDEFAULT as well
3600 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3601 // neither because it is not handled as a special value by Windows then
3602 // and so we have to choose some default value for it
3604 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3610 NB: there used to be some code here which set the initial size of the
3611 window to the client size of the parent if no explicit size was
3612 specified. This was wrong because wxWidgets programs often assume
3613 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3614 it. To see why, you should understand that Windows sends WM_SIZE from
3615 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3616 from some base class ctor and so this WM_SIZE is not processed in the
3617 real class' OnSize() (because it's not fully constructed yet and the
3618 event goes to some base class OnSize() instead). So the WM_SIZE we
3619 rely on is the one sent when the parent frame resizes its children
3620 but here is the problem: if the child already has just the right
3621 size, nothing will happen as both wxWidgets and Windows check for
3622 this and ignore any attempts to change the window size to the size it
3623 already has - so no WM_SIZE would be sent.
3627 // we don't use CW_USEDEFAULT here for several reasons:
3629 // 1. it results in huge frames on modern screens (1000*800 is not
3630 // uncommon on my 1280*1024 screen) which is way too big for a half
3631 // empty frame of most of wxWidgets samples for example)
3633 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3634 // the default is for whatever reason 8*8 which breaks client <->
3635 // window size calculations (it would be nice if it didn't, but it
3636 // does and the simplest way to fix it seemed to change the broken
3637 // default size anyhow)
3639 // 3. there is just no advantage in doing it: with x and y it is
3640 // possible that [future versions of] Windows position the new top
3641 // level window in some smart way which we can't do, but we can
3642 // guess a reasonably good size for a new window just as well
3645 // However, on PocketPC devices, we must use the default
3646 // size if possible.
3648 if (size
.x
== wxDefaultCoord
)
3652 if (size
.y
== wxDefaultCoord
)
3657 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3661 w
= WidthDefault(size
.x
);
3662 h
= HeightDefault(size
.y
);
3665 AdjustForParentClientOrigin(x
, y
);
3670 WXHWND
wxWindowMSW::MSWGetParent() const
3672 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3675 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3676 const wxChar
*title
,
3680 WXDWORD extendedStyle
)
3682 // check a common bug in the user code: if the window is created with a
3683 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3684 // single wxWindow object and this results in all sorts of trouble,
3685 // especially for wxTLWs
3686 wxCHECK_MSG( !m_hWnd
, true, "window can't be recreated" );
3688 // choose the position/size for the new window
3690 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3692 // controlId is menu handle for the top level windows, so set it to 0
3693 // unless we're creating a child window
3694 int controlId
= style
& WS_CHILD
? GetId() : 0;
3696 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3697 // which is the same but without CS_[HV]REDRAW class styles so using it
3698 // ensures that the window is not fully repainted on each resize
3699 wxString
className(wclass
);
3700 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3702 className
+= wxT("NR");
3705 // do create the window
3706 wxWindowCreationHook
hook(this);
3708 m_hWnd
= (WXHWND
)::CreateWindowEx
3712 title
? title
: m_windowName
.wx_str(),
3715 (HWND
)MSWGetParent(),
3716 (HMENU
)wxUIntToPtr(controlId
),
3718 NULL
// no extra data
3723 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3728 SubclassWin(m_hWnd
);
3733 // ===========================================================================
3734 // MSW message handlers
3735 // ===========================================================================
3737 // ---------------------------------------------------------------------------
3739 // ---------------------------------------------------------------------------
3741 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3743 #ifndef __WXMICROWIN__
3744 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3745 HWND hWnd
= hdr
->hwndFrom
;
3746 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
3748 // if the control is one of our windows, let it handle the message itself
3751 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3754 // VZ: why did we do it? normally this is unnecessary and, besides, it
3755 // breaks the message processing for the toolbars because the tooltip
3756 // notifications were being forwarded to the toolbar child controls
3757 // (if it had any) before being passed to the toolbar itself, so in my
3758 // example the tooltip for the combobox was always shown instead of the
3759 // correct button tooltips
3761 // try all our children
3762 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3765 wxWindow
*child
= node
->GetData();
3766 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3771 node
= node
->GetNext();
3775 // by default, handle it ourselves
3776 return MSWOnNotify(idCtrl
, lParam
, result
);
3777 #else // __WXMICROWIN__
3784 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3786 const wxString
& ttip
)
3788 // I don't know why it happens, but the versions of comctl32.dll starting
3789 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3790 // this message is supposed to be sent to Unicode programs only) -- hence
3791 // we need to handle it as well, otherwise no tooltips will be shown in
3794 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3797 // not a tooltip message or no tooltip to show anyhow
3802 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3804 // We don't want to use the szText buffer because it has a limit of 80
3805 // bytes and this is not enough, especially for Unicode build where it
3806 // limits the tooltip string length to only 40 characters
3808 // The best would be, of course, to not impose any length limitations at
3809 // all but then the buffer would have to be dynamic and someone would have
3810 // to free it and we don't have the tooltip owner object here any more, so
3811 // for now use our own static buffer with a higher fixed max length.
3813 // Note that using a static buffer should not be a problem as only a single
3814 // tooltip can be shown at the same time anyhow.
3816 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3818 // We need to convert tooltip from multi byte to Unicode on the fly.
3819 static wchar_t buf
[513];
3821 // Truncate tooltip length if needed as otherwise we might not have
3822 // enough space for it in the buffer and MultiByteToWideChar() would
3824 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3826 // Convert to WideChar without adding the NULL character. The NULL
3827 // character is added afterwards (this is more efficient).
3828 int len
= ::MultiByteToWideChar
3840 wxLogLastError(_T("MultiByteToWideChar()"));
3844 ttText
->lpszText
= (LPSTR
) buf
;
3846 else // TTN_NEEDTEXTA
3847 #endif // !wxUSE_UNICODE
3849 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3850 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3851 // to copy the string we have into the buffer
3852 static wxChar buf
[513];
3853 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3854 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3855 ttText
->lpszText
= buf
;
3861 #endif // wxUSE_TOOLTIPS
3863 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3865 WXLPARAM
* WXUNUSED(result
))
3870 NMHDR
* hdr
= (NMHDR
*)lParam
;
3871 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3878 wxUnusedVar(lParam
);
3879 #endif // wxUSE_TOOLTIPS
3884 // ---------------------------------------------------------------------------
3885 // end session messages
3886 // ---------------------------------------------------------------------------
3888 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3890 #ifdef ENDSESSION_LOGOFF
3891 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3892 event
.SetEventObject(wxTheApp
);
3893 event
.SetCanVeto(true);
3894 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3896 bool rc
= wxTheApp
->ProcessEvent(event
);
3900 // we may end only if the app didn't veto session closing (double
3902 *mayEnd
= !event
.GetVeto();
3907 wxUnusedVar(logOff
);
3908 wxUnusedVar(mayEnd
);
3913 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3915 #ifdef ENDSESSION_LOGOFF
3916 // do nothing if the session isn't ending
3921 if ( (this != wxTheApp
->GetTopWindow()) )
3924 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3925 event
.SetEventObject(wxTheApp
);
3926 event
.SetCanVeto(false);
3927 event
.SetLoggingOff((logOff
& ENDSESSION_LOGOFF
) != 0);
3929 return wxTheApp
->ProcessEvent(event
);
3931 wxUnusedVar(endSession
);
3932 wxUnusedVar(logOff
);
3937 // ---------------------------------------------------------------------------
3938 // window creation/destruction
3939 // ---------------------------------------------------------------------------
3941 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3944 // VZ: why is this commented out for WinCE? If it doesn't support
3945 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3946 // not with multiple #ifdef's!
3948 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3949 EnsureParentHasControlParentStyle(GetParent());
3950 #endif // !__WXWINCE__
3957 bool wxWindowMSW::HandleDestroy()
3961 // delete our drop target if we've got one
3962 #if wxUSE_DRAG_AND_DROP
3963 if ( m_dropTarget
!= NULL
)
3965 m_dropTarget
->Revoke(m_hWnd
);
3967 delete m_dropTarget
;
3968 m_dropTarget
= NULL
;
3970 #endif // wxUSE_DRAG_AND_DROP
3972 // WM_DESTROY handled
3976 // ---------------------------------------------------------------------------
3978 // ---------------------------------------------------------------------------
3980 bool wxWindowMSW::HandleActivate(int state
,
3981 bool WXUNUSED(minimized
),
3982 WXHWND
WXUNUSED(activate
))
3984 wxActivateEvent
event(wxEVT_ACTIVATE
,
3985 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3987 event
.SetEventObject(this);
3989 return HandleWindowEvent(event
);
3992 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3994 // Strangly enough, some controls get set focus events when they are being
3995 // deleted, even if they already had focus before.
3996 if ( m_isBeingDeleted
)
4001 // notify the parent keeping track of focus for the kbd navigation
4002 // purposes that we got it
4003 wxChildFocusEvent
eventFocus((wxWindow
*)this);
4004 (void)HandleWindowEvent(eventFocus
);
4010 m_caret
->OnSetFocus();
4012 #endif // wxUSE_CARET
4014 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
4015 event
.SetEventObject(this);
4017 // wxFindWinFromHandle() may return NULL, it is ok
4018 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4020 return HandleWindowEvent(event
);
4023 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4029 m_caret
->OnKillFocus();
4031 #endif // wxUSE_CARET
4033 // Don't send the event when in the process of being deleted. This can
4034 // only cause problems if the event handler tries to access the object.
4035 if ( m_isBeingDeleted
)
4040 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4041 event
.SetEventObject(this);
4043 // wxFindWinFromHandle() may return NULL, it is ok
4044 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4046 return HandleWindowEvent(event
);
4049 // ---------------------------------------------------------------------------
4051 // ---------------------------------------------------------------------------
4053 void wxWindowMSW::SetLabel( const wxString
& label
)
4055 SetWindowText(GetHwnd(), label
.c_str());
4058 wxString
wxWindowMSW::GetLabel() const
4060 return wxGetWindowText(GetHWND());
4063 // ---------------------------------------------------------------------------
4065 // ---------------------------------------------------------------------------
4067 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4069 wxShowEvent
event(GetId(), show
);
4070 event
.SetEventObject(this);
4072 return HandleWindowEvent(event
);
4075 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4077 wxInitDialogEvent
event(GetId());
4078 event
.SetEventObject(this);
4080 return HandleWindowEvent(event
);
4083 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4085 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4086 wxUnusedVar(wParam
);
4088 #else // __WXMICROWIN__
4089 HDROP hFilesInfo
= (HDROP
) wParam
;
4091 // Get the total number of files dropped
4092 UINT gwFilesDropped
= ::DragQueryFile
4100 wxString
*files
= new wxString
[gwFilesDropped
];
4101 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4103 // first get the needed buffer length (+1 for terminating NUL)
4104 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4106 // and now get the file name
4107 ::DragQueryFile(hFilesInfo
, wIndex
,
4108 wxStringBuffer(files
[wIndex
], len
), len
);
4110 DragFinish (hFilesInfo
);
4112 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4113 event
.SetEventObject(this);
4116 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4117 event
.m_pos
.x
= dropPoint
.x
;
4118 event
.m_pos
.y
= dropPoint
.y
;
4120 return HandleWindowEvent(event
);
4125 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4127 int WXUNUSED(mouseMsg
))
4129 #ifndef __WXMICROWIN__
4130 // the logic is as follows:
4131 // 0. if we're busy, set the busy cursor (even for non client elements)
4132 // 1. don't set custom cursor for non client area of enabled windows
4133 // 2. ask user EVT_SET_CURSOR handler for the cursor
4134 // 3. if still no cursor but we're in a TLW, set the global cursor
4136 HCURSOR hcursor
= 0;
4139 hcursor
= wxGetCurrentBusyCursor();
4143 if ( nHitTest
!= HTCLIENT
)
4146 // first ask the user code - it may wish to set the cursor in some very
4147 // specific way (for example, depending on the current position)
4150 if ( !::GetCursorPosWinCE(&pt
))
4152 if ( !::GetCursorPos(&pt
) )
4155 wxLogLastError(wxT("GetCursorPos"));
4160 ScreenToClient(&x
, &y
);
4161 wxSetCursorEvent
event(x
, y
);
4163 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4164 if ( processedEvtSetCursor
&& event
.HasCursor() )
4166 hcursor
= GetHcursorOf(event
.GetCursor());
4171 // the test for processedEvtSetCursor is here to prevent using
4172 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4173 // nothing from it - this is a way to say that our cursor shouldn't
4174 // be used for this point
4175 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4177 hcursor
= GetHcursorOf(m_cursor
);
4180 if ( !hcursor
&& !GetParent() )
4182 const wxCursor
*cursor
= wxGetGlobalCursor();
4183 if ( cursor
&& cursor
->Ok() )
4185 hcursor
= GetHcursorOf(*cursor
);
4194 ::SetCursor(hcursor
);
4196 // cursor set, stop here
4199 #endif // __WXMICROWIN__
4201 // pass up the window chain
4205 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4206 WXLPARAM
WXUNUSED(lParam
),
4207 bool *WXUNUSED_IN_WINCE(vetoed
))
4213 wxEventType evtType
;
4216 case PBT_APMQUERYSUSPEND
:
4217 evtType
= wxEVT_POWER_SUSPENDING
;
4220 case PBT_APMQUERYSUSPENDFAILED
:
4221 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4224 case PBT_APMSUSPEND
:
4225 evtType
= wxEVT_POWER_SUSPENDED
;
4228 case PBT_APMRESUMESUSPEND
:
4229 evtType
= wxEVT_POWER_RESUME
;
4233 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4236 // these messages are currently not mapped to wx events
4237 case PBT_APMQUERYSTANDBY
:
4238 case PBT_APMQUERYSTANDBYFAILED
:
4239 case PBT_APMSTANDBY
:
4240 case PBT_APMRESUMESTANDBY
:
4241 case PBT_APMBATTERYLOW
:
4242 case PBT_APMPOWERSTATUSCHANGE
:
4243 case PBT_APMOEMEVENT
:
4244 case PBT_APMRESUMECRITICAL
:
4245 #ifdef PBT_APMRESUMEAUTOMATIC
4246 case PBT_APMRESUMEAUTOMATIC
:
4248 evtType
= wxEVT_NULL
;
4252 // don't handle unknown messages
4253 if ( evtType
== wxEVT_NULL
)
4256 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4258 wxPowerEvent
event(evtType
);
4259 if ( !HandleWindowEvent(event
) )
4262 *vetoed
= event
.IsVetoed();
4268 bool wxWindowMSW::IsDoubleBuffered() const
4270 for ( const wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4272 if ( wxHasWindowExStyle(win
, WS_EX_COMPOSITED
) )
4275 if ( win
->IsTopLevel() )
4282 void wxWindowMSW::SetDoubleBuffered(bool on
)
4284 // Get the current extended style bits
4285 long exstyle
= wxGetWindowExStyle(this);
4287 // Twiddle the bit as needed
4289 exstyle
|= WS_EX_COMPOSITED
;
4291 exstyle
&= ~WS_EX_COMPOSITED
;
4294 wxSetWindowExStyle(this, exstyle
);
4297 // ---------------------------------------------------------------------------
4298 // owner drawn stuff
4299 // ---------------------------------------------------------------------------
4301 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4302 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4303 #define WXUNUSED_UNLESS_ODRAWN(param) param
4305 #define WXUNUSED_UNLESS_ODRAWN(param)
4309 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4310 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4312 #if wxUSE_OWNER_DRAWN
4314 #if wxUSE_MENUS_NATIVE
4315 // is it a menu item?
4316 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4317 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4319 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4321 // see comment before the same test in MSWOnMeasureItem() below
4325 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4326 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
4328 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4329 // the DC from being released
4330 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4331 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4332 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4333 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4335 return pMenuItem
->OnDrawItem
4339 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4340 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4343 #endif // wxUSE_MENUS_NATIVE
4345 #endif // USE_OWNER_DRAWN
4347 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4349 #if wxUSE_OWNER_DRAWN
4350 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4351 #else // !wxUSE_OWNER_DRAWN
4352 // we may still have owner-drawn buttons internally because we have to make
4353 // them owner-drawn to support colour change
4356 wxDynamicCast(FindItem(id
), wxButton
)
4361 #endif // USE_OWNER_DRAWN
4365 return item
->MSWOnDraw(itemStruct
);
4368 #endif // wxUSE_CONTROLS
4374 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4376 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4377 // is it a menu item?
4378 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4379 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4381 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4383 // according to Carsten Fuchs the pointer may be NULL under XP if an
4384 // MDI child frame is initially maximized, see this for more info:
4385 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4387 // so silently ignore it instead of asserting
4391 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4392 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4395 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4397 pMeasureStruct
->itemWidth
= w
;
4398 pMeasureStruct
->itemHeight
= h
;
4403 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4406 return item
->MSWOnMeasure(itemStruct
);
4410 wxUnusedVar(itemStruct
);
4411 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4416 // ---------------------------------------------------------------------------
4417 // colours and palettes
4418 // ---------------------------------------------------------------------------
4420 bool wxWindowMSW::HandleSysColorChange()
4422 wxSysColourChangedEvent event
;
4423 event
.SetEventObject(this);
4425 (void)HandleWindowEvent(event
);
4427 // always let the system carry on the default processing to allow the
4428 // native controls to react to the colours update
4432 bool wxWindowMSW::HandleDisplayChange()
4434 wxDisplayChangedEvent event
;
4435 event
.SetEventObject(this);
4437 return HandleWindowEvent(event
);
4440 #ifndef __WXMICROWIN__
4442 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4444 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4448 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4451 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4453 #endif // wxUSE_CONTROLS
4456 return *brush
!= NULL
;
4459 #endif // __WXMICROWIN__
4461 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4464 // same as below except we don't respond to our own messages
4465 if ( hWndPalChange
!= GetHWND() )
4467 // check to see if we our our parents have a custom palette
4468 wxWindowMSW
*win
= this;
4469 while ( win
&& !win
->HasCustomPalette() )
4471 win
= win
->GetParent();
4474 if ( win
&& win
->HasCustomPalette() )
4476 // realize the palette to see whether redrawing is needed
4477 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4478 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4479 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4481 int result
= ::RealizePalette(hdc
);
4483 // restore the palette (before releasing the DC)
4484 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4485 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4486 ::RealizePalette(hdc
);
4487 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4489 // now check for the need to redraw
4491 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4495 #endif // wxUSE_PALETTE
4497 wxPaletteChangedEvent
event(GetId());
4498 event
.SetEventObject(this);
4499 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4501 return HandleWindowEvent(event
);
4504 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4506 // notify windows on the capture stack about lost capture
4507 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4508 wxWindowBase::NotifyCaptureLost();
4510 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4511 wxMouseCaptureChangedEvent
event(GetId(), win
);
4512 event
.SetEventObject(this);
4513 return HandleWindowEvent(event
);
4516 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4518 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4519 // we need to send this to child windows (it is only sent to top-level
4520 // windows) so {list,tree}ctrls can adjust their font size if necessary
4521 // this is exactly how explorer does it to enable the font size changes
4523 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4526 // top-level windows already get this message from the system
4527 wxWindow
*win
= node
->GetData();
4528 if ( !win
->IsTopLevel() )
4530 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4533 node
= node
->GetNext();
4536 // let the system handle it
4540 bool wxWindowMSW::HandleQueryNewPalette()
4544 // check to see if we our our parents have a custom palette
4545 wxWindowMSW
*win
= this;
4546 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4547 if (win
->HasCustomPalette()) {
4548 /* realize the palette to see whether redrawing is needed */
4549 HDC hdc
= ::GetDC((HWND
) GetHWND());
4550 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4551 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4553 int result
= ::RealizePalette(hdc
);
4554 /* restore the palette (before releasing the DC) */
4555 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4556 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4557 ::RealizePalette(hdc
);
4558 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4559 /* now check for the need to redraw */
4561 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4563 #endif // wxUSE_PALETTE
4565 wxQueryNewPaletteEvent
event(GetId());
4566 event
.SetEventObject(this);
4568 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4571 // Responds to colour changes: passes event on to children.
4572 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4574 // the top level window also reset the standard colour map as it might have
4575 // changed (there is no need to do it for the non top level windows as we
4576 // only have to do it once)
4580 gs_hasStdCmap
= false;
4582 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4585 // Only propagate to non-top-level windows because Windows already
4586 // sends this event to all top-level ones
4587 wxWindow
*win
= node
->GetData();
4588 if ( !win
->IsTopLevel() )
4590 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4591 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4592 // the standard controls
4593 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4596 node
= node
->GetNext();
4600 extern wxCOLORMAP
*wxGetStdColourMap()
4602 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4603 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4605 if ( !gs_hasStdCmap
)
4607 static bool s_coloursInit
= false;
4609 if ( !s_coloursInit
)
4611 // When a bitmap is loaded, the RGB values can change (apparently
4612 // because Windows adjusts them to care for the old programs always
4613 // using 0xc0c0c0 while the transparent colour for the new Windows
4614 // versions is different). But we do this adjustment ourselves so
4615 // we want to avoid Windows' "help" and for this we need to have a
4616 // reference bitmap which can tell us what the RGB values change
4618 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4619 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4620 if ( stdColourBitmap
.Ok() )
4622 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4623 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4624 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4627 memDC
.SelectObject(stdColourBitmap
);
4630 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4632 memDC
.GetPixel(i
, 0, &colour
);
4633 s_stdColours
[i
] = wxColourToRGB(colour
);
4636 else // wxBITMAP_STD_COLOURS couldn't be loaded
4638 s_stdColours
[0] = RGB(000,000,000); // black
4639 s_stdColours
[1] = RGB(128,128,128); // dark grey
4640 s_stdColours
[2] = RGB(192,192,192); // light grey
4641 s_stdColours
[3] = RGB(255,255,255); // white
4642 //s_stdColours[4] = RGB(000,000,255); // blue
4643 //s_stdColours[5] = RGB(255,000,255); // magenta
4646 s_coloursInit
= true;
4649 gs_hasStdCmap
= true;
4651 // create the colour map
4652 #define INIT_CMAP_ENTRY(col) \
4653 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4654 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4656 INIT_CMAP_ENTRY(BTNTEXT
);
4657 INIT_CMAP_ENTRY(BTNSHADOW
);
4658 INIT_CMAP_ENTRY(BTNFACE
);
4659 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4661 #undef INIT_CMAP_ENTRY
4667 // ---------------------------------------------------------------------------
4669 // ---------------------------------------------------------------------------
4671 bool wxWindowMSW::HandlePaint()
4673 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4675 wxLogLastError(wxT("CreateRectRgn"));
4676 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4677 wxLogLastError(wxT("GetUpdateRgn"));
4679 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4681 wxPaintEvent
event(m_windowId
);
4682 event
.SetEventObject(this);
4684 bool processed
= HandleWindowEvent(event
);
4686 // note that we must generate NC event after the normal one as otherwise
4687 // BeginPaint() will happily overwrite our decorations with the background
4689 wxNcPaintEvent
eventNc(m_windowId
);
4690 eventNc
.SetEventObject(this);
4691 HandleWindowEvent(eventNc
);
4693 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4694 // be called from inside the event handlers called above)
4695 m_updateRegion
.Clear();
4700 // Can be called from an application's OnPaint handler
4701 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4703 #ifdef __WXUNIVERSAL__
4706 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4709 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4714 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4716 wxDCTemp
dc(hdc
, GetClientSize());
4717 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4720 impl
->SetWindow((wxWindow
*)this);
4722 wxEraseEvent
event(m_windowId
, &dc
);
4723 event
.SetEventObject(this);
4724 bool rc
= HandleWindowEvent(event
);
4726 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4727 impl
->SelectOldObjects(hdc
);
4732 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4734 // standard non top level controls (i.e. except the dialogs) always erase
4735 // their background themselves in HandleCtlColor() or have some control-
4736 // specific ways to set the colours (common controls)
4737 if ( IsOfStandardClass() && !IsTopLevel() )
4743 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4745 // don't skip the event here, custom background means that the app
4746 // is drawing it itself in its OnPaint(), so don't draw it at all
4747 // now to avoid flicker
4751 wxDC
*dc
= event
.GetDC();
4753 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
->GetImpl();
4755 // do default background painting
4756 if ( !DoEraseBackground(GetHdcOf(*impl
)) )
4758 // let the system paint the background
4763 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4765 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4769 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4775 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4779 // our background colour applies to:
4780 // 1. this window itself, always
4781 // 2. all children unless the colour is "not inheritable"
4782 // 3. even if it is not inheritable, our immediate transparent
4783 // children should still inherit it -- but not any transparent
4784 // children because it would look wrong if a child of non
4785 // transparent child would show our bg colour when the child itself
4787 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4790 (win
&& win
->HasTransparentBackground() &&
4791 win
->GetParent() == this) )
4793 // draw children with the same colour as the parent
4795 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4797 return (WXHBRUSH
)GetHbrushOf(*brush
);
4804 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4807 hWndToPaint
= GetHWND();
4809 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4811 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4815 // background is not inherited beyond top level windows
4816 if ( win
->IsTopLevel() )
4823 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4825 // we receive this message when DrawThemeParentBackground() is
4826 // called from def window proc of several controls under XP and we
4827 // must draw properly themed background here
4829 // note that naively I'd expect filling the client rect with the
4830 // brush returned by MSWGetBgBrush() work -- but for some reason it
4831 // doesn't and we have to call parents MSWPrintChild() which is
4832 // supposed to call DrawThemeBackground() with appropriate params
4834 // also note that in this case lParam == PRF_CLIENT but we're
4835 // clearly expected to paint the background and nothing else!
4837 if ( IsTopLevel() || InheritsBackgroundColour() )
4840 // sometimes we don't want the parent to handle it at all, instead
4841 // return whatever value this window wants
4842 if ( !MSWShouldPropagatePrintChild() )
4843 return MSWPrintChild(hDC
, (wxWindow
*)this);
4845 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4847 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4850 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4857 // ---------------------------------------------------------------------------
4858 // moving and resizing
4859 // ---------------------------------------------------------------------------
4861 bool wxWindowMSW::HandleMinimize()
4863 wxIconizeEvent
event(m_windowId
);
4864 event
.SetEventObject(this);
4866 return HandleWindowEvent(event
);
4869 bool wxWindowMSW::HandleMaximize()
4871 wxMaximizeEvent
event(m_windowId
);
4872 event
.SetEventObject(this);
4874 return HandleWindowEvent(event
);
4877 bool wxWindowMSW::HandleMove(int x
, int y
)
4880 wxMoveEvent
event(point
, m_windowId
);
4881 event
.SetEventObject(this);
4883 return HandleWindowEvent(event
);
4886 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4888 wxMoveEvent
event(rect
, m_windowId
);
4889 event
.SetEventObject(this);
4891 bool rc
= HandleWindowEvent(event
);
4893 rect
= event
.GetRect();
4897 bool wxWindowMSW::HandleEnterSizeMove()
4899 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4900 event
.SetEventType(wxEVT_MOVE_START
);
4901 event
.SetEventObject(this);
4903 return HandleWindowEvent(event
);
4906 bool wxWindowMSW::HandleExitSizeMove()
4908 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4909 event
.SetEventType(wxEVT_MOVE_END
);
4910 event
.SetEventObject(this);
4912 return HandleWindowEvent(event
);
4915 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4917 #if USE_DEFERRED_SIZING
4918 // when we resize this window, its children are probably going to be
4919 // repositioned as well, prepare to use DeferWindowPos() for them
4920 int numChildren
= 0;
4921 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4923 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4928 // Protect against valid m_hDWP being overwritten
4929 bool useDefer
= false;
4931 if ( numChildren
> 1 )
4935 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4938 wxLogLastError(_T("BeginDeferWindowPos"));
4944 #endif // USE_DEFERRED_SIZING
4946 // update this window size
4947 bool processed
= false;
4951 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4952 // fall through nevertheless
4956 // we're not interested in these messages at all
4959 case SIZE_MINIMIZED
:
4960 processed
= HandleMinimize();
4963 case SIZE_MAXIMIZED
:
4964 /* processed = */ HandleMaximize();
4965 // fall through to send a normal size event as well
4968 // don't use w and h parameters as they specify the client size
4969 // while according to the docs EVT_SIZE handler is supposed to
4970 // receive the total size
4971 wxSizeEvent
event(GetSize(), m_windowId
);
4972 event
.SetEventObject(this);
4974 processed
= HandleWindowEvent(event
);
4977 #if USE_DEFERRED_SIZING
4978 // and finally change the positions of all child windows at once
4979 if ( useDefer
&& m_hDWP
)
4981 // reset m_hDWP to NULL so that child windows don't try to use our
4982 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4983 // happen anyhow normally but who knows what weird flow of control we
4984 // may have depending on what the users EVT_SIZE handler does...)
4985 HDWP hDWP
= (HDWP
)m_hDWP
;
4988 // do put all child controls in place at once
4989 if ( !::EndDeferWindowPos(hDWP
) )
4991 wxLogLastError(_T("EndDeferWindowPos"));
4994 // Reset our children's pending pos/size values.
4995 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4997 node
= node
->GetNext() )
4999 wxWindowMSW
*child
= node
->GetData();
5000 child
->m_pendingPosition
= wxDefaultPosition
;
5001 child
->m_pendingSize
= wxDefaultSize
;
5004 #endif // USE_DEFERRED_SIZING
5009 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
5011 wxSizeEvent
event(rect
, m_windowId
);
5012 event
.SetEventObject(this);
5014 bool rc
= HandleWindowEvent(event
);
5016 rect
= event
.GetRect();
5020 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5025 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5029 int minWidth
= GetMinWidth(),
5030 minHeight
= GetMinHeight(),
5031 maxWidth
= GetMaxWidth(),
5032 maxHeight
= GetMaxHeight();
5034 if ( minWidth
!= wxDefaultCoord
)
5036 info
->ptMinTrackSize
.x
= minWidth
;
5040 if ( minHeight
!= wxDefaultCoord
)
5042 info
->ptMinTrackSize
.y
= minHeight
;
5046 if ( maxWidth
!= wxDefaultCoord
)
5048 info
->ptMaxTrackSize
.x
= maxWidth
;
5052 if ( maxHeight
!= wxDefaultCoord
)
5054 info
->ptMaxTrackSize
.y
= maxHeight
;
5062 // ---------------------------------------------------------------------------
5064 // ---------------------------------------------------------------------------
5066 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5068 // sign extend to int from short before comparing with the other int ids
5069 int id
= (signed short)id_
;
5071 #if wxUSE_MENUS_NATIVE
5072 if ( !cmd
&& wxCurrentPopupMenu
)
5074 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5075 wxCurrentPopupMenu
= NULL
;
5077 return popupMenu
->MSWCommand(cmd
, id
);
5079 #endif // wxUSE_MENUS_NATIVE
5081 wxWindow
*win
= NULL
;
5083 // first try to find it from HWND - this works even with the broken
5084 // programs using the same ids for different controls
5087 win
= wxFindWinFromHandle(control
);
5098 return win
->MSWCommand(cmd
, id
);
5101 // the messages sent from the in-place edit control used by the treectrl
5102 // for label editing have id == 0, but they should _not_ be treated as menu
5103 // messages (they are EN_XXX ones, in fact) so don't translate anything
5104 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5107 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, id
);
5108 event
.SetEventObject(this);
5111 return HandleWindowEvent(event
);
5115 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5116 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5117 // notifications to its parent which we want to reflect back to
5119 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5120 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5122 #endif // wxUSE_SPINCTRL
5124 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5125 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5126 // notifications to its parent which we want to reflect back to
5128 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5129 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5137 // ---------------------------------------------------------------------------
5139 // ---------------------------------------------------------------------------
5141 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5145 // our client coords are not quite the same as Windows ones
5146 wxPoint pt
= GetClientAreaOrigin();
5147 event
.m_x
= x
- pt
.x
;
5148 event
.m_y
= y
- pt
.y
;
5150 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5151 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5152 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5153 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5154 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5155 #ifdef wxHAS_XBUTTON
5156 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5157 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5158 #endif // wxHAS_XBUTTON
5159 event
.m_altDown
= ::wxIsAltDown();
5162 event
.SetTimestamp(::GetMessageTime());
5165 event
.SetEventObject(this);
5166 event
.SetId(GetId());
5168 #if wxUSE_MOUSEEVENT_HACK
5169 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5170 gs_lastMouseEvent
.type
= event
.GetEventType();
5171 #endif // wxUSE_MOUSEEVENT_HACK
5175 // Windows doesn't send the mouse events to the static controls (which are
5176 // transparent in the sense that their WM_NCHITTEST handler returns
5177 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5178 // and so we manually check if we don't have a child window under mouse and if
5179 // we do, send the event to it instead of the window Windows had sent WM_XXX
5182 // Notice that this is not done for the mouse move events because this could
5183 // (would?) be too slow, but only for clicks which means that the static texts
5184 // still don't get move, enter nor leave events.
5185 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5187 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
5189 // first try to find a non transparent child: this allows us to send events
5190 // to a static text which is inside a static box, for example
5191 POINT pt
= { *x
, *y
};
5192 HWND hwnd
= GetHwndOf(win
),
5196 hwndUnderMouse
= ::ChildWindowFromPoint
5202 hwndUnderMouse
= ::ChildWindowFromPointEx
5212 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5214 // now try any child window at all
5215 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5218 // check that we have a child window which is susceptible to receive mouse
5219 // events: for this it must be shown and enabled
5220 if ( hwndUnderMouse
&&
5221 hwndUnderMouse
!= hwnd
&&
5222 ::IsWindowVisible(hwndUnderMouse
) &&
5223 ::IsWindowEnabled(hwndUnderMouse
) )
5225 wxWindow
*winUnderMouse
= wxFindWinFromHandle(hwndUnderMouse
);
5226 if ( winUnderMouse
)
5228 // translate the mouse coords to the other window coords
5229 win
->ClientToScreen(x
, y
);
5230 winUnderMouse
->ScreenToClient(x
, y
);
5232 win
= winUnderMouse
;
5238 #endif // __WXWINCE__
5240 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5242 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5243 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5244 // from the message id and take the value in the table to get wxWin event
5246 static const wxEventType eventsMouse
[] =
5257 wxEVT_MIDDLE_DCLICK
,
5258 0, // this one is for wxEVT_MOTION which is not used here
5267 #ifdef wxHAS_XBUTTON
5268 // the same messages are used for both auxillary mouse buttons so we need
5269 // to adjust the index manually
5272 case WM_XBUTTONDOWN
:
5274 case WM_XBUTTONDBLCLK
:
5275 if ( flags
& MK_XBUTTON2
)
5276 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5278 #endif // wxHAS_XBUTTON
5280 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5281 InitMouseEvent(event
, x
, y
, flags
);
5283 return HandleWindowEvent(event
);
5286 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5288 if ( !m_mouseInWindow
)
5290 // it would be wrong to assume that just because we get a mouse move
5291 // event that the mouse is inside the window: although this is usually
5292 // true, it is not if we had captured the mouse, so we need to check
5293 // the mouse coordinates here
5294 if ( !HasCapture() || IsMouseInWindow() )
5296 // Generate an ENTER event
5297 m_mouseInWindow
= true;
5299 #ifdef HAVE_TRACKMOUSEEVENT
5300 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5302 static const _TrackMouseEvent_t
5303 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5304 #else // !__WXWINCE__
5305 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5306 static bool s_initDone
= false;
5311 wxDynamicLibrary
dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM
);
5312 if ( dllComCtl32
.IsLoaded() )
5314 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5315 dllComCtl32
.GetSymbol(_T("_TrackMouseEvent"));
5320 // notice that it's ok to unload comctl32.dll here as it won't
5321 // be really unloaded, being still in use because we link to it
5325 if ( s_pfn_TrackMouseEvent
)
5326 #endif // __WXWINCE__/!__WXWINCE__
5328 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5330 trackinfo
.dwFlags
= TME_LEAVE
;
5331 trackinfo
.hwndTrack
= GetHwnd();
5333 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5335 #endif // HAVE_TRACKMOUSEEVENT
5337 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5338 InitMouseEvent(event
, x
, y
, flags
);
5340 (void)HandleWindowEvent(event
);
5343 #ifdef HAVE_TRACKMOUSEEVENT
5344 else // mouse not in window
5346 // Check if we need to send a LEAVE event
5347 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5348 // send it here if we are using native mouse leave tracking
5349 if ( HasCapture() && !IsMouseInWindow() )
5351 GenerateMouseLeave();
5354 #endif // HAVE_TRACKMOUSEEVENT
5356 #if wxUSE_MOUSEEVENT_HACK
5357 // Windows often generates mouse events even if mouse position hasn't
5358 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5360 // Filter this out as it can result in unexpected behaviour compared to
5362 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5363 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5364 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5365 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5367 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5369 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5374 #endif // wxUSE_MOUSEEVENT_HACK
5376 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5380 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5382 #if wxUSE_MOUSEWHEEL
5383 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5384 // forwarded up to the parent by DefWindowProc()) and not in the client
5385 // ones as all the other messages, translate them to the client coords for
5388 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5389 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5390 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5391 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5392 event
.m_wheelDelta
= WHEEL_DELTA
;
5394 static int s_linesPerRotation
= -1;
5395 if ( s_linesPerRotation
== -1 )
5397 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5398 &s_linesPerRotation
, 0))
5400 // this is not supposed to happen
5401 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5403 // the default is 3, so use it if SystemParametersInfo() failed
5404 s_linesPerRotation
= 3;
5408 event
.m_linesPerAction
= s_linesPerRotation
;
5409 return HandleWindowEvent(event
);
5411 #else // !wxUSE_MOUSEWHEEL
5412 wxUnusedVar(wParam
);
5413 wxUnusedVar(lParam
);
5416 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5419 void wxWindowMSW::GenerateMouseLeave()
5421 m_mouseInWindow
= false;
5424 if ( wxIsShiftDown() )
5426 if ( wxIsCtrlDown() )
5427 state
|= MK_CONTROL
;
5429 // Only the high-order bit should be tested
5430 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5431 state
|= MK_LBUTTON
;
5432 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5433 state
|= MK_MBUTTON
;
5434 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5435 state
|= MK_RBUTTON
;
5439 if ( !::GetCursorPosWinCE(&pt
) )
5441 if ( !::GetCursorPos(&pt
) )
5444 wxLogLastError(_T("GetCursorPos"));
5447 // we need to have client coordinates here for symmetry with
5448 // wxEVT_ENTER_WINDOW
5449 RECT rect
= wxGetWindowRect(GetHwnd());
5453 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5454 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5456 (void)HandleWindowEvent(event
);
5459 // ---------------------------------------------------------------------------
5460 // keyboard handling
5461 // ---------------------------------------------------------------------------
5463 // create the key event of the given type for the given key - used by
5464 // HandleChar and HandleKeyDown/Up
5465 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5468 WXWPARAM wParam
) const
5470 wxKeyEvent
event(evType
);
5471 event
.SetId(GetId());
5472 event
.m_shiftDown
= wxIsShiftDown();
5473 event
.m_controlDown
= wxIsCtrlDown();
5474 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5476 event
.SetEventObject((wxWindow
*)this); // const_cast
5477 event
.m_keyCode
= id
;
5479 event
.m_uniChar
= (wxChar
) wParam
;
5481 event
.m_rawCode
= (wxUint32
) wParam
;
5482 event
.m_rawFlags
= (wxUint32
) lParam
;
5484 event
.SetTimestamp(::GetMessageTime());
5487 // translate the position to client coords
5490 GetCursorPosWinCE(&pt
);
5495 GetWindowRect(GetHwnd(),&rect
);
5505 // isASCII is true only when we're called from WM_CHAR handler and not from
5507 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5514 else // we're called from WM_KEYDOWN
5516 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5517 // to get numpad key codes: CHAR events should use the logical keys
5518 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5519 id
= wxCharCodeMSWToWX(wParam
);
5522 // it's ASCII and will be processed here only when called from
5523 // WM_CHAR (i.e. when isASCII = true), don't process it now
5528 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5530 // the alphanumeric keys produced by pressing AltGr+something on European
5531 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5532 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5533 // alphanumeric, so pretend that there are no modifiers at all (the
5534 // KEY_DOWN event would still have the correct modifiers if they're really
5536 if ( event
.m_controlDown
&& event
.m_altDown
&&
5537 (id
>= 32 && id
< 256) )
5539 event
.m_controlDown
=
5540 event
.m_altDown
= false;
5543 return HandleWindowEvent(event
);
5546 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5548 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5552 // normal ASCII char
5556 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5557 return HandleWindowEvent(event
);
5560 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5562 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5566 // normal ASCII char
5570 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5571 return HandleWindowEvent(event
);
5575 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5576 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5578 // FIXME: implement GetMenuItemCount for WinCE, possibly
5579 // in terms of GetMenuItemInfo
5581 const HMENU hmenu
= (HMENU
)lParam
;
5585 mii
.cbSize
= sizeof(MENUITEMINFO
);
5587 // we could use MIIM_FTYPE here as we only need to know if the item is
5588 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5589 // MIIM_FTYPE is not supported under Win95
5590 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5592 // find if we have this letter in any owner drawn item
5593 const int count
= ::GetMenuItemCount(hmenu
);
5594 for ( int i
= 0; i
< count
; i
++ )
5596 // previous loop iteration could modify it, reset it back before
5597 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5600 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5602 if ( mii
.fType
== MFT_OWNERDRAW
)
5604 // dwItemData member of the MENUITEMINFO is a
5605 // pointer to the associated wxMenuItem -- see the
5606 // menu creation code
5607 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5609 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), _T('&'));
5612 if ( *p
== _T('&') )
5614 // this is not the accel char, find the real one
5615 p
= wxStrchr(p
+ 1, _T('&'));
5617 else // got the accel char
5619 // FIXME-UNICODE: this comparison doesn't risk to work
5620 // for non ASCII accelerator characters I'm afraid, but
5622 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5628 // this one doesn't match
5635 else // failed to get the menu text?
5637 // it's not fatal, so don't show error, but still log it
5638 wxLogLastError(_T("GetMenuItemInfo"));
5645 #endif // wxUSE_MENUS
5647 bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg
)
5649 const wxEventType type
= nMsg
== WM_CUT
? wxEVT_COMMAND_TEXT_CUT
5650 : nMsg
== WM_COPY
? wxEVT_COMMAND_TEXT_COPY
5651 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE
;
5652 wxClipboardTextEvent
evt(type
, GetId());
5654 evt
.SetEventObject(this);
5656 return HandleWindowEvent(evt
);
5659 // ---------------------------------------------------------------------------
5661 // ---------------------------------------------------------------------------
5663 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5667 if ( flags
& JOY_BUTTON1CHG
)
5668 change
= wxJOY_BUTTON1
;
5669 if ( flags
& JOY_BUTTON2CHG
)
5670 change
= wxJOY_BUTTON2
;
5671 if ( flags
& JOY_BUTTON3CHG
)
5672 change
= wxJOY_BUTTON3
;
5673 if ( flags
& JOY_BUTTON4CHG
)
5674 change
= wxJOY_BUTTON4
;
5677 if ( flags
& JOY_BUTTON1
)
5678 buttons
|= wxJOY_BUTTON1
;
5679 if ( flags
& JOY_BUTTON2
)
5680 buttons
|= wxJOY_BUTTON2
;
5681 if ( flags
& JOY_BUTTON3
)
5682 buttons
|= wxJOY_BUTTON3
;
5683 if ( flags
& JOY_BUTTON4
)
5684 buttons
|= wxJOY_BUTTON4
;
5686 // the event ids aren't consecutive so we can't use table based lookup
5688 wxEventType eventType
;
5693 eventType
= wxEVT_JOY_MOVE
;
5698 eventType
= wxEVT_JOY_MOVE
;
5703 eventType
= wxEVT_JOY_ZMOVE
;
5708 eventType
= wxEVT_JOY_ZMOVE
;
5711 case MM_JOY1BUTTONDOWN
:
5713 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5716 case MM_JOY2BUTTONDOWN
:
5718 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5721 case MM_JOY1BUTTONUP
:
5723 eventType
= wxEVT_JOY_BUTTON_UP
;
5726 case MM_JOY2BUTTONUP
:
5728 eventType
= wxEVT_JOY_BUTTON_UP
;
5732 wxFAIL_MSG(wxT("no such joystick event"));
5737 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5738 event
.SetPosition(wxPoint(x
, y
));
5739 event
.SetEventObject(this);
5741 return HandleWindowEvent(event
);
5751 // ---------------------------------------------------------------------------
5753 // ---------------------------------------------------------------------------
5755 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5756 WXWORD pos
, WXHWND control
)
5758 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5760 wxWindow
*child
= wxFindWinFromHandle(control
);
5762 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5765 wxScrollWinEvent event
;
5766 event
.SetPosition(pos
);
5767 event
.SetOrientation(orientation
);
5768 event
.SetEventObject(this);
5773 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5777 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5781 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5785 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5789 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5793 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5796 case SB_THUMBPOSITION
:
5798 // under Win32, the scrollbar range and position are 32 bit integers,
5799 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5800 // explicitly query the scrollbar for the correct position (this must
5801 // be done only for these two SB_ events as they are the only one
5802 // carrying the scrollbar position)
5804 WinStruct
<SCROLLINFO
> scrollInfo
;
5805 scrollInfo
.fMask
= SIF_TRACKPOS
;
5807 if ( !::GetScrollInfo(GetHwnd(),
5808 orientation
== wxHORIZONTAL
? SB_HORZ
5812 // Not necessarily an error, if there are no scrollbars yet.
5813 // wxLogLastError(_T("GetScrollInfo"));
5816 event
.SetPosition(scrollInfo
.nTrackPos
);
5819 event
.SetEventType( wParam
== SB_THUMBPOSITION
5820 ? wxEVT_SCROLLWIN_THUMBRELEASE
5821 : wxEVT_SCROLLWIN_THUMBTRACK
);
5828 return HandleWindowEvent(event
);
5831 // ----------------------------------------------------------------------------
5832 // custom message handlers
5833 // ----------------------------------------------------------------------------
5836 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5838 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5839 false, _T("registering handler for the same message twice") );
5841 gs_messageHandlers
[msg
] = handler
;
5846 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5848 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5849 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5850 _T("unregistering non-registered handler?") );
5852 gs_messageHandlers
.erase(i
);
5855 // ===========================================================================
5857 // ===========================================================================
5859 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5862 HDC dc
= ::GetDC((HWND
) wnd
);
5865 // the_font.UseResource();
5866 // the_font.RealizeResource();
5867 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5869 was
= (HFONT
) SelectObject(dc
,fnt
);
5871 GetTextMetrics(dc
, &tm
);
5874 SelectObject(dc
,was
);
5876 ReleaseDC((HWND
)wnd
, dc
);
5879 *x
= tm
.tmAveCharWidth
;
5881 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5883 // the_font.ReleaseResource();
5886 // use the "extended" bit (24) of lParam to distinguish extended keys
5887 // from normal keys as the same key is sent
5889 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5891 // except that if lParam is 0, it means we don't have real lParam from
5892 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5893 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5894 // non-numpad (hence extended) key as this is a more common case
5895 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5898 // this array contains the Windows virtual key codes which map one to one to
5899 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5901 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5902 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5903 static const struct wxKeyMapping
5907 } gs_specialKeys
[] =
5909 { VK_CANCEL
, WXK_CANCEL
},
5910 { VK_BACK
, WXK_BACK
},
5911 { VK_TAB
, WXK_TAB
},
5912 { VK_CLEAR
, WXK_CLEAR
},
5913 { VK_SHIFT
, WXK_SHIFT
},
5914 { VK_CONTROL
, WXK_CONTROL
},
5915 { VK_MENU
, WXK_ALT
},
5916 { VK_PAUSE
, WXK_PAUSE
},
5917 { VK_CAPITAL
, WXK_CAPITAL
},
5918 { VK_SPACE
, WXK_SPACE
},
5919 { VK_ESCAPE
, WXK_ESCAPE
},
5920 { VK_SELECT
, WXK_SELECT
},
5921 { VK_PRINT
, WXK_PRINT
},
5922 { VK_EXECUTE
, WXK_EXECUTE
},
5923 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5924 { VK_HELP
, WXK_HELP
},
5926 { VK_NUMPAD0
, WXK_NUMPAD0
},
5927 { VK_NUMPAD1
, WXK_NUMPAD1
},
5928 { VK_NUMPAD2
, WXK_NUMPAD2
},
5929 { VK_NUMPAD3
, WXK_NUMPAD3
},
5930 { VK_NUMPAD4
, WXK_NUMPAD4
},
5931 { VK_NUMPAD5
, WXK_NUMPAD5
},
5932 { VK_NUMPAD6
, WXK_NUMPAD6
},
5933 { VK_NUMPAD7
, WXK_NUMPAD7
},
5934 { VK_NUMPAD8
, WXK_NUMPAD8
},
5935 { VK_NUMPAD9
, WXK_NUMPAD9
},
5936 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5937 { VK_ADD
, WXK_NUMPAD_ADD
},
5938 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5939 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5940 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5951 { VK_F10
, WXK_F10
},
5952 { VK_F11
, WXK_F11
},
5953 { VK_F12
, WXK_F12
},
5954 { VK_F13
, WXK_F13
},
5955 { VK_F14
, WXK_F14
},
5956 { VK_F15
, WXK_F15
},
5957 { VK_F16
, WXK_F16
},
5958 { VK_F17
, WXK_F17
},
5959 { VK_F18
, WXK_F18
},
5960 { VK_F19
, WXK_F19
},
5961 { VK_F20
, WXK_F20
},
5962 { VK_F21
, WXK_F21
},
5963 { VK_F22
, WXK_F22
},
5964 { VK_F23
, WXK_F23
},
5965 { VK_F24
, WXK_F24
},
5967 { VK_NUMLOCK
, WXK_NUMLOCK
},
5968 { VK_SCROLL
, WXK_SCROLL
},
5971 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5972 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5973 { VK_APPS
, WXK_WINDOWS_MENU
},
5974 #endif // VK_APPS defined
5977 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5978 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5979 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5981 // check the table first
5982 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5984 if ( gs_specialKeys
[n
].vk
== vk
)
5985 return gs_specialKeys
[n
].wxk
;
5988 // keys requiring special handling
5992 // the mapping for these keys may be incorrect on non-US keyboards so
5993 // maybe we shouldn't map them to ASCII values at all
5994 case VK_OEM_1
: wxk
= ';'; break;
5995 case VK_OEM_PLUS
: wxk
= '+'; break;
5996 case VK_OEM_COMMA
: wxk
= ','; break;
5997 case VK_OEM_MINUS
: wxk
= '-'; break;
5998 case VK_OEM_PERIOD
: wxk
= '.'; break;
5999 case VK_OEM_2
: wxk
= '/'; break;
6000 case VK_OEM_3
: wxk
= '~'; break;
6001 case VK_OEM_4
: wxk
= '['; break;
6002 case VK_OEM_5
: wxk
= '\\'; break;
6003 case VK_OEM_6
: wxk
= ']'; break;
6004 case VK_OEM_7
: wxk
= '\''; break;
6006 // handle extended keys
6008 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
6012 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
6016 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6020 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6024 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6028 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6032 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6036 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6040 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6044 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6048 // don't use ChooseNormalOrExtended() here as the keys are reversed
6049 // here: numpad enter is the extended one
6050 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6060 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
6065 // check the table first
6066 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6068 if ( gs_specialKeys
[n
].wxk
== wxk
)
6069 return gs_specialKeys
[n
].vk
;
6072 // and then check for special keys not included in the table
6077 case WXK_NUMPAD_PAGEUP
:
6082 case WXK_NUMPAD_PAGEDOWN
:
6087 case WXK_NUMPAD_END
:
6092 case WXK_NUMPAD_HOME
:
6097 case WXK_NUMPAD_LEFT
:
6107 case WXK_NUMPAD_RIGHT
:
6112 case WXK_NUMPAD_DOWN
:
6117 case WXK_NUMPAD_INSERT
:
6122 case WXK_NUMPAD_DELETE
:
6127 // no VkKeyScan() under CE unfortunately, we need to test how does
6128 // it handle OEM keys
6130 // check to see if its one of the OEM key codes.
6131 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6137 #endif // !__WXWINCE__
6148 // small helper for wxGetKeyState() and wxGetMouseState()
6149 static inline bool wxIsKeyDown(WXWORD vk
)
6151 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6152 #ifdef SM_SWAPBUTTON
6153 if ( vk
== VK_LBUTTON
|| vk
== VK_RBUTTON
)
6155 if ( ::GetSystemMetrics(SM_SWAPBUTTON
) )
6157 if ( vk
== VK_LBUTTON
)
6159 else // vk == VK_RBUTTON
6163 #endif // SM_SWAPBUTTON
6165 // the low order bit indicates whether the key was pressed since the last
6166 // call and the high order one indicates whether it is down right now and
6167 // we only want that one
6168 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6171 bool wxGetKeyState(wxKeyCode key
)
6173 // although this does work under Windows, it is not supported under other
6174 // platforms so don't allow it, you must use wxGetMouseState() instead
6175 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6176 key
!= VK_RBUTTON
&&
6178 wxT("can't use wxGetKeyState() for mouse buttons") );
6180 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6182 // if the requested key is a LED key, return true if the led is pressed
6183 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6185 // low order bit means LED is highlighted and high order one means the
6186 // key is down; for compatibility with the other ports return true if
6187 // either one is set
6188 return GetKeyState(vk
) != 0;
6193 return wxIsKeyDown(vk
);
6198 wxMouseState
wxGetMouseState()
6202 GetCursorPos( &pt
);
6206 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6207 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6208 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6209 #ifdef wxHAS_XBUTTON
6210 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6211 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6212 #endif // wxHAS_XBUTTON
6214 ms
.SetControlDown(wxIsCtrlDown ());
6215 ms
.SetShiftDown (wxIsShiftDown());
6216 ms
.SetAltDown (wxIsAltDown ());
6217 // ms.SetMetaDown();
6223 wxWindow
*wxGetActiveWindow()
6225 HWND hWnd
= GetActiveWindow();
6228 return wxFindWinFromHandle(hWnd
);
6233 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6235 HWND hwnd
= (HWND
)hWnd
;
6237 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6238 // by code in msw/radiobox.cpp), for all the others we just search up the
6240 wxWindow
*win
= (wxWindow
*)NULL
;
6243 win
= wxFindWinFromHandle(hwnd
);
6247 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6248 // wxWindow class which overrides WM_GETDLGCODE processing to
6249 // do it as well, win would be already non NULL
6250 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6252 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6254 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6255 #endif // wxUSE_RADIOBOX
6257 // spin control text buddy window should be mapped to spin ctrl
6258 // itself so try it too
6259 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6262 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6264 #endif // wxUSE_SPINCTRL
6268 while ( hwnd
&& !win
)
6270 // this is a really ugly hack needed to avoid mistakenly returning the
6271 // parent frame wxWindow for the find/replace modeless dialog HWND -
6272 // this, in turn, is needed to call IsDialogMessage() from
6273 // wxApp::ProcessMessage() as for this we must return NULL from here
6275 // FIXME: this is clearly not the best way to do it but I think we'll
6276 // need to change HWND <-> wxWindow code more heavily than I can
6277 // do it now to fix it
6278 #ifndef __WXMICROWIN__
6279 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6281 // it's a dialog box, don't go upwards
6286 hwnd
= ::GetParent(hwnd
);
6287 win
= wxFindWinFromHandle(hwnd
);
6293 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6295 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6296 // in active frames and dialogs, regardless of where the focus is.
6297 static HHOOK wxTheKeyboardHook
= 0;
6298 static FARPROC wxTheKeyboardHookProc
= 0;
6299 int APIENTRY _EXPORT
6300 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
6302 void wxSetKeyboardHook(bool doIt
)
6306 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
6307 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
6309 GetCurrentThreadId()
6310 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
6315 UnhookWindowsHookEx(wxTheKeyboardHook
);
6319 int APIENTRY _EXPORT
6320 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6322 DWORD hiWord
= HIWORD(lParam
);
6323 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6325 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6328 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6329 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6330 event
.m_altDown
= true;
6332 event
.SetEventObject(NULL
);
6333 event
.m_keyCode
= id
;
6334 event
.m_shiftDown
= wxIsShiftDown();
6335 event
.m_controlDown
= wxIsCtrlDown();
6337 event
.SetTimestamp(::GetMessageTime());
6339 wxWindow
*win
= wxGetActiveWindow();
6340 wxEvtHandler
*handler
;
6343 handler
= win
->GetEventHandler();
6344 event
.SetId(win
->GetId());
6349 event
.SetId(wxID_ANY
);
6352 if ( handler
&& handler
->ProcessEvent(event
) )
6360 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6363 #endif // !__WXMICROWIN__
6366 const wxChar
*wxGetMessageName(int message
)
6370 case 0x0000: return wxT("WM_NULL");
6371 case 0x0001: return wxT("WM_CREATE");
6372 case 0x0002: return wxT("WM_DESTROY");
6373 case 0x0003: return wxT("WM_MOVE");
6374 case 0x0005: return wxT("WM_SIZE");
6375 case 0x0006: return wxT("WM_ACTIVATE");
6376 case 0x0007: return wxT("WM_SETFOCUS");
6377 case 0x0008: return wxT("WM_KILLFOCUS");
6378 case 0x000A: return wxT("WM_ENABLE");
6379 case 0x000B: return wxT("WM_SETREDRAW");
6380 case 0x000C: return wxT("WM_SETTEXT");
6381 case 0x000D: return wxT("WM_GETTEXT");
6382 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6383 case 0x000F: return wxT("WM_PAINT");
6384 case 0x0010: return wxT("WM_CLOSE");
6385 case 0x0011: return wxT("WM_QUERYENDSESSION");
6386 case 0x0012: return wxT("WM_QUIT");
6387 case 0x0013: return wxT("WM_QUERYOPEN");
6388 case 0x0014: return wxT("WM_ERASEBKGND");
6389 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6390 case 0x0016: return wxT("WM_ENDSESSION");
6391 case 0x0017: return wxT("WM_SYSTEMERROR");
6392 case 0x0018: return wxT("WM_SHOWWINDOW");
6393 case 0x0019: return wxT("WM_CTLCOLOR");
6394 case 0x001A: return wxT("WM_WININICHANGE");
6395 case 0x001B: return wxT("WM_DEVMODECHANGE");
6396 case 0x001C: return wxT("WM_ACTIVATEAPP");
6397 case 0x001D: return wxT("WM_FONTCHANGE");
6398 case 0x001E: return wxT("WM_TIMECHANGE");
6399 case 0x001F: return wxT("WM_CANCELMODE");
6400 case 0x0020: return wxT("WM_SETCURSOR");
6401 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6402 case 0x0022: return wxT("WM_CHILDACTIVATE");
6403 case 0x0023: return wxT("WM_QUEUESYNC");
6404 case 0x0024: return wxT("WM_GETMINMAXINFO");
6405 case 0x0026: return wxT("WM_PAINTICON");
6406 case 0x0027: return wxT("WM_ICONERASEBKGND");
6407 case 0x0028: return wxT("WM_NEXTDLGCTL");
6408 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6409 case 0x002B: return wxT("WM_DRAWITEM");
6410 case 0x002C: return wxT("WM_MEASUREITEM");
6411 case 0x002D: return wxT("WM_DELETEITEM");
6412 case 0x002E: return wxT("WM_VKEYTOITEM");
6413 case 0x002F: return wxT("WM_CHARTOITEM");
6414 case 0x0030: return wxT("WM_SETFONT");
6415 case 0x0031: return wxT("WM_GETFONT");
6416 case 0x0037: return wxT("WM_QUERYDRAGICON");
6417 case 0x0039: return wxT("WM_COMPAREITEM");
6418 case 0x0041: return wxT("WM_COMPACTING");
6419 case 0x0044: return wxT("WM_COMMNOTIFY");
6420 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6421 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6422 case 0x0048: return wxT("WM_POWER");
6424 case 0x004A: return wxT("WM_COPYDATA");
6425 case 0x004B: return wxT("WM_CANCELJOURNAL");
6426 case 0x004E: return wxT("WM_NOTIFY");
6427 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6428 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6429 case 0x0052: return wxT("WM_TCARD");
6430 case 0x0053: return wxT("WM_HELP");
6431 case 0x0054: return wxT("WM_USERCHANGED");
6432 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6433 case 0x007B: return wxT("WM_CONTEXTMENU");
6434 case 0x007C: return wxT("WM_STYLECHANGING");
6435 case 0x007D: return wxT("WM_STYLECHANGED");
6436 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6437 case 0x007F: return wxT("WM_GETICON");
6438 case 0x0080: return wxT("WM_SETICON");
6440 case 0x0081: return wxT("WM_NCCREATE");
6441 case 0x0082: return wxT("WM_NCDESTROY");
6442 case 0x0083: return wxT("WM_NCCALCSIZE");
6443 case 0x0084: return wxT("WM_NCHITTEST");
6444 case 0x0085: return wxT("WM_NCPAINT");
6445 case 0x0086: return wxT("WM_NCACTIVATE");
6446 case 0x0087: return wxT("WM_GETDLGCODE");
6447 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6448 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6449 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6450 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6451 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6452 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6453 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6454 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6455 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6456 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6458 case 0x00B0: return wxT("EM_GETSEL");
6459 case 0x00B1: return wxT("EM_SETSEL");
6460 case 0x00B2: return wxT("EM_GETRECT");
6461 case 0x00B3: return wxT("EM_SETRECT");
6462 case 0x00B4: return wxT("EM_SETRECTNP");
6463 case 0x00B5: return wxT("EM_SCROLL");
6464 case 0x00B6: return wxT("EM_LINESCROLL");
6465 case 0x00B7: return wxT("EM_SCROLLCARET");
6466 case 0x00B8: return wxT("EM_GETMODIFY");
6467 case 0x00B9: return wxT("EM_SETMODIFY");
6468 case 0x00BA: return wxT("EM_GETLINECOUNT");
6469 case 0x00BB: return wxT("EM_LINEINDEX");
6470 case 0x00BC: return wxT("EM_SETHANDLE");
6471 case 0x00BD: return wxT("EM_GETHANDLE");
6472 case 0x00BE: return wxT("EM_GETTHUMB");
6473 case 0x00C1: return wxT("EM_LINELENGTH");
6474 case 0x00C2: return wxT("EM_REPLACESEL");
6475 case 0x00C4: return wxT("EM_GETLINE");
6476 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6477 case 0x00C6: return wxT("EM_CANUNDO");
6478 case 0x00C7: return wxT("EM_UNDO");
6479 case 0x00C8: return wxT("EM_FMTLINES");
6480 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6481 case 0x00CB: return wxT("EM_SETTABSTOPS");
6482 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6483 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6484 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6485 case 0x00CF: return wxT("EM_SETREADONLY");
6486 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6487 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6488 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6489 case 0x00D3: return wxT("EM_SETMARGINS");
6490 case 0x00D4: return wxT("EM_GETMARGINS");
6491 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6492 case 0x00D6: return wxT("EM_POSFROMCHAR");
6493 case 0x00D7: return wxT("EM_CHARFROMPOS");
6494 case 0x00D8: return wxT("EM_SETIMESTATUS");
6495 case 0x00D9: return wxT("EM_GETIMESTATUS");
6497 case 0x0100: return wxT("WM_KEYDOWN");
6498 case 0x0101: return wxT("WM_KEYUP");
6499 case 0x0102: return wxT("WM_CHAR");
6500 case 0x0103: return wxT("WM_DEADCHAR");
6501 case 0x0104: return wxT("WM_SYSKEYDOWN");
6502 case 0x0105: return wxT("WM_SYSKEYUP");
6503 case 0x0106: return wxT("WM_SYSCHAR");
6504 case 0x0107: return wxT("WM_SYSDEADCHAR");
6505 case 0x0108: return wxT("WM_KEYLAST");
6507 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6508 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6509 case 0x010F: return wxT("WM_IME_COMPOSITION");
6511 case 0x0110: return wxT("WM_INITDIALOG");
6512 case 0x0111: return wxT("WM_COMMAND");
6513 case 0x0112: return wxT("WM_SYSCOMMAND");
6514 case 0x0113: return wxT("WM_TIMER");
6515 case 0x0114: return wxT("WM_HSCROLL");
6516 case 0x0115: return wxT("WM_VSCROLL");
6517 case 0x0116: return wxT("WM_INITMENU");
6518 case 0x0117: return wxT("WM_INITMENUPOPUP");
6519 case 0x011F: return wxT("WM_MENUSELECT");
6520 case 0x0120: return wxT("WM_MENUCHAR");
6521 case 0x0121: return wxT("WM_ENTERIDLE");
6523 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6524 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6525 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6526 case 0x0135: return wxT("WM_CTLCOLORBTN");
6527 case 0x0136: return wxT("WM_CTLCOLORDLG");
6528 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6529 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6530 case 0x01E1: return wxT("MN_GETHMENU");
6532 case 0x0200: return wxT("WM_MOUSEMOVE");
6533 case 0x0201: return wxT("WM_LBUTTONDOWN");
6534 case 0x0202: return wxT("WM_LBUTTONUP");
6535 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6536 case 0x0204: return wxT("WM_RBUTTONDOWN");
6537 case 0x0205: return wxT("WM_RBUTTONUP");
6538 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6539 case 0x0207: return wxT("WM_MBUTTONDOWN");
6540 case 0x0208: return wxT("WM_MBUTTONUP");
6541 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6542 case 0x020A: return wxT("WM_MOUSEWHEEL");
6543 case 0x020B: return wxT("WM_XBUTTONDOWN");
6544 case 0x020C: return wxT("WM_XBUTTONUP");
6545 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6546 case 0x0210: return wxT("WM_PARENTNOTIFY");
6547 case 0x0211: return wxT("WM_ENTERMENULOOP");
6548 case 0x0212: return wxT("WM_EXITMENULOOP");
6550 case 0x0213: return wxT("WM_NEXTMENU");
6551 case 0x0214: return wxT("WM_SIZING");
6552 case 0x0215: return wxT("WM_CAPTURECHANGED");
6553 case 0x0216: return wxT("WM_MOVING");
6554 case 0x0218: return wxT("WM_POWERBROADCAST");
6555 case 0x0219: return wxT("WM_DEVICECHANGE");
6557 case 0x0220: return wxT("WM_MDICREATE");
6558 case 0x0221: return wxT("WM_MDIDESTROY");
6559 case 0x0222: return wxT("WM_MDIACTIVATE");
6560 case 0x0223: return wxT("WM_MDIRESTORE");
6561 case 0x0224: return wxT("WM_MDINEXT");
6562 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6563 case 0x0226: return wxT("WM_MDITILE");
6564 case 0x0227: return wxT("WM_MDICASCADE");
6565 case 0x0228: return wxT("WM_MDIICONARRANGE");
6566 case 0x0229: return wxT("WM_MDIGETACTIVE");
6567 case 0x0230: return wxT("WM_MDISETMENU");
6568 case 0x0233: return wxT("WM_DROPFILES");
6570 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6571 case 0x0282: return wxT("WM_IME_NOTIFY");
6572 case 0x0283: return wxT("WM_IME_CONTROL");
6573 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6574 case 0x0285: return wxT("WM_IME_SELECT");
6575 case 0x0286: return wxT("WM_IME_CHAR");
6576 case 0x0290: return wxT("WM_IME_KEYDOWN");
6577 case 0x0291: return wxT("WM_IME_KEYUP");
6579 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6580 case 0x02A1: return wxT("WM_MOUSEHOVER");
6581 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6582 case 0x02A3: return wxT("WM_MOUSELEAVE");
6584 case 0x0300: return wxT("WM_CUT");
6585 case 0x0301: return wxT("WM_COPY");
6586 case 0x0302: return wxT("WM_PASTE");
6587 case 0x0303: return wxT("WM_CLEAR");
6588 case 0x0304: return wxT("WM_UNDO");
6589 case 0x0305: return wxT("WM_RENDERFORMAT");
6590 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6591 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6592 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6593 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6594 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6595 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6596 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6597 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6598 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6599 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6600 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6601 case 0x0311: return wxT("WM_PALETTECHANGED");
6602 case 0x0312: return wxT("WM_HOTKEY");
6604 case 0x0317: return wxT("WM_PRINT");
6605 case 0x0318: return wxT("WM_PRINTCLIENT");
6607 // common controls messages - although they're not strictly speaking
6608 // standard, it's nice to decode them nevertheless
6611 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6612 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6613 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6614 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6615 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6616 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6617 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6618 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6619 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6620 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6621 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6622 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6623 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6624 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6625 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6626 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6627 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6628 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6629 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6630 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6631 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6632 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6633 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6634 case 0x1000 + 18: return wxT("LVM_HITTEST");
6635 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6636 case 0x1000 + 20: return wxT("LVM_SCROLL");
6637 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6638 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6639 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6640 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6641 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6642 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6643 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6644 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6645 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6646 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6647 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6648 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6649 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6650 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6651 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6652 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6653 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6654 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6655 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6656 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6657 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6658 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6659 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6660 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6661 case 0x1000 + 42: return wxT("LVM_UPDATE");
6662 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6663 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6664 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6665 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6666 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6667 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6668 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6669 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6670 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6671 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6672 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6673 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6674 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6675 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6676 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6677 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6678 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6679 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6680 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6681 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6682 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6683 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6684 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6685 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6686 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6687 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6690 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6691 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6692 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6693 case 0x1100 + 2: return wxT("TVM_EXPAND");
6694 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6695 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6696 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6697 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6698 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6699 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6700 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6701 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6702 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6703 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6704 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6705 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6706 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6707 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6708 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6709 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6710 case 0x1100 + 17: return wxT("TVM_HITTEST");
6711 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6712 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6713 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6714 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6715 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6716 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6717 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6718 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6719 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6722 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6723 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6724 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6725 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6726 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6727 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6728 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6729 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6730 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6731 case 0x1200 + 6: return wxT("HDM_HITTEST");
6732 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6733 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6734 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6735 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6736 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6737 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6738 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6739 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6742 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6743 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6744 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6745 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6746 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6747 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6748 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6749 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6750 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6751 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6752 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6753 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6754 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6755 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6756 case 0x1300 + 13: return wxT("TCM_HITTEST");
6757 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6758 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6759 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6760 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6761 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6762 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6763 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6764 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6765 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6766 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6767 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6768 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6771 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6772 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6773 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6774 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6775 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6776 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6777 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6778 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6779 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6780 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6781 case WM_USER
+17: return wxT("TB_SETSTATE");
6782 case WM_USER
+18: return wxT("TB_GETSTATE");
6783 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6784 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6785 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6786 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6787 case WM_USER
+23: return wxT("TB_GETBUTTON");
6788 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6789 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6790 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6791 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6792 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6793 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6794 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6795 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6796 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6797 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6798 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6799 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6800 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6801 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6802 case WM_USER
+37: return wxT("TB_SETPARENT");
6803 case WM_USER
+39: return wxT("TB_SETROWS");
6804 case WM_USER
+40: return wxT("TB_GETROWS");
6805 case WM_USER
+42: return wxT("TB_SETCMDID");
6806 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6807 case WM_USER
+44: return wxT("TB_GETBITMAP");
6808 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6809 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6810 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6811 case WM_USER
+47: return wxT("TB_SETINDENT");
6812 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6813 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6814 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6815 case WM_USER
+51: return wxT("TB_GETRECT");
6816 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6817 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6818 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6819 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6820 case WM_USER
+56: return wxT("TB_SETSTYLE");
6821 case WM_USER
+57: return wxT("TB_GETSTYLE");
6822 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6823 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6824 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6825 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6826 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6829 static wxString s_szBuf
;
6830 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6831 return s_szBuf
.c_str();
6834 #endif //__WXDEBUG__
6836 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6840 HWND hwnd
= GetHwndOf(win
);
6841 HDC hdc
= ::GetDC(hwnd
);
6843 #if !wxDIALOG_UNIT_COMPATIBILITY
6844 // and select the current font into it
6845 HFONT hfont
= GetHfontOf(win
->GetFont());
6848 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6852 // finally retrieve the text metrics from it
6853 GetTextMetrics(hdc
, &tm
);
6855 #if !wxDIALOG_UNIT_COMPATIBILITY
6859 (void)::SelectObject(hdc
, hfont
);
6863 ::ReleaseDC(hwnd
, hdc
);
6868 // Find the wxWindow at the current mouse position, returning the mouse
6870 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6872 pt
= wxGetMousePosition();
6873 return wxFindWindowAtPoint(pt
);
6876 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6882 HWND hWnd
= ::WindowFromPoint(pt2
);
6884 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6887 // Get the current mouse position.
6888 wxPoint
wxGetMousePosition()
6892 GetCursorPosWinCE(&pt
);
6894 GetCursorPos( & pt
);
6897 return wxPoint(pt
.x
, pt
.y
);
6902 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6903 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6905 // Register hotkeys for the hardware buttons
6907 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6909 UnregisterFunc1Proc procUnregisterFunc
;
6910 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6913 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6914 if (procUnregisterFunc
)
6915 procUnregisterFunc(modifiers
, id
);
6916 FreeLibrary(hCoreDll
);
6921 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6923 UINT win_modifiers
=0;
6924 if ( modifiers
& wxMOD_ALT
)
6925 win_modifiers
|= MOD_ALT
;
6926 if ( modifiers
& wxMOD_SHIFT
)
6927 win_modifiers
|= MOD_SHIFT
;
6928 if ( modifiers
& wxMOD_CONTROL
)
6929 win_modifiers
|= MOD_CONTROL
;
6930 if ( modifiers
& wxMOD_WIN
)
6931 win_modifiers
|= MOD_WIN
;
6933 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6934 // Required for PPC and Smartphone hardware buttons
6935 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6936 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6939 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6941 wxLogLastError(_T("RegisterHotKey"));
6949 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6951 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6952 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6955 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6957 wxLogLastError(_T("UnregisterHotKey"));
6967 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6969 int hotkeyId
= wParam
;
6970 int virtualKey
= HIWORD(lParam
);
6971 int win_modifiers
= LOWORD(lParam
);
6973 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6974 event
.SetId(hotkeyId
);
6975 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6976 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6977 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6978 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6980 return HandleWindowEvent(event
);
6983 #endif // wxUSE_ACCEL
6985 #endif // wxUSE_HOTKEY
6987 // Not tested under WinCE
6990 // this class installs a message hook which really wakes up our idle processing
6991 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6992 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6993 // being dragged or even inside ::MessageBox()) and so don't control message
6994 // dispatching otherwise
6995 class wxIdleWakeUpModule
: public wxModule
6998 virtual bool OnInit()
7000 ms_hMsgHookProc
= ::SetWindowsHookEx
7003 &wxIdleWakeUpModule::MsgHookProc
,
7005 GetCurrentThreadId()
7008 if ( !ms_hMsgHookProc
)
7010 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
7018 virtual void OnExit()
7020 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
7023 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
7025 MSG
*msg
= (MSG
*)lParam
;
7027 // only process the message if it is actually going to be removed from
7028 // the message queue, this prevents that the same event from being
7029 // processed multiple times if now someone just called PeekMessage()
7030 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7032 wxTheApp
->ProcessPendingEvents();
7035 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7039 static HHOOK ms_hMsgHookProc
;
7041 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7044 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7046 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7048 #endif // __WXWINCE__
7053 static void wxAdjustZOrder(wxWindow
* parent
)
7055 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7057 // Set the z-order correctly
7058 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7061 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7064 wxWindow
*childWin
= current
->GetData();
7065 wxAdjustZOrder(childWin
);
7066 current
= current
->GetNext();
7071 // We need to adjust the z-order of static boxes in WinCE, to
7072 // make 'contained' controls visible
7073 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7076 wxAdjustZOrder(this);