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 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
155 // when mouse position didnd't change
157 #define wxUSE_MOUSEEVENT_HACK 0
159 #define wxUSE_MOUSEEVENT_HACK 1
162 // not all compilers/platforms have X button related declarations (notably
163 // Windows CE doesn't, and probably some old SDKs don't neither)
164 #ifdef WM_XBUTTONDOWN
165 #define wxHAS_XBUTTON
168 // ---------------------------------------------------------------------------
170 // ---------------------------------------------------------------------------
172 #if wxUSE_MENUS_NATIVE
173 extern wxMenu
*wxCurrentPopupMenu
;
179 // true if we had already created the std colour map, used by
180 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
181 bool gs_hasStdCmap
= false;
183 // last mouse event information we need to filter out the duplicates
184 #if wxUSE_MOUSEEVENT_HACK
185 struct MouseEventInfoDummy
187 // mouse position (in screen coordinates)
190 // last mouse event type
193 #endif // wxUSE_MOUSEEVENT_HACK
195 // hash containing the registered handlers for the custom messages
196 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
197 wxIntegerHash
, wxIntegerEqual
,
200 MSWMessageHandlers gs_messageHandlers
;
202 // hash containing all our windows, it uses HWND keys and wxWindow* values
203 WX_DECLARE_HASH_MAP(HWND
, wxWindow
*,
204 wxPointerHash
, wxPointerEqual
,
207 WindowHandles gs_windowHandles
;
209 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
211 // temporary override for WM_ERASEBKGND processing: we don't store this in
212 // wxWindow itself as we don't need it during most of the time so don't
213 // increase the size of all window objects unnecessarily
214 WX_DECLARE_HASH_MAP(wxWindow
*, wxWindow
*,
215 wxPointerHash
, wxPointerEqual
,
218 EraseBgHooks gs_eraseBgHooks
;
220 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
222 } // anonymous namespace
224 // ---------------------------------------------------------------------------
226 // ---------------------------------------------------------------------------
228 // the window proc for all our windows
229 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
230 WPARAM wParam
, LPARAM lParam
);
233 #if wxDEBUG_LEVEL >= 2
234 const wxChar
*wxGetMessageName(int message
);
235 #endif // wxDEBUG_LEVEL >= 2
237 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
238 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
240 // get the text metrics for the current font
241 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
244 // find the window for the mouse event at the specified position
245 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
246 #endif // __WXWINCE__
248 // wrapper around BringWindowToTop() API
249 static inline void wxBringWindowToTop(HWND hwnd
)
251 #ifdef __WXMICROWIN__
252 // It seems that MicroWindows brings the _parent_ of the window to the top,
253 // which can be the wrong one.
255 // activate (set focus to) specified window
259 // raise top level parent to top of z order
260 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
262 wxLogLastError(wxT("SetWindowPos"));
268 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
269 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
272 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
273 parent as well as otherwise several Win32 functions using
274 GetNextDlgTabItem() to iterate over all controls such as
275 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
276 all of them iterate over all the controls starting from the currently
277 focused one and stop iterating when they get back to the focus but
278 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
279 get back to the initial (focused) window: as we do have this style,
280 GetNextDlgTabItem() will leave this window and continue in its parent,
281 but if the parent doesn't have it, it wouldn't recurse inside it later
282 on and so wouldn't have a chance of getting back to this window either.
284 while ( parent
&& !parent
->IsTopLevel() )
286 LONG exStyle
= wxGetWindowExStyle(parent
);
287 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
289 // force the parent to have this style
290 wxSetWindowExStyle(parent
, exStyle
| WS_EX_CONTROLPARENT
);
293 parent
= parent
->GetParent();
297 #endif // !__WXWINCE__
300 // On Windows CE, GetCursorPos can return an error, so use this function
302 bool GetCursorPosWinCE(POINT
* pt
)
304 if (!GetCursorPos(pt
))
306 DWORD pos
= GetMessagePos();
314 // ---------------------------------------------------------------------------
316 // ---------------------------------------------------------------------------
318 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
320 #ifdef __WXUNIVERSAL__
321 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
323 #if wxUSE_EXTENDED_RTTI
325 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
326 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
327 // windows with negative ids never can be recreated anyway
329 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
331 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
332 if ( win
&& win
->GetId() < 0 )
337 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
339 // make wxWindowList known before the property is used
341 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
343 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
345 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
348 WX_DEFINE_FLAGS( wxWindowStyle
)
350 wxBEGIN_FLAGS( wxWindowStyle
)
351 // new style border flags, we put them first to
352 // use them for streaming out
354 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
355 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
356 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
357 wxFLAGS_MEMBER(wxBORDER_RAISED
)
358 wxFLAGS_MEMBER(wxBORDER_STATIC
)
359 wxFLAGS_MEMBER(wxBORDER_NONE
)
361 // old style border flags
362 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
363 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
364 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
365 wxFLAGS_MEMBER(wxRAISED_BORDER
)
366 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
367 wxFLAGS_MEMBER(wxBORDER
)
369 // standard window styles
370 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
371 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
372 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
373 wxFLAGS_MEMBER(wxWANTS_CHARS
)
374 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
375 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
376 wxFLAGS_MEMBER(wxVSCROLL
)
377 wxFLAGS_MEMBER(wxHSCROLL
)
379 wxEND_FLAGS( wxWindowStyle
)
381 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
382 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
383 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
384 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
385 // Always constructor Properties first
387 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
388 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
389 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
390 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
391 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
393 // Then all relations of the object graph
395 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
397 // and finally all other properties
399 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
400 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
401 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
402 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
403 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
405 // possible property candidates (not in xrc) or not valid in all subclasses
406 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
407 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
408 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
409 // MaxHeight, Width , MinHeight , Width
410 // TODO switch label to control and title to toplevels
412 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
413 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
414 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
415 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
420 wxEND_PROPERTIES_TABLE()
422 wxBEGIN_HANDLERS_TABLE(wxWindow
)
423 wxEND_HANDLERS_TABLE()
425 wxCONSTRUCTOR_DUMMY(wxWindow
)
428 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
430 #endif // __WXUNIVERSAL__/__WXMSW__
432 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
433 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
435 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
439 // ===========================================================================
441 // ===========================================================================
443 // ---------------------------------------------------------------------------
444 // wxWindow utility functions
445 // ---------------------------------------------------------------------------
447 // Find an item given the MS Windows id
448 wxWindow
*wxWindowMSW::FindItem(long id
) const
451 wxControl
*item
= wxDynamicCastThis(wxControl
);
454 // is it us or one of our "internal" children?
455 if ( item
->GetId() == id
456 #ifndef __WXUNIVERSAL__
457 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
458 #endif // __WXUNIVERSAL__
464 #endif // wxUSE_CONTROLS
466 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
469 wxWindow
*childWin
= current
->GetData();
471 wxWindow
*wnd
= childWin
->FindItem(id
);
475 current
= current
->GetNext();
481 // Find an item given the MS Windows handle
482 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
484 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
487 wxWindow
*parent
= current
->GetData();
489 // Do a recursive search.
490 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
496 || parent
->IsKindOf(CLASSINFO(wxControl
))
497 #endif // wxUSE_CONTROLS
500 wxWindow
*item
= current
->GetData();
501 if ( item
->GetHWND() == hWnd
)
505 if ( item
->ContainsHWND(hWnd
) )
510 current
= current
->GetNext();
515 // Default command handler
516 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
521 // ----------------------------------------------------------------------------
522 // constructors and such
523 // ----------------------------------------------------------------------------
525 void wxWindowMSW::Init()
529 m_mouseInWindow
= false;
530 m_lastKeydownProcessed
= false;
537 #if wxUSE_DEFERRED_SIZING
539 m_pendingPosition
= wxDefaultPosition
;
540 m_pendingSize
= wxDefaultSize
;
541 #endif // wxUSE_DEFERRED_SIZING
544 m_contextMenuEnabled
= false;
549 wxWindowMSW::~wxWindowMSW()
553 #ifndef __WXUNIVERSAL__
554 // VS: make sure there's no wxFrame with last focus set to us:
555 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
557 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
560 if ( frame
->GetLastFocus() == this )
562 frame
->SetLastFocus(NULL
);
565 // apparently sometimes we can end up with our grand parent
566 // pointing to us as well: this is surely a bug in focus handling
567 // code but it's not clear where it happens so for now just try to
568 // fix it here by not breaking out of the loop
572 #endif // __WXUNIVERSAL__
574 // VS: destroy children first and _then_ detach *this from its parent.
575 // If we did it the other way around, children wouldn't be able
576 // find their parent frame (see above).
581 // VZ: test temp removed to understand what really happens here
582 //if (::IsWindow(GetHwnd()))
584 if ( !::DestroyWindow(GetHwnd()) )
586 wxLogLastError(wxT("DestroyWindow"));
590 // remove hWnd <-> wxWindow association
591 wxRemoveHandleAssociation(this);
597 const wxChar
*wxWindowMSW::MSWGetRegisteredClassName()
599 return wxApp::GetRegisteredClassName(wxT("wxWindow"), COLOR_BTNFACE
);
602 // real construction (Init() must have been called before!)
603 bool wxWindowMSW::Create(wxWindow
*parent
,
608 const wxString
& name
)
610 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
612 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
615 parent
->AddChild(this);
618 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
620 #ifdef __WXUNIVERSAL__
621 // no borders, we draw them ourselves
622 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
626 msflags
&= ~WS_BORDER
;
627 #endif // wxUniversal
631 msflags
|= WS_VISIBLE
;
634 if ( !MSWCreate(MSWGetRegisteredClassName(),
635 NULL
, pos
, size
, msflags
, exstyle
) )
643 // ---------------------------------------------------------------------------
645 // ---------------------------------------------------------------------------
647 void wxWindowMSW::SetFocus()
649 HWND hWnd
= GetHwnd();
650 wxCHECK_RET( hWnd
, wxT("can't set focus to invalid window") );
652 #if !defined(__WXWINCE__)
656 if ( !::SetFocus(hWnd
) )
658 // was there really an error?
659 DWORD dwRes
= ::GetLastError();
662 HWND hwndFocus
= ::GetFocus();
663 if ( hwndFocus
!= hWnd
)
665 wxLogApiError(wxT("SetFocus"), dwRes
);
671 void wxWindowMSW::SetFocusFromKbd()
673 // when the focus is given to the control with DLGC_HASSETSEL style from
674 // keyboard its contents should be entirely selected: this is what
675 // ::IsDialogMessage() does and so we should do it as well to provide the
676 // same LNF as the native programs
677 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
679 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
682 // do this after (maybe) setting the selection as like this when
683 // wxEVT_SET_FOCUS handler is called, the selection would have been already
684 // set correctly -- this may be important
685 wxWindowBase::SetFocusFromKbd();
688 // Get the window with the focus
689 wxWindow
*wxWindowBase::DoFindFocus()
691 HWND hWnd
= ::GetFocus();
694 return wxGetWindowFromHWND((WXHWND
)hWnd
);
700 void wxWindowMSW::DoEnable( bool enable
)
702 HWND hWnd
= GetHwnd();
704 ::EnableWindow(hWnd
, (BOOL
)enable
);
707 bool wxWindowMSW::Show(bool show
)
709 if ( !wxWindowBase::Show(show
) )
712 HWND hWnd
= GetHwnd();
714 // we could be called before the underlying window is created (this is
715 // actually useful to prevent it from being initially shown), e.g.
717 // wxFoo *foo = new wxFoo;
719 // foo->Create(parent, ...);
721 // should work without errors
724 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
729 // DoFreeze/DoThaw don't do anything if the window is not shown, so
730 // we have to call them from here now
741 wxWindowMSW::MSWShowWithEffect(bool show
,
745 if ( effect
== wxSHOW_EFFECT_NONE
)
748 if ( !wxWindowBase::Show(show
) )
751 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
753 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
754 static bool s_initDone
= false;
757 wxDynamicLibrary
dllUser32(wxT("user32.dll"), wxDL_VERBATIM
| wxDL_QUIET
);
758 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
762 // notice that it's ok to unload user32.dll here as it won't be really
763 // unloaded, being still in use because we link to it statically too
766 if ( !s_pfnAnimateWindow
)
769 // Show() has a side effect of sending a WM_SIZE to the window, which helps
770 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
771 // this so send the event ourselves
774 // prepare to use AnimateWindow()
777 timeout
= 200; // this is the default animation timeout, per MSDN
779 DWORD dwFlags
= show
? 0 : AW_HIDE
;
783 case wxSHOW_EFFECT_ROLL_TO_LEFT
:
784 dwFlags
|= AW_HOR_NEGATIVE
;
787 case wxSHOW_EFFECT_ROLL_TO_RIGHT
:
788 dwFlags
|= AW_HOR_POSITIVE
;
791 case wxSHOW_EFFECT_ROLL_TO_TOP
:
792 dwFlags
|= AW_VER_NEGATIVE
;
795 case wxSHOW_EFFECT_ROLL_TO_BOTTOM
:
796 dwFlags
|= AW_VER_POSITIVE
;
799 case wxSHOW_EFFECT_SLIDE_TO_LEFT
:
800 dwFlags
|= AW_SLIDE
| AW_HOR_NEGATIVE
;
803 case wxSHOW_EFFECT_SLIDE_TO_RIGHT
:
804 dwFlags
|= AW_SLIDE
| AW_HOR_POSITIVE
;
807 case wxSHOW_EFFECT_SLIDE_TO_TOP
:
808 dwFlags
|= AW_SLIDE
| AW_VER_NEGATIVE
;
811 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM
:
812 dwFlags
|= AW_SLIDE
| AW_VER_POSITIVE
;
815 case wxSHOW_EFFECT_BLEND
:
819 case wxSHOW_EFFECT_EXPAND
:
820 dwFlags
|= AW_CENTER
;
824 case wxSHOW_EFFECT_MAX
:
825 wxFAIL_MSG( wxT("invalid window show effect") );
829 wxFAIL_MSG( wxT("unknown window show effect") );
833 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
835 wxLogLastError(wxT("AnimateWindow"));
843 // Raise the window to the top of the Z order
844 void wxWindowMSW::Raise()
846 wxBringWindowToTop(GetHwnd());
849 // Lower the window to the bottom of the Z order
850 void wxWindowMSW::Lower()
852 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
853 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
856 void wxWindowMSW::DoCaptureMouse()
858 HWND hWnd
= GetHwnd();
865 void wxWindowMSW::DoReleaseMouse()
867 if ( !::ReleaseCapture() )
869 wxLogLastError(wxT("ReleaseCapture"));
873 /* static */ wxWindow
*wxWindowBase::GetCapture()
875 HWND hwnd
= ::GetCapture();
876 return hwnd
? wxFindWinFromHandle(hwnd
) : NULL
;
879 bool wxWindowMSW::SetFont(const wxFont
& font
)
881 if ( !wxWindowBase::SetFont(font
) )
887 HWND hWnd
= GetHwnd();
890 // note the use of GetFont() instead of m_font: our own font could have
891 // just been reset and in this case we need to change the font used by
892 // the native window to the default for this class, i.e. exactly what
894 WXHANDLE hFont
= GetFont().GetResourceHandle();
896 wxASSERT_MSG( hFont
, wxT("should have valid font") );
898 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
903 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
905 if ( !wxWindowBase::SetCursor(cursor
) )
911 // don't "overwrite" busy cursor
912 if ( m_cursor
.Ok() && !wxIsBusy() )
914 // normally we should change the cursor only if it's over this window
915 // but we should do it always if we capture the mouse currently
916 bool set
= HasCapture();
919 HWND hWnd
= GetHwnd();
923 ::GetCursorPosWinCE(&point
);
925 ::GetCursorPos(&point
);
928 RECT rect
= wxGetWindowRect(hWnd
);
930 set
= ::PtInRect(&rect
, point
) != 0;
935 ::SetCursor(GetHcursorOf(m_cursor
));
937 //else: will be set later when the mouse enters this window
943 void wxWindowMSW::WarpPointer(int x
, int y
)
945 ClientToScreen(&x
, &y
);
947 if ( !::SetCursorPos(x
, y
) )
949 wxLogLastError(wxT("SetCursorPos"));
953 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
955 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
956 // to use it on older systems -- and could possibly do some harm
957 static int s_needToUpdate
= -1;
958 if ( s_needToUpdate
== -1 )
961 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
965 if ( s_needToUpdate
)
967 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
968 // won't send WM_UPDATEUISTATE
969 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
973 // ---------------------------------------------------------------------------
975 // ---------------------------------------------------------------------------
980 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
982 #ifdef __WXMICROWIN__
983 return ::GetScrollPosWX(hWnd
, wOrient
);
985 WinStruct
<SCROLLINFO
> scrollInfo
;
986 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
987 scrollInfo
.fMask
= SIF_POS
;
988 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
990 return scrollInfo
.nPos
;
995 inline UINT
WXOrientToSB(int orient
)
997 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
1000 } // anonymous namespace
1002 int wxWindowMSW::GetScrollPos(int orient
) const
1004 HWND hWnd
= GetHwnd();
1005 wxCHECK_MSG( hWnd
, 0, wxT("no HWND in GetScrollPos") );
1007 return GetScrollPosition(hWnd
, WXOrientToSB(orient
));
1010 // This now returns the whole range, not just the number
1011 // of positions that we can scroll.
1012 int wxWindowMSW::GetScrollRange(int orient
) const
1015 HWND hWnd
= GetHwnd();
1018 WinStruct
<SCROLLINFO
> scrollInfo
;
1019 scrollInfo
.fMask
= SIF_RANGE
;
1020 if ( !::GetScrollInfo(hWnd
, WXOrientToSB(orient
), &scrollInfo
) )
1022 // Most of the time this is not really an error, since the return
1023 // value can also be zero when there is no scrollbar yet.
1024 // wxLogLastError(wxT("GetScrollInfo"));
1026 maxPos
= scrollInfo
.nMax
;
1028 // undo "range - 1" done in SetScrollbar()
1032 int wxWindowMSW::GetScrollThumb(int orient
) const
1034 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
1037 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
1039 HWND hWnd
= GetHwnd();
1040 wxCHECK_RET( hWnd
, wxT("SetScrollPos: no HWND") );
1042 WinStruct
<SCROLLINFO
> info
;
1046 info
.fMask
= SIF_POS
;
1047 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1049 // disable scrollbar instead of removing it then
1050 info
.fMask
|= SIF_DISABLENOSCROLL
;
1053 ::SetScrollInfo(hWnd
, WXOrientToSB(orient
), &info
, refresh
);
1056 // New function that will replace some of the above.
1057 void wxWindowMSW::SetScrollbar(int orient
,
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 HWND hwnd
= GetHwnd();
1071 WinStruct
<SCROLLINFO
> info
;
1074 info
.nPage
= pageSize
;
1075 info
.nMin
= 0; // range is nMax - nMin + 1
1076 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1079 // enable the scrollbar if it had been disabled before by specifying
1080 // SIF_DISABLENOSCROLL below: as we can't know whether this had been
1081 // done or not just do it always
1082 ::EnableScrollBar(hwnd
, WXOrientToSB(orient
), ESB_ENABLE_BOTH
);
1084 //else: leave all the fields to be 0
1086 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1087 if ( HasFlag(wxALWAYS_SHOW_SB
) || range
== -1 )
1089 // disable scrollbar instead of removing it then
1090 info
.fMask
|= SIF_DISABLENOSCROLL
;
1093 ::SetScrollInfo(hwnd
, WXOrientToSB(orient
), &info
, refresh
);
1096 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1102 wxCopyRectToRECT(*prect
, rect
);
1112 // FIXME: is this the exact equivalent of the line below?
1113 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1115 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1119 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1121 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1124 for ( int n
= 0; n
< count
; n
++ )
1126 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1128 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1129 if ( posNew
== pos
)
1131 // don't bother to continue, we're already at top/bottom
1138 return pos
!= posStart
;
1141 bool wxWindowMSW::ScrollLines(int lines
)
1143 bool down
= lines
> 0;
1145 return ScrollVertically(GetHwnd(),
1146 down
? SB_LINEDOWN
: SB_LINEUP
,
1147 down
? lines
: -lines
);
1150 bool wxWindowMSW::ScrollPages(int pages
)
1152 bool down
= pages
> 0;
1154 return ScrollVertically(GetHwnd(),
1155 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1156 down
? pages
: -pages
);
1159 // ----------------------------------------------------------------------------
1161 // ----------------------------------------------------------------------------
1163 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1168 wxCHECK_RET( GetHwnd(),
1169 wxT("layout direction must be set after window creation") );
1171 LONG styleOld
= wxGetWindowExStyle(this);
1173 LONG styleNew
= styleOld
;
1176 case wxLayout_LeftToRight
:
1177 styleNew
&= ~WS_EX_LAYOUTRTL
;
1180 case wxLayout_RightToLeft
:
1181 styleNew
|= WS_EX_LAYOUTRTL
;
1185 wxFAIL_MSG(wxT("unsupported layout direction"));
1189 if ( styleNew
!= styleOld
)
1191 wxSetWindowExStyle(this, styleNew
);
1196 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1199 return wxLayout_Default
;
1201 wxCHECK_MSG( GetHwnd(), wxLayout_Default
, wxT("invalid window") );
1203 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL
) ? wxLayout_RightToLeft
1204 : wxLayout_LeftToRight
;
1209 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1210 wxCoord
WXUNUSED(width
),
1211 wxCoord
WXUNUSED(widthTotal
)) const
1213 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1214 // redo it ourselves
1218 // ---------------------------------------------------------------------------
1220 // ---------------------------------------------------------------------------
1222 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1224 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1226 HWND hwnd
= (HWND
)hWnd
;
1227 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1231 wxAssociateWinWithHandle(hwnd
, this);
1233 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1235 // we don't need to subclass the window of our own class (in the Windows
1236 // sense of the word)
1237 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1239 wxSetWindowProc(hwnd
, wxWndProc
);
1243 // don't bother restoring it either: this also makes it easy to
1244 // implement IsOfStandardClass() method which returns true for the
1245 // standard controls and false for the wxWidgets own windows as it can
1246 // simply check m_oldWndProc
1247 m_oldWndProc
= NULL
;
1250 // we're officially created now, send the event
1251 wxWindowCreateEvent
event((wxWindow
*)this);
1252 (void)HandleWindowEvent(event
);
1255 void wxWindowMSW::UnsubclassWin()
1257 wxRemoveHandleAssociation(this);
1259 // Restore old Window proc
1260 HWND hwnd
= GetHwnd();
1265 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1269 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1271 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1274 m_oldWndProc
= NULL
;
1279 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1283 if ( !::DestroyWindow(GetHwnd()) )
1285 wxLogLastError(wxT("DestroyWindow"));
1289 WXHWND wxhwnd
= (WXHWND
)handle
;
1291 // this also calls SetHWND(wxhwnd)
1292 SubclassWin(wxhwnd
);
1295 void wxWindowMSW::DissociateHandle()
1297 // this also calls SetHWND(0) for us
1302 bool wxCheckWindowWndProc(WXHWND hWnd
,
1303 WXFARPROC
WXUNUSED(wndProc
))
1305 const wxString
str(wxGetWindowClass(hWnd
));
1307 // TODO: get rid of wxTLWHiddenParent special case (currently it's not
1308 // registered by wxApp but using ad hoc code in msw/toplevel.cpp);
1309 // there is also a hidden window class used by sockets &c
1310 return wxApp::IsRegisteredClassName(str
) || str
== wxT("wxTLWHiddenParent");
1313 // ----------------------------------------------------------------------------
1315 // ----------------------------------------------------------------------------
1317 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1319 long flagsOld
= GetWindowStyleFlag();
1320 if ( flags
== flagsOld
)
1323 // update the internal variable
1324 wxWindowBase::SetWindowStyleFlag(flags
);
1326 // and the real window flags
1327 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1330 void wxWindowMSW::SetExtraStyle(long exflags
)
1332 long exflagsOld
= GetExtraStyle();
1333 if ( exflags
== exflagsOld
)
1336 // update the internal variable
1337 wxWindowBase::SetExtraStyle(exflags
);
1339 // and the real window flags
1340 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1343 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1345 // now update the Windows style as well if needed - and if the window had
1346 // been already created
1350 // we may need to call SetWindowPos() when we change some styles
1351 bool callSWP
= false;
1354 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1356 // this is quite a horrible hack but we need it because MSWGetStyle()
1357 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1358 // and so we have to modify the window exflags temporarily to get the
1359 // correct exstyleOld
1360 long exflagsNew
= GetExtraStyle();
1361 wxWindowBase::SetExtraStyle(exflagsOld
);
1364 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1366 wxWindowBase::SetExtraStyle(exflagsNew
);
1369 if ( style
!= styleOld
)
1371 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1372 // this function so instead of simply setting the style to the new
1373 // value we clear the bits which were set in styleOld but are set in
1374 // the new one and set the ones which were not set before
1375 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1376 styleReal
&= ~styleOld
;
1379 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1381 // we need to call SetWindowPos() if any of the styles affecting the
1382 // frame appearance have changed
1383 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1392 // and the extended style
1393 long exstyleReal
= wxGetWindowExStyle(this);
1395 if ( exstyle
!= exstyleOld
)
1397 exstyleReal
&= ~exstyleOld
;
1398 exstyleReal
|= exstyle
;
1400 wxSetWindowExStyle(this, exstyleReal
);
1402 // ex style changes don't take effect without calling SetWindowPos
1408 // we must call SetWindowPos() to flush the cached extended style and
1409 // also to make the change to wxSTAY_ON_TOP style take effect: just
1410 // setting the style simply doesn't work
1411 if ( !::SetWindowPos(GetHwnd(),
1412 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1415 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1417 wxLogLastError(wxT("SetWindowPos"));
1422 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1424 return wxBORDER_THEME
;
1427 wxBorder
wxWindowMSW::GetDefaultBorder() const
1429 return wxWindowBase::GetDefaultBorder();
1432 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1433 // that makes most sense for this Windows environment
1434 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1436 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1437 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1438 return wxBORDER_SIMPLE
;
1440 return wxBORDER_NONE
;
1443 if (border
== wxBORDER_THEME
)
1445 if (CanApplyThemeBorder())
1447 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1449 return wxBORDER_THEME
;
1451 return wxBORDER_SUNKEN
;
1459 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1461 // translate common wxWidgets styles to Windows ones
1463 // most of windows are child ones, those which are not (such as
1464 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1465 WXDWORD style
= WS_CHILD
;
1467 // using this flag results in very significant reduction in flicker,
1468 // especially with controls inside the static boxes (as the interior of the
1469 // box is not redrawn twice), but sometimes results in redraw problems, so
1470 // optionally allow the old code to continue to use it provided a special
1471 // system option is turned on
1472 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1473 || (flags
& wxCLIP_CHILDREN
) )
1474 style
|= WS_CLIPCHILDREN
;
1476 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1477 // don't support overlapping windows and it only makes sense for them and,
1478 // presumably, gives the system some extra work (to manage more clipping
1479 // regions), so avoid it alltogether
1482 if ( flags
& wxVSCROLL
)
1483 style
|= WS_VSCROLL
;
1485 if ( flags
& wxHSCROLL
)
1486 style
|= WS_HSCROLL
;
1488 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1490 // After translation, border is now optimized for the specific version of Windows
1491 // and theme engine presence.
1493 // WS_BORDER is only required for wxBORDER_SIMPLE
1494 if ( border
== wxBORDER_SIMPLE
)
1497 // now deal with ext style if the caller wants it
1503 if ( flags
& wxTRANSPARENT_WINDOW
)
1504 *exstyle
|= WS_EX_TRANSPARENT
;
1510 case wxBORDER_DEFAULT
:
1511 wxFAIL_MSG( wxT("unknown border style") );
1515 case wxBORDER_SIMPLE
:
1516 case wxBORDER_THEME
:
1519 case wxBORDER_STATIC
:
1520 *exstyle
|= WS_EX_STATICEDGE
;
1523 case wxBORDER_RAISED
:
1524 *exstyle
|= WS_EX_DLGMODALFRAME
;
1527 case wxBORDER_SUNKEN
:
1528 *exstyle
|= WS_EX_CLIENTEDGE
;
1529 style
&= ~WS_BORDER
;
1532 // case wxBORDER_DOUBLE:
1533 // *exstyle |= WS_EX_DLGMODALFRAME;
1537 // wxUniv doesn't use Windows dialog navigation functions at all
1538 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1539 // to make the dialog navigation work with the nested panels we must
1540 // use this style (top level windows such as dialogs don't need it)
1541 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1543 *exstyle
|= WS_EX_CONTROLPARENT
;
1545 #endif // __WXUNIVERSAL__
1551 // Setup background and foreground colours correctly
1552 void wxWindowMSW::SetupColours()
1555 SetBackgroundColour(GetParent()->GetBackgroundColour());
1558 bool wxWindowMSW::IsMouseInWindow() const
1560 // get the mouse position
1563 ::GetCursorPosWinCE(&pt
);
1565 ::GetCursorPos(&pt
);
1568 // find the window which currently has the cursor and go up the window
1569 // chain until we find this window - or exhaust it
1570 HWND hwnd
= ::WindowFromPoint(pt
);
1571 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1572 hwnd
= ::GetParent(hwnd
);
1574 return hwnd
!= NULL
;
1577 void wxWindowMSW::OnInternalIdle()
1579 #ifndef HAVE_TRACKMOUSEEVENT
1580 // Check if we need to send a LEAVE event
1581 if ( m_mouseInWindow
)
1583 // note that we should generate the leave event whether the window has
1584 // or doesn't have mouse capture
1585 if ( !IsMouseInWindow() )
1587 GenerateMouseLeave();
1590 #endif // !HAVE_TRACKMOUSEEVENT
1592 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1593 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1596 // Set this window to be the child of 'parent'.
1597 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1599 if ( !wxWindowBase::Reparent(parent
) )
1602 HWND hWndChild
= GetHwnd();
1603 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1605 ::SetParent(hWndChild
, hWndParent
);
1608 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT
) )
1610 EnsureParentHasControlParentStyle(GetParent());
1612 #endif // !__WXWINCE__
1617 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1619 #ifndef __WXMICROWIN__
1620 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1624 void wxWindowMSW::DoFreeze()
1627 return; // no point in freezing hidden window
1629 SendSetRedraw(GetHwnd(), false);
1632 void wxWindowMSW::DoThaw()
1635 return; // hidden windows aren't frozen by DoFreeze
1637 SendSetRedraw(GetHwnd(), true);
1639 // we need to refresh everything or otherwise the invalidated area
1640 // is not going to be repainted
1644 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1646 HWND hWnd
= GetHwnd();
1653 wxCopyRectToRECT(*rect
, mswRect
);
1661 // RedrawWindow not available on SmartPhone or eVC++ 3
1662 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1663 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1667 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1669 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1674 void wxWindowMSW::Update()
1676 if ( !::UpdateWindow(GetHwnd()) )
1678 wxLogLastError(wxT("UpdateWindow"));
1681 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1682 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1683 // handler needs to be really drawn right now
1688 // ---------------------------------------------------------------------------
1690 // ---------------------------------------------------------------------------
1692 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1696 // we need to lower the sibling static boxes so controls contained within can be
1698 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1700 // no sibling static boxes if we have no parent (ie TLW)
1704 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1706 node
= node
->GetNext() )
1708 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1711 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1712 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1717 #else // !wxUSE_STATBOX
1719 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1723 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1725 #endif // drag and drop is used
1727 #if wxUSE_DRAG_AND_DROP
1728 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1730 if ( m_dropTarget
!= 0 ) {
1731 m_dropTarget
->Revoke(m_hWnd
);
1732 delete m_dropTarget
;
1735 m_dropTarget
= pDropTarget
;
1736 if ( m_dropTarget
!= 0 )
1738 AdjustStaticBoxZOrder(GetParent());
1739 m_dropTarget
->Register(m_hWnd
);
1742 #endif // wxUSE_DRAG_AND_DROP
1744 // old-style file manager drag&drop support: we retain the old-style
1745 // DragAcceptFiles in parallel with SetDropTarget.
1746 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1749 HWND hWnd
= GetHwnd();
1752 AdjustStaticBoxZOrder(GetParent());
1753 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1758 // ----------------------------------------------------------------------------
1760 // ----------------------------------------------------------------------------
1764 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1766 wxWindowBase::DoSetToolTip(tooltip
);
1769 m_tooltip
->SetWindow((wxWindow
*)this);
1772 #endif // wxUSE_TOOLTIPS
1774 // ---------------------------------------------------------------------------
1775 // moving and resizing
1776 // ---------------------------------------------------------------------------
1778 bool wxWindowMSW::IsSizeDeferred() const
1780 #if wxUSE_DEFERRED_SIZING
1781 if ( m_pendingPosition
!= wxDefaultPosition
||
1782 m_pendingSize
!= wxDefaultSize
)
1784 #endif // wxUSE_DEFERRED_SIZING
1790 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1792 #if wxUSE_DEFERRED_SIZING
1793 // if SetSize() had been called at wx level but not realized at Windows
1794 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1795 // the new and not the old position to the other wx code
1796 if ( m_pendingSize
!= wxDefaultSize
)
1799 *x
= m_pendingSize
.x
;
1801 *y
= m_pendingSize
.y
;
1803 else // use current size
1804 #endif // wxUSE_DEFERRED_SIZING
1806 RECT rect
= wxGetWindowRect(GetHwnd());
1809 *x
= rect
.right
- rect
.left
;
1811 *y
= rect
.bottom
- rect
.top
;
1815 // Get size *available for subwindows* i.e. excluding menu bar etc.
1816 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1818 #if wxUSE_DEFERRED_SIZING
1819 if ( m_pendingSize
!= wxDefaultSize
)
1821 // we need to calculate the client size corresponding to pending size
1823 rect
.left
= m_pendingPosition
.x
;
1824 rect
.top
= m_pendingPosition
.y
;
1825 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1826 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1828 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1831 *x
= rect
.right
- rect
.left
;
1833 *y
= rect
.bottom
- rect
.top
;
1836 #endif // wxUSE_DEFERRED_SIZING
1838 RECT rect
= wxGetClientRect(GetHwnd());
1847 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1849 wxWindow
* const parent
= GetParent();
1852 if ( m_pendingPosition
!= wxDefaultPosition
)
1854 pos
= m_pendingPosition
;
1856 else // use current position
1858 RECT rect
= wxGetWindowRect(GetHwnd());
1861 point
.x
= rect
.left
;
1864 // we do the adjustments with respect to the parent only for the "real"
1865 // children, not for the dialogs/frames
1866 if ( !IsTopLevel() )
1868 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1870 // In RTL mode, we want the logical left x-coordinate,
1871 // which would be the physical right x-coordinate.
1872 point
.x
= rect
.right
;
1875 // Since we now have the absolute screen coords, if there's a
1876 // parent we must subtract its top left corner
1879 ::ScreenToClient(GetHwndOf(parent
), &point
);
1887 // we also must adjust by the client area offset: a control which is just
1888 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1889 if ( parent
&& !IsTopLevel() )
1891 const wxPoint
pt(parent
->GetClientAreaOrigin());
1902 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1910 ::ScreenToClient(GetHwnd(), &pt
);
1918 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1926 ::ClientToScreen(GetHwnd(), &pt
);
1935 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1937 #if wxUSE_DEFERRED_SIZING
1938 // if our parent had prepared a defer window handle for us, use it (unless
1939 // we are a top level window)
1940 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1942 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1945 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1946 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1949 wxLogLastError(wxT("DeferWindowPos"));
1955 // hdwp must be updated as it may have been changed
1956 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1961 // did deferred move, remember new coordinates of the window as they're
1962 // different from what Windows would return for it
1966 // otherwise (or if deferring failed) move the window in place immediately
1967 #endif // wxUSE_DEFERRED_SIZING
1968 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1970 wxLogLastError(wxT("MoveWindow"));
1973 // if wxUSE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1974 // ignored otherwise
1978 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1980 // TODO: is this consistent with other platforms?
1981 // Still, negative width or height shouldn't be allowed
1987 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1989 #if wxUSE_DEFERRED_SIZING
1990 m_pendingPosition
= wxPoint(x
, y
);
1991 m_pendingSize
= wxSize(width
, height
);
1993 else // window was moved immediately, without deferring it
1995 m_pendingPosition
= wxDefaultPosition
;
1996 m_pendingSize
= wxDefaultSize
;
1997 #endif // wxUSE_DEFERRED_SIZING
2001 // set the size of the window: if the dimensions are positive, just use them,
2002 // but if any of them is equal to -1, it means that we must find the value for
2003 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
2004 // which case -1 is a valid value for x and y)
2006 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
2007 // the width/height to best suit our contents, otherwise we reuse the current
2009 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
2011 // get the current size and position...
2012 int currentX
, currentY
;
2013 int currentW
, currentH
;
2015 GetPosition(¤tX
, ¤tY
);
2016 GetSize(¤tW
, ¤tH
);
2018 // ... and don't do anything (avoiding flicker) if it's already ok unless
2019 // we're forced to resize the window
2020 if ( x
== currentX
&& y
== currentY
&&
2021 width
== currentW
&& height
== currentH
&&
2022 !(sizeFlags
& wxSIZE_FORCE
) )
2024 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2026 wxSizeEvent
event( wxSize(width
,height
), GetId() );
2027 event
.SetEventObject( this );
2028 HandleWindowEvent( event
);
2033 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2035 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2038 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2040 wxSize size
= wxDefaultSize
;
2041 if ( width
== wxDefaultCoord
)
2043 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2045 size
= GetBestSize();
2050 // just take the current one
2055 if ( height
== wxDefaultCoord
)
2057 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2059 if ( size
.x
== wxDefaultCoord
)
2061 size
= GetBestSize();
2063 //else: already called GetBestSize() above
2069 // just take the current one
2074 DoMoveWindow(x
, y
, width
, height
);
2077 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2079 // setting the client size is less obvious than it could have been
2080 // because in the result of changing the total size the window scrollbar
2081 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2082 // doesn't take neither into account) and so the client size will not be
2083 // correct as the difference between the total and client size changes --
2084 // so we keep changing it until we get it right
2086 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2087 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2088 // may become 3 if the window had 0 size originally and so we didn't
2089 // calculate the scrollbar correction correctly during the first iteration)
2090 // but just to be on the safe side we check for it instead of making it an
2091 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2092 for ( int i
= 0; i
< 4; i
++ )
2095 ::GetClientRect(GetHwnd(), &rectClient
);
2097 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2098 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2099 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2104 // Find the difference between the entire window (title bar and all)
2105 // and the client area; add this to the new client size to move the
2108 ::GetWindowRect(GetHwnd(), &rectWin
);
2110 const int widthWin
= rectWin
.right
- rectWin
.left
,
2111 heightWin
= rectWin
.bottom
- rectWin
.top
;
2113 // MoveWindow positions the child windows relative to the parent, so
2114 // adjust if necessary
2115 if ( !IsTopLevel() )
2117 wxWindow
*parent
= GetParent();
2120 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2124 // don't call DoMoveWindow() because we want to move window immediately
2125 // and not defer it here as otherwise the value returned by
2126 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2128 if ( !::MoveWindow(GetHwnd(),
2131 width
+ widthWin
- rectClient
.right
,
2132 height
+ heightWin
- rectClient
.bottom
,
2135 wxLogLastError(wxT("MoveWindow"));
2140 wxSize
wxWindowMSW::DoGetBorderSize() const
2143 switch ( GetBorder() )
2145 case wxBORDER_STATIC
:
2146 case wxBORDER_SIMPLE
:
2150 case wxBORDER_SUNKEN
:
2154 case wxBORDER_RAISED
:
2155 case wxBORDER_DOUBLE
:
2160 wxFAIL_MSG( wxT("unknown border style") );
2167 return 2*wxSize(border
, border
);
2170 // ---------------------------------------------------------------------------
2172 // ---------------------------------------------------------------------------
2174 int wxWindowMSW::GetCharHeight() const
2176 return wxGetTextMetrics(this).tmHeight
;
2179 int wxWindowMSW::GetCharWidth() const
2181 // +1 is needed because Windows apparently adds it when calculating the
2182 // dialog units size in pixels
2183 #if wxDIALOG_UNIT_COMPATIBILITY
2184 return wxGetTextMetrics(this).tmAveCharWidth
;
2186 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2190 void wxWindowMSW::DoGetTextExtent(const wxString
& string
,
2193 int *externalLeading
,
2194 const wxFont
*fontToUse
) const
2196 wxASSERT_MSG( !fontToUse
|| fontToUse
->Ok(),
2197 wxT("invalid font in GetTextExtent()") );
2201 hfontToUse
= GetHfontOf(*fontToUse
);
2203 hfontToUse
= GetHfontOf(GetFont());
2205 WindowHDC
hdc(GetHwnd());
2206 SelectInHDC
selectFont(hdc
, hfontToUse
);
2210 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2211 GetTextMetrics(hdc
, &tm
);
2218 *descent
= tm
.tmDescent
;
2219 if ( externalLeading
)
2220 *externalLeading
= tm
.tmExternalLeading
;
2223 // ---------------------------------------------------------------------------
2225 // ---------------------------------------------------------------------------
2227 #if wxUSE_MENUS_NATIVE
2229 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2230 // immediately, without waiting for the next event loop iteration
2232 // NB: this function should probably be made public later as it can almost
2233 // surely replace wxYield() elsewhere as well
2234 static void wxYieldForCommandsOnly()
2236 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2237 // want to process it here)
2239 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2241 if ( msg
.message
== WM_QUIT
)
2243 // if we retrieved a WM_QUIT, insert back into the message queue.
2244 ::PostQuitMessage(0);
2248 // luckily (as we don't have access to wxEventLoopImpl method from here
2249 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2251 ::TranslateMessage(&msg
);
2252 ::DispatchMessage(&msg
);
2256 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2258 menu
->SetInvokingWindow(this);
2261 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2263 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2264 x
= mouse
.x
; y
= mouse
.y
;
2267 HWND hWnd
= GetHwnd();
2268 HMENU hMenu
= GetHmenuOf(menu
);
2272 ::ClientToScreen(hWnd
, &point
);
2273 #if defined(__WXWINCE__)
2274 static const UINT flags
= 0;
2275 #else // !__WXWINCE__
2276 UINT flags
= TPM_RIGHTBUTTON
;
2277 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2278 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2279 // side and not to use it there neither -- modify the test if it does work
2281 if ( wxGetWinVersion() >= wxWinVersion_5
)
2283 // using TPM_RECURSE allows us to show a popup menu while another menu
2284 // is opened which can be useful and is supported by the other
2285 // platforms, so allow it under Windows too
2286 flags
|= TPM_RECURSE
;
2288 #endif // __WXWINCE__/!__WXWINCE__
2290 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2292 // we need to do it right now as otherwise the events are never going to be
2293 // sent to wxCurrentPopupMenu from HandleCommand()
2295 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2296 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2297 // destroyed as soon as we return (it can be a local variable in the caller
2298 // for example) and so we do need to process the event immediately
2299 wxYieldForCommandsOnly();
2301 menu
->SetInvokingWindow(NULL
);
2306 #endif // wxUSE_MENUS_NATIVE
2308 // ===========================================================================
2309 // pre/post message processing
2310 // ===========================================================================
2312 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2315 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2317 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2320 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2322 // wxUniversal implements tab traversal itself
2323 #ifndef __WXUNIVERSAL__
2324 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2326 // intercept dialog navigation keys
2327 MSG
*msg
= (MSG
*)pMsg
;
2329 // here we try to do all the job which ::IsDialogMessage() usually does
2331 if ( msg
->message
== WM_KEYDOWN
)
2333 bool bCtrlDown
= wxIsCtrlDown();
2334 bool bShiftDown
= wxIsShiftDown();
2336 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2337 // don't process it if it's the case (except for Ctrl-Tab/Enter
2338 // combinations which are always processed)
2339 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2341 // surprisingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2342 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2343 // it, of course, implies them
2344 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2346 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2349 bool bForward
= true,
2350 bWindowChange
= false,
2353 // should we process this message specially?
2354 bool bProcess
= true;
2355 switch ( msg
->wParam
)
2358 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2360 // let the control have the TAB
2363 else // use it for navigation
2365 // Ctrl-Tab cycles thru notebook pages
2366 bWindowChange
= bCtrlDown
;
2367 bForward
= !bShiftDown
;
2374 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2382 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2391 // we treat PageUp/Dn as arrows because chances are that
2392 // a control which needs arrows also needs them for
2393 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2394 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2396 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2397 bWindowChange
= true;
2403 // currently active button should get enter press even
2404 // if there is a default button elsewhere so check if
2405 // this window is a button first
2406 wxWindow
*btn
= NULL
;
2407 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2409 // let IsDialogMessage() handle this for all
2410 // buttons except the owner-drawn ones which it
2411 // just seems to ignore
2412 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2413 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2415 // emulate the button click
2416 btn
= wxFindWinFromHandle(msg
->hwnd
);
2421 else // not a button itself, do we have default button?
2423 // check if this window or any of its ancestors
2424 // wants the message for itself (we always reserve
2425 // Ctrl-Enter for dialog navigation though)
2426 wxWindow
*win
= this;
2429 // this will contain the dialog code of this
2430 // window and all of its parent windows in turn
2431 LONG lDlgCode2
= lDlgCode
;
2435 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2437 // as it wants to process Enter itself,
2438 // don't call IsDialogMessage() which
2443 // don't propagate keyboard messages beyond
2444 // the first top level window parent
2445 if ( win
->IsTopLevel() )
2448 win
= win
->GetParent();
2450 lDlgCode2
= ::SendMessage
2461 win
= wxGetTopLevelParent(win
);
2464 wxTopLevelWindow
* const
2465 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2468 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2473 if ( btn
&& btn
->IsEnabled() )
2475 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2479 #endif // wxUSE_BUTTON
2482 // map Enter presses into button presses on PDAs
2483 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2484 event
.SetEventObject(this);
2485 if ( HandleWindowEvent(event
) )
2487 #endif // __WXWINCE__
2497 wxNavigationKeyEvent event
;
2498 event
.SetDirection(bForward
);
2499 event
.SetWindowChange(bWindowChange
);
2500 event
.SetFromTab(bFromTab
);
2501 event
.SetEventObject(this);
2503 if ( HandleWindowEvent(event
) )
2505 // as we don't call IsDialogMessage(), which would take of
2506 // this by default, we need to manually send this message
2507 // so that controls can change their UI state if needed
2508 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2515 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2517 // IsDialogMessage() did something...
2521 #endif // __WXUNIVERSAL__
2526 // relay mouse move events to the tooltip control
2527 MSG
*msg
= (MSG
*)pMsg
;
2528 if ( msg
->message
== WM_MOUSEMOVE
)
2529 wxToolTip::RelayEvent(pMsg
);
2531 #endif // wxUSE_TOOLTIPS
2536 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2538 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2539 return m_acceleratorTable
.Translate(this, pMsg
);
2543 #endif // wxUSE_ACCEL
2546 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2548 // all tests below have to deal with various bugs/misfeatures of
2549 // IsDialogMessage(): we have to prevent it from being called from our
2550 // MSWProcessMessage() in some situations
2552 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2553 // message even when there is no cancel button and when the message is
2554 // needed by the control itself: in particular, it prevents the tree in
2555 // place edit control from being closed with Escape in a dialog
2556 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2561 // ::IsDialogMessage() is broken and may sometimes hang the application by
2562 // going into an infinite loop when it tries to find the control to give
2563 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2564 // situations when this may happen and not call it then
2565 if ( msg
->message
!= WM_SYSCHAR
)
2568 // assume we can call it by default
2569 bool canSafelyCallIsDlgMsg
= true;
2571 HWND hwndFocus
= ::GetFocus();
2573 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2574 // ::IsDialogMessage() will also enter an infinite loop, because it will
2575 // recursively check the child windows but not the window itself and so if
2576 // none of the children accepts focus it loops forever (as it only stops
2577 // when it gets back to the window it started from)
2579 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2580 // style has the focus, it can happen. One such possibility is if
2581 // all windows are either toplevel, wxDialog, wxPanel or static
2582 // controls and no window can actually accept keyboard input.
2583 #if !defined(__WXWINCE__)
2584 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2586 // pessimistic by default
2587 canSafelyCallIsDlgMsg
= false;
2588 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2590 node
= node
->GetNext() )
2592 wxWindow
* const win
= node
->GetData();
2593 if ( win
->CanAcceptFocus() &&
2594 !wxHasWindowExStyle(win
, WS_EX_CONTROLPARENT
) )
2596 // it shouldn't hang...
2597 canSafelyCallIsDlgMsg
= true;
2603 #endif // !__WXWINCE__
2605 if ( canSafelyCallIsDlgMsg
)
2607 // ::IsDialogMessage() can enter in an infinite loop when the
2608 // currently focused window is disabled or hidden and its
2609 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2613 if ( !::IsWindowEnabled(hwndFocus
) ||
2614 !::IsWindowVisible(hwndFocus
) )
2616 // it would enter an infinite loop if we do this!
2617 canSafelyCallIsDlgMsg
= false;
2622 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2624 // it's a top level window, don't go further -- e.g. even
2625 // if the parent of a dialog is disabled, this doesn't
2626 // break navigation inside the dialog
2630 hwndFocus
= ::GetParent(hwndFocus
);
2634 return canSafelyCallIsDlgMsg
;
2637 // ---------------------------------------------------------------------------
2638 // message params unpackers
2639 // ---------------------------------------------------------------------------
2641 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2642 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2644 *id
= LOWORD(wParam
);
2645 *hwnd
= (WXHWND
)lParam
;
2646 *cmd
= HIWORD(wParam
);
2649 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2650 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2652 *state
= LOWORD(wParam
);
2653 *minimized
= HIWORD(wParam
);
2654 *hwnd
= (WXHWND
)lParam
;
2657 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2658 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2660 *code
= LOWORD(wParam
);
2661 *pos
= HIWORD(wParam
);
2662 *hwnd
= (WXHWND
)lParam
;
2665 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2666 WXHDC
*hdc
, WXHWND
*hwnd
)
2668 *hwnd
= (WXHWND
)lParam
;
2669 *hdc
= (WXHDC
)wParam
;
2672 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2673 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2675 *item
= (WXWORD
)wParam
;
2676 *flags
= HIWORD(wParam
);
2677 *hmenu
= (WXHMENU
)lParam
;
2680 // ---------------------------------------------------------------------------
2681 // Main wxWidgets window proc and the window proc for wxWindow
2682 // ---------------------------------------------------------------------------
2684 // Hook for new window just as it's being created, when the window isn't yet
2685 // associated with the handle
2686 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2688 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2689 // window being created and insures that it's always unset back later
2690 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2692 gs_winBeingCreated
= winBeingCreated
;
2695 wxWindowCreationHook::~wxWindowCreationHook()
2697 gs_winBeingCreated
= NULL
;
2701 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2703 // trace all messages: useful for the debugging but noticeably slows down
2704 // the code so don't do it by default
2705 #if wxDEBUG_LEVEL >= 2
2706 wxLogTrace("winmsg",
2707 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2708 wxGetMessageName(message
), hWnd
, (long)wParam
, lParam
);
2709 #endif // wxDEBUG_LEVEL >= 2
2711 wxWindowMSW
*wnd
= wxFindWinFromHandle(hWnd
);
2713 // when we get the first message for the HWND we just created, we associate
2714 // it with wxWindow stored in gs_winBeingCreated
2715 if ( !wnd
&& gs_winBeingCreated
)
2717 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2718 wnd
= gs_winBeingCreated
;
2719 gs_winBeingCreated
= NULL
;
2720 wnd
->SetHWND((WXHWND
)hWnd
);
2725 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2726 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2728 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2733 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2735 // did we process the message?
2736 bool processed
= false;
2746 // for most messages we should return 0 when we do process the message
2754 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2757 // return 0 to allow window creation
2758 rc
.result
= mayCreate
? 0 : -1;
2764 // never set processed to true and *always* pass WM_DESTROY to
2765 // DefWindowProc() as Windows may do some internal cleanup when
2766 // processing it and failing to pass the message along may cause
2767 // memory and resource leaks!
2768 (void)HandleDestroy();
2772 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2776 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2779 #if !defined(__WXWINCE__)
2782 LPRECT pRect
= (LPRECT
)lParam
;
2784 rc
.SetLeft(pRect
->left
);
2785 rc
.SetTop(pRect
->top
);
2786 rc
.SetRight(pRect
->right
);
2787 rc
.SetBottom(pRect
->bottom
);
2788 processed
= HandleMoving(rc
);
2790 pRect
->left
= rc
.GetLeft();
2791 pRect
->top
= rc
.GetTop();
2792 pRect
->right
= rc
.GetRight();
2793 pRect
->bottom
= rc
.GetBottom();
2798 case WM_ENTERSIZEMOVE
:
2800 processed
= HandleEnterSizeMove();
2804 case WM_EXITSIZEMOVE
:
2806 processed
= HandleExitSizeMove();
2812 LPRECT pRect
= (LPRECT
)lParam
;
2814 rc
.SetLeft(pRect
->left
);
2815 rc
.SetTop(pRect
->top
);
2816 rc
.SetRight(pRect
->right
);
2817 rc
.SetBottom(pRect
->bottom
);
2818 processed
= HandleSizing(rc
);
2820 pRect
->left
= rc
.GetLeft();
2821 pRect
->top
= rc
.GetTop();
2822 pRect
->right
= rc
.GetRight();
2823 pRect
->bottom
= rc
.GetBottom();
2827 #endif // !__WXWINCE__
2829 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2830 case WM_ACTIVATEAPP
:
2831 // This implicitly sends a wxEVT_ACTIVATE_APP event
2832 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2838 WXWORD state
, minimized
;
2840 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2842 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2847 processed
= HandleSetFocus((WXHWND
)wParam
);
2851 processed
= HandleKillFocus((WXHWND
)wParam
);
2854 case WM_PRINTCLIENT
:
2855 processed
= HandlePrintClient((WXHDC
)wParam
);
2861 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2863 processed
= HandlePaint();
2867 processed
= HandlePaint();
2872 #ifdef __WXUNIVERSAL__
2873 // Universal uses its own wxFrame/wxDialog, so we don't receive
2874 // close events unless we have this.
2876 #endif // __WXUNIVERSAL__
2878 // don't let the DefWindowProc() destroy our window - we'll do it
2879 // ourselves in ~wxWindow
2885 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2889 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2890 GET_Y_LPARAM(lParam
),
2894 #ifdef HAVE_TRACKMOUSEEVENT
2896 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2898 if ( m_mouseInWindow
)
2900 GenerateMouseLeave();
2903 // always pass processed back as false, this allows the window
2904 // manager to process the message too. This is needed to
2905 // ensure windows XP themes work properly as the mouse moves
2906 // over widgets like buttons. So don't set processed to true here.
2908 #endif // HAVE_TRACKMOUSEEVENT
2910 #if wxUSE_MOUSEWHEEL
2912 processed
= HandleMouseWheel(wParam
, lParam
);
2916 case WM_LBUTTONDOWN
:
2918 case WM_LBUTTONDBLCLK
:
2919 case WM_RBUTTONDOWN
:
2921 case WM_RBUTTONDBLCLK
:
2922 case WM_MBUTTONDOWN
:
2924 case WM_MBUTTONDBLCLK
:
2925 #ifdef wxHAS_XBUTTON
2926 case WM_XBUTTONDOWN
:
2928 case WM_XBUTTONDBLCLK
:
2929 #endif // wxHAS_XBUTTON
2931 #ifdef __WXMICROWIN__
2932 // MicroWindows seems to ignore the fact that a window is
2933 // disabled. So catch mouse events and throw them away if
2935 wxWindowMSW
* win
= this;
2938 if (!win
->IsEnabled())
2944 win
= win
->GetParent();
2945 if ( !win
|| win
->IsTopLevel() )
2952 #endif // __WXMICROWIN__
2953 int x
= GET_X_LPARAM(lParam
),
2954 y
= GET_Y_LPARAM(lParam
);
2957 // redirect the event to a static control if necessary by
2958 // finding one under mouse because under CE the static controls
2959 // don't generate mouse events (even with SS_NOTIFY)
2961 if ( GetCapture() == this )
2963 // but don't do it if the mouse is captured by this window
2964 // because then it should really get this event itself
2969 win
= FindWindowForMouseEvent(this, &x
, &y
);
2971 // this should never happen
2972 wxCHECK_MSG( win
, 0,
2973 wxT("FindWindowForMouseEvent() returned NULL") );
2976 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2978 SHRGINFO shrgi
= {0};
2980 shrgi
.cbSize
= sizeof(SHRGINFO
);
2981 shrgi
.hwndClient
= (HWND
) GetHWND();
2985 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2986 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2988 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2991 pt
= ClientToScreen(pt
);
2993 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2995 evtCtx
.SetEventObject(this);
2996 if (HandleWindowEvent(evtCtx
))
3005 #else // !__WXWINCE__
3006 wxWindowMSW
*win
= this;
3007 #endif // __WXWINCE__/!__WXWINCE__
3009 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
3011 // if the app didn't eat the event, handle it in the default
3012 // way, that is by giving this window the focus
3015 // for the standard classes their WndProc sets the focus to
3016 // them anyhow and doing it from here results in some weird
3017 // problems, so don't do it for them (unnecessary anyhow)
3018 if ( !win
->IsOfStandardClass() )
3020 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
3032 case MM_JOY1BUTTONDOWN
:
3033 case MM_JOY2BUTTONDOWN
:
3034 case MM_JOY1BUTTONUP
:
3035 case MM_JOY2BUTTONUP
:
3036 processed
= HandleJoystickEvent(message
,
3037 GET_X_LPARAM(lParam
),
3038 GET_Y_LPARAM(lParam
),
3041 #endif // __WXMICROWIN__
3047 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
3049 processed
= HandleCommand(id
, cmd
, hwnd
);
3054 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
3057 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3058 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3059 // apparently doesn't always behave properly and needs some help
3060 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3061 case WM_NOTIFYFORMAT
:
3062 if ( lParam
== NF_QUERY
)
3065 rc
.result
= NFR_UNICODE
;
3068 #endif // wxUSE_UNICODE_MSLU
3070 // for these messages we must return true if process the message
3073 processed
= MSWOnDrawItem(wParam
, (WXDRAWITEMSTRUCT
*)lParam
);
3078 case WM_MEASUREITEM
:
3079 processed
= MSWOnMeasureItem(wParam
, (WXMEASUREITEMSTRUCT
*)lParam
);
3083 #endif // defined(WM_DRAWITEM)
3086 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3088 // we always want to get the char events
3089 rc
.result
= DLGC_WANTCHARS
;
3091 if ( HasFlag(wxWANTS_CHARS
) )
3093 // in fact, we want everything
3094 rc
.result
|= DLGC_WANTARROWS
|
3101 //else: get the dlg code from the DefWindowProc()
3106 // If this has been processed by an event handler, return 0 now
3107 // (we've handled it).
3108 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3109 if ( m_lastKeydownProcessed
)
3118 // we consider these messages "not interesting" to OnChar, so
3119 // just don't do anything more with them
3129 // avoid duplicate messages to OnChar for these ASCII keys:
3130 // they will be translated by TranslateMessage() and received
3163 // but set processed to false, not true to still pass them
3164 // to the control's default window proc - otherwise
3165 // built-in keyboard handling won't work
3170 // special case of VK_APPS: treat it the same as right mouse
3171 // click because both usually pop up a context menu
3173 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3178 // do generate a CHAR event
3179 processed
= HandleChar((WORD
)wParam
, lParam
);
3182 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3189 // special case of VK_APPS: treat it the same as right mouse button
3190 if ( wParam
== VK_APPS
)
3192 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3197 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3202 case WM_CHAR
: // Always an ASCII character
3203 if ( m_lastKeydownProcessed
)
3205 // The key was handled in the EVT_KEY_DOWN and handling
3206 // a key in an EVT_KEY_DOWN handler is meant, by
3207 // design, to prevent EVT_CHARs from happening
3208 m_lastKeydownProcessed
= false;
3213 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3219 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3221 #endif // wxUSE_HOTKEY
3226 processed
= HandleClipboardEvent(message
);
3234 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3236 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3242 // CTLCOLOR messages are sent by children to query the parent for their
3244 #ifndef __WXMICROWIN__
3245 case WM_CTLCOLORMSGBOX
:
3246 case WM_CTLCOLOREDIT
:
3247 case WM_CTLCOLORLISTBOX
:
3248 case WM_CTLCOLORBTN
:
3249 case WM_CTLCOLORDLG
:
3250 case WM_CTLCOLORSCROLLBAR
:
3251 case WM_CTLCOLORSTATIC
:
3255 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3257 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3260 #endif // !__WXMICROWIN__
3262 case WM_SYSCOLORCHANGE
:
3263 // the return value for this message is ignored
3264 processed
= HandleSysColorChange();
3267 #if !defined(__WXWINCE__)
3268 case WM_DISPLAYCHANGE
:
3269 processed
= HandleDisplayChange();
3273 case WM_PALETTECHANGED
:
3274 processed
= HandlePaletteChanged((WXHWND
)wParam
);
3277 case WM_CAPTURECHANGED
:
3278 processed
= HandleCaptureChanged((WXHWND
)lParam
);
3281 case WM_SETTINGCHANGE
:
3282 processed
= HandleSettingChange(wParam
, lParam
);
3285 case WM_QUERYNEWPALETTE
:
3286 processed
= HandleQueryNewPalette();
3291 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
3292 // check if an override was configured for this window
3293 EraseBgHooks::const_iterator it
= gs_eraseBgHooks
.find(this);
3294 if ( it
!= gs_eraseBgHooks
.end() )
3295 processed
= it
->second
->MSWEraseBgHook((WXHDC
)wParam
);
3297 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
3298 processed
= HandleEraseBkgnd((WXHDC
)wParam
);
3303 // we processed the message, i.e. erased the background
3308 #if !defined(__WXWINCE__)
3310 processed
= HandleDropFiles(wParam
);
3315 processed
= HandleInitDialog((WXHWND
)wParam
);
3319 // we never set focus from here
3324 #if !defined(__WXWINCE__)
3325 case WM_QUERYENDSESSION
:
3326 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3330 processed
= HandleEndSession(wParam
!= 0, lParam
);
3333 case WM_GETMINMAXINFO
:
3334 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3339 processed
= HandleSetCursor((WXHWND
)wParam
,
3340 LOWORD(lParam
), // hit test
3341 HIWORD(lParam
)); // mouse msg
3345 // returning TRUE stops the DefWindowProc() from further
3346 // processing this message - exactly what we need because we've
3347 // just set the cursor.
3352 #if wxUSE_ACCESSIBILITY
3355 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3356 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3358 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3360 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3366 #if defined(WM_HELP)
3369 // by default, WM_HELP is propagated by DefWindowProc() upwards
3370 // to the window parent but as we do it ourselves already
3371 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3372 // to get the other events if we process this message at all
3375 // WM_HELP doesn't use lParam under CE
3377 HELPINFO
* info
= (HELPINFO
*) lParam
;
3378 if ( info
->iContextType
== HELPINFO_WINDOW
)
3380 #endif // !__WXWINCE__
3381 wxHelpEvent helpEvent
3386 wxGetMousePosition() // what else?
3388 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3392 helpEvent
.SetEventObject(this);
3393 HandleWindowEvent(helpEvent
);
3396 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3398 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3399 helpEvent
.SetEventObject(this);
3400 HandleWindowEvent(helpEvent
);
3403 else // unknown help event?
3407 #endif // !__WXWINCE__
3412 #if !defined(__WXWINCE__)
3413 case WM_CONTEXTMENU
:
3415 // we don't convert from screen to client coordinates as
3416 // the event may be handled by a parent window
3417 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3419 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3421 // we could have got an event from our child, reflect it back
3422 // to it if this is the case
3423 wxWindowMSW
*win
= NULL
;
3424 WXHWND hWnd
= (WXHWND
)wParam
;
3425 if ( hWnd
!= m_hWnd
)
3427 win
= FindItemByHWND(hWnd
);
3433 evtCtx
.SetEventObject(win
);
3434 processed
= win
->HandleWindowEvent(evtCtx
);
3441 // we're only interested in our own menus, not MF_SYSMENU
3442 if ( HIWORD(wParam
) == MF_POPUP
)
3444 // handle menu chars for ownerdrawn menu items
3445 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3446 if ( i
!= wxNOT_FOUND
)
3448 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3453 #endif // wxUSE_MENUS
3456 case WM_POWERBROADCAST
:
3459 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3460 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3463 #endif // __WXWINCE__
3466 // If we want the default themed border then we need to draw it ourselves
3469 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3470 const wxBorder border
= TranslateBorder(GetBorder());
3471 if (theme
&& border
== wxBORDER_THEME
)
3473 // first ask the widget to calculate the border size
3474 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3477 // now alter the client size making room for drawing a
3480 NCCALCSIZE_PARAMS
*csparam
= NULL
;
3483 csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3484 rect
= &csparam
->rgrc
[0];
3488 rect
= (RECT
*)lParam
;
3491 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3492 RECT rcClient
= { 0, 0, 0, 0 };
3493 wxClientDC
dc((wxWindow
*)this);
3494 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3496 if ( theme
->GetThemeBackgroundContentRect
3503 &rcClient
) == S_OK
)
3505 InflateRect(&rcClient
, -1, -1);
3507 csparam
->rgrc
[0] = rcClient
;
3509 *((RECT
*)lParam
) = rcClient
;
3511 // WVR_REDRAW triggers a bug whereby child windows are moved up and left,
3513 // rc.result = WVR_REDRAW;
3521 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3522 const wxBorder border
= TranslateBorder(GetBorder());
3523 if (theme
&& border
== wxBORDER_THEME
)
3525 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3526 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3529 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3530 wxWindowDC
dc((wxWindow
*)this);
3531 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3533 // Clip the DC so that you only draw on the non-client area
3535 wxCopyRectToRECT(GetSize(), rcBorder
);
3538 theme
->GetThemeBackgroundContentRect(
3539 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3540 InflateRect(&rcClient
, -1, -1);
3542 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3543 rcClient
.right
, rcClient
.bottom
);
3545 // Make sure the background is in a proper state
3546 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3548 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3554 nState
= ETS_DISABLED
;
3555 // should we check this?
3556 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3557 // nState = ETS_READONLY;
3559 nState
= ETS_NORMAL
;
3560 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3565 #endif // wxUSE_UXTHEME
3568 // try a custom message handler
3569 const MSWMessageHandlers::const_iterator
3570 i
= gs_messageHandlers
.find(message
);
3571 if ( i
!= gs_messageHandlers
.end() )
3573 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3579 #if wxDEBUG_LEVEL >= 2
3580 wxLogTrace("winmsg", wxT("Forwarding %s to DefWindowProc."),
3581 wxGetMessageName(message
));
3582 #endif // wxDEBUG_LEVEL >= 2
3583 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3589 // ----------------------------------------------------------------------------
3590 // wxWindow <-> HWND map
3591 // ----------------------------------------------------------------------------
3593 wxWindow
*wxFindWinFromHandle(HWND hwnd
)
3595 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3596 return i
== gs_windowHandles
.end() ? NULL
: i
->second
;
3599 void wxAssociateWinWithHandle(HWND hwnd
, wxWindowMSW
*win
)
3601 // adding NULL hwnd is (first) surely a result of an error and
3602 // (secondly) breaks menu command processing
3603 wxCHECK_RET( hwnd
!= (HWND
)NULL
,
3604 wxT("attempt to add a NULL hwnd to window list ignored") );
3607 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3608 if ( i
!= gs_windowHandles
.end() )
3610 if ( i
->second
!= win
)
3614 wxT("HWND %p already associated with another window (%s)"),
3615 hwnd
, win
->GetClassInfo()->GetClassName()
3619 //else: this actually happens currently because we associate the window
3620 // with its HWND during creation (if we create it) and also when
3621 // SubclassWin() is called later, this is ok
3623 #endif // wxDEBUG_LEVEL
3625 gs_windowHandles
[hwnd
] = (wxWindow
*)win
;
3628 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3630 gs_windowHandles
.erase(GetHwndOf(win
));
3633 // ----------------------------------------------------------------------------
3634 // various MSW speciic class dependent functions
3635 // ----------------------------------------------------------------------------
3637 // Default destroyer - override if you destroy it in some other way
3638 // (e.g. with MDI child windows)
3639 void wxWindowMSW::MSWDestroyWindow()
3643 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3646 int& w
, int& h
) const
3648 // yes, those are just some arbitrary hardcoded numbers
3649 static const int DEFAULT_Y
= 200;
3651 bool nonDefault
= false;
3653 if ( pos
.x
== wxDefaultCoord
)
3655 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3656 // can just as well set it to CW_USEDEFAULT as well
3662 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3663 // neither because it is not handled as a special value by Windows then
3664 // and so we have to choose some default value for it
3666 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3672 NB: there used to be some code here which set the initial size of the
3673 window to the client size of the parent if no explicit size was
3674 specified. This was wrong because wxWidgets programs often assume
3675 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3676 it. To see why, you should understand that Windows sends WM_SIZE from
3677 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3678 from some base class ctor and so this WM_SIZE is not processed in the
3679 real class' OnSize() (because it's not fully constructed yet and the
3680 event goes to some base class OnSize() instead). So the WM_SIZE we
3681 rely on is the one sent when the parent frame resizes its children
3682 but here is the problem: if the child already has just the right
3683 size, nothing will happen as both wxWidgets and Windows check for
3684 this and ignore any attempts to change the window size to the size it
3685 already has - so no WM_SIZE would be sent.
3689 // we don't use CW_USEDEFAULT here for several reasons:
3691 // 1. it results in huge frames on modern screens (1000*800 is not
3692 // uncommon on my 1280*1024 screen) which is way too big for a half
3693 // empty frame of most of wxWidgets samples for example)
3695 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3696 // the default is for whatever reason 8*8 which breaks client <->
3697 // window size calculations (it would be nice if it didn't, but it
3698 // does and the simplest way to fix it seemed to change the broken
3699 // default size anyhow)
3701 // 3. there is just no advantage in doing it: with x and y it is
3702 // possible that [future versions of] Windows position the new top
3703 // level window in some smart way which we can't do, but we can
3704 // guess a reasonably good size for a new window just as well
3707 // However, on PocketPC devices, we must use the default
3708 // size if possible.
3710 if (size
.x
== wxDefaultCoord
)
3714 if (size
.y
== wxDefaultCoord
)
3719 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3723 w
= WidthDefault(size
.x
);
3724 h
= HeightDefault(size
.y
);
3727 AdjustForParentClientOrigin(x
, y
);
3732 WXHWND
wxWindowMSW::MSWGetParent() const
3734 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3737 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3738 const wxChar
*title
,
3742 WXDWORD extendedStyle
)
3744 // check a common bug in the user code: if the window is created with a
3745 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3746 // single wxWindow object and this results in all sorts of trouble,
3747 // especially for wxTLWs
3748 wxCHECK_MSG( !m_hWnd
, true, "window can't be recreated" );
3750 // this can happen if this function is called using the return value of
3751 // wxApp::GetRegisteredClassName() which failed
3752 wxCHECK_MSG( wclass
, false, "failed to register window class?" );
3755 // choose the position/size for the new window
3757 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3759 // controlId is menu handle for the top level windows, so set it to 0
3760 // unless we're creating a child window
3761 int controlId
= style
& WS_CHILD
? GetId() : 0;
3763 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3764 // which is the same but without CS_[HV]REDRAW class styles so using it
3765 // ensures that the window is not fully repainted on each resize
3766 wxString
className(wclass
);
3767 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3769 className
+= wxApp::GetNoRedrawClassSuffix();
3772 // do create the window
3773 wxWindowCreationHook
hook(this);
3775 m_hWnd
= (WXHWND
)::CreateWindowEx
3779 title
? title
: m_windowName
.wx_str(),
3782 (HWND
)MSWGetParent(),
3783 (HMENU
)wxUIntToPtr(controlId
),
3785 NULL
// no extra data
3790 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3795 SubclassWin(m_hWnd
);
3800 // ===========================================================================
3801 // MSW message handlers
3802 // ===========================================================================
3804 // ---------------------------------------------------------------------------
3806 // ---------------------------------------------------------------------------
3808 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3810 #ifndef __WXMICROWIN__
3811 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3812 HWND hWnd
= hdr
->hwndFrom
;
3813 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
3815 // if the control is one of our windows, let it handle the message itself
3818 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3821 // VZ: why did we do it? normally this is unnecessary and, besides, it
3822 // breaks the message processing for the toolbars because the tooltip
3823 // notifications were being forwarded to the toolbar child controls
3824 // (if it had any) before being passed to the toolbar itself, so in my
3825 // example the tooltip for the combobox was always shown instead of the
3826 // correct button tooltips
3828 // try all our children
3829 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3832 wxWindow
*child
= node
->GetData();
3833 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3838 node
= node
->GetNext();
3842 // by default, handle it ourselves
3843 return MSWOnNotify(idCtrl
, lParam
, result
);
3844 #else // __WXMICROWIN__
3851 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3853 const wxString
& ttip
)
3855 // I don't know why it happens, but the versions of comctl32.dll starting
3856 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3857 // this message is supposed to be sent to Unicode programs only) -- hence
3858 // we need to handle it as well, otherwise no tooltips will be shown in
3861 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3864 // not a tooltip message or no tooltip to show anyhow
3869 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3871 // We don't want to use the szText buffer because it has a limit of 80
3872 // bytes and this is not enough, especially for Unicode build where it
3873 // limits the tooltip string length to only 40 characters
3875 // The best would be, of course, to not impose any length limitations at
3876 // all but then the buffer would have to be dynamic and someone would have
3877 // to free it and we don't have the tooltip owner object here any more, so
3878 // for now use our own static buffer with a higher fixed max length.
3880 // Note that using a static buffer should not be a problem as only a single
3881 // tooltip can be shown at the same time anyhow.
3883 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3885 // We need to convert tooltip from multi byte to Unicode on the fly.
3886 static wchar_t buf
[513];
3888 // Truncate tooltip length if needed as otherwise we might not have
3889 // enough space for it in the buffer and MultiByteToWideChar() would
3891 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3893 // Convert to WideChar without adding the NULL character. The NULL
3894 // character is added afterwards (this is more efficient).
3895 int len
= ::MultiByteToWideChar
3907 wxLogLastError(wxT("MultiByteToWideChar()"));
3911 ttText
->lpszText
= (LPSTR
) buf
;
3913 else // TTN_NEEDTEXTA
3914 #endif // !wxUSE_UNICODE
3916 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3917 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3918 // to copy the string we have into the buffer
3919 static wxChar buf
[513];
3920 wxStrlcpy(buf
, ttip
.c_str(), WXSIZEOF(buf
));
3921 ttText
->lpszText
= buf
;
3927 #endif // wxUSE_TOOLTIPS
3929 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3931 WXLPARAM
* WXUNUSED(result
))
3936 NMHDR
* hdr
= (NMHDR
*)lParam
;
3937 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3944 wxUnusedVar(lParam
);
3945 #endif // wxUSE_TOOLTIPS
3950 // ---------------------------------------------------------------------------
3951 // end session messages
3952 // ---------------------------------------------------------------------------
3954 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3956 #ifdef ENDSESSION_LOGOFF
3957 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3958 event
.SetEventObject(wxTheApp
);
3959 event
.SetCanVeto(true);
3960 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3962 bool rc
= wxTheApp
->ProcessEvent(event
);
3966 // we may end only if the app didn't veto session closing (double
3968 *mayEnd
= !event
.GetVeto();
3973 wxUnusedVar(logOff
);
3974 wxUnusedVar(mayEnd
);
3979 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3981 #ifdef ENDSESSION_LOGOFF
3982 // do nothing if the session isn't ending
3987 if ( (this != wxTheApp
->GetTopWindow()) )
3990 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3991 event
.SetEventObject(wxTheApp
);
3992 event
.SetCanVeto(false);
3993 event
.SetLoggingOff((logOff
& ENDSESSION_LOGOFF
) != 0);
3995 return wxTheApp
->ProcessEvent(event
);
3997 wxUnusedVar(endSession
);
3998 wxUnusedVar(logOff
);
4003 // ---------------------------------------------------------------------------
4004 // window creation/destruction
4005 // ---------------------------------------------------------------------------
4007 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
4010 // VZ: why is this commented out for WinCE? If it doesn't support
4011 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
4012 // not with multiple #ifdef's!
4014 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
4015 EnsureParentHasControlParentStyle(GetParent());
4016 #endif // !__WXWINCE__
4023 bool wxWindowMSW::HandleDestroy()
4025 // delete our drop target if we've got one
4026 #if wxUSE_DRAG_AND_DROP
4027 if ( m_dropTarget
!= NULL
)
4029 m_dropTarget
->Revoke(m_hWnd
);
4031 delete m_dropTarget
;
4032 m_dropTarget
= NULL
;
4034 #endif // wxUSE_DRAG_AND_DROP
4036 // WM_DESTROY handled
4040 // ---------------------------------------------------------------------------
4042 // ---------------------------------------------------------------------------
4044 bool wxWindowMSW::HandleActivate(int state
,
4045 bool WXUNUSED(minimized
),
4046 WXHWND
WXUNUSED(activate
))
4048 wxActivateEvent
event(wxEVT_ACTIVATE
,
4049 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
4051 event
.SetEventObject(this);
4053 return HandleWindowEvent(event
);
4056 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
4058 // Strangly enough, some controls get set focus events when they are being
4059 // deleted, even if they already had focus before.
4060 if ( m_isBeingDeleted
)
4065 // notify the parent keeping track of focus for the kbd navigation
4066 // purposes that we got it
4067 wxChildFocusEvent
eventFocus((wxWindow
*)this);
4068 (void)HandleWindowEvent(eventFocus
);
4074 m_caret
->OnSetFocus();
4076 #endif // wxUSE_CARET
4078 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
4079 event
.SetEventObject(this);
4081 // wxFindWinFromHandle() may return NULL, it is ok
4082 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4084 return HandleWindowEvent(event
);
4087 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4093 m_caret
->OnKillFocus();
4095 #endif // wxUSE_CARET
4097 // Don't send the event when in the process of being deleted. This can
4098 // only cause problems if the event handler tries to access the object.
4099 if ( m_isBeingDeleted
)
4104 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4105 event
.SetEventObject(this);
4107 // wxFindWinFromHandle() may return NULL, it is ok
4108 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4110 return HandleWindowEvent(event
);
4113 // ---------------------------------------------------------------------------
4115 // ---------------------------------------------------------------------------
4117 void wxWindowMSW::SetLabel( const wxString
& label
)
4119 SetWindowText(GetHwnd(), label
.c_str());
4122 wxString
wxWindowMSW::GetLabel() const
4124 return wxGetWindowText(GetHWND());
4127 // ---------------------------------------------------------------------------
4129 // ---------------------------------------------------------------------------
4131 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4133 wxShowEvent
event(GetId(), show
);
4134 event
.SetEventObject(this);
4136 return HandleWindowEvent(event
);
4139 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4141 wxInitDialogEvent
event(GetId());
4142 event
.SetEventObject(this);
4144 return HandleWindowEvent(event
);
4147 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4149 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4150 wxUnusedVar(wParam
);
4152 #else // __WXMICROWIN__
4153 HDROP hFilesInfo
= (HDROP
) wParam
;
4155 // Get the total number of files dropped
4156 UINT gwFilesDropped
= ::DragQueryFile
4164 wxString
*files
= new wxString
[gwFilesDropped
];
4165 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4167 // first get the needed buffer length (+1 for terminating NUL)
4168 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4170 // and now get the file name
4171 ::DragQueryFile(hFilesInfo
, wIndex
,
4172 wxStringBuffer(files
[wIndex
], len
), len
);
4175 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4176 event
.SetEventObject(this);
4179 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4180 event
.m_pos
.x
= dropPoint
.x
;
4181 event
.m_pos
.y
= dropPoint
.y
;
4183 DragFinish(hFilesInfo
);
4185 return HandleWindowEvent(event
);
4190 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4192 int WXUNUSED(mouseMsg
))
4194 #ifndef __WXMICROWIN__
4195 // the logic is as follows:
4196 // 0. if we're busy, set the busy cursor (even for non client elements)
4197 // 1. don't set custom cursor for non client area of enabled windows
4198 // 2. ask user EVT_SET_CURSOR handler for the cursor
4199 // 3. if still no cursor but we're in a TLW, set the global cursor
4201 HCURSOR hcursor
= 0;
4204 hcursor
= wxGetCurrentBusyCursor();
4208 if ( nHitTest
!= HTCLIENT
)
4211 // first ask the user code - it may wish to set the cursor in some very
4212 // specific way (for example, depending on the current position)
4215 if ( !::GetCursorPosWinCE(&pt
))
4217 if ( !::GetCursorPos(&pt
) )
4220 wxLogLastError(wxT("GetCursorPos"));
4225 ScreenToClient(&x
, &y
);
4226 wxSetCursorEvent
event(x
, y
);
4228 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4229 if ( processedEvtSetCursor
&& event
.HasCursor() )
4231 hcursor
= GetHcursorOf(event
.GetCursor());
4236 // the test for processedEvtSetCursor is here to prevent using
4237 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4238 // nothing from it - this is a way to say that our cursor shouldn't
4239 // be used for this point
4240 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4242 hcursor
= GetHcursorOf(m_cursor
);
4245 if ( !hcursor
&& !GetParent() )
4247 const wxCursor
*cursor
= wxGetGlobalCursor();
4248 if ( cursor
&& cursor
->Ok() )
4250 hcursor
= GetHcursorOf(*cursor
);
4259 ::SetCursor(hcursor
);
4261 // cursor set, stop here
4264 #endif // __WXMICROWIN__
4266 // pass up the window chain
4270 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4271 WXLPARAM
WXUNUSED(lParam
),
4272 bool *WXUNUSED_IN_WINCE(vetoed
))
4278 wxEventType evtType
;
4281 case PBT_APMQUERYSUSPEND
:
4282 evtType
= wxEVT_POWER_SUSPENDING
;
4285 case PBT_APMQUERYSUSPENDFAILED
:
4286 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4289 case PBT_APMSUSPEND
:
4290 evtType
= wxEVT_POWER_SUSPENDED
;
4293 case PBT_APMRESUMESUSPEND
:
4294 evtType
= wxEVT_POWER_RESUME
;
4298 wxLogDebug(wxT("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4301 // these messages are currently not mapped to wx events
4302 case PBT_APMQUERYSTANDBY
:
4303 case PBT_APMQUERYSTANDBYFAILED
:
4304 case PBT_APMSTANDBY
:
4305 case PBT_APMRESUMESTANDBY
:
4306 case PBT_APMBATTERYLOW
:
4307 case PBT_APMPOWERSTATUSCHANGE
:
4308 case PBT_APMOEMEVENT
:
4309 case PBT_APMRESUMECRITICAL
:
4310 #ifdef PBT_APMRESUMEAUTOMATIC
4311 case PBT_APMRESUMEAUTOMATIC
:
4313 evtType
= wxEVT_NULL
;
4317 // don't handle unknown messages
4318 if ( evtType
== wxEVT_NULL
)
4321 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4323 wxPowerEvent
event(evtType
);
4324 if ( !HandleWindowEvent(event
) )
4327 *vetoed
= event
.IsVetoed();
4333 bool wxWindowMSW::IsDoubleBuffered() const
4335 for ( const wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4337 if ( wxHasWindowExStyle(win
, WS_EX_COMPOSITED
) )
4340 if ( win
->IsTopLevel() )
4347 void wxWindowMSW::SetDoubleBuffered(bool on
)
4349 // Get the current extended style bits
4350 long exstyle
= wxGetWindowExStyle(this);
4352 // Twiddle the bit as needed
4354 exstyle
|= WS_EX_COMPOSITED
;
4356 exstyle
&= ~WS_EX_COMPOSITED
;
4359 wxSetWindowExStyle(this, exstyle
);
4362 // ---------------------------------------------------------------------------
4363 // owner drawn stuff
4364 // ---------------------------------------------------------------------------
4366 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4367 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4368 #define WXUNUSED_UNLESS_ODRAWN(param) param
4370 #define WXUNUSED_UNLESS_ODRAWN(param)
4374 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4375 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4377 #if wxUSE_OWNER_DRAWN
4379 #if wxUSE_MENUS_NATIVE
4380 // is it a menu item?
4381 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4382 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4384 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4386 // see comment before the same test in MSWOnMeasureItem() below
4390 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4391 false, wxT("MSWOnDrawItem: bad wxMenuItem pointer") );
4393 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4394 // the DC from being released
4395 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4396 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4397 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4398 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4400 return pMenuItem
->OnDrawItem
4404 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4405 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4408 #endif // wxUSE_MENUS_NATIVE
4410 #endif // USE_OWNER_DRAWN
4412 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4414 #if wxUSE_OWNER_DRAWN
4415 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4416 #else // !wxUSE_OWNER_DRAWN
4417 // we may still have owner-drawn buttons internally because we have to make
4418 // them owner-drawn to support colour change
4421 wxDynamicCast(FindItem(id
), wxButton
)
4426 #endif // USE_OWNER_DRAWN
4430 return item
->MSWOnDraw(itemStruct
);
4433 #endif // wxUSE_CONTROLS
4439 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4441 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4442 // is it a menu item?
4443 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4444 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4446 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4448 // according to Carsten Fuchs the pointer may be NULL under XP if an
4449 // MDI child frame is initially maximized, see this for more info:
4450 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4452 // so silently ignore it instead of asserting
4456 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4457 false, wxT("MSWOnMeasureItem: bad wxMenuItem pointer") );
4460 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4462 pMeasureStruct
->itemWidth
= w
;
4463 pMeasureStruct
->itemHeight
= h
;
4468 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4471 return item
->MSWOnMeasure(itemStruct
);
4475 wxUnusedVar(itemStruct
);
4476 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4481 // ---------------------------------------------------------------------------
4482 // colours and palettes
4483 // ---------------------------------------------------------------------------
4485 bool wxWindowMSW::HandleSysColorChange()
4487 wxSysColourChangedEvent event
;
4488 event
.SetEventObject(this);
4490 (void)HandleWindowEvent(event
);
4492 // always let the system carry on the default processing to allow the
4493 // native controls to react to the colours update
4497 bool wxWindowMSW::HandleDisplayChange()
4499 wxDisplayChangedEvent event
;
4500 event
.SetEventObject(this);
4502 return HandleWindowEvent(event
);
4505 #ifndef __WXMICROWIN__
4507 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4509 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4513 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4516 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4518 #endif // wxUSE_CONTROLS
4521 return *brush
!= NULL
;
4524 #endif // __WXMICROWIN__
4526 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4529 // same as below except we don't respond to our own messages
4530 if ( hWndPalChange
!= GetHWND() )
4532 // check to see if we our our parents have a custom palette
4533 wxWindowMSW
*win
= this;
4534 while ( win
&& !win
->HasCustomPalette() )
4536 win
= win
->GetParent();
4539 if ( win
&& win
->HasCustomPalette() )
4541 // realize the palette to see whether redrawing is needed
4542 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4543 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4544 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4546 int result
= ::RealizePalette(hdc
);
4548 // restore the palette (before releasing the DC)
4549 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4550 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4551 ::RealizePalette(hdc
);
4552 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4554 // now check for the need to redraw
4556 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4560 #endif // wxUSE_PALETTE
4562 wxPaletteChangedEvent
event(GetId());
4563 event
.SetEventObject(this);
4564 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4566 return HandleWindowEvent(event
);
4569 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4571 // notify windows on the capture stack about lost capture
4572 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4573 wxWindowBase::NotifyCaptureLost();
4575 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4576 wxMouseCaptureChangedEvent
event(GetId(), win
);
4577 event
.SetEventObject(this);
4578 return HandleWindowEvent(event
);
4581 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4583 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4584 // we need to send this to child windows (it is only sent to top-level
4585 // windows) so {list,tree}ctrls can adjust their font size if necessary
4586 // this is exactly how explorer does it to enable the font size changes
4588 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4591 // top-level windows already get this message from the system
4592 wxWindow
*win
= node
->GetData();
4593 if ( !win
->IsTopLevel() )
4595 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4598 node
= node
->GetNext();
4601 // let the system handle it
4605 bool wxWindowMSW::HandleQueryNewPalette()
4609 // check to see if we our our parents have a custom palette
4610 wxWindowMSW
*win
= this;
4611 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4612 if (win
->HasCustomPalette()) {
4613 /* realize the palette to see whether redrawing is needed */
4614 HDC hdc
= ::GetDC((HWND
) GetHWND());
4615 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4616 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4618 int result
= ::RealizePalette(hdc
);
4619 /* restore the palette (before releasing the DC) */
4620 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4621 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4622 ::RealizePalette(hdc
);
4623 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4624 /* now check for the need to redraw */
4626 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4628 #endif // wxUSE_PALETTE
4630 wxQueryNewPaletteEvent
event(GetId());
4631 event
.SetEventObject(this);
4633 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4636 // Responds to colour changes: passes event on to children.
4637 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4639 // the top level window also reset the standard colour map as it might have
4640 // changed (there is no need to do it for the non top level windows as we
4641 // only have to do it once)
4645 gs_hasStdCmap
= false;
4647 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4650 // Only propagate to non-top-level windows because Windows already
4651 // sends this event to all top-level ones
4652 wxWindow
*win
= node
->GetData();
4653 if ( !win
->IsTopLevel() )
4655 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4656 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4657 // the standard controls
4658 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4661 node
= node
->GetNext();
4665 extern wxCOLORMAP
*wxGetStdColourMap()
4667 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4668 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4670 if ( !gs_hasStdCmap
)
4672 static bool s_coloursInit
= false;
4674 if ( !s_coloursInit
)
4676 // When a bitmap is loaded, the RGB values can change (apparently
4677 // because Windows adjusts them to care for the old programs always
4678 // using 0xc0c0c0 while the transparent colour for the new Windows
4679 // versions is different). But we do this adjustment ourselves so
4680 // we want to avoid Windows' "help" and for this we need to have a
4681 // reference bitmap which can tell us what the RGB values change
4683 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4684 wxBitmap
stdColourBitmap(wxT("wxBITMAP_STD_COLOURS"));
4685 if ( stdColourBitmap
.Ok() )
4687 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4688 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4689 wxT("forgot to update wxBITMAP_STD_COLOURS!") );
4692 memDC
.SelectObject(stdColourBitmap
);
4695 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4697 memDC
.GetPixel(i
, 0, &colour
);
4698 s_stdColours
[i
] = wxColourToRGB(colour
);
4701 else // wxBITMAP_STD_COLOURS couldn't be loaded
4703 s_stdColours
[0] = RGB(000,000,000); // black
4704 s_stdColours
[1] = RGB(128,128,128); // dark grey
4705 s_stdColours
[2] = RGB(192,192,192); // light grey
4706 s_stdColours
[3] = RGB(255,255,255); // white
4707 //s_stdColours[4] = RGB(000,000,255); // blue
4708 //s_stdColours[5] = RGB(255,000,255); // magenta
4711 s_coloursInit
= true;
4714 gs_hasStdCmap
= true;
4716 // create the colour map
4717 #define INIT_CMAP_ENTRY(col) \
4718 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4719 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4721 INIT_CMAP_ENTRY(BTNTEXT
);
4722 INIT_CMAP_ENTRY(BTNSHADOW
);
4723 INIT_CMAP_ENTRY(BTNFACE
);
4724 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4726 #undef INIT_CMAP_ENTRY
4732 #if wxUSE_UXTHEME && !defined(TMT_FILLCOLOR)
4733 #define TMT_FILLCOLOR 3802
4734 #define TMT_TEXTCOLOR 3803
4735 #define TMT_BORDERCOLOR 3801
4738 wxColour
wxWindowMSW::MSWGetThemeColour(const wchar_t *themeName
,
4741 MSWThemeColour themeColour
,
4742 wxSystemColour fallback
) const
4745 const wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
4748 int themeProperty
= 0;
4750 // TODO: Convert this into a table? Sure would be faster.
4751 switch ( themeColour
)
4753 case ThemeColourBackground
:
4754 themeProperty
= TMT_FILLCOLOR
;
4756 case ThemeColourText
:
4757 themeProperty
= TMT_TEXTCOLOR
;
4759 case ThemeColourBorder
:
4760 themeProperty
= TMT_BORDERCOLOR
;
4763 wxFAIL_MSG(wxT("unsupported theme colour"));
4766 wxUxThemeHandle
hTheme((const wxWindow
*)this, themeName
);
4768 HRESULT hr
= theme
->GetThemeColor
4777 if ( SUCCEEDED(hr
) )
4778 return wxRGBToColour(col
);
4782 "GetThemeColor(%s, %i, %i, %i)",
4783 themeName
, themePart
, themeState
, themeProperty
),
4787 wxUnusedVar(themeName
);
4788 wxUnusedVar(themePart
);
4789 wxUnusedVar(themeState
);
4790 wxUnusedVar(themeColour
);
4792 return wxSystemSettings::GetColour(fallback
);
4795 // ---------------------------------------------------------------------------
4797 // ---------------------------------------------------------------------------
4799 // this variable is used to check that a paint event handler which processed
4800 // the event did create a wxPaintDC inside its code and called BeginPaint() to
4801 // validate the invalidated window area as otherwise we'd keep getting an
4802 // endless stream of WM_PAINT messages for this window resulting in a lot of
4803 // difficult to debug problems (e.g. impossibility to repaint other windows,
4804 // lack of timer and idle events and so on)
4805 extern bool wxDidCreatePaintDC
;
4806 bool wxDidCreatePaintDC
= false;
4808 bool wxWindowMSW::HandlePaint()
4810 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4813 wxLogLastError(wxT("CreateRectRgn"));
4815 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4817 wxLogLastError(wxT("GetUpdateRgn"));
4820 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4822 wxDidCreatePaintDC
= false;
4824 wxPaintEvent
event(m_windowId
);
4825 event
.SetEventObject(this);
4827 bool processed
= HandleWindowEvent(event
);
4829 if ( processed
&& !wxDidCreatePaintDC
)
4831 // do call MSWDefWindowProc() to validate the update region to avoid
4832 // the problems mentioned above
4836 // note that we must generate NC event after the normal one as otherwise
4837 // BeginPaint() will happily overwrite our decorations with the background
4839 wxNcPaintEvent
eventNc(m_windowId
);
4840 eventNc
.SetEventObject(this);
4841 HandleWindowEvent(eventNc
);
4843 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4844 // be called from inside the event handlers called above)
4845 m_updateRegion
.Clear();
4850 // Can be called from an application's OnPaint handler
4851 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4853 #ifdef __WXUNIVERSAL__
4856 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4859 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4864 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4866 switch ( GetBackgroundStyle() )
4868 case wxBG_STYLE_ERASE
:
4869 case wxBG_STYLE_COLOUR
:
4870 // we need to generate an erase background event
4872 wxDCTemp
dc(hdc
, GetClientSize());
4873 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4876 impl
->SetWindow((wxWindow
*)this);
4878 wxEraseEvent
event(m_windowId
, &dc
);
4879 event
.SetEventObject(this);
4880 bool rc
= HandleWindowEvent(event
);
4882 // must be called manually as ~wxDC doesn't do anything for
4884 impl
->SelectOldObjects(hdc
);
4888 // background erased by the user-defined handler
4894 case wxBG_STYLE_SYSTEM
:
4895 if ( !DoEraseBackground(hdc
) )
4897 // let the default processing to take place if we didn't erase
4898 // the background ourselves
4903 case wxBG_STYLE_PAINT
:
4904 case wxBG_STYLE_TRANSPARENT
:
4905 // no need to do anything here at all, background will be entirely
4906 // redrawn in WM_PAINT handler
4910 wxFAIL_MSG( "unknown background style" );
4916 #ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
4918 bool wxWindowMSW::MSWHasEraseBgHook() const
4920 return gs_eraseBgHooks
.find(this) != gs_eraseBgHooks
.end();
4923 void wxWindowMSW::MSWSetEraseBgHook(wxWindow
*child
)
4927 if ( !gs_eraseBgHooks
.insert(
4928 EraseBgHooks::value_type(this, child
)).second
)
4930 wxFAIL_MSG( wxT("Setting erase background hook twice?") );
4933 else // reset the hook
4935 if ( gs_eraseBgHooks
.erase(this) != 1 )
4937 wxFAIL_MSG( wxT("Resetting erase background which was not set?") );
4942 #endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
4944 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4946 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4950 // erase just the client area of the window, this is important for the
4951 // frames to avoid drawing over the toolbar part of the window (you might
4952 // think using WS_CLIPCHILDREN would prevent this from happening, but it
4955 wxCopyRectToRECT(GetClientRect(), rc
);
4956 ::FillRect((HDC
)hDC
, &rc
, hbr
);
4962 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), wxWindowMSW
*child
)
4966 // our background colour applies to:
4967 // 1. this window itself, always
4968 // 2. all children unless the colour is "not inheritable"
4969 // 3. even if it is not inheritable, our immediate transparent
4970 // children should still inherit it -- but not any transparent
4971 // children because it would look wrong if a child of non
4972 // transparent child would show our bg colour when the child itself
4974 if ( child
== this ||
4976 (child
->HasTransparentBackground() &&
4977 child
->GetParent() == this) )
4979 // draw children with the same colour as the parent
4981 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4983 return (WXHBRUSH
)GetHbrushOf(*brush
);
4990 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, wxWindowMSW
*child
)
4992 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4994 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, child
);
4998 // background is not inherited beyond top level windows
4999 if ( win
->IsTopLevel() )
5006 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
5008 // we receive this message when DrawThemeParentBackground() is
5009 // called from def window proc of several controls under XP and we
5010 // must draw properly themed background here
5012 // note that naively I'd expect filling the client rect with the
5013 // brush returned by MSWGetBgBrush() work -- but for some reason it
5014 // doesn't and we have to call parents MSWPrintChild() which is
5015 // supposed to call DrawThemeBackground() with appropriate params
5017 // also note that in this case lParam == PRF_CLIENT but we're
5018 // clearly expected to paint the background and nothing else!
5020 if ( IsTopLevel() || InheritsBackgroundColour() )
5023 // sometimes we don't want the parent to handle it at all, instead
5024 // return whatever value this window wants
5025 if ( !MSWShouldPropagatePrintChild() )
5026 return MSWPrintChild(hDC
, (wxWindow
*)this);
5028 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
5030 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
5033 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
5040 // ---------------------------------------------------------------------------
5041 // moving and resizing
5042 // ---------------------------------------------------------------------------
5044 bool wxWindowMSW::HandleMinimize()
5046 wxIconizeEvent
event(m_windowId
);
5047 event
.SetEventObject(this);
5049 return HandleWindowEvent(event
);
5052 bool wxWindowMSW::HandleMaximize()
5054 wxMaximizeEvent
event(m_windowId
);
5055 event
.SetEventObject(this);
5057 return HandleWindowEvent(event
);
5060 bool wxWindowMSW::HandleMove(int x
, int y
)
5063 wxMoveEvent
event(point
, m_windowId
);
5064 event
.SetEventObject(this);
5066 return HandleWindowEvent(event
);
5069 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
5071 wxMoveEvent
event(rect
, m_windowId
);
5072 event
.SetEventObject(this);
5074 bool rc
= HandleWindowEvent(event
);
5076 rect
= event
.GetRect();
5080 bool wxWindowMSW::HandleEnterSizeMove()
5082 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
5083 event
.SetEventType(wxEVT_MOVE_START
);
5084 event
.SetEventObject(this);
5086 return HandleWindowEvent(event
);
5089 bool wxWindowMSW::HandleExitSizeMove()
5091 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
5092 event
.SetEventType(wxEVT_MOVE_END
);
5093 event
.SetEventObject(this);
5095 return HandleWindowEvent(event
);
5098 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
5100 #if wxUSE_DEFERRED_SIZING
5101 // when we resize this window, its children are probably going to be
5102 // repositioned as well, prepare to use DeferWindowPos() for them
5103 int numChildren
= 0;
5104 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
5106 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
5111 // Protect against valid m_hDWP being overwritten
5112 bool useDefer
= false;
5114 if ( numChildren
> 1 )
5118 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
5121 wxLogLastError(wxT("BeginDeferWindowPos"));
5127 #endif // wxUSE_DEFERRED_SIZING
5129 // update this window size
5130 bool processed
= false;
5134 wxFAIL_MSG( wxT("unexpected WM_SIZE parameter") );
5135 // fall through nevertheless
5139 // we're not interested in these messages at all
5142 case SIZE_MINIMIZED
:
5143 processed
= HandleMinimize();
5146 case SIZE_MAXIMIZED
:
5147 /* processed = */ HandleMaximize();
5148 // fall through to send a normal size event as well
5151 // don't use w and h parameters as they specify the client size
5152 // while according to the docs EVT_SIZE handler is supposed to
5153 // receive the total size
5154 wxSizeEvent
event(GetSize(), m_windowId
);
5155 event
.SetEventObject(this);
5157 processed
= HandleWindowEvent(event
);
5160 #if wxUSE_DEFERRED_SIZING
5161 // and finally change the positions of all child windows at once
5162 if ( useDefer
&& m_hDWP
)
5164 // reset m_hDWP to NULL so that child windows don't try to use our
5165 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
5166 // happen anyhow normally but who knows what weird flow of control we
5167 // may have depending on what the users EVT_SIZE handler does...)
5168 HDWP hDWP
= (HDWP
)m_hDWP
;
5171 // do put all child controls in place at once
5172 if ( !::EndDeferWindowPos(hDWP
) )
5174 wxLogLastError(wxT("EndDeferWindowPos"));
5177 // Reset our children's pending pos/size values.
5178 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
5180 node
= node
->GetNext() )
5182 wxWindowMSW
* const child
= node
->GetData();
5183 child
->MSWEndDeferWindowPos();
5186 #endif // wxUSE_DEFERRED_SIZING
5191 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
5193 wxSizeEvent
event(rect
, m_windowId
);
5194 event
.SetEventObject(this);
5196 bool rc
= HandleWindowEvent(event
);
5198 rect
= event
.GetRect();
5202 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5207 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5211 int minWidth
= GetMinWidth(),
5212 minHeight
= GetMinHeight(),
5213 maxWidth
= GetMaxWidth(),
5214 maxHeight
= GetMaxHeight();
5216 if ( minWidth
!= wxDefaultCoord
)
5218 info
->ptMinTrackSize
.x
= minWidth
;
5222 if ( minHeight
!= wxDefaultCoord
)
5224 info
->ptMinTrackSize
.y
= minHeight
;
5228 if ( maxWidth
!= wxDefaultCoord
)
5230 info
->ptMaxTrackSize
.x
= maxWidth
;
5234 if ( maxHeight
!= wxDefaultCoord
)
5236 info
->ptMaxTrackSize
.y
= maxHeight
;
5244 // ---------------------------------------------------------------------------
5246 // ---------------------------------------------------------------------------
5248 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5250 // sign extend to int from short before comparing with the other int ids
5251 int id
= (signed short)id_
;
5253 #if wxUSE_MENUS_NATIVE
5254 if ( !cmd
&& wxCurrentPopupMenu
)
5256 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5257 wxCurrentPopupMenu
= NULL
;
5259 return popupMenu
->MSWCommand(cmd
, id
);
5261 #endif // wxUSE_MENUS_NATIVE
5263 wxWindow
*win
= NULL
;
5265 // first try to find it from HWND - this works even with the broken
5266 // programs using the same ids for different controls
5269 win
= wxFindWinFromHandle(control
);
5280 return win
->MSWCommand(cmd
, id
);
5283 // the messages sent from the in-place edit control used by the treectrl
5284 // for label editing have id == 0, but they should _not_ be treated as menu
5285 // messages (they are EN_XXX ones, in fact) so don't translate anything
5286 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5289 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, id
);
5290 event
.SetEventObject(this);
5293 return HandleWindowEvent(event
);
5297 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5298 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5299 // notifications to its parent which we want to reflect back to
5301 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5302 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5304 #endif // wxUSE_SPINCTRL
5306 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5307 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5308 // notifications to its parent which we want to reflect back to
5310 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5311 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5319 // ---------------------------------------------------------------------------
5321 // ---------------------------------------------------------------------------
5323 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5327 // our client coords are not quite the same as Windows ones
5328 wxPoint pt
= GetClientAreaOrigin();
5329 event
.m_x
= x
- pt
.x
;
5330 event
.m_y
= y
- pt
.y
;
5332 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5333 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5334 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5335 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5336 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5337 #ifdef wxHAS_XBUTTON
5338 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5339 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5340 #endif // wxHAS_XBUTTON
5341 event
.m_altDown
= ::wxIsAltDown();
5344 event
.SetTimestamp(::GetMessageTime());
5347 event
.SetEventObject(this);
5348 event
.SetId(GetId());
5350 #if wxUSE_MOUSEEVENT_HACK
5351 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5352 gs_lastMouseEvent
.type
= event
.GetEventType();
5353 #endif // wxUSE_MOUSEEVENT_HACK
5357 // Windows doesn't send the mouse events to the static controls (which are
5358 // transparent in the sense that their WM_NCHITTEST handler returns
5359 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5360 // and so we manually check if we don't have a child window under mouse and if
5361 // we do, send the event to it instead of the window Windows had sent WM_XXX
5364 // Notice that this is not done for the mouse move events because this could
5365 // (would?) be too slow, but only for clicks which means that the static texts
5366 // still don't get move, enter nor leave events.
5367 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5369 wxCHECK_MSG( x
&& y
, win
, wxT("NULL pointer in FindWindowForMouseEvent") );
5371 // first try to find a non transparent child: this allows us to send events
5372 // to a static text which is inside a static box, for example
5373 POINT pt
= { *x
, *y
};
5374 HWND hwnd
= GetHwndOf(win
),
5378 hwndUnderMouse
= ::ChildWindowFromPoint
5384 hwndUnderMouse
= ::ChildWindowFromPointEx
5394 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5396 // now try any child window at all
5397 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5400 // check that we have a child window which is susceptible to receive mouse
5401 // events: for this it must be shown and enabled
5402 if ( hwndUnderMouse
&&
5403 hwndUnderMouse
!= hwnd
&&
5404 ::IsWindowVisible(hwndUnderMouse
) &&
5405 ::IsWindowEnabled(hwndUnderMouse
) )
5407 wxWindow
*winUnderMouse
= wxFindWinFromHandle(hwndUnderMouse
);
5408 if ( winUnderMouse
)
5410 // translate the mouse coords to the other window coords
5411 win
->ClientToScreen(x
, y
);
5412 winUnderMouse
->ScreenToClient(x
, y
);
5414 win
= winUnderMouse
;
5420 #endif // __WXWINCE__
5422 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5424 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5425 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5426 // from the message id and take the value in the table to get wxWin event
5428 static const wxEventType eventsMouse
[] =
5439 wxEVT_MIDDLE_DCLICK
,
5440 0, // this one is for wxEVT_MOTION which is not used here
5449 #ifdef wxHAS_XBUTTON
5450 // the same messages are used for both auxillary mouse buttons so we need
5451 // to adjust the index manually
5454 case WM_XBUTTONDOWN
:
5456 case WM_XBUTTONDBLCLK
:
5457 if ( flags
& MK_XBUTTON2
)
5458 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5460 #endif // wxHAS_XBUTTON
5462 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5463 InitMouseEvent(event
, x
, y
, flags
);
5465 return HandleWindowEvent(event
);
5468 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5470 if ( !m_mouseInWindow
)
5472 // it would be wrong to assume that just because we get a mouse move
5473 // event that the mouse is inside the window: although this is usually
5474 // true, it is not if we had captured the mouse, so we need to check
5475 // the mouse coordinates here
5476 if ( !HasCapture() || IsMouseInWindow() )
5478 // Generate an ENTER event
5479 m_mouseInWindow
= true;
5481 #ifdef HAVE_TRACKMOUSEEVENT
5482 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5484 static const _TrackMouseEvent_t
5485 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5486 #else // !__WXWINCE__
5487 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5488 static bool s_initDone
= false;
5491 // see comment in wxApp::GetComCtl32Version() explaining the
5492 // use of wxLoadedDLL
5493 wxLoadedDLL
dllComCtl32(wxT("comctl32.dll"));
5494 if ( dllComCtl32
.IsLoaded() )
5496 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5497 dllComCtl32
.RawGetSymbol(wxT("_TrackMouseEvent"));
5503 if ( s_pfn_TrackMouseEvent
)
5504 #endif // __WXWINCE__/!__WXWINCE__
5506 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5508 trackinfo
.dwFlags
= TME_LEAVE
;
5509 trackinfo
.hwndTrack
= GetHwnd();
5511 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5513 #endif // HAVE_TRACKMOUSEEVENT
5515 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5516 InitMouseEvent(event
, x
, y
, flags
);
5518 (void)HandleWindowEvent(event
);
5521 #ifdef HAVE_TRACKMOUSEEVENT
5522 else // mouse not in window
5524 // Check if we need to send a LEAVE event
5525 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5526 // send it here if we are using native mouse leave tracking
5527 if ( HasCapture() && !IsMouseInWindow() )
5529 GenerateMouseLeave();
5532 #endif // HAVE_TRACKMOUSEEVENT
5534 #if wxUSE_MOUSEEVENT_HACK
5535 // Windows often generates mouse events even if mouse position hasn't
5536 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5538 // Filter this out as it can result in unexpected behaviour compared to
5540 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5541 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5542 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5543 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5545 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5547 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5552 #endif // wxUSE_MOUSEEVENT_HACK
5554 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5558 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5560 #if wxUSE_MOUSEWHEEL
5561 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5562 // forwarded up to the parent by DefWindowProc()) and not in the client
5563 // ones as all the other messages, translate them to the client coords for
5566 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5567 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5568 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5569 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5570 event
.m_wheelDelta
= WHEEL_DELTA
;
5572 static int s_linesPerRotation
= -1;
5573 if ( s_linesPerRotation
== -1 )
5575 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5576 &s_linesPerRotation
, 0))
5578 // this is not supposed to happen
5579 wxLogLastError(wxT("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5581 // the default is 3, so use it if SystemParametersInfo() failed
5582 s_linesPerRotation
= 3;
5586 event
.m_linesPerAction
= s_linesPerRotation
;
5587 return HandleWindowEvent(event
);
5589 #else // !wxUSE_MOUSEWHEEL
5590 wxUnusedVar(wParam
);
5591 wxUnusedVar(lParam
);
5594 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5597 void wxWindowMSW::GenerateMouseLeave()
5599 m_mouseInWindow
= false;
5602 if ( wxIsShiftDown() )
5604 if ( wxIsCtrlDown() )
5605 state
|= MK_CONTROL
;
5607 // Only the high-order bit should be tested
5608 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5609 state
|= MK_LBUTTON
;
5610 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5611 state
|= MK_MBUTTON
;
5612 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5613 state
|= MK_RBUTTON
;
5617 if ( !::GetCursorPosWinCE(&pt
) )
5619 if ( !::GetCursorPos(&pt
) )
5622 wxLogLastError(wxT("GetCursorPos"));
5625 // we need to have client coordinates here for symmetry with
5626 // wxEVT_ENTER_WINDOW
5627 RECT rect
= wxGetWindowRect(GetHwnd());
5631 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5632 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5634 (void)HandleWindowEvent(event
);
5637 // ---------------------------------------------------------------------------
5638 // keyboard handling
5639 // ---------------------------------------------------------------------------
5641 // create the key event of the given type for the given key - used by
5642 // HandleChar and HandleKeyDown/Up
5643 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5646 WXWPARAM wParam
) const
5648 wxKeyEvent
event(evType
);
5649 event
.SetId(GetId());
5650 event
.m_shiftDown
= wxIsShiftDown();
5651 event
.m_controlDown
= wxIsCtrlDown();
5652 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5654 event
.SetEventObject((wxWindow
*)this); // const_cast
5655 event
.m_keyCode
= id
;
5657 event
.m_uniChar
= (wxChar
) wParam
;
5659 event
.m_rawCode
= (wxUint32
) wParam
;
5660 event
.m_rawFlags
= (wxUint32
) lParam
;
5662 event
.SetTimestamp(::GetMessageTime());
5665 // translate the position to client coords
5668 GetCursorPosWinCE(&pt
);
5673 GetWindowRect(GetHwnd(),&rect
);
5683 // isASCII is true only when we're called from WM_CHAR handler and not from
5685 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5692 else // we're called from WM_KEYDOWN
5694 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5695 // to get numpad key codes: CHAR events should use the logical keys
5696 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5697 id
= wxCharCodeMSWToWX(wParam
);
5700 // it's ASCII and will be processed here only when called from
5701 // WM_CHAR (i.e. when isASCII = true), don't process it now
5706 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5708 // the alphanumeric keys produced by pressing AltGr+something on European
5709 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5710 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5711 // alphanumeric, so pretend that there are no modifiers at all (the
5712 // KEY_DOWN event would still have the correct modifiers if they're really
5714 if ( event
.m_controlDown
&& event
.m_altDown
&&
5715 (id
>= 32 && id
< 256) )
5717 event
.m_controlDown
=
5718 event
.m_altDown
= false;
5721 return HandleWindowEvent(event
);
5724 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5726 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5730 // normal ASCII char
5734 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5735 return HandleWindowEvent(event
);
5738 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5740 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5744 // normal ASCII char
5748 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5749 return HandleWindowEvent(event
);
5753 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5754 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5756 // FIXME: implement GetMenuItemCount for WinCE, possibly
5757 // in terms of GetMenuItemInfo
5759 const HMENU hmenu
= (HMENU
)lParam
;
5763 mii
.cbSize
= sizeof(MENUITEMINFO
);
5765 // we could use MIIM_FTYPE here as we only need to know if the item is
5766 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5767 // MIIM_FTYPE is not supported under Win95
5768 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5770 // find if we have this letter in any owner drawn item
5771 const int count
= ::GetMenuItemCount(hmenu
);
5772 for ( int i
= 0; i
< count
; i
++ )
5774 // previous loop iteration could modify it, reset it back before
5775 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5778 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5780 if ( mii
.fType
== MFT_OWNERDRAW
)
5782 // dwItemData member of the MENUITEMINFO is a
5783 // pointer to the associated wxMenuItem -- see the
5784 // menu creation code
5785 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5787 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), wxT('&'));
5790 if ( *p
== wxT('&') )
5792 // this is not the accel char, find the real one
5793 p
= wxStrchr(p
+ 1, wxT('&'));
5795 else // got the accel char
5797 // FIXME-UNICODE: this comparison doesn't risk to work
5798 // for non ASCII accelerator characters I'm afraid, but
5800 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5806 // this one doesn't match
5813 else // failed to get the menu text?
5815 // it's not fatal, so don't show error, but still log it
5816 wxLogLastError(wxT("GetMenuItemInfo"));
5823 #endif // wxUSE_MENUS
5825 bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg
)
5827 const wxEventType type
= nMsg
== WM_CUT
? wxEVT_COMMAND_TEXT_CUT
5828 : nMsg
== WM_COPY
? wxEVT_COMMAND_TEXT_COPY
5829 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE
;
5830 wxClipboardTextEvent
evt(type
, GetId());
5832 evt
.SetEventObject(this);
5834 return HandleWindowEvent(evt
);
5837 // ---------------------------------------------------------------------------
5839 // ---------------------------------------------------------------------------
5841 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5845 if ( flags
& JOY_BUTTON1CHG
)
5846 change
= wxJOY_BUTTON1
;
5847 if ( flags
& JOY_BUTTON2CHG
)
5848 change
= wxJOY_BUTTON2
;
5849 if ( flags
& JOY_BUTTON3CHG
)
5850 change
= wxJOY_BUTTON3
;
5851 if ( flags
& JOY_BUTTON4CHG
)
5852 change
= wxJOY_BUTTON4
;
5855 if ( flags
& JOY_BUTTON1
)
5856 buttons
|= wxJOY_BUTTON1
;
5857 if ( flags
& JOY_BUTTON2
)
5858 buttons
|= wxJOY_BUTTON2
;
5859 if ( flags
& JOY_BUTTON3
)
5860 buttons
|= wxJOY_BUTTON3
;
5861 if ( flags
& JOY_BUTTON4
)
5862 buttons
|= wxJOY_BUTTON4
;
5864 // the event ids aren't consecutive so we can't use table based lookup
5866 wxEventType eventType
;
5871 eventType
= wxEVT_JOY_MOVE
;
5876 eventType
= wxEVT_JOY_MOVE
;
5881 eventType
= wxEVT_JOY_ZMOVE
;
5886 eventType
= wxEVT_JOY_ZMOVE
;
5889 case MM_JOY1BUTTONDOWN
:
5891 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5894 case MM_JOY2BUTTONDOWN
:
5896 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5899 case MM_JOY1BUTTONUP
:
5901 eventType
= wxEVT_JOY_BUTTON_UP
;
5904 case MM_JOY2BUTTONUP
:
5906 eventType
= wxEVT_JOY_BUTTON_UP
;
5910 wxFAIL_MSG(wxT("no such joystick event"));
5915 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5916 event
.SetPosition(wxPoint(x
, y
));
5917 event
.SetEventObject(this);
5919 return HandleWindowEvent(event
);
5929 // ---------------------------------------------------------------------------
5931 // ---------------------------------------------------------------------------
5933 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5934 WXWORD pos
, WXHWND control
)
5936 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5938 wxWindow
*child
= wxFindWinFromHandle(control
);
5940 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5943 wxScrollWinEvent event
;
5944 event
.SetPosition(pos
);
5945 event
.SetOrientation(orientation
);
5946 event
.SetEventObject(this);
5951 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5955 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5959 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5963 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5967 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5971 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5974 case SB_THUMBPOSITION
:
5976 // under Win32, the scrollbar range and position are 32 bit integers,
5977 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5978 // explicitly query the scrollbar for the correct position (this must
5979 // be done only for these two SB_ events as they are the only one
5980 // carrying the scrollbar position)
5982 WinStruct
<SCROLLINFO
> scrollInfo
;
5983 scrollInfo
.fMask
= SIF_TRACKPOS
;
5985 if ( !::GetScrollInfo(GetHwnd(),
5986 WXOrientToSB(orientation
),
5989 // Not necessarily an error, if there are no scrollbars yet.
5990 // wxLogLastError(wxT("GetScrollInfo"));
5993 event
.SetPosition(scrollInfo
.nTrackPos
);
5996 event
.SetEventType( wParam
== SB_THUMBPOSITION
5997 ? wxEVT_SCROLLWIN_THUMBRELEASE
5998 : wxEVT_SCROLLWIN_THUMBTRACK
);
6005 return HandleWindowEvent(event
);
6008 // ----------------------------------------------------------------------------
6009 // custom message handlers
6010 // ----------------------------------------------------------------------------
6013 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
6015 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
6016 false, wxT("registering handler for the same message twice") );
6018 gs_messageHandlers
[msg
] = handler
;
6023 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
6025 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
6026 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
6027 wxT("unregistering non-registered handler?") );
6029 gs_messageHandlers
.erase(i
);
6032 // ===========================================================================
6034 // ===========================================================================
6036 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
6039 HDC dc
= ::GetDC((HWND
) wnd
);
6042 // the_font.UseResource();
6043 // the_font.RealizeResource();
6044 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
6046 was
= (HFONT
) SelectObject(dc
,fnt
);
6048 GetTextMetrics(dc
, &tm
);
6051 SelectObject(dc
,was
);
6053 ReleaseDC((HWND
)wnd
, dc
);
6056 *x
= tm
.tmAveCharWidth
;
6058 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
6060 // the_font.ReleaseResource();
6063 // use the "extended" bit (24) of lParam to distinguish extended keys
6064 // from normal keys as the same key is sent
6066 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
6068 // except that if lParam is 0, it means we don't have real lParam from
6069 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
6070 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
6071 // non-numpad (hence extended) key as this is a more common case
6072 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
6075 // this array contains the Windows virtual key codes which map one to one to
6076 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
6078 // note that keys having a normal and numpad version (e.g. WXK_HOME and
6079 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
6080 static const struct wxKeyMapping
6084 } gs_specialKeys
[] =
6086 { VK_CANCEL
, WXK_CANCEL
},
6087 { VK_BACK
, WXK_BACK
},
6088 { VK_TAB
, WXK_TAB
},
6089 { VK_CLEAR
, WXK_CLEAR
},
6090 { VK_SHIFT
, WXK_SHIFT
},
6091 { VK_CONTROL
, WXK_CONTROL
},
6092 { VK_MENU
, WXK_ALT
},
6093 { VK_PAUSE
, WXK_PAUSE
},
6094 { VK_CAPITAL
, WXK_CAPITAL
},
6095 { VK_SPACE
, WXK_SPACE
},
6096 { VK_ESCAPE
, WXK_ESCAPE
},
6097 { VK_SELECT
, WXK_SELECT
},
6098 { VK_PRINT
, WXK_PRINT
},
6099 { VK_EXECUTE
, WXK_EXECUTE
},
6100 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
6101 { VK_HELP
, WXK_HELP
},
6103 { VK_NUMPAD0
, WXK_NUMPAD0
},
6104 { VK_NUMPAD1
, WXK_NUMPAD1
},
6105 { VK_NUMPAD2
, WXK_NUMPAD2
},
6106 { VK_NUMPAD3
, WXK_NUMPAD3
},
6107 { VK_NUMPAD4
, WXK_NUMPAD4
},
6108 { VK_NUMPAD5
, WXK_NUMPAD5
},
6109 { VK_NUMPAD6
, WXK_NUMPAD6
},
6110 { VK_NUMPAD7
, WXK_NUMPAD7
},
6111 { VK_NUMPAD8
, WXK_NUMPAD8
},
6112 { VK_NUMPAD9
, WXK_NUMPAD9
},
6113 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
6114 { VK_ADD
, WXK_NUMPAD_ADD
},
6115 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
6116 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
6117 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
6128 { VK_F10
, WXK_F10
},
6129 { VK_F11
, WXK_F11
},
6130 { VK_F12
, WXK_F12
},
6131 { VK_F13
, WXK_F13
},
6132 { VK_F14
, WXK_F14
},
6133 { VK_F15
, WXK_F15
},
6134 { VK_F16
, WXK_F16
},
6135 { VK_F17
, WXK_F17
},
6136 { VK_F18
, WXK_F18
},
6137 { VK_F19
, WXK_F19
},
6138 { VK_F20
, WXK_F20
},
6139 { VK_F21
, WXK_F21
},
6140 { VK_F22
, WXK_F22
},
6141 { VK_F23
, WXK_F23
},
6142 { VK_F24
, WXK_F24
},
6144 { VK_NUMLOCK
, WXK_NUMLOCK
},
6145 { VK_SCROLL
, WXK_SCROLL
},
6148 { VK_LWIN
, WXK_WINDOWS_LEFT
},
6149 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
6150 { VK_APPS
, WXK_WINDOWS_MENU
},
6151 #endif // VK_APPS defined
6154 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
6155 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
6156 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
6158 // check the table first
6159 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6161 if ( gs_specialKeys
[n
].vk
== vk
)
6162 return gs_specialKeys
[n
].wxk
;
6165 // keys requiring special handling
6169 // the mapping for these keys may be incorrect on non-US keyboards so
6170 // maybe we shouldn't map them to ASCII values at all
6171 case VK_OEM_1
: wxk
= ';'; break;
6172 case VK_OEM_PLUS
: wxk
= '+'; break;
6173 case VK_OEM_COMMA
: wxk
= ','; break;
6174 case VK_OEM_MINUS
: wxk
= '-'; break;
6175 case VK_OEM_PERIOD
: wxk
= '.'; break;
6176 case VK_OEM_2
: wxk
= '/'; break;
6177 case VK_OEM_3
: wxk
= '~'; break;
6178 case VK_OEM_4
: wxk
= '['; break;
6179 case VK_OEM_5
: wxk
= '\\'; break;
6180 case VK_OEM_6
: wxk
= ']'; break;
6181 case VK_OEM_7
: wxk
= '\''; break;
6183 // handle extended keys
6185 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
6189 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
6193 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6197 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6201 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6205 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6209 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6213 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6217 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6221 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6225 // don't use ChooseNormalOrExtended() here as the keys are reversed
6226 // here: numpad enter is the extended one
6227 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6237 WXWORD
wxCharCodeWXToMSW(int wxk
)
6239 // check the table first
6240 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6242 if ( gs_specialKeys
[n
].wxk
== wxk
)
6243 return gs_specialKeys
[n
].vk
;
6246 // and then check for special keys not included in the table
6251 case WXK_NUMPAD_PAGEUP
:
6256 case WXK_NUMPAD_PAGEDOWN
:
6261 case WXK_NUMPAD_END
:
6266 case WXK_NUMPAD_HOME
:
6271 case WXK_NUMPAD_LEFT
:
6281 case WXK_NUMPAD_RIGHT
:
6286 case WXK_NUMPAD_DOWN
:
6291 case WXK_NUMPAD_INSERT
:
6296 case WXK_NUMPAD_DELETE
:
6301 // no VkKeyScan() under CE unfortunately, we need to test how does
6302 // it handle OEM keys
6304 // check to see if its one of the OEM key codes.
6305 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6311 #endif // !__WXWINCE__
6320 // small helper for wxGetKeyState() and wxGetMouseState()
6321 static inline bool wxIsKeyDown(WXWORD vk
)
6323 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6324 #ifdef SM_SWAPBUTTON
6325 if ( vk
== VK_LBUTTON
|| vk
== VK_RBUTTON
)
6327 if ( ::GetSystemMetrics(SM_SWAPBUTTON
) )
6329 if ( vk
== VK_LBUTTON
)
6331 else // vk == VK_RBUTTON
6335 #endif // SM_SWAPBUTTON
6337 // the low order bit indicates whether the key was pressed since the last
6338 // call and the high order one indicates whether it is down right now and
6339 // we only want that one
6340 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6343 bool wxGetKeyState(wxKeyCode key
)
6345 // although this does work under Windows, it is not supported under other
6346 // platforms so don't allow it, you must use wxGetMouseState() instead
6347 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6348 key
!= VK_RBUTTON
&&
6350 wxT("can't use wxGetKeyState() for mouse buttons") );
6352 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6354 // if the requested key is a LED key, return true if the led is pressed
6355 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6357 // low order bit means LED is highlighted and high order one means the
6358 // key is down; for compatibility with the other ports return true if
6359 // either one is set
6360 return GetKeyState(vk
) != 0;
6365 return wxIsKeyDown(vk
);
6370 wxMouseState
wxGetMouseState()
6374 GetCursorPos( &pt
);
6378 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6379 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6380 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6381 #ifdef wxHAS_XBUTTON
6382 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6383 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6384 #endif // wxHAS_XBUTTON
6386 ms
.SetControlDown(wxIsCtrlDown ());
6387 ms
.SetShiftDown (wxIsShiftDown());
6388 ms
.SetAltDown (wxIsAltDown ());
6389 // ms.SetMetaDown();
6395 wxWindow
*wxGetActiveWindow()
6397 HWND hWnd
= GetActiveWindow();
6400 return wxFindWinFromHandle(hWnd
);
6405 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6407 HWND hwnd
= (HWND
)hWnd
;
6409 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6410 // by code in msw/radiobox.cpp), for all the others we just search up the
6412 wxWindow
*win
= NULL
;
6415 win
= wxFindWinFromHandle(hwnd
);
6419 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6420 // wxWindow class which overrides WM_GETDLGCODE processing to
6421 // do it as well, win would be already non NULL
6422 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6424 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6426 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6427 #endif // wxUSE_RADIOBOX
6429 // spin control text buddy window should be mapped to spin ctrl
6430 // itself so try it too
6431 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6434 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6436 #endif // wxUSE_SPINCTRL
6440 while ( hwnd
&& !win
)
6442 // this is a really ugly hack needed to avoid mistakenly returning the
6443 // parent frame wxWindow for the find/replace modeless dialog HWND -
6444 // this, in turn, is needed to call IsDialogMessage() from
6445 // wxApp::ProcessMessage() as for this we must return NULL from here
6447 // FIXME: this is clearly not the best way to do it but I think we'll
6448 // need to change HWND <-> wxWindow code more heavily than I can
6449 // do it now to fix it
6450 #ifndef __WXMICROWIN__
6451 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6453 // it's a dialog box, don't go upwards
6458 hwnd
= ::GetParent(hwnd
);
6459 win
= wxFindWinFromHandle(hwnd
);
6465 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6467 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6468 // in active frames and dialogs, regardless of where the focus is.
6469 static HHOOK wxTheKeyboardHook
= 0;
6472 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6474 DWORD hiWord
= HIWORD(lParam
);
6475 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6477 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6480 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6481 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6482 event
.m_altDown
= true;
6484 event
.SetEventObject(NULL
);
6485 event
.m_keyCode
= id
;
6486 event
.m_shiftDown
= wxIsShiftDown();
6487 event
.m_controlDown
= wxIsCtrlDown();
6489 event
.SetTimestamp(::GetMessageTime());
6491 wxWindow
*win
= wxGetActiveWindow();
6492 wxEvtHandler
*handler
;
6495 handler
= win
->GetEventHandler();
6496 event
.SetId(win
->GetId());
6501 event
.SetId(wxID_ANY
);
6504 if ( handler
&& handler
->ProcessEvent(event
) )
6512 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6515 void wxSetKeyboardHook(bool doIt
)
6519 wxTheKeyboardHook
= ::SetWindowsHookEx
6522 (HOOKPROC
)wxKeyboardHook
,
6523 NULL
, // must be NULL for process hook
6524 ::GetCurrentThreadId()
6526 if ( !wxTheKeyboardHook
)
6528 wxLogLastError(wxT("SetWindowsHookEx(wxKeyboardHook)"));
6533 if ( wxTheKeyboardHook
)
6534 ::UnhookWindowsHookEx(wxTheKeyboardHook
);
6538 #endif // !__WXMICROWIN__
6540 #if wxDEBUG_LEVEL >= 2
6541 const wxChar
*wxGetMessageName(int message
)
6545 case 0x0000: return wxT("WM_NULL");
6546 case 0x0001: return wxT("WM_CREATE");
6547 case 0x0002: return wxT("WM_DESTROY");
6548 case 0x0003: return wxT("WM_MOVE");
6549 case 0x0005: return wxT("WM_SIZE");
6550 case 0x0006: return wxT("WM_ACTIVATE");
6551 case 0x0007: return wxT("WM_SETFOCUS");
6552 case 0x0008: return wxT("WM_KILLFOCUS");
6553 case 0x000A: return wxT("WM_ENABLE");
6554 case 0x000B: return wxT("WM_SETREDRAW");
6555 case 0x000C: return wxT("WM_SETTEXT");
6556 case 0x000D: return wxT("WM_GETTEXT");
6557 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6558 case 0x000F: return wxT("WM_PAINT");
6559 case 0x0010: return wxT("WM_CLOSE");
6560 case 0x0011: return wxT("WM_QUERYENDSESSION");
6561 case 0x0012: return wxT("WM_QUIT");
6562 case 0x0013: return wxT("WM_QUERYOPEN");
6563 case 0x0014: return wxT("WM_ERASEBKGND");
6564 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6565 case 0x0016: return wxT("WM_ENDSESSION");
6566 case 0x0017: return wxT("WM_SYSTEMERROR");
6567 case 0x0018: return wxT("WM_SHOWWINDOW");
6568 case 0x0019: return wxT("WM_CTLCOLOR");
6569 case 0x001A: return wxT("WM_WININICHANGE");
6570 case 0x001B: return wxT("WM_DEVMODECHANGE");
6571 case 0x001C: return wxT("WM_ACTIVATEAPP");
6572 case 0x001D: return wxT("WM_FONTCHANGE");
6573 case 0x001E: return wxT("WM_TIMECHANGE");
6574 case 0x001F: return wxT("WM_CANCELMODE");
6575 case 0x0020: return wxT("WM_SETCURSOR");
6576 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6577 case 0x0022: return wxT("WM_CHILDACTIVATE");
6578 case 0x0023: return wxT("WM_QUEUESYNC");
6579 case 0x0024: return wxT("WM_GETMINMAXINFO");
6580 case 0x0026: return wxT("WM_PAINTICON");
6581 case 0x0027: return wxT("WM_ICONERASEBKGND");
6582 case 0x0028: return wxT("WM_NEXTDLGCTL");
6583 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6584 case 0x002B: return wxT("WM_DRAWITEM");
6585 case 0x002C: return wxT("WM_MEASUREITEM");
6586 case 0x002D: return wxT("WM_DELETEITEM");
6587 case 0x002E: return wxT("WM_VKEYTOITEM");
6588 case 0x002F: return wxT("WM_CHARTOITEM");
6589 case 0x0030: return wxT("WM_SETFONT");
6590 case 0x0031: return wxT("WM_GETFONT");
6591 case 0x0037: return wxT("WM_QUERYDRAGICON");
6592 case 0x0039: return wxT("WM_COMPAREITEM");
6593 case 0x0041: return wxT("WM_COMPACTING");
6594 case 0x0044: return wxT("WM_COMMNOTIFY");
6595 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6596 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6597 case 0x0048: return wxT("WM_POWER");
6599 case 0x004A: return wxT("WM_COPYDATA");
6600 case 0x004B: return wxT("WM_CANCELJOURNAL");
6601 case 0x004E: return wxT("WM_NOTIFY");
6602 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6603 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6604 case 0x0052: return wxT("WM_TCARD");
6605 case 0x0053: return wxT("WM_HELP");
6606 case 0x0054: return wxT("WM_USERCHANGED");
6607 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6608 case 0x007B: return wxT("WM_CONTEXTMENU");
6609 case 0x007C: return wxT("WM_STYLECHANGING");
6610 case 0x007D: return wxT("WM_STYLECHANGED");
6611 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6612 case 0x007F: return wxT("WM_GETICON");
6613 case 0x0080: return wxT("WM_SETICON");
6615 case 0x0081: return wxT("WM_NCCREATE");
6616 case 0x0082: return wxT("WM_NCDESTROY");
6617 case 0x0083: return wxT("WM_NCCALCSIZE");
6618 case 0x0084: return wxT("WM_NCHITTEST");
6619 case 0x0085: return wxT("WM_NCPAINT");
6620 case 0x0086: return wxT("WM_NCACTIVATE");
6621 case 0x0087: return wxT("WM_GETDLGCODE");
6622 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6623 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6624 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6625 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6626 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6627 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6628 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6629 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6630 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6631 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6633 case 0x00B0: return wxT("EM_GETSEL");
6634 case 0x00B1: return wxT("EM_SETSEL");
6635 case 0x00B2: return wxT("EM_GETRECT");
6636 case 0x00B3: return wxT("EM_SETRECT");
6637 case 0x00B4: return wxT("EM_SETRECTNP");
6638 case 0x00B5: return wxT("EM_SCROLL");
6639 case 0x00B6: return wxT("EM_LINESCROLL");
6640 case 0x00B7: return wxT("EM_SCROLLCARET");
6641 case 0x00B8: return wxT("EM_GETMODIFY");
6642 case 0x00B9: return wxT("EM_SETMODIFY");
6643 case 0x00BA: return wxT("EM_GETLINECOUNT");
6644 case 0x00BB: return wxT("EM_LINEINDEX");
6645 case 0x00BC: return wxT("EM_SETHANDLE");
6646 case 0x00BD: return wxT("EM_GETHANDLE");
6647 case 0x00BE: return wxT("EM_GETTHUMB");
6648 case 0x00C1: return wxT("EM_LINELENGTH");
6649 case 0x00C2: return wxT("EM_REPLACESEL");
6650 case 0x00C4: return wxT("EM_GETLINE");
6651 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6652 case 0x00C6: return wxT("EM_CANUNDO");
6653 case 0x00C7: return wxT("EM_UNDO");
6654 case 0x00C8: return wxT("EM_FMTLINES");
6655 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6656 case 0x00CB: return wxT("EM_SETTABSTOPS");
6657 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6658 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6659 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6660 case 0x00CF: return wxT("EM_SETREADONLY");
6661 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6662 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6663 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6664 case 0x00D3: return wxT("EM_SETMARGINS");
6665 case 0x00D4: return wxT("EM_GETMARGINS");
6666 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6667 case 0x00D6: return wxT("EM_POSFROMCHAR");
6668 case 0x00D7: return wxT("EM_CHARFROMPOS");
6669 case 0x00D8: return wxT("EM_SETIMESTATUS");
6670 case 0x00D9: return wxT("EM_GETIMESTATUS");
6672 case 0x0100: return wxT("WM_KEYDOWN");
6673 case 0x0101: return wxT("WM_KEYUP");
6674 case 0x0102: return wxT("WM_CHAR");
6675 case 0x0103: return wxT("WM_DEADCHAR");
6676 case 0x0104: return wxT("WM_SYSKEYDOWN");
6677 case 0x0105: return wxT("WM_SYSKEYUP");
6678 case 0x0106: return wxT("WM_SYSCHAR");
6679 case 0x0107: return wxT("WM_SYSDEADCHAR");
6680 case 0x0108: return wxT("WM_KEYLAST");
6682 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6683 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6684 case 0x010F: return wxT("WM_IME_COMPOSITION");
6686 case 0x0110: return wxT("WM_INITDIALOG");
6687 case 0x0111: return wxT("WM_COMMAND");
6688 case 0x0112: return wxT("WM_SYSCOMMAND");
6689 case 0x0113: return wxT("WM_TIMER");
6690 case 0x0114: return wxT("WM_HSCROLL");
6691 case 0x0115: return wxT("WM_VSCROLL");
6692 case 0x0116: return wxT("WM_INITMENU");
6693 case 0x0117: return wxT("WM_INITMENUPOPUP");
6694 case 0x011F: return wxT("WM_MENUSELECT");
6695 case 0x0120: return wxT("WM_MENUCHAR");
6696 case 0x0121: return wxT("WM_ENTERIDLE");
6698 case 0x0127: return wxT("WM_CHANGEUISTATE");
6699 case 0x0128: return wxT("WM_UPDATEUISTATE");
6700 case 0x0129: return wxT("WM_QUERYUISTATE");
6702 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6703 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6704 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6705 case 0x0135: return wxT("WM_CTLCOLORBTN");
6706 case 0x0136: return wxT("WM_CTLCOLORDLG");
6707 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6708 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6709 case 0x01E1: return wxT("MN_GETHMENU");
6711 case 0x0200: return wxT("WM_MOUSEMOVE");
6712 case 0x0201: return wxT("WM_LBUTTONDOWN");
6713 case 0x0202: return wxT("WM_LBUTTONUP");
6714 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6715 case 0x0204: return wxT("WM_RBUTTONDOWN");
6716 case 0x0205: return wxT("WM_RBUTTONUP");
6717 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6718 case 0x0207: return wxT("WM_MBUTTONDOWN");
6719 case 0x0208: return wxT("WM_MBUTTONUP");
6720 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6721 case 0x020A: return wxT("WM_MOUSEWHEEL");
6722 case 0x020B: return wxT("WM_XBUTTONDOWN");
6723 case 0x020C: return wxT("WM_XBUTTONUP");
6724 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6725 case 0x0210: return wxT("WM_PARENTNOTIFY");
6726 case 0x0211: return wxT("WM_ENTERMENULOOP");
6727 case 0x0212: return wxT("WM_EXITMENULOOP");
6729 case 0x0213: return wxT("WM_NEXTMENU");
6730 case 0x0214: return wxT("WM_SIZING");
6731 case 0x0215: return wxT("WM_CAPTURECHANGED");
6732 case 0x0216: return wxT("WM_MOVING");
6733 case 0x0218: return wxT("WM_POWERBROADCAST");
6734 case 0x0219: return wxT("WM_DEVICECHANGE");
6736 case 0x0220: return wxT("WM_MDICREATE");
6737 case 0x0221: return wxT("WM_MDIDESTROY");
6738 case 0x0222: return wxT("WM_MDIACTIVATE");
6739 case 0x0223: return wxT("WM_MDIRESTORE");
6740 case 0x0224: return wxT("WM_MDINEXT");
6741 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6742 case 0x0226: return wxT("WM_MDITILE");
6743 case 0x0227: return wxT("WM_MDICASCADE");
6744 case 0x0228: return wxT("WM_MDIICONARRANGE");
6745 case 0x0229: return wxT("WM_MDIGETACTIVE");
6746 case 0x0230: return wxT("WM_MDISETMENU");
6747 case 0x0233: return wxT("WM_DROPFILES");
6749 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6750 case 0x0282: return wxT("WM_IME_NOTIFY");
6751 case 0x0283: return wxT("WM_IME_CONTROL");
6752 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6753 case 0x0285: return wxT("WM_IME_SELECT");
6754 case 0x0286: return wxT("WM_IME_CHAR");
6755 case 0x0290: return wxT("WM_IME_KEYDOWN");
6756 case 0x0291: return wxT("WM_IME_KEYUP");
6758 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6759 case 0x02A1: return wxT("WM_MOUSEHOVER");
6760 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6761 case 0x02A3: return wxT("WM_MOUSELEAVE");
6763 case 0x0300: return wxT("WM_CUT");
6764 case 0x0301: return wxT("WM_COPY");
6765 case 0x0302: return wxT("WM_PASTE");
6766 case 0x0303: return wxT("WM_CLEAR");
6767 case 0x0304: return wxT("WM_UNDO");
6768 case 0x0305: return wxT("WM_RENDERFORMAT");
6769 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6770 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6771 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6772 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6773 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6774 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6775 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6776 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6777 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6778 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6779 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6780 case 0x0311: return wxT("WM_PALETTECHANGED");
6781 case 0x0312: return wxT("WM_HOTKEY");
6783 case 0x0317: return wxT("WM_PRINT");
6784 case 0x0318: return wxT("WM_PRINTCLIENT");
6786 // common controls messages - although they're not strictly speaking
6787 // standard, it's nice to decode them nevertheless
6790 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6791 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6792 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6793 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6794 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6795 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6796 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6797 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6798 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6799 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6800 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6801 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6802 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6803 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6804 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6805 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6806 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6807 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6808 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6809 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6810 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6811 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6812 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6813 case 0x1000 + 18: return wxT("LVM_HITTEST");
6814 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6815 case 0x1000 + 20: return wxT("LVM_SCROLL");
6816 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6817 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6818 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6819 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6820 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6821 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6822 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6823 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6824 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6825 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6826 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6827 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6828 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6829 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6830 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6831 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6832 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6833 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6834 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6835 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6836 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6837 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6838 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6839 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6840 case 0x1000 + 42: return wxT("LVM_UPDATE");
6841 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6842 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6843 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6844 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6845 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6846 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6847 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6848 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6849 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6850 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6851 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6852 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6853 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6854 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6855 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6856 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6857 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6858 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6859 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6860 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6861 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6862 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6863 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6864 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6865 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6866 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6869 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6870 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6871 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6872 case 0x1100 + 2: return wxT("TVM_EXPAND");
6873 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6874 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6875 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6876 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6877 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6878 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6879 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6880 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6881 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6882 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6883 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6884 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6885 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6886 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6887 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6888 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6889 case 0x1100 + 17: return wxT("TVM_HITTEST");
6890 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6891 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6892 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6893 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6894 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6895 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6896 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6897 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6898 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6901 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6902 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6903 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6904 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6905 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6906 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6907 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6908 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6909 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6910 case 0x1200 + 6: return wxT("HDM_HITTEST");
6911 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6912 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6913 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6914 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6915 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6916 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6917 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6918 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6921 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6922 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6923 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6924 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6925 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6926 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6927 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6928 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6929 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6930 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6931 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6932 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6933 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6934 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6935 case 0x1300 + 13: return wxT("TCM_HITTEST");
6936 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6937 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6938 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6939 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6940 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6941 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6942 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6943 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6944 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6945 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6946 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6947 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6950 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6951 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6952 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6953 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6954 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6955 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6956 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6957 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6958 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6959 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6960 case WM_USER
+17: return wxT("TB_SETSTATE");
6961 case WM_USER
+18: return wxT("TB_GETSTATE");
6962 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6963 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6964 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6965 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6966 case WM_USER
+23: return wxT("TB_GETBUTTON");
6967 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6968 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6969 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6970 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6971 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6972 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6973 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6974 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6975 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6976 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6977 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6978 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6979 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6980 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6981 case WM_USER
+37: return wxT("TB_SETPARENT");
6982 case WM_USER
+39: return wxT("TB_SETROWS");
6983 case WM_USER
+40: return wxT("TB_GETROWS");
6984 case WM_USER
+42: return wxT("TB_SETCMDID");
6985 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6986 case WM_USER
+44: return wxT("TB_GETBITMAP");
6987 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6988 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6989 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6990 case WM_USER
+47: return wxT("TB_SETINDENT");
6991 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6992 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6993 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6994 case WM_USER
+51: return wxT("TB_GETRECT");
6995 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6996 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6997 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6998 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6999 case WM_USER
+56: return wxT("TB_SETSTYLE");
7000 case WM_USER
+57: return wxT("TB_GETSTYLE");
7001 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
7002 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
7003 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
7004 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
7005 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
7008 static wxString s_szBuf
;
7009 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
7010 return s_szBuf
.c_str();
7013 #endif // wxDEBUG_LEVEL >= 2
7015 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
7019 HWND hwnd
= GetHwndOf(win
);
7020 HDC hdc
= ::GetDC(hwnd
);
7022 #if !wxDIALOG_UNIT_COMPATIBILITY
7023 // and select the current font into it
7024 HFONT hfont
= GetHfontOf(win
->GetFont());
7027 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
7031 // finally retrieve the text metrics from it
7032 GetTextMetrics(hdc
, &tm
);
7034 #if !wxDIALOG_UNIT_COMPATIBILITY
7038 (void)::SelectObject(hdc
, hfont
);
7042 ::ReleaseDC(hwnd
, hdc
);
7047 // Find the wxWindow at the current mouse position, returning the mouse
7049 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
7051 pt
= wxGetMousePosition();
7052 return wxFindWindowAtPoint(pt
);
7055 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
7061 HWND hWnd
= ::WindowFromPoint(pt2
);
7063 return wxGetWindowFromHWND((WXHWND
)hWnd
);
7066 // Get the current mouse position.
7067 wxPoint
wxGetMousePosition()
7071 GetCursorPosWinCE(&pt
);
7073 GetCursorPos( & pt
);
7076 return wxPoint(pt
.x
, pt
.y
);
7081 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7082 static void WinCEUnregisterHotKey(int modifiers
, int id
)
7084 // Register hotkeys for the hardware buttons
7086 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
7088 UnregisterFunc1Proc procUnregisterFunc
;
7089 hCoreDll
= LoadLibrary(wxT("coredll.dll"));
7092 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, wxT("UnregisterFunc1"));
7093 if (procUnregisterFunc
)
7094 procUnregisterFunc(modifiers
, id
);
7095 FreeLibrary(hCoreDll
);
7100 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
7102 UINT win_modifiers
=0;
7103 if ( modifiers
& wxMOD_ALT
)
7104 win_modifiers
|= MOD_ALT
;
7105 if ( modifiers
& wxMOD_SHIFT
)
7106 win_modifiers
|= MOD_SHIFT
;
7107 if ( modifiers
& wxMOD_CONTROL
)
7108 win_modifiers
|= MOD_CONTROL
;
7109 if ( modifiers
& wxMOD_WIN
)
7110 win_modifiers
|= MOD_WIN
;
7112 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7113 // Required for PPC and Smartphone hardware buttons
7114 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
7115 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
7118 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
7120 wxLogLastError(wxT("RegisterHotKey"));
7128 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
7130 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7131 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
7134 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
7136 wxLogLastError(wxT("UnregisterHotKey"));
7146 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
7148 int hotkeyId
= wParam
;
7149 int virtualKey
= HIWORD(lParam
);
7150 int win_modifiers
= LOWORD(lParam
);
7152 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
7153 event
.SetId(hotkeyId
);
7154 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
7155 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
7156 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
7157 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
7159 return HandleWindowEvent(event
);
7162 #endif // wxUSE_ACCEL
7164 #endif // wxUSE_HOTKEY
7166 // Not tested under WinCE
7169 // this class installs a message hook which really wakes up our idle processing
7170 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
7171 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
7172 // being dragged or even inside ::MessageBox()) and so don't control message
7173 // dispatching otherwise
7174 class wxIdleWakeUpModule
: public wxModule
7177 virtual bool OnInit()
7179 ms_hMsgHookProc
= ::SetWindowsHookEx
7182 &wxIdleWakeUpModule::MsgHookProc
,
7184 GetCurrentThreadId()
7187 if ( !ms_hMsgHookProc
)
7189 wxLogLastError(wxT("SetWindowsHookEx(WH_GETMESSAGE)"));
7197 virtual void OnExit()
7199 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
7202 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
7204 MSG
*msg
= (MSG
*)lParam
;
7206 // only process the message if it is actually going to be removed from
7207 // the message queue, this prevents that the same event from being
7208 // processed multiple times if now someone just called PeekMessage()
7209 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7211 wxTheApp
->ProcessPendingEvents();
7214 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7218 static HHOOK ms_hMsgHookProc
;
7220 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7223 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7225 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7227 #endif // __WXWINCE__
7232 static void wxAdjustZOrder(wxWindow
* parent
)
7234 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7236 // Set the z-order correctly
7237 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7240 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7243 wxWindow
*childWin
= current
->GetData();
7244 wxAdjustZOrder(childWin
);
7245 current
= current
->GetNext();
7250 // We need to adjust the z-order of static boxes in WinCE, to
7251 // make 'contained' controls visible
7252 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7255 wxAdjustZOrder(this);