1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/window.cpp
3 // Purpose: wxWindowMSW
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/window.h"
30 #include "wx/msw/wrapwin.h"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
56 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
60 #include "wx/hashmap.h"
61 #include "wx/evtloop.h"
63 #include "wx/sysopt.h"
65 #if wxUSE_DRAG_AND_DROP
69 #if wxUSE_ACCESSIBILITY
70 #include "wx/access.h"
74 #define WM_GETOBJECT 0x003D
77 #define OBJID_CLIENT 0xFFFFFFFC
81 #include "wx/msw/private.h"
82 #include "wx/msw/dcclient.h"
85 #include "wx/tooltip.h"
93 #include "wx/spinctrl.h"
94 #endif // wxUSE_SPINCTRL
96 #include "wx/notebook.h"
97 #include "wx/listctrl.h"
98 #include "wx/dynlib.h"
102 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
103 #include <shellapi.h>
104 #include <mmsystem.h>
108 #include <windowsx.h>
111 #if !defined __WXWINCE__ && !defined NEED_PBT_H
115 #if defined(__WXWINCE__)
116 #include "wx/msw/wince/missing.h"
119 #include <shellapi.h>
121 #include <aygshell.h>
126 #include "wx/msw/uxtheme.h"
127 #define EP_EDITTEXT 1
130 #define ETS_SELECTED 3
131 #define ETS_DISABLED 4
132 #define ETS_FOCUSED 5
133 #define ETS_READONLY 6
137 // define the constants used by AnimateWindow() if our SDK doesn't have them
139 #define AW_HOR_POSITIVE 0x00000001
140 #define AW_HOR_NEGATIVE 0x00000002
141 #define AW_VER_POSITIVE 0x00000004
142 #define AW_VER_NEGATIVE 0x00000008
143 #define AW_CENTER 0x00000010
144 #define AW_HIDE 0x00010000
145 #define AW_ACTIVATE 0x00020000
146 #define AW_SLIDE 0x00040000
147 #define AW_BLEND 0x00080000
150 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
151 #define HAVE_TRACKMOUSEEVENT
152 #endif // everything needed for TrackMouseEvent()
154 // if this is set to 1, we use deferred window sizing to reduce flicker when
155 // resizing complicated window hierarchies, but this can in theory result in
156 // different behaviour than the old code so we keep the possibility to use it
157 // by setting this to 0 (in the future this should be removed completely)
159 #define USE_DEFERRED_SIZING 0
161 #define USE_DEFERRED_SIZING 1
164 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
165 // when mouse position didnd't change
167 #define wxUSE_MOUSEEVENT_HACK 0
169 #define wxUSE_MOUSEEVENT_HACK 1
172 // not all compilers/platforms have X button related declarations (notably
173 // Windows CE doesn't, and probably some old SDKs don't neither)
174 #ifdef WM_XBUTTONDOWN
175 #define wxHAS_XBUTTON
178 // ---------------------------------------------------------------------------
180 // ---------------------------------------------------------------------------
182 #if wxUSE_MENUS_NATIVE
183 extern wxMenu
*wxCurrentPopupMenu
;
187 extern wxChar
*wxCanvasClassName
;
189 extern const wxChar
*wxCanvasClassName
;
192 // true if we had already created the std colour map, used by
193 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
194 static bool gs_hasStdCmap
= false;
196 // last mouse event information we need to filter out the duplicates
197 #if wxUSE_MOUSEEVENT_HACK
198 static struct MouseEventInfoDummy
200 // mouse position (in screen coordinates)
203 // last mouse event type
206 #endif // wxUSE_MOUSEEVENT_HACK
208 // hash containing the registered handlers for the custom messages
209 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
210 wxIntegerHash
, wxIntegerEqual
,
213 static MSWMessageHandlers gs_messageHandlers
;
215 // ---------------------------------------------------------------------------
217 // ---------------------------------------------------------------------------
219 // the window proc for all our windows
220 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
221 WPARAM wParam
, LPARAM lParam
);
225 const wxChar
*wxGetMessageName(int message
);
228 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
229 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
230 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
232 // get the text metrics for the current font
233 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
236 // find the window for the mouse event at the specified position
237 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
238 #endif // __WXWINCE__
240 // wrapper around BringWindowToTop() API
241 static inline void wxBringWindowToTop(HWND hwnd
)
243 #ifdef __WXMICROWIN__
244 // It seems that MicroWindows brings the _parent_ of the window to the top,
245 // which can be the wrong one.
247 // activate (set focus to) specified window
251 // raise top level parent to top of z order
252 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
254 wxLogLastError(_T("SetWindowPos"));
260 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
261 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
264 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
265 parent as well as otherwise several Win32 functions using
266 GetNextDlgTabItem() to iterate over all controls such as
267 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
268 all of them iterate over all the controls starting from the currently
269 focused one and stop iterating when they get back to the focus but
270 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
271 get back to the initial (focused) window: as we do have this style,
272 GetNextDlgTabItem() will leave this window and continue in its parent,
273 but if the parent doesn't have it, it wouldn't recurse inside it later
274 on and so wouldn't have a chance of getting back to this window either.
276 while ( parent
&& !parent
->IsTopLevel() )
278 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
279 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
281 // force the parent to have this style
282 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
283 exStyle
| WS_EX_CONTROLPARENT
);
286 parent
= parent
->GetParent();
290 #endif // !__WXWINCE__
293 // On Windows CE, GetCursorPos can return an error, so use this function
295 bool GetCursorPosWinCE(POINT
* pt
)
297 if (!GetCursorPos(pt
))
299 DWORD pos
= GetMessagePos();
307 // ---------------------------------------------------------------------------
309 // ---------------------------------------------------------------------------
311 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
313 #ifdef __WXUNIVERSAL__
314 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
316 #if wxUSE_EXTENDED_RTTI
318 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
319 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
320 // windows with negative ids never can be recreated anyway
322 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
324 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
325 if ( win
&& win
->GetId() < 0 )
330 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
332 // make wxWindowList known before the property is used
334 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
336 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
338 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
341 WX_DEFINE_FLAGS( wxWindowStyle
)
343 wxBEGIN_FLAGS( wxWindowStyle
)
344 // new style border flags, we put them first to
345 // use them for streaming out
347 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
348 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
349 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
350 wxFLAGS_MEMBER(wxBORDER_RAISED
)
351 wxFLAGS_MEMBER(wxBORDER_STATIC
)
352 wxFLAGS_MEMBER(wxBORDER_NONE
)
354 // old style border flags
355 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
356 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
357 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
358 wxFLAGS_MEMBER(wxRAISED_BORDER
)
359 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
360 wxFLAGS_MEMBER(wxBORDER
)
362 // standard window styles
363 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
364 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
365 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
366 wxFLAGS_MEMBER(wxWANTS_CHARS
)
367 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
368 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
369 wxFLAGS_MEMBER(wxVSCROLL
)
370 wxFLAGS_MEMBER(wxHSCROLL
)
372 wxEND_FLAGS( wxWindowStyle
)
374 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
375 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
376 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
377 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
378 // Always constructor Properties first
380 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
381 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
382 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
383 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
384 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
386 // Then all relations of the object graph
388 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
390 // and finally all other properties
392 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
393 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
394 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
395 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
396 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
398 // possible property candidates (not in xrc) or not valid in all subclasses
399 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
400 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
401 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
402 // MaxHeight, Width , MinHeight , Width
403 // TODO switch label to control and title to toplevels
405 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
406 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
407 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
408 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
413 wxEND_PROPERTIES_TABLE()
415 wxBEGIN_HANDLERS_TABLE(wxWindow
)
416 wxEND_HANDLERS_TABLE()
418 wxCONSTRUCTOR_DUMMY(wxWindow
)
421 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
423 #endif // __WXUNIVERSAL__/__WXMSW__
425 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
426 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
427 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
429 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
433 // ===========================================================================
435 // ===========================================================================
437 // ---------------------------------------------------------------------------
438 // wxWindow utility functions
439 // ---------------------------------------------------------------------------
441 // Find an item given the MS Windows id
442 wxWindow
*wxWindowMSW::FindItem(long id
) const
445 wxControl
*item
= wxDynamicCastThis(wxControl
);
448 // is it us or one of our "internal" children?
449 if ( item
->GetId() == id
450 #ifndef __WXUNIVERSAL__
451 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
452 #endif // __WXUNIVERSAL__
458 #endif // wxUSE_CONTROLS
460 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
463 wxWindow
*childWin
= current
->GetData();
465 wxWindow
*wnd
= childWin
->FindItem(id
);
469 current
= current
->GetNext();
475 // Find an item given the MS Windows handle
476 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
478 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
481 wxWindow
*parent
= current
->GetData();
483 // Do a recursive search.
484 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
490 || parent
->IsKindOf(CLASSINFO(wxControl
))
491 #endif // wxUSE_CONTROLS
494 wxWindow
*item
= current
->GetData();
495 if ( item
->GetHWND() == hWnd
)
499 if ( item
->ContainsHWND(hWnd
) )
504 current
= current
->GetNext();
509 // Default command handler
510 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
515 // ----------------------------------------------------------------------------
516 // constructors and such
517 // ----------------------------------------------------------------------------
519 void wxWindowMSW::Init()
522 m_isBeingDeleted
= false;
524 m_mouseInWindow
= false;
525 m_lastKeydownProcessed
= false;
533 m_pendingPosition
= wxDefaultPosition
;
534 m_pendingSize
= wxDefaultSize
;
537 m_contextMenuEnabled
= false;
542 wxWindowMSW::~wxWindowMSW()
544 m_isBeingDeleted
= true;
546 #ifndef __WXUNIVERSAL__
547 // VS: make sure there's no wxFrame with last focus set to us:
548 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
550 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
553 if ( frame
->GetLastFocus() == this )
555 frame
->SetLastFocus(NULL
);
558 // apparently sometimes we can end up with our grand parent
559 // pointing to us as well: this is surely a bug in focus handling
560 // code but it's not clear where it happens so for now just try to
561 // fix it here by not breaking out of the loop
565 #endif // __WXUNIVERSAL__
567 // VS: destroy children first and _then_ detach *this from its parent.
568 // If we did it the other way around, children wouldn't be able
569 // find their parent frame (see above).
574 // VZ: test temp removed to understand what really happens here
575 //if (::IsWindow(GetHwnd()))
577 if ( !::DestroyWindow(GetHwnd()) )
578 wxLogLastError(wxT("DestroyWindow"));
581 // remove hWnd <-> wxWindow association
582 wxRemoveHandleAssociation(this);
587 // real construction (Init() must have been called before!)
588 bool wxWindowMSW::Create(wxWindow
*parent
,
593 const wxString
& name
)
595 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
597 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
600 parent
->AddChild(this);
603 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
605 #ifdef __WXUNIVERSAL__
606 // no borders, we draw them ourselves
607 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
611 msflags
&= ~WS_BORDER
;
612 #endif // wxUniversal
616 msflags
|= WS_VISIBLE
;
619 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
627 // ---------------------------------------------------------------------------
629 // ---------------------------------------------------------------------------
631 void wxWindowMSW::SetFocus()
633 HWND hWnd
= GetHwnd();
634 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
636 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
640 if ( !::SetFocus(hWnd
) )
642 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
643 // was there really an error?
644 DWORD dwRes
= ::GetLastError();
647 HWND hwndFocus
= ::GetFocus();
648 if ( hwndFocus
!= hWnd
)
650 wxLogApiError(_T("SetFocus"), dwRes
);
657 void wxWindowMSW::SetFocusFromKbd()
659 // when the focus is given to the control with DLGC_HASSETSEL style from
660 // keyboard its contents should be entirely selected: this is what
661 // ::IsDialogMessage() does and so we should do it as well to provide the
662 // same LNF as the native programs
663 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
665 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
668 // do this after (maybe) setting the selection as like this when
669 // wxEVT_SET_FOCUS handler is called, the selection would have been already
670 // set correctly -- this may be important
671 wxWindowBase::SetFocusFromKbd();
674 // Get the window with the focus
675 wxWindow
*wxWindowBase::DoFindFocus()
677 HWND hWnd
= ::GetFocus();
680 return wxGetWindowFromHWND((WXHWND
)hWnd
);
686 void wxWindowMSW::DoEnable( bool enable
)
688 HWND hWnd
= GetHwnd();
690 ::EnableWindow(hWnd
, (BOOL
)enable
);
693 bool wxWindowMSW::Show(bool show
)
695 if ( !wxWindowBase::Show(show
) )
698 HWND hWnd
= GetHwnd();
700 // we could be called before the underlying window is created (this is
701 // actually useful to prevent it from being initially shown), e.g.
703 // wxFoo *foo = new wxFoo;
705 // foo->Create(parent, ...);
707 // should work without errors
710 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
717 wxWindowMSW::MSWShowWithEffect(bool show
,
722 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
724 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
725 static bool s_initDone
= false;
730 wxDynamicLibrary
dllUser32(_T("user32.dll"), wxDL_VERBATIM
);
731 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
735 // notice that it's ok to unload user32.dll here as it won't be really
736 // unloaded, being still in use because we link to it statically too
739 if ( !s_pfnAnimateWindow
)
742 // prepare to use AnimateWindow()
745 timeout
= 200; // this is the default animation timeout, per MSDN
747 DWORD dwFlags
= show
? 0 : AW_HIDE
;
748 bool needsDir
= false;
751 case wxSHOW_EFFECT_ROLL
:
755 case wxSHOW_EFFECT_SLIDE
:
760 case wxSHOW_EFFECT_BLEND
:
764 case wxSHOW_EFFECT_EXPAND
:
765 dwFlags
|= AW_CENTER
;
769 case wxSHOW_EFFECT_MAX
:
770 wxFAIL_MSG( _T("invalid window show effect") );
774 wxFAIL_MSG( _T("unknown window show effect") );
783 dwFlags
|= AW_VER_NEGATIVE
;
787 dwFlags
|= AW_VER_POSITIVE
;
791 dwFlags
|= AW_HOR_NEGATIVE
;
795 dwFlags
|= AW_HOR_POSITIVE
;
799 wxFAIL_MSG( _T("unknown window effect direction") );
803 else // animation effect which doesn't need the direction
805 wxASSERT_MSG( dir
== wxBOTTOM
,
806 _T("non-default direction used unnecessarily") );
810 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
812 wxLogLastError(_T("AnimateWindow"));
820 // Raise the window to the top of the Z order
821 void wxWindowMSW::Raise()
823 wxBringWindowToTop(GetHwnd());
826 // Lower the window to the bottom of the Z order
827 void wxWindowMSW::Lower()
829 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
830 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
833 void wxWindowMSW::DoCaptureMouse()
835 HWND hWnd
= GetHwnd();
842 void wxWindowMSW::DoReleaseMouse()
844 if ( !::ReleaseCapture() )
846 wxLogLastError(_T("ReleaseCapture"));
850 /* static */ wxWindow
*wxWindowBase::GetCapture()
852 HWND hwnd
= ::GetCapture();
853 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
856 bool wxWindowMSW::SetFont(const wxFont
& font
)
858 if ( !wxWindowBase::SetFont(font
) )
864 HWND hWnd
= GetHwnd();
867 WXHANDLE hFont
= m_font
.GetResourceHandle();
869 wxASSERT_MSG( hFont
, wxT("should have valid font") );
871 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
876 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
878 if ( !wxWindowBase::SetCursor(cursor
) )
884 // don't "overwrite" busy cursor
885 if ( m_cursor
.Ok() && !wxIsBusy() )
887 // normally we should change the cursor only if it's over this window
888 // but we should do it always if we capture the mouse currently
889 bool set
= HasCapture();
892 HWND hWnd
= GetHwnd();
896 ::GetCursorPosWinCE(&point
);
898 ::GetCursorPos(&point
);
901 RECT rect
= wxGetWindowRect(hWnd
);
903 set
= ::PtInRect(&rect
, point
) != 0;
908 ::SetCursor(GetHcursorOf(m_cursor
));
910 //else: will be set later when the mouse enters this window
916 void wxWindowMSW::WarpPointer(int x
, int y
)
918 ClientToScreen(&x
, &y
);
920 if ( !::SetCursorPos(x
, y
) )
922 wxLogLastError(_T("SetCursorPos"));
926 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
928 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
929 // to use it on older systems -- and could possibly do some harm
930 static int s_needToUpdate
= -1;
931 if ( s_needToUpdate
== -1 )
934 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
938 if ( s_needToUpdate
)
940 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
941 // won't send WM_UPDATEUISTATE
942 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
946 // ---------------------------------------------------------------------------
948 // ---------------------------------------------------------------------------
950 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
952 #ifdef __WXMICROWIN__
953 return ::GetScrollPosWX(hWnd
, wOrient
);
955 WinStruct
<SCROLLINFO
> scrollInfo
;
956 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
957 scrollInfo
.fMask
= SIF_POS
;
958 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
960 return scrollInfo
.nPos
;
965 int wxWindowMSW::GetScrollPos(int orient
) const
967 HWND hWnd
= GetHwnd();
968 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
970 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
973 // This now returns the whole range, not just the number
974 // of positions that we can scroll.
975 int wxWindowMSW::GetScrollRange(int orient
) const
978 HWND hWnd
= GetHwnd();
982 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
985 WinStruct
<SCROLLINFO
> scrollInfo
;
986 scrollInfo
.fMask
= SIF_RANGE
;
987 if ( !::GetScrollInfo(hWnd
,
988 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
991 // Most of the time this is not really an error, since the return
992 // value can also be zero when there is no scrollbar yet.
993 // wxLogLastError(_T("GetScrollInfo"));
995 maxPos
= scrollInfo
.nMax
;
997 // undo "range - 1" done in SetScrollbar()
1001 int wxWindowMSW::GetScrollThumb(int orient
) const
1003 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
1006 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
1008 HWND hWnd
= GetHwnd();
1009 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
1011 WinStruct
<SCROLLINFO
> info
;
1015 info
.fMask
= SIF_POS
;
1016 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1018 // disable scrollbar instead of removing it then
1019 info
.fMask
|= SIF_DISABLENOSCROLL
;
1022 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1026 // New function that will replace some of the above.
1027 void wxWindowMSW::SetScrollbar(int orient
,
1033 WinStruct
<SCROLLINFO
> info
;
1034 info
.nPage
= pageSize
;
1035 info
.nMin
= 0; // range is nMax - nMin + 1
1036 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1038 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1039 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1041 // disable scrollbar instead of removing it then
1042 info
.fMask
|= SIF_DISABLENOSCROLL
;
1045 HWND hWnd
= GetHwnd();
1048 // We have to set the variables here to make them valid in events
1049 // triggered by ::SetScrollInfo()
1050 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1052 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
1057 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1063 wxCopyRectToRECT(*prect
, rect
);
1073 // FIXME: is this the exact equivalent of the line below?
1074 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1076 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1080 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1082 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1085 for ( int n
= 0; n
< count
; n
++ )
1087 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1089 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1090 if ( posNew
== pos
)
1092 // don't bother to continue, we're already at top/bottom
1099 return pos
!= posStart
;
1102 bool wxWindowMSW::ScrollLines(int lines
)
1104 bool down
= lines
> 0;
1106 return ScrollVertically(GetHwnd(),
1107 down
? SB_LINEDOWN
: SB_LINEUP
,
1108 down
? lines
: -lines
);
1111 bool wxWindowMSW::ScrollPages(int pages
)
1113 bool down
= pages
> 0;
1115 return ScrollVertically(GetHwnd(),
1116 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1117 down
? pages
: -pages
);
1120 // ----------------------------------------------------------------------------
1122 // ----------------------------------------------------------------------------
1124 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1129 const HWND hwnd
= GetHwnd();
1130 wxCHECK_RET( hwnd
, _T("layout direction must be set after window creation") );
1132 LONG styleOld
= ::GetWindowLong(hwnd
, GWL_EXSTYLE
);
1134 LONG styleNew
= styleOld
;
1137 case wxLayout_LeftToRight
:
1138 styleNew
&= ~WS_EX_LAYOUTRTL
;
1141 case wxLayout_RightToLeft
:
1142 styleNew
|= WS_EX_LAYOUTRTL
;
1146 wxFAIL_MSG(_T("unsupported layout direction"));
1150 if ( styleNew
!= styleOld
)
1152 ::SetWindowLong(hwnd
, GWL_EXSTYLE
, styleNew
);
1157 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1160 return wxLayout_Default
;
1162 const HWND hwnd
= GetHwnd();
1163 wxCHECK_MSG( hwnd
, wxLayout_Default
, _T("invalid window") );
1165 return ::GetWindowLong(hwnd
, GWL_EXSTYLE
) & WS_EX_LAYOUTRTL
1166 ? wxLayout_RightToLeft
1167 : wxLayout_LeftToRight
;
1172 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1173 wxCoord
WXUNUSED(width
),
1174 wxCoord
WXUNUSED(widthTotal
)) const
1176 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1177 // redo it ourselves
1181 // ---------------------------------------------------------------------------
1183 // ---------------------------------------------------------------------------
1185 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1187 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1189 HWND hwnd
= (HWND
)hWnd
;
1190 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1192 wxAssociateWinWithHandle(hwnd
, this);
1194 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1196 // we don't need to subclass the window of our own class (in the Windows
1197 // sense of the word)
1198 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1200 wxSetWindowProc(hwnd
, wxWndProc
);
1204 // don't bother restoring it either: this also makes it easy to
1205 // implement IsOfStandardClass() method which returns true for the
1206 // standard controls and false for the wxWidgets own windows as it can
1207 // simply check m_oldWndProc
1208 m_oldWndProc
= NULL
;
1211 // we're officially created now, send the event
1212 wxWindowCreateEvent
event((wxWindow
*)this);
1213 (void)HandleWindowEvent(event
);
1216 void wxWindowMSW::UnsubclassWin()
1218 wxRemoveHandleAssociation(this);
1220 // Restore old Window proc
1221 HWND hwnd
= GetHwnd();
1226 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1230 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1232 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1235 m_oldWndProc
= NULL
;
1240 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1244 if ( !::DestroyWindow(GetHwnd()) )
1245 wxLogLastError(wxT("DestroyWindow"));
1248 WXHWND wxhwnd
= (WXHWND
)handle
;
1251 SubclassWin(wxhwnd
);
1254 void wxWindowMSW::DissociateHandle()
1256 // this also calls SetHWND(0) for us
1261 bool wxCheckWindowWndProc(WXHWND hWnd
,
1262 WXFARPROC
WXUNUSED(wndProc
))
1264 // TODO: This list of window class names should be factored out so they can be
1265 // managed in one place and then accessed from here and other places, such as
1266 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1269 extern wxChar
*wxCanvasClassName
;
1270 extern wxChar
*wxCanvasClassNameNR
;
1272 extern const wxChar
*wxCanvasClassName
;
1273 extern const wxChar
*wxCanvasClassNameNR
;
1275 extern const wxChar
*wxMDIFrameClassName
;
1276 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1277 extern const wxChar
*wxMDIChildFrameClassName
;
1278 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1279 wxString
str(wxGetWindowClass(hWnd
));
1280 if (str
== wxCanvasClassName
||
1281 str
== wxCanvasClassNameNR
||
1283 str
== _T("wxGLCanvasClass") ||
1284 str
== _T("wxGLCanvasClassNR") ||
1285 #endif // wxUSE_GLCANVAS
1286 str
== wxMDIFrameClassName
||
1287 str
== wxMDIFrameClassNameNoRedraw
||
1288 str
== wxMDIChildFrameClassName
||
1289 str
== wxMDIChildFrameClassNameNoRedraw
||
1290 str
== _T("wxTLWHiddenParent"))
1291 return true; // Effectively means don't subclass
1296 // ----------------------------------------------------------------------------
1298 // ----------------------------------------------------------------------------
1300 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1302 long flagsOld
= GetWindowStyleFlag();
1303 if ( flags
== flagsOld
)
1306 // update the internal variable
1307 wxWindowBase::SetWindowStyleFlag(flags
);
1309 // and the real window flags
1310 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1313 void wxWindowMSW::SetExtraStyle(long exflags
)
1315 long exflagsOld
= GetExtraStyle();
1316 if ( exflags
== exflagsOld
)
1319 // update the internal variable
1320 wxWindowBase::SetExtraStyle(exflags
);
1322 // and the real window flags
1323 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1326 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1328 // now update the Windows style as well if needed - and if the window had
1329 // been already created
1333 // we may need to call SetWindowPos() when we change some styles
1334 bool callSWP
= false;
1337 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1339 // this is quite a horrible hack but we need it because MSWGetStyle()
1340 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1341 // and so we have to modify the window exflags temporarily to get the
1342 // correct exstyleOld
1343 long exflagsNew
= GetExtraStyle();
1344 wxWindowBase::SetExtraStyle(exflagsOld
);
1347 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1349 wxWindowBase::SetExtraStyle(exflagsNew
);
1352 if ( style
!= styleOld
)
1354 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1355 // this function so instead of simply setting the style to the new
1356 // value we clear the bits which were set in styleOld but are set in
1357 // the new one and set the ones which were not set before
1358 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1359 styleReal
&= ~styleOld
;
1362 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1364 // we need to call SetWindowPos() if any of the styles affecting the
1365 // frame appearance have changed
1366 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1375 // and the extended style
1376 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1378 if ( exstyle
!= exstyleOld
)
1380 exstyleReal
&= ~exstyleOld
;
1381 exstyleReal
|= exstyle
;
1383 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1385 // ex style changes don't take effect without calling SetWindowPos
1391 // we must call SetWindowPos() to flush the cached extended style and
1392 // also to make the change to wxSTAY_ON_TOP style take effect: just
1393 // setting the style simply doesn't work
1394 if ( !::SetWindowPos(GetHwnd(),
1395 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1398 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1400 wxLogLastError(_T("SetWindowPos"));
1405 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1407 return wxBORDER_THEME
;
1410 wxBorder
wxWindowMSW::GetDefaultBorder() const
1412 return wxWindowBase::GetDefaultBorder();
1415 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1416 // that makes most sense for this Windows environment
1417 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1419 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1420 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1421 return wxBORDER_SIMPLE
;
1423 return wxBORDER_NONE
;
1426 if (border
== wxBORDER_THEME
)
1428 if (CanApplyThemeBorder())
1430 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1432 return wxBORDER_THEME
;
1434 return wxBORDER_SUNKEN
;
1442 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1444 // translate common wxWidgets styles to Windows ones
1446 // most of windows are child ones, those which are not (such as
1447 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1448 WXDWORD style
= WS_CHILD
;
1450 // using this flag results in very significant reduction in flicker,
1451 // especially with controls inside the static boxes (as the interior of the
1452 // box is not redrawn twice), but sometimes results in redraw problems, so
1453 // optionally allow the old code to continue to use it provided a special
1454 // system option is turned on
1455 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1456 || (flags
& wxCLIP_CHILDREN
) )
1457 style
|= WS_CLIPCHILDREN
;
1459 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1460 // don't support overlapping windows and it only makes sense for them and,
1461 // presumably, gives the system some extra work (to manage more clipping
1462 // regions), so avoid it alltogether
1465 if ( flags
& wxVSCROLL
)
1466 style
|= WS_VSCROLL
;
1468 if ( flags
& wxHSCROLL
)
1469 style
|= WS_HSCROLL
;
1471 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1473 // After translation, border is now optimized for the specific version of Windows
1474 // and theme engine presence.
1476 // WS_BORDER is only required for wxBORDER_SIMPLE
1477 if ( border
== wxBORDER_SIMPLE
)
1480 // now deal with ext style if the caller wants it
1486 if ( flags
& wxTRANSPARENT_WINDOW
)
1487 *exstyle
|= WS_EX_TRANSPARENT
;
1493 case wxBORDER_DEFAULT
:
1494 wxFAIL_MSG( _T("unknown border style") );
1498 case wxBORDER_SIMPLE
:
1499 case wxBORDER_THEME
:
1502 case wxBORDER_STATIC
:
1503 *exstyle
|= WS_EX_STATICEDGE
;
1506 case wxBORDER_RAISED
:
1507 *exstyle
|= WS_EX_DLGMODALFRAME
;
1510 case wxBORDER_SUNKEN
:
1511 *exstyle
|= WS_EX_CLIENTEDGE
;
1512 style
&= ~WS_BORDER
;
1515 // case wxBORDER_DOUBLE:
1516 // *exstyle |= WS_EX_DLGMODALFRAME;
1520 // wxUniv doesn't use Windows dialog navigation functions at all
1521 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1522 // to make the dialog navigation work with the nested panels we must
1523 // use this style (top level windows such as dialogs don't need it)
1524 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1526 *exstyle
|= WS_EX_CONTROLPARENT
;
1528 #endif // __WXUNIVERSAL__
1534 // Setup background and foreground colours correctly
1535 void wxWindowMSW::SetupColours()
1538 SetBackgroundColour(GetParent()->GetBackgroundColour());
1541 bool wxWindowMSW::IsMouseInWindow() const
1543 // get the mouse position
1546 ::GetCursorPosWinCE(&pt
);
1548 ::GetCursorPos(&pt
);
1551 // find the window which currently has the cursor and go up the window
1552 // chain until we find this window - or exhaust it
1553 HWND hwnd
= ::WindowFromPoint(pt
);
1554 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1555 hwnd
= ::GetParent(hwnd
);
1557 return hwnd
!= NULL
;
1560 void wxWindowMSW::OnInternalIdle()
1562 #ifndef HAVE_TRACKMOUSEEVENT
1563 // Check if we need to send a LEAVE event
1564 if ( m_mouseInWindow
)
1566 // note that we should generate the leave event whether the window has
1567 // or doesn't have mouse capture
1568 if ( !IsMouseInWindow() )
1570 GenerateMouseLeave();
1573 #endif // !HAVE_TRACKMOUSEEVENT
1575 if (wxUpdateUIEvent::CanUpdate(this) && IsShown())
1576 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1579 // Set this window to be the child of 'parent'.
1580 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1582 if ( !wxWindowBase::Reparent(parent
) )
1585 HWND hWndChild
= GetHwnd();
1586 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1588 ::SetParent(hWndChild
, hWndParent
);
1591 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1593 EnsureParentHasControlParentStyle(GetParent());
1595 #endif // !__WXWINCE__
1600 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1602 #ifndef __WXMICROWIN__
1603 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1607 void wxWindowMSW::DoFreeze()
1610 SendSetRedraw(GetHwnd(), false);
1613 void wxWindowMSW::DoThaw()
1617 SendSetRedraw(GetHwnd(), true);
1619 // we need to refresh everything or otherwise the invalidated area
1620 // is not going to be repainted
1625 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1627 HWND hWnd
= GetHwnd();
1634 wxCopyRectToRECT(*rect
, mswRect
);
1642 // RedrawWindow not available on SmartPhone or eVC++ 3
1643 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1644 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1648 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1650 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1655 void wxWindowMSW::Update()
1657 if ( !::UpdateWindow(GetHwnd()) )
1659 wxLogLastError(_T("UpdateWindow"));
1662 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1663 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1664 // handler needs to be really drawn right now
1669 // ---------------------------------------------------------------------------
1671 // ---------------------------------------------------------------------------
1673 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1677 // we need to lower the sibling static boxes so controls contained within can be
1679 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1681 // no sibling static boxes if we have no parent (ie TLW)
1685 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1687 node
= node
->GetNext() )
1689 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1692 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1693 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1698 #else // !wxUSE_STATBOX
1700 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1704 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1706 #endif // drag and drop is used
1708 #if wxUSE_DRAG_AND_DROP
1709 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1711 if ( m_dropTarget
!= 0 ) {
1712 m_dropTarget
->Revoke(m_hWnd
);
1713 delete m_dropTarget
;
1716 m_dropTarget
= pDropTarget
;
1717 if ( m_dropTarget
!= 0 )
1719 AdjustStaticBoxZOrder(GetParent());
1720 m_dropTarget
->Register(m_hWnd
);
1723 #endif // wxUSE_DRAG_AND_DROP
1725 // old-style file manager drag&drop support: we retain the old-style
1726 // DragAcceptFiles in parallel with SetDropTarget.
1727 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1730 HWND hWnd
= GetHwnd();
1733 AdjustStaticBoxZOrder(GetParent());
1734 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1739 // ----------------------------------------------------------------------------
1741 // ----------------------------------------------------------------------------
1745 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1747 wxWindowBase::DoSetToolTip(tooltip
);
1750 m_tooltip
->SetWindow((wxWindow
*)this);
1753 #endif // wxUSE_TOOLTIPS
1755 // ---------------------------------------------------------------------------
1756 // moving and resizing
1757 // ---------------------------------------------------------------------------
1759 bool wxWindowMSW::IsSizeDeferred() const
1761 #if USE_DEFERRED_SIZING
1762 if ( m_pendingPosition
!= wxDefaultPosition
||
1763 m_pendingSize
!= wxDefaultSize
)
1765 #endif // USE_DEFERRED_SIZING
1771 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1773 #if USE_DEFERRED_SIZING
1774 // if SetSize() had been called at wx level but not realized at Windows
1775 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1776 // the new and not the old position to the other wx code
1777 if ( m_pendingSize
!= wxDefaultSize
)
1780 *x
= m_pendingSize
.x
;
1782 *y
= m_pendingSize
.y
;
1784 else // use current size
1785 #endif // USE_DEFERRED_SIZING
1787 RECT rect
= wxGetWindowRect(GetHwnd());
1790 *x
= rect
.right
- rect
.left
;
1792 *y
= rect
.bottom
- rect
.top
;
1796 // Get size *available for subwindows* i.e. excluding menu bar etc.
1797 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1799 #if USE_DEFERRED_SIZING
1800 if ( m_pendingSize
!= wxDefaultSize
)
1802 // we need to calculate the client size corresponding to pending size
1804 rect
.left
= m_pendingPosition
.x
;
1805 rect
.top
= m_pendingPosition
.y
;
1806 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1807 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1809 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1812 *x
= rect
.right
- rect
.left
;
1814 *y
= rect
.bottom
- rect
.top
;
1817 #endif // USE_DEFERRED_SIZING
1819 RECT rect
= wxGetClientRect(GetHwnd());
1828 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1830 wxWindow
* const parent
= GetParent();
1833 if ( m_pendingPosition
!= wxDefaultPosition
)
1835 pos
= m_pendingPosition
;
1837 else // use current position
1839 RECT rect
= wxGetWindowRect(GetHwnd());
1842 point
.x
= rect
.left
;
1845 // we do the adjustments with respect to the parent only for the "real"
1846 // children, not for the dialogs/frames
1847 if ( !IsTopLevel() )
1849 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1851 // In RTL mode, we want the logical left x-coordinate,
1852 // which would be the physical right x-coordinate.
1853 point
.x
= rect
.right
;
1856 // Since we now have the absolute screen coords, if there's a
1857 // parent we must subtract its top left corner
1860 ::ScreenToClient(GetHwndOf(parent
), &point
);
1868 // we also must adjust by the client area offset: a control which is just
1869 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1870 if ( parent
&& !IsTopLevel() )
1872 const wxPoint
pt(parent
->GetClientAreaOrigin());
1883 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1891 ::ScreenToClient(GetHwnd(), &pt
);
1899 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1907 ::ClientToScreen(GetHwnd(), &pt
);
1916 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1918 #if USE_DEFERRED_SIZING
1919 // if our parent had prepared a defer window handle for us, use it (unless
1920 // we are a top level window)
1921 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1923 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1926 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1927 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1930 wxLogLastError(_T("DeferWindowPos"));
1936 // hdwp must be updated as it may have been changed
1937 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1942 // did deferred move, remember new coordinates of the window as they're
1943 // different from what Windows would return for it
1947 // otherwise (or if deferring failed) move the window in place immediately
1948 #endif // USE_DEFERRED_SIZING
1949 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1951 wxLogLastError(wxT("MoveWindow"));
1954 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1955 // ignored otherwise
1959 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1961 // TODO: is this consistent with other platforms?
1962 // Still, negative width or height shouldn't be allowed
1968 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1970 #if USE_DEFERRED_SIZING
1971 m_pendingPosition
= wxPoint(x
, y
);
1972 m_pendingSize
= wxSize(width
, height
);
1973 #endif // USE_DEFERRED_SIZING
1977 // set the size of the window: if the dimensions are positive, just use them,
1978 // but if any of them is equal to -1, it means that we must find the value for
1979 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1980 // which case -1 is a valid value for x and y)
1982 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1983 // the width/height to best suit our contents, otherwise we reuse the current
1985 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1987 // get the current size and position...
1988 int currentX
, currentY
;
1989 int currentW
, currentH
;
1991 GetPosition(¤tX
, ¤tY
);
1992 GetSize(¤tW
, ¤tH
);
1994 // ... and don't do anything (avoiding flicker) if it's already ok unless
1995 // we're forced to resize the window
1996 if ( x
== currentX
&& y
== currentY
&&
1997 width
== currentW
&& height
== currentH
&&
1998 !(sizeFlags
& wxSIZE_FORCE
) )
2003 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2005 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2008 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2010 wxSize size
= wxDefaultSize
;
2011 if ( width
== wxDefaultCoord
)
2013 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2015 size
= DoGetBestSize();
2020 // just take the current one
2025 if ( height
== wxDefaultCoord
)
2027 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2029 if ( size
.x
== wxDefaultCoord
)
2031 size
= DoGetBestSize();
2033 //else: already called DoGetBestSize() above
2039 // just take the current one
2044 DoMoveWindow(x
, y
, width
, height
);
2047 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2049 // setting the client size is less obvious than it could have been
2050 // because in the result of changing the total size the window scrollbar
2051 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2052 // doesn't take neither into account) and so the client size will not be
2053 // correct as the difference between the total and client size changes --
2054 // so we keep changing it until we get it right
2056 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2057 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2058 // may become 3 if the window had 0 size originally and so we didn't
2059 // calculate the scrollbar correction correctly during the first iteration)
2060 // but just to be on the safe side we check for it instead of making it an
2061 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2062 for ( int i
= 0; i
< 4; i
++ )
2065 ::GetClientRect(GetHwnd(), &rectClient
);
2067 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2068 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2069 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2074 // Find the difference between the entire window (title bar and all)
2075 // and the client area; add this to the new client size to move the
2078 ::GetWindowRect(GetHwnd(), &rectWin
);
2080 const int widthWin
= rectWin
.right
- rectWin
.left
,
2081 heightWin
= rectWin
.bottom
- rectWin
.top
;
2083 // MoveWindow positions the child windows relative to the parent, so
2084 // adjust if necessary
2085 if ( !IsTopLevel() )
2087 wxWindow
*parent
= GetParent();
2090 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2094 // don't call DoMoveWindow() because we want to move window immediately
2095 // and not defer it here as otherwise the value returned by
2096 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2098 if ( !::MoveWindow(GetHwnd(),
2101 width
+ widthWin
- rectClient
.right
,
2102 height
+ heightWin
- rectClient
.bottom
,
2105 wxLogLastError(_T("MoveWindow"));
2110 // ---------------------------------------------------------------------------
2112 // ---------------------------------------------------------------------------
2114 int wxWindowMSW::GetCharHeight() const
2116 return wxGetTextMetrics(this).tmHeight
;
2119 int wxWindowMSW::GetCharWidth() const
2121 // +1 is needed because Windows apparently adds it when calculating the
2122 // dialog units size in pixels
2123 #if wxDIALOG_UNIT_COMPATIBILITY
2124 return wxGetTextMetrics(this).tmAveCharWidth
;
2126 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2130 void wxWindowMSW::GetTextExtent(const wxString
& string
,
2132 int *descent
, int *externalLeading
,
2133 const wxFont
*theFont
) const
2135 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
2136 _T("invalid font in GetTextExtent()") );
2140 fontToUse
= *theFont
;
2142 fontToUse
= GetFont();
2144 WindowHDC
hdc(GetHwnd());
2145 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
2149 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2150 GetTextMetrics(hdc
, &tm
);
2157 *descent
= tm
.tmDescent
;
2158 if ( externalLeading
)
2159 *externalLeading
= tm
.tmExternalLeading
;
2162 // ---------------------------------------------------------------------------
2164 // ---------------------------------------------------------------------------
2166 #if wxUSE_MENUS_NATIVE
2168 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2169 // immediately, without waiting for the next event loop iteration
2171 // NB: this function should probably be made public later as it can almost
2172 // surely replace wxYield() elsewhere as well
2173 static void wxYieldForCommandsOnly()
2175 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2176 // want to process it here)
2178 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2180 if ( msg
.message
== WM_QUIT
)
2182 // if we retrieved a WM_QUIT, insert back into the message queue.
2183 ::PostQuitMessage(0);
2187 // luckily (as we don't have access to wxEventLoopImpl method from here
2188 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2190 ::TranslateMessage(&msg
);
2191 ::DispatchMessage(&msg
);
2195 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2197 menu
->SetInvokingWindow(this);
2200 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2202 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2203 x
= mouse
.x
; y
= mouse
.y
;
2206 HWND hWnd
= GetHwnd();
2207 HMENU hMenu
= GetHmenuOf(menu
);
2211 ::ClientToScreen(hWnd
, &point
);
2212 #if defined(__WXWINCE__)
2213 static const UINT flags
= 0;
2214 #else // !__WXWINCE__
2215 UINT flags
= TPM_RIGHTBUTTON
;
2216 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2217 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2218 // side and not to use it there neither -- modify the test if it does work
2220 if ( wxGetWinVersion() >= wxWinVersion_5
)
2222 // using TPM_RECURSE allows us to show a popup menu while another menu
2223 // is opened which can be useful and is supported by the other
2224 // platforms, so allow it under Windows too
2225 flags
|= TPM_RECURSE
;
2227 #endif // __WXWINCE__/!__WXWINCE__
2229 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2231 // we need to do it right now as otherwise the events are never going to be
2232 // sent to wxCurrentPopupMenu from HandleCommand()
2234 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2235 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2236 // destroyed as soon as we return (it can be a local variable in the caller
2237 // for example) and so we do need to process the event immediately
2238 wxYieldForCommandsOnly();
2240 menu
->SetInvokingWindow(NULL
);
2245 #endif // wxUSE_MENUS_NATIVE
2247 // ===========================================================================
2248 // pre/post message processing
2249 // ===========================================================================
2251 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2254 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2256 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2259 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2261 // wxUniversal implements tab traversal itself
2262 #ifndef __WXUNIVERSAL__
2263 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2265 // intercept dialog navigation keys
2266 MSG
*msg
= (MSG
*)pMsg
;
2268 // here we try to do all the job which ::IsDialogMessage() usually does
2270 if ( msg
->message
== WM_KEYDOWN
)
2272 bool bCtrlDown
= wxIsCtrlDown();
2273 bool bShiftDown
= wxIsShiftDown();
2275 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2276 // don't process it if it's the case (except for Ctrl-Tab/Enter
2277 // combinations which are always processed)
2278 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2280 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2281 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2282 // it, of course, implies them
2283 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2285 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2288 bool bForward
= true,
2289 bWindowChange
= false,
2292 // should we process this message specially?
2293 bool bProcess
= true;
2294 switch ( msg
->wParam
)
2297 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2299 // let the control have the TAB
2302 else // use it for navigation
2304 // Ctrl-Tab cycles thru notebook pages
2305 bWindowChange
= bCtrlDown
;
2306 bForward
= !bShiftDown
;
2313 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2321 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2330 // we treat PageUp/Dn as arrows because chances are that
2331 // a control which needs arrows also needs them for
2332 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2333 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2335 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2336 bWindowChange
= true;
2342 // currently active button should get enter press even
2343 // if there is a default button elsewhere so check if
2344 // this window is a button first
2345 wxWindow
*btn
= NULL
;
2346 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2348 // let IsDialogMessage() handle this for all
2349 // buttons except the owner-drawn ones which it
2350 // just seems to ignore
2351 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2352 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2354 // emulate the button click
2355 btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2360 else // not a button itself, do we have default button?
2362 // check if this window or any of its ancestors
2363 // wants the message for itself (we always reserve
2364 // Ctrl-Enter for dialog navigation though)
2365 wxWindow
*win
= this;
2368 // this will contain the dialog code of this
2369 // window and all of its parent windows in turn
2370 LONG lDlgCode2
= lDlgCode
;
2374 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2376 // as it wants to process Enter itself,
2377 // don't call IsDialogMessage() which
2382 // don't propagate keyboard messages beyond
2383 // the first top level window parent
2384 if ( win
->IsTopLevel() )
2387 win
= win
->GetParent();
2389 lDlgCode2
= ::SendMessage
2400 win
= wxGetTopLevelParent(win
);
2403 wxTopLevelWindow
* const
2404 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2407 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2412 if ( btn
&& btn
->IsEnabled() )
2414 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2418 #endif // wxUSE_BUTTON
2421 // map Enter presses into button presses on PDAs
2422 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2423 event
.SetEventObject(this);
2424 if ( HandleWindowEvent(event
) )
2426 #endif // __WXWINCE__
2436 wxNavigationKeyEvent event
;
2437 event
.SetDirection(bForward
);
2438 event
.SetWindowChange(bWindowChange
);
2439 event
.SetFromTab(bFromTab
);
2440 event
.SetEventObject(this);
2442 if ( HandleWindowEvent(event
) )
2444 // as we don't call IsDialogMessage(), which would take of
2445 // this by default, we need to manually send this message
2446 // so that controls can change their UI state if needed
2447 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2454 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2456 // IsDialogMessage() did something...
2460 #endif // __WXUNIVERSAL__
2465 // relay mouse move events to the tooltip control
2466 MSG
*msg
= (MSG
*)pMsg
;
2467 if ( msg
->message
== WM_MOUSEMOVE
)
2468 wxToolTip::RelayEvent(pMsg
);
2470 #endif // wxUSE_TOOLTIPS
2475 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2477 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2478 return m_acceleratorTable
.Translate(this, pMsg
);
2482 #endif // wxUSE_ACCEL
2485 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2487 // all tests below have to deal with various bugs/misfeatures of
2488 // IsDialogMessage(): we have to prevent it from being called from our
2489 // MSWProcessMessage() in some situations
2491 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2492 // message even when there is no cancel button and when the message is
2493 // needed by the control itself: in particular, it prevents the tree in
2494 // place edit control from being closed with Escape in a dialog
2495 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2500 // ::IsDialogMessage() is broken and may sometimes hang the application by
2501 // going into an infinite loop when it tries to find the control to give
2502 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2503 // situations when this may happen and not call it then
2504 if ( msg
->message
!= WM_SYSCHAR
)
2507 // assume we can call it by default
2508 bool canSafelyCallIsDlgMsg
= true;
2510 HWND hwndFocus
= ::GetFocus();
2512 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2513 // ::IsDialogMessage() will also enter an infinite loop, because it will
2514 // recursively check the child windows but not the window itself and so if
2515 // none of the children accepts focus it loops forever (as it only stops
2516 // when it gets back to the window it started from)
2518 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2519 // style has the focus, it can happen. One such possibility is if
2520 // all windows are either toplevel, wxDialog, wxPanel or static
2521 // controls and no window can actually accept keyboard input.
2522 #if !defined(__WXWINCE__)
2523 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2525 // pessimistic by default
2526 canSafelyCallIsDlgMsg
= false;
2527 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2529 node
= node
->GetNext() )
2531 wxWindow
* const win
= node
->GetData();
2532 if ( win
->CanAcceptFocus() &&
2533 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2534 WS_EX_CONTROLPARENT
) )
2536 // it shouldn't hang...
2537 canSafelyCallIsDlgMsg
= true;
2543 #endif // !__WXWINCE__
2545 if ( canSafelyCallIsDlgMsg
)
2547 // ::IsDialogMessage() can enter in an infinite loop when the
2548 // currently focused window is disabled or hidden and its
2549 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2553 if ( !::IsWindowEnabled(hwndFocus
) ||
2554 !::IsWindowVisible(hwndFocus
) )
2556 // it would enter an infinite loop if we do this!
2557 canSafelyCallIsDlgMsg
= false;
2562 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2564 // it's a top level window, don't go further -- e.g. even
2565 // if the parent of a dialog is disabled, this doesn't
2566 // break navigation inside the dialog
2570 hwndFocus
= ::GetParent(hwndFocus
);
2574 return canSafelyCallIsDlgMsg
;
2577 // ---------------------------------------------------------------------------
2578 // message params unpackers
2579 // ---------------------------------------------------------------------------
2581 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2582 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2584 *id
= LOWORD(wParam
);
2585 *hwnd
= (WXHWND
)lParam
;
2586 *cmd
= HIWORD(wParam
);
2589 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2590 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2592 *state
= LOWORD(wParam
);
2593 *minimized
= HIWORD(wParam
);
2594 *hwnd
= (WXHWND
)lParam
;
2597 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2598 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2600 *code
= LOWORD(wParam
);
2601 *pos
= HIWORD(wParam
);
2602 *hwnd
= (WXHWND
)lParam
;
2605 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2606 WXHDC
*hdc
, WXHWND
*hwnd
)
2608 *hwnd
= (WXHWND
)lParam
;
2609 *hdc
= (WXHDC
)wParam
;
2612 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2613 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2615 *item
= (WXWORD
)wParam
;
2616 *flags
= HIWORD(wParam
);
2617 *hmenu
= (WXHMENU
)lParam
;
2620 // ---------------------------------------------------------------------------
2621 // Main wxWidgets window proc and the window proc for wxWindow
2622 // ---------------------------------------------------------------------------
2624 // Hook for new window just as it's being created, when the window isn't yet
2625 // associated with the handle
2626 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2628 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2629 // window being created and insures that it's always unset back later
2630 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2632 gs_winBeingCreated
= winBeingCreated
;
2635 wxWindowCreationHook::~wxWindowCreationHook()
2637 gs_winBeingCreated
= NULL
;
2641 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2643 // trace all messages - useful for the debugging
2645 wxLogTrace(wxTraceMessages
,
2646 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2647 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2648 #endif // __WXDEBUG__
2650 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2652 // when we get the first message for the HWND we just created, we associate
2653 // it with wxWindow stored in gs_winBeingCreated
2654 if ( !wnd
&& gs_winBeingCreated
)
2656 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2657 wnd
= gs_winBeingCreated
;
2658 gs_winBeingCreated
= NULL
;
2659 wnd
->SetHWND((WXHWND
)hWnd
);
2664 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2665 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2667 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2672 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2674 // did we process the message?
2675 bool processed
= false;
2685 // for most messages we should return 0 when we do process the message
2693 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2696 // return 0 to allow window creation
2697 rc
.result
= mayCreate
? 0 : -1;
2703 // never set processed to true and *always* pass WM_DESTROY to
2704 // DefWindowProc() as Windows may do some internal cleanup when
2705 // processing it and failing to pass the message along may cause
2706 // memory and resource leaks!
2707 (void)HandleDestroy();
2711 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2715 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2718 #if !defined(__WXWINCE__)
2721 LPRECT pRect
= (LPRECT
)lParam
;
2723 rc
.SetLeft(pRect
->left
);
2724 rc
.SetTop(pRect
->top
);
2725 rc
.SetRight(pRect
->right
);
2726 rc
.SetBottom(pRect
->bottom
);
2727 processed
= HandleMoving(rc
);
2729 pRect
->left
= rc
.GetLeft();
2730 pRect
->top
= rc
.GetTop();
2731 pRect
->right
= rc
.GetRight();
2732 pRect
->bottom
= rc
.GetBottom();
2737 case WM_ENTERSIZEMOVE
:
2739 processed
= HandleEnterSizeMove();
2743 case WM_EXITSIZEMOVE
:
2745 processed
= HandleExitSizeMove();
2751 LPRECT pRect
= (LPRECT
)lParam
;
2753 rc
.SetLeft(pRect
->left
);
2754 rc
.SetTop(pRect
->top
);
2755 rc
.SetRight(pRect
->right
);
2756 rc
.SetBottom(pRect
->bottom
);
2757 processed
= HandleSizing(rc
);
2759 pRect
->left
= rc
.GetLeft();
2760 pRect
->top
= rc
.GetTop();
2761 pRect
->right
= rc
.GetRight();
2762 pRect
->bottom
= rc
.GetBottom();
2766 #endif // !__WXWINCE__
2768 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2769 case WM_ACTIVATEAPP
:
2770 // This implicitly sends a wxEVT_ACTIVATE_APP event
2771 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2777 WXWORD state
, minimized
;
2779 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2781 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2786 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2790 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2793 case WM_PRINTCLIENT
:
2794 processed
= HandlePrintClient((WXHDC
)wParam
);
2800 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2802 processed
= HandlePaint();
2806 processed
= HandlePaint();
2811 #ifdef __WXUNIVERSAL__
2812 // Universal uses its own wxFrame/wxDialog, so we don't receive
2813 // close events unless we have this.
2815 #endif // __WXUNIVERSAL__
2817 // don't let the DefWindowProc() destroy our window - we'll do it
2818 // ourselves in ~wxWindow
2824 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2828 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2829 GET_Y_LPARAM(lParam
),
2833 #ifdef HAVE_TRACKMOUSEEVENT
2835 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2837 if ( m_mouseInWindow
)
2839 GenerateMouseLeave();
2842 // always pass processed back as false, this allows the window
2843 // manager to process the message too. This is needed to
2844 // ensure windows XP themes work properly as the mouse moves
2845 // over widgets like buttons. So don't set processed to true here.
2847 #endif // HAVE_TRACKMOUSEEVENT
2849 #if wxUSE_MOUSEWHEEL
2851 processed
= HandleMouseWheel(wParam
, lParam
);
2855 case WM_LBUTTONDOWN
:
2857 case WM_LBUTTONDBLCLK
:
2858 case WM_RBUTTONDOWN
:
2860 case WM_RBUTTONDBLCLK
:
2861 case WM_MBUTTONDOWN
:
2863 case WM_MBUTTONDBLCLK
:
2864 #ifdef wxHAS_XBUTTON
2865 case WM_XBUTTONDOWN
:
2867 case WM_XBUTTONDBLCLK
:
2868 #endif // wxHAS_XBUTTON
2870 #ifdef __WXMICROWIN__
2871 // MicroWindows seems to ignore the fact that a window is
2872 // disabled. So catch mouse events and throw them away if
2874 wxWindowMSW
* win
= this;
2877 if (!win
->IsEnabled())
2883 win
= win
->GetParent();
2884 if ( !win
|| win
->IsTopLevel() )
2891 #endif // __WXMICROWIN__
2892 int x
= GET_X_LPARAM(lParam
),
2893 y
= GET_Y_LPARAM(lParam
);
2896 // redirect the event to a static control if necessary by
2897 // finding one under mouse because under CE the static controls
2898 // don't generate mouse events (even with SS_NOTIFY)
2900 if ( GetCapture() == this )
2902 // but don't do it if the mouse is captured by this window
2903 // because then it should really get this event itself
2908 win
= FindWindowForMouseEvent(this, &x
, &y
);
2910 // this should never happen
2911 wxCHECK_MSG( win
, 0,
2912 _T("FindWindowForMouseEvent() returned NULL") );
2915 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2917 SHRGINFO shrgi
= {0};
2919 shrgi
.cbSize
= sizeof(SHRGINFO
);
2920 shrgi
.hwndClient
= (HWND
) GetHWND();
2924 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2925 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2927 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2930 pt
= ClientToScreen(pt
);
2932 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2934 evtCtx
.SetEventObject(this);
2935 if (HandleWindowEvent(evtCtx
))
2944 #else // !__WXWINCE__
2945 wxWindowMSW
*win
= this;
2946 #endif // __WXWINCE__/!__WXWINCE__
2948 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2950 // if the app didn't eat the event, handle it in the default
2951 // way, that is by giving this window the focus
2954 // for the standard classes their WndProc sets the focus to
2955 // them anyhow and doing it from here results in some weird
2956 // problems, so don't do it for them (unnecessary anyhow)
2957 if ( !win
->IsOfStandardClass() )
2959 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
2971 case MM_JOY1BUTTONDOWN
:
2972 case MM_JOY2BUTTONDOWN
:
2973 case MM_JOY1BUTTONUP
:
2974 case MM_JOY2BUTTONUP
:
2975 processed
= HandleJoystickEvent(message
,
2976 GET_X_LPARAM(lParam
),
2977 GET_Y_LPARAM(lParam
),
2980 #endif // __WXMICROWIN__
2986 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2988 processed
= HandleCommand(id
, cmd
, hwnd
);
2993 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2996 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2997 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2998 // apparently doesn't always behave properly and needs some help
2999 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3000 case WM_NOTIFYFORMAT
:
3001 if ( lParam
== NF_QUERY
)
3004 rc
.result
= NFR_UNICODE
;
3007 #endif // wxUSE_UNICODE_MSLU
3009 // for these messages we must return true if process the message
3012 case WM_MEASUREITEM
:
3014 int idCtrl
= (UINT
)wParam
;
3015 if ( message
== WM_DRAWITEM
)
3017 processed
= MSWOnDrawItem(idCtrl
,
3018 (WXDRAWITEMSTRUCT
*)lParam
);
3022 processed
= MSWOnMeasureItem(idCtrl
,
3023 (WXMEASUREITEMSTRUCT
*)lParam
);
3030 #endif // defined(WM_DRAWITEM)
3033 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3035 // we always want to get the char events
3036 rc
.result
= DLGC_WANTCHARS
;
3038 if ( HasFlag(wxWANTS_CHARS
) )
3040 // in fact, we want everything
3041 rc
.result
|= DLGC_WANTARROWS
|
3048 //else: get the dlg code from the DefWindowProc()
3053 // If this has been processed by an event handler, return 0 now
3054 // (we've handled it).
3055 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3056 if ( m_lastKeydownProcessed
)
3065 // we consider these messages "not interesting" to OnChar, so
3066 // just don't do anything more with them
3076 // avoid duplicate messages to OnChar for these ASCII keys:
3077 // they will be translated by TranslateMessage() and received
3109 // but set processed to false, not true to still pass them
3110 // to the control's default window proc - otherwise
3111 // built-in keyboard handling won't work
3116 // special case of VK_APPS: treat it the same as right mouse
3117 // click because both usually pop up a context menu
3119 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3124 // do generate a CHAR event
3125 processed
= HandleChar((WORD
)wParam
, lParam
);
3128 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3135 // special case of VK_APPS: treat it the same as right mouse button
3136 if ( wParam
== VK_APPS
)
3138 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3143 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3148 case WM_CHAR
: // Always an ASCII character
3149 if ( m_lastKeydownProcessed
)
3151 // The key was handled in the EVT_KEY_DOWN and handling
3152 // a key in an EVT_KEY_DOWN handler is meant, by
3153 // design, to prevent EVT_CHARs from happening
3154 m_lastKeydownProcessed
= false;
3159 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3165 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3167 #endif // wxUSE_HOTKEY
3174 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3176 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3182 // CTLCOLOR messages are sent by children to query the parent for their
3184 #ifndef __WXMICROWIN__
3185 case WM_CTLCOLORMSGBOX
:
3186 case WM_CTLCOLOREDIT
:
3187 case WM_CTLCOLORLISTBOX
:
3188 case WM_CTLCOLORBTN
:
3189 case WM_CTLCOLORDLG
:
3190 case WM_CTLCOLORSCROLLBAR
:
3191 case WM_CTLCOLORSTATIC
:
3195 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3197 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3200 #endif // !__WXMICROWIN__
3202 case WM_SYSCOLORCHANGE
:
3203 // the return value for this message is ignored
3204 processed
= HandleSysColorChange();
3207 #if !defined(__WXWINCE__)
3208 case WM_DISPLAYCHANGE
:
3209 processed
= HandleDisplayChange();
3213 case WM_PALETTECHANGED
:
3214 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
3217 case WM_CAPTURECHANGED
:
3218 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
3221 case WM_SETTINGCHANGE
:
3222 processed
= HandleSettingChange(wParam
, lParam
);
3225 case WM_QUERYNEWPALETTE
:
3226 processed
= HandleQueryNewPalette();
3230 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
3233 // we processed the message, i.e. erased the background
3238 #if !defined(__WXWINCE__)
3240 processed
= HandleDropFiles(wParam
);
3245 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
3249 // we never set focus from here
3254 #if !defined(__WXWINCE__)
3255 case WM_QUERYENDSESSION
:
3256 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3260 processed
= HandleEndSession(wParam
!= 0, lParam
);
3263 case WM_GETMINMAXINFO
:
3264 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3269 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
3270 LOWORD(lParam
), // hit test
3271 HIWORD(lParam
)); // mouse msg
3275 // returning TRUE stops the DefWindowProc() from further
3276 // processing this message - exactly what we need because we've
3277 // just set the cursor.
3282 #if wxUSE_ACCESSIBILITY
3285 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3286 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3288 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3290 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3296 #if defined(WM_HELP)
3299 // by default, WM_HELP is propagated by DefWindowProc() upwards
3300 // to the window parent but as we do it ourselves already
3301 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3302 // to get the other events if we process this message at all
3305 // WM_HELP doesn't use lParam under CE
3307 HELPINFO
* info
= (HELPINFO
*) lParam
;
3308 if ( info
->iContextType
== HELPINFO_WINDOW
)
3310 #endif // !__WXWINCE__
3311 wxHelpEvent helpEvent
3316 wxGetMousePosition() // what else?
3318 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3322 helpEvent
.SetEventObject(this);
3323 HandleWindowEvent(helpEvent
);
3326 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3328 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3329 helpEvent
.SetEventObject(this);
3330 HandleWindowEvent(helpEvent
);
3333 else // unknown help event?
3337 #endif // !__WXWINCE__
3342 #if !defined(__WXWINCE__)
3343 case WM_CONTEXTMENU
:
3345 // we don't convert from screen to client coordinates as
3346 // the event may be handled by a parent window
3347 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3349 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3351 // we could have got an event from our child, reflect it back
3352 // to it if this is the case
3353 wxWindowMSW
*win
= NULL
;
3354 if ( (WXHWND
)wParam
!= m_hWnd
)
3356 win
= FindItemByHWND((WXHWND
)wParam
);
3362 evtCtx
.SetEventObject(win
);
3363 processed
= win
->HandleWindowEvent(evtCtx
);
3370 // we're only interested in our own menus, not MF_SYSMENU
3371 if ( HIWORD(wParam
) == MF_POPUP
)
3373 // handle menu chars for ownerdrawn menu items
3374 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3375 if ( i
!= wxNOT_FOUND
)
3377 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3382 #endif // wxUSE_MENUS
3385 case WM_POWERBROADCAST
:
3388 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3389 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3392 #endif // __WXWINCE__
3395 // If we want the default themed border then we need to draw it ourselves
3398 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3399 const wxBorder border
= TranslateBorder(GetBorder());
3400 if (theme
&& border
== wxBORDER_THEME
)
3402 // first ask the widget to calculate the border size
3403 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3406 // now alter the client size making room for drawing a themed border
3407 NCCALCSIZE_PARAMS
*csparam
= NULL
;
3411 csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3412 rect
= csparam
->rgrc
[0];
3416 rect
= *((RECT
*)lParam
);
3418 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3419 RECT rcClient
= { 0, 0, 0, 0 };
3420 wxClientDC
dc((wxWindow
*)this);
3421 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3423 if (theme
->GetThemeBackgroundContentRect(
3424 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
,
3425 &rect
, &rcClient
) == S_OK
)
3427 InflateRect(&rcClient
, -1, -1);
3429 csparam
->rgrc
[0] = rcClient
;
3431 *((RECT
*)lParam
) = rcClient
;
3432 rc
.result
= WVR_REDRAW
;
3440 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3441 const wxBorder border
= TranslateBorder(GetBorder());
3442 if (theme
&& border
== wxBORDER_THEME
)
3444 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3445 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3448 wxUxThemeHandle
hTheme((wxWindow
*)this, L
"EDIT");
3449 wxWindowDC
dc((wxWindow
*)this);
3450 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3452 // Clip the DC so that you only draw on the non-client area
3454 wxCopyRectToRECT(GetSize(), rcBorder
);
3457 theme
->GetThemeBackgroundContentRect(
3458 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3459 InflateRect(&rcClient
, -1, -1);
3461 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3462 rcClient
.right
, rcClient
.bottom
);
3464 // Make sure the background is in a proper state
3465 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3467 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3473 nState
= ETS_DISABLED
;
3474 // should we check this?
3475 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3476 // nState = ETS_READONLY;
3478 nState
= ETS_NORMAL
;
3479 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3484 #endif // wxUSE_UXTHEME
3487 // try a custom message handler
3488 const MSWMessageHandlers::const_iterator
3489 i
= gs_messageHandlers
.find(message
);
3490 if ( i
!= gs_messageHandlers
.end() )
3492 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3499 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3500 wxGetMessageName(message
));
3501 #endif // __WXDEBUG__
3502 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3508 // ----------------------------------------------------------------------------
3509 // wxWindow <-> HWND map
3510 // ----------------------------------------------------------------------------
3512 wxWinHashTable
*wxWinHandleHash
= NULL
;
3514 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3516 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3519 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3521 // adding NULL hWnd is (first) surely a result of an error and
3522 // (secondly) breaks menu command processing
3523 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3524 wxT("attempt to add a NULL hWnd to window list ignored") );
3526 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3528 if ( oldWin
&& (oldWin
!= win
) )
3530 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3531 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3534 #endif // __WXDEBUG__
3537 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3541 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3543 wxWinHandleHash
->Delete((long)win
->GetHWND());
3546 // ----------------------------------------------------------------------------
3547 // various MSW speciic class dependent functions
3548 // ----------------------------------------------------------------------------
3550 // Default destroyer - override if you destroy it in some other way
3551 // (e.g. with MDI child windows)
3552 void wxWindowMSW::MSWDestroyWindow()
3556 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3559 int& w
, int& h
) const
3561 // yes, those are just some arbitrary hardcoded numbers
3562 static const int DEFAULT_Y
= 200;
3564 bool nonDefault
= false;
3566 if ( pos
.x
== wxDefaultCoord
)
3568 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3569 // can just as well set it to CW_USEDEFAULT as well
3575 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3576 // neither because it is not handled as a special value by Windows then
3577 // and so we have to choose some default value for it
3579 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3585 NB: there used to be some code here which set the initial size of the
3586 window to the client size of the parent if no explicit size was
3587 specified. This was wrong because wxWidgets programs often assume
3588 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3589 it. To see why, you should understand that Windows sends WM_SIZE from
3590 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3591 from some base class ctor and so this WM_SIZE is not processed in the
3592 real class' OnSize() (because it's not fully constructed yet and the
3593 event goes to some base class OnSize() instead). So the WM_SIZE we
3594 rely on is the one sent when the parent frame resizes its children
3595 but here is the problem: if the child already has just the right
3596 size, nothing will happen as both wxWidgets and Windows check for
3597 this and ignore any attempts to change the window size to the size it
3598 already has - so no WM_SIZE would be sent.
3602 // we don't use CW_USEDEFAULT here for several reasons:
3604 // 1. it results in huge frames on modern screens (1000*800 is not
3605 // uncommon on my 1280*1024 screen) which is way too big for a half
3606 // empty frame of most of wxWidgets samples for example)
3608 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3609 // the default is for whatever reason 8*8 which breaks client <->
3610 // window size calculations (it would be nice if it didn't, but it
3611 // does and the simplest way to fix it seemed to change the broken
3612 // default size anyhow)
3614 // 3. there is just no advantage in doing it: with x and y it is
3615 // possible that [future versions of] Windows position the new top
3616 // level window in some smart way which we can't do, but we can
3617 // guess a reasonably good size for a new window just as well
3620 // However, on PocketPC devices, we must use the default
3621 // size if possible.
3623 if (size
.x
== wxDefaultCoord
)
3627 if (size
.y
== wxDefaultCoord
)
3632 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3636 w
= WidthDefault(size
.x
);
3637 h
= HeightDefault(size
.y
);
3640 AdjustForParentClientOrigin(x
, y
);
3645 WXHWND
wxWindowMSW::MSWGetParent() const
3647 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3650 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3651 const wxChar
*title
,
3655 WXDWORD extendedStyle
)
3657 // choose the position/size for the new window
3659 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3661 // controlId is menu handle for the top level windows, so set it to 0
3662 // unless we're creating a child window
3663 int controlId
= style
& WS_CHILD
? GetId() : 0;
3665 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3666 // which is the same but without CS_[HV]REDRAW class styles so using it
3667 // ensures that the window is not fully repainted on each resize
3668 wxString
className(wclass
);
3669 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3671 className
+= wxT("NR");
3674 // do create the window
3675 wxWindowCreationHook
hook(this);
3677 m_hWnd
= (WXHWND
)::CreateWindowEx
3681 title
? title
: m_windowName
.wx_str(),
3684 (HWND
)MSWGetParent(),
3687 NULL
// no extra data
3692 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3697 SubclassWin(m_hWnd
);
3702 // ===========================================================================
3703 // MSW message handlers
3704 // ===========================================================================
3706 // ---------------------------------------------------------------------------
3708 // ---------------------------------------------------------------------------
3710 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3712 #ifndef __WXMICROWIN__
3713 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3714 HWND hWnd
= hdr
->hwndFrom
;
3715 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3717 // if the control is one of our windows, let it handle the message itself
3720 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3723 // VZ: why did we do it? normally this is unnecessary and, besides, it
3724 // breaks the message processing for the toolbars because the tooltip
3725 // notifications were being forwarded to the toolbar child controls
3726 // (if it had any) before being passed to the toolbar itself, so in my
3727 // example the tooltip for the combobox was always shown instead of the
3728 // correct button tooltips
3730 // try all our children
3731 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3734 wxWindow
*child
= node
->GetData();
3735 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3740 node
= node
->GetNext();
3744 // by default, handle it ourselves
3745 return MSWOnNotify(idCtrl
, lParam
, result
);
3746 #else // __WXMICROWIN__
3753 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3755 const wxString
& ttip
)
3757 // I don't know why it happens, but the versions of comctl32.dll starting
3758 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3759 // this message is supposed to be sent to Unicode programs only) -- hence
3760 // we need to handle it as well, otherwise no tooltips will be shown in
3763 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3766 // not a tooltip message or no tooltip to show anyhow
3771 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3773 // We don't want to use the szText buffer because it has a limit of 80
3774 // bytes and this is not enough, especially for Unicode build where it
3775 // limits the tooltip string length to only 40 characters
3777 // The best would be, of course, to not impose any length limitations at
3778 // all but then the buffer would have to be dynamic and someone would have
3779 // to free it and we don't have the tooltip owner object here any more, so
3780 // for now use our own static buffer with a higher fixed max length.
3782 // Note that using a static buffer should not be a problem as only a single
3783 // tooltip can be shown at the same time anyhow.
3785 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3787 // We need to convert tooltip from multi byte to Unicode on the fly.
3788 static wchar_t buf
[513];
3790 // Truncate tooltip length if needed as otherwise we might not have
3791 // enough space for it in the buffer and MultiByteToWideChar() would
3793 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3795 // Convert to WideChar without adding the NULL character. The NULL
3796 // character is added afterwards (this is more efficient).
3797 int len
= ::MultiByteToWideChar
3809 wxLogLastError(_T("MultiByteToWideChar()"));
3813 ttText
->lpszText
= (LPSTR
) buf
;
3815 else // TTN_NEEDTEXTA
3816 #endif // !wxUSE_UNICODE
3818 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3819 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3820 // to copy the string we have into the buffer
3821 static wxChar buf
[513];
3822 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3823 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3824 ttText
->lpszText
= buf
;
3830 #endif // wxUSE_TOOLTIPS
3832 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3834 WXLPARAM
* WXUNUSED(result
))
3839 NMHDR
* hdr
= (NMHDR
*)lParam
;
3840 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3847 wxUnusedVar(lParam
);
3848 #endif // wxUSE_TOOLTIPS
3853 // ---------------------------------------------------------------------------
3854 // end session messages
3855 // ---------------------------------------------------------------------------
3857 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3859 #ifdef ENDSESSION_LOGOFF
3860 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3861 event
.SetEventObject(wxTheApp
);
3862 event
.SetCanVeto(true);
3863 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3865 bool rc
= wxTheApp
->ProcessEvent(event
);
3869 // we may end only if the app didn't veto session closing (double
3871 *mayEnd
= !event
.GetVeto();
3876 wxUnusedVar(logOff
);
3877 wxUnusedVar(mayEnd
);
3882 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3884 #ifdef ENDSESSION_LOGOFF
3885 // do nothing if the session isn't ending
3890 if ( (this != wxTheApp
->GetTopWindow()) )
3893 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3894 event
.SetEventObject(wxTheApp
);
3895 event
.SetCanVeto(false);
3896 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3898 return wxTheApp
->ProcessEvent(event
);
3900 wxUnusedVar(endSession
);
3901 wxUnusedVar(logOff
);
3906 // ---------------------------------------------------------------------------
3907 // window creation/destruction
3908 // ---------------------------------------------------------------------------
3910 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3913 // VZ: why is this commented out for WinCE? If it doesn't support
3914 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3915 // not with multiple #ifdef's!
3917 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3918 EnsureParentHasControlParentStyle(GetParent());
3919 #endif // !__WXWINCE__
3926 bool wxWindowMSW::HandleDestroy()
3930 // delete our drop target if we've got one
3931 #if wxUSE_DRAG_AND_DROP
3932 if ( m_dropTarget
!= NULL
)
3934 m_dropTarget
->Revoke(m_hWnd
);
3936 delete m_dropTarget
;
3937 m_dropTarget
= NULL
;
3939 #endif // wxUSE_DRAG_AND_DROP
3941 // WM_DESTROY handled
3945 // ---------------------------------------------------------------------------
3947 // ---------------------------------------------------------------------------
3949 bool wxWindowMSW::HandleActivate(int state
,
3950 bool WXUNUSED(minimized
),
3951 WXHWND
WXUNUSED(activate
))
3953 wxActivateEvent
event(wxEVT_ACTIVATE
,
3954 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3956 event
.SetEventObject(this);
3958 return HandleWindowEvent(event
);
3961 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3963 // Strangly enough, some controls get set focus events when they are being
3964 // deleted, even if they already had focus before.
3965 if ( m_isBeingDeleted
)
3970 // notify the parent keeping track of focus for the kbd navigation
3971 // purposes that we got it
3972 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3973 (void)HandleWindowEvent(eventFocus
);
3979 m_caret
->OnSetFocus();
3981 #endif // wxUSE_CARET
3984 // If it's a wxTextCtrl don't send the event as it will be done
3985 // after the control gets to process it from EN_FOCUS handler
3986 if ( wxDynamicCastThis(wxTextCtrl
) )
3990 #endif // wxUSE_TEXTCTRL
3992 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3993 event
.SetEventObject(this);
3995 // wxFindWinFromHandle() may return NULL, it is ok
3996 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3998 return HandleWindowEvent(event
);
4001 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4007 m_caret
->OnKillFocus();
4009 #endif // wxUSE_CARET
4012 // If it's a wxTextCtrl don't send the event as it will be done
4013 // after the control gets to process it.
4014 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
4021 // Don't send the event when in the process of being deleted. This can
4022 // only cause problems if the event handler tries to access the object.
4023 if ( m_isBeingDeleted
)
4028 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4029 event
.SetEventObject(this);
4031 // wxFindWinFromHandle() may return NULL, it is ok
4032 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4034 return HandleWindowEvent(event
);
4037 // ---------------------------------------------------------------------------
4039 // ---------------------------------------------------------------------------
4041 void wxWindowMSW::SetLabel( const wxString
& label
)
4043 SetWindowText(GetHwnd(), label
.c_str());
4046 wxString
wxWindowMSW::GetLabel() const
4048 return wxGetWindowText(GetHWND());
4051 // ---------------------------------------------------------------------------
4053 // ---------------------------------------------------------------------------
4055 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4057 wxShowEvent
event(GetId(), show
);
4058 event
.SetEventObject(this);
4060 return HandleWindowEvent(event
);
4063 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4065 wxInitDialogEvent
event(GetId());
4066 event
.SetEventObject(this);
4068 return HandleWindowEvent(event
);
4071 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4073 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4074 wxUnusedVar(wParam
);
4076 #else // __WXMICROWIN__
4077 HDROP hFilesInfo
= (HDROP
) wParam
;
4079 // Get the total number of files dropped
4080 UINT gwFilesDropped
= ::DragQueryFile
4088 wxString
*files
= new wxString
[gwFilesDropped
];
4089 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4091 // first get the needed buffer length (+1 for terminating NUL)
4092 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4094 // and now get the file name
4095 ::DragQueryFile(hFilesInfo
, wIndex
,
4096 wxStringBuffer(files
[wIndex
], len
), len
);
4098 DragFinish (hFilesInfo
);
4100 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4101 event
.SetEventObject(this);
4104 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4105 event
.m_pos
.x
= dropPoint
.x
;
4106 event
.m_pos
.y
= dropPoint
.y
;
4108 return HandleWindowEvent(event
);
4113 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4115 int WXUNUSED(mouseMsg
))
4117 #ifndef __WXMICROWIN__
4118 // the logic is as follows:
4119 // 0. if we're busy, set the busy cursor (even for non client elements)
4120 // 1. don't set custom cursor for non client area of enabled windows
4121 // 2. ask user EVT_SET_CURSOR handler for the cursor
4122 // 3. if still no cursor but we're in a TLW, set the global cursor
4124 HCURSOR hcursor
= 0;
4127 hcursor
= wxGetCurrentBusyCursor();
4131 if ( nHitTest
!= HTCLIENT
)
4134 // first ask the user code - it may wish to set the cursor in some very
4135 // specific way (for example, depending on the current position)
4138 if ( !::GetCursorPosWinCE(&pt
))
4140 if ( !::GetCursorPos(&pt
) )
4143 wxLogLastError(wxT("GetCursorPos"));
4148 ScreenToClient(&x
, &y
);
4149 wxSetCursorEvent
event(x
, y
);
4151 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4152 if ( processedEvtSetCursor
&& event
.HasCursor() )
4154 hcursor
= GetHcursorOf(event
.GetCursor());
4159 // the test for processedEvtSetCursor is here to prevent using
4160 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4161 // nothing from it - this is a way to say that our cursor shouldn't
4162 // be used for this point
4163 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4165 hcursor
= GetHcursorOf(m_cursor
);
4168 if ( !hcursor
&& !GetParent() )
4170 const wxCursor
*cursor
= wxGetGlobalCursor();
4171 if ( cursor
&& cursor
->Ok() )
4173 hcursor
= GetHcursorOf(*cursor
);
4182 ::SetCursor(hcursor
);
4184 // cursor set, stop here
4187 #endif // __WXMICROWIN__
4189 // pass up the window chain
4193 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4194 WXLPARAM
WXUNUSED(lParam
),
4195 bool *WXUNUSED_IN_WINCE(vetoed
))
4201 wxEventType evtType
;
4204 case PBT_APMQUERYSUSPEND
:
4205 evtType
= wxEVT_POWER_SUSPENDING
;
4208 case PBT_APMQUERYSUSPENDFAILED
:
4209 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4212 case PBT_APMSUSPEND
:
4213 evtType
= wxEVT_POWER_SUSPENDED
;
4216 case PBT_APMRESUMESUSPEND
:
4217 #ifdef PBT_APMRESUMEAUTOMATIC
4218 case PBT_APMRESUMEAUTOMATIC
:
4220 evtType
= wxEVT_POWER_RESUME
;
4224 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4227 // these messages are currently not mapped to wx events
4228 case PBT_APMQUERYSTANDBY
:
4229 case PBT_APMQUERYSTANDBYFAILED
:
4230 case PBT_APMSTANDBY
:
4231 case PBT_APMRESUMESTANDBY
:
4232 case PBT_APMBATTERYLOW
:
4233 case PBT_APMPOWERSTATUSCHANGE
:
4234 case PBT_APMOEMEVENT
:
4235 case PBT_APMRESUMECRITICAL
:
4236 evtType
= wxEVT_NULL
;
4240 // don't handle unknown messages
4241 if ( evtType
== wxEVT_NULL
)
4244 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4246 wxPowerEvent
event(evtType
);
4247 if ( !HandleWindowEvent(event
) )
4250 *vetoed
= event
.IsVetoed();
4256 bool wxWindowMSW::IsDoubleBuffered() const
4258 for ( const wxWindowMSW
*wnd
= this;
4259 wnd
&& !wnd
->IsTopLevel(); wnd
=
4262 if ( ::GetWindowLong(GetHwndOf(wnd
), GWL_EXSTYLE
) & WS_EX_COMPOSITED
)
4269 // ---------------------------------------------------------------------------
4270 // owner drawn stuff
4271 // ---------------------------------------------------------------------------
4273 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4274 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4275 #define WXUNUSED_UNLESS_ODRAWN(param) param
4277 #define WXUNUSED_UNLESS_ODRAWN(param)
4281 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4282 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4284 #if wxUSE_OWNER_DRAWN
4286 #if wxUSE_MENUS_NATIVE
4287 // is it a menu item?
4288 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4289 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4291 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4293 // see comment before the same test in MSWOnMeasureItem() below
4297 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4298 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
4300 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4301 // the DC from being released
4302 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4303 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4304 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4305 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4307 return pMenuItem
->OnDrawItem
4311 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4312 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4315 #endif // wxUSE_MENUS_NATIVE
4317 #endif // USE_OWNER_DRAWN
4319 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4321 #if wxUSE_OWNER_DRAWN
4322 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4323 #else // !wxUSE_OWNER_DRAWN
4324 // we may still have owner-drawn buttons internally because we have to make
4325 // them owner-drawn to support colour change
4328 wxDynamicCast(FindItem(id
), wxButton
)
4333 #endif // USE_OWNER_DRAWN
4337 return item
->MSWOnDraw(itemStruct
);
4340 #endif // wxUSE_CONTROLS
4346 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4348 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4349 // is it a menu item?
4350 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4351 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4353 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4355 // according to Carsten Fuchs the pointer may be NULL under XP if an
4356 // MDI child frame is initially maximized, see this for more info:
4357 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4359 // so silently ignore it instead of asserting
4363 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4364 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4367 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4369 pMeasureStruct
->itemWidth
= w
;
4370 pMeasureStruct
->itemHeight
= h
;
4375 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4378 return item
->MSWOnMeasure(itemStruct
);
4382 wxUnusedVar(itemStruct
);
4383 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4388 // ---------------------------------------------------------------------------
4389 // colours and palettes
4390 // ---------------------------------------------------------------------------
4392 bool wxWindowMSW::HandleSysColorChange()
4394 wxSysColourChangedEvent event
;
4395 event
.SetEventObject(this);
4397 (void)HandleWindowEvent(event
);
4399 // always let the system carry on the default processing to allow the
4400 // native controls to react to the colours update
4404 bool wxWindowMSW::HandleDisplayChange()
4406 wxDisplayChangedEvent event
;
4407 event
.SetEventObject(this);
4409 return HandleWindowEvent(event
);
4412 #ifndef __WXMICROWIN__
4414 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4416 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4420 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4423 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4425 #endif // wxUSE_CONTROLS
4428 return *brush
!= NULL
;
4431 #endif // __WXMICROWIN__
4433 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4436 // same as below except we don't respond to our own messages
4437 if ( hWndPalChange
!= GetHWND() )
4439 // check to see if we our our parents have a custom palette
4440 wxWindowMSW
*win
= this;
4441 while ( win
&& !win
->HasCustomPalette() )
4443 win
= win
->GetParent();
4446 if ( win
&& win
->HasCustomPalette() )
4448 // realize the palette to see whether redrawing is needed
4449 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4450 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4451 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4453 int result
= ::RealizePalette(hdc
);
4455 // restore the palette (before releasing the DC)
4456 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4457 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4458 ::RealizePalette(hdc
);
4459 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4461 // now check for the need to redraw
4463 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4467 #endif // wxUSE_PALETTE
4469 wxPaletteChangedEvent
event(GetId());
4470 event
.SetEventObject(this);
4471 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4473 return HandleWindowEvent(event
);
4476 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4478 // notify windows on the capture stack about lost capture
4479 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4480 wxWindowBase::NotifyCaptureLost();
4482 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4483 wxMouseCaptureChangedEvent
event(GetId(), win
);
4484 event
.SetEventObject(this);
4485 return HandleWindowEvent(event
);
4488 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4490 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4491 // we need to send this to child windows (it is only sent to top-level
4492 // windows) so {list,tree}ctrls can adjust their font size if necessary
4493 // this is exactly how explorer does it to enable the font size changes
4495 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4498 // top-level windows already get this message from the system
4499 wxWindow
*win
= node
->GetData();
4500 if ( !win
->IsTopLevel() )
4502 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4505 node
= node
->GetNext();
4508 // let the system handle it
4512 bool wxWindowMSW::HandleQueryNewPalette()
4516 // check to see if we our our parents have a custom palette
4517 wxWindowMSW
*win
= this;
4518 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4519 if (win
->HasCustomPalette()) {
4520 /* realize the palette to see whether redrawing is needed */
4521 HDC hdc
= ::GetDC((HWND
) GetHWND());
4522 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4523 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4525 int result
= ::RealizePalette(hdc
);
4526 /* restore the palette (before releasing the DC) */
4527 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4528 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4529 ::RealizePalette(hdc
);
4530 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4531 /* now check for the need to redraw */
4533 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4535 #endif // wxUSE_PALETTE
4537 wxQueryNewPaletteEvent
event(GetId());
4538 event
.SetEventObject(this);
4540 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4543 // Responds to colour changes: passes event on to children.
4544 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4546 // the top level window also reset the standard colour map as it might have
4547 // changed (there is no need to do it for the non top level windows as we
4548 // only have to do it once)
4552 gs_hasStdCmap
= false;
4554 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4557 // Only propagate to non-top-level windows because Windows already
4558 // sends this event to all top-level ones
4559 wxWindow
*win
= node
->GetData();
4560 if ( !win
->IsTopLevel() )
4562 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4563 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4564 // the standard controls
4565 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4568 node
= node
->GetNext();
4572 extern wxCOLORMAP
*wxGetStdColourMap()
4574 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4575 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4577 if ( !gs_hasStdCmap
)
4579 static bool s_coloursInit
= false;
4581 if ( !s_coloursInit
)
4583 // When a bitmap is loaded, the RGB values can change (apparently
4584 // because Windows adjusts them to care for the old programs always
4585 // using 0xc0c0c0 while the transparent colour for the new Windows
4586 // versions is different). But we do this adjustment ourselves so
4587 // we want to avoid Windows' "help" and for this we need to have a
4588 // reference bitmap which can tell us what the RGB values change
4590 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4591 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4592 if ( stdColourBitmap
.Ok() )
4594 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4595 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4596 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4599 memDC
.SelectObject(stdColourBitmap
);
4602 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4604 memDC
.GetPixel(i
, 0, &colour
);
4605 s_stdColours
[i
] = wxColourToRGB(colour
);
4608 else // wxBITMAP_STD_COLOURS couldn't be loaded
4610 s_stdColours
[0] = RGB(000,000,000); // black
4611 s_stdColours
[1] = RGB(128,128,128); // dark grey
4612 s_stdColours
[2] = RGB(192,192,192); // light grey
4613 s_stdColours
[3] = RGB(255,255,255); // white
4614 //s_stdColours[4] = RGB(000,000,255); // blue
4615 //s_stdColours[5] = RGB(255,000,255); // magenta
4618 s_coloursInit
= true;
4621 gs_hasStdCmap
= true;
4623 // create the colour map
4624 #define INIT_CMAP_ENTRY(col) \
4625 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4626 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4628 INIT_CMAP_ENTRY(BTNTEXT
);
4629 INIT_CMAP_ENTRY(BTNSHADOW
);
4630 INIT_CMAP_ENTRY(BTNFACE
);
4631 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4633 #undef INIT_CMAP_ENTRY
4639 // ---------------------------------------------------------------------------
4641 // ---------------------------------------------------------------------------
4643 bool wxWindowMSW::HandlePaint()
4645 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4647 wxLogLastError(wxT("CreateRectRgn"));
4648 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4649 wxLogLastError(wxT("GetUpdateRgn"));
4651 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4653 wxPaintEvent
event(m_windowId
);
4654 event
.SetEventObject(this);
4656 bool processed
= HandleWindowEvent(event
);
4658 // note that we must generate NC event after the normal one as otherwise
4659 // BeginPaint() will happily overwrite our decorations with the background
4661 wxNcPaintEvent
eventNc(m_windowId
);
4662 eventNc
.SetEventObject(this);
4663 HandleWindowEvent(eventNc
);
4665 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4666 // be called from inside the event handlers called above)
4667 m_updateRegion
.Clear();
4672 // Can be called from an application's OnPaint handler
4673 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4675 #ifdef __WXUNIVERSAL__
4678 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4681 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4686 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4688 wxDCTemp
dc(hdc
, GetClientSize());
4689 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4692 impl
->SetWindow((wxWindow
*)this);
4694 wxEraseEvent
event(m_windowId
, &dc
);
4695 event
.SetEventObject(this);
4696 bool rc
= HandleWindowEvent(event
);
4698 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4699 impl
->SelectOldObjects(hdc
);
4704 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4706 // standard non top level controls (i.e. except the dialogs) always erase
4707 // their background themselves in HandleCtlColor() or have some control-
4708 // specific ways to set the colours (common controls)
4709 if ( IsOfStandardClass() && !IsTopLevel() )
4715 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4717 // don't skip the event here, custom background means that the app
4718 // is drawing it itself in its OnPaint(), so don't draw it at all
4719 // now to avoid flicker
4723 wxDC
*dc
= event
.GetDC();
4725 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
->GetImpl();
4727 // do default background painting
4728 if ( !DoEraseBackground(GetHdcOf(*impl
)) )
4730 // let the system paint the background
4735 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4737 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4741 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4747 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4751 // our background colour applies to:
4752 // 1. this window itself, always
4753 // 2. all children unless the colour is "not inheritable"
4754 // 3. even if it is not inheritable, our immediate transparent
4755 // children should still inherit it -- but not any transparent
4756 // children because it would look wrong if a child of non
4757 // transparent child would show our bg colour when the child itself
4759 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4762 (win
&& win
->HasTransparentBackground() &&
4763 win
->GetParent() == this) )
4765 // draw children with the same colour as the parent
4767 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4769 return (WXHBRUSH
)GetHbrushOf(*brush
);
4776 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4779 hWndToPaint
= GetHWND();
4781 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4783 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4787 // background is not inherited beyond top level windows
4788 if ( win
->IsTopLevel() )
4795 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4797 // we receive this message when DrawThemeParentBackground() is
4798 // called from def window proc of several controls under XP and we
4799 // must draw properly themed background here
4801 // note that naively I'd expect filling the client rect with the
4802 // brush returned by MSWGetBgBrush() work -- but for some reason it
4803 // doesn't and we have to call parents MSWPrintChild() which is
4804 // supposed to call DrawThemeBackground() with appropriate params
4806 // also note that in this case lParam == PRF_CLIENT but we're
4807 // clearly expected to paint the background and nothing else!
4809 if ( IsTopLevel() || InheritsBackgroundColour() )
4812 // sometimes we don't want the parent to handle it at all, instead
4813 // return whatever value this window wants
4814 if ( !MSWShouldPropagatePrintChild() )
4815 return MSWPrintChild(hDC
, (wxWindow
*)this);
4817 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4819 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4822 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4829 // ---------------------------------------------------------------------------
4830 // moving and resizing
4831 // ---------------------------------------------------------------------------
4833 bool wxWindowMSW::HandleMinimize()
4835 wxIconizeEvent
event(m_windowId
);
4836 event
.SetEventObject(this);
4838 return HandleWindowEvent(event
);
4841 bool wxWindowMSW::HandleMaximize()
4843 wxMaximizeEvent
event(m_windowId
);
4844 event
.SetEventObject(this);
4846 return HandleWindowEvent(event
);
4849 bool wxWindowMSW::HandleMove(int x
, int y
)
4852 wxMoveEvent
event(point
, m_windowId
);
4853 event
.SetEventObject(this);
4855 return HandleWindowEvent(event
);
4858 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4860 wxMoveEvent
event(rect
, m_windowId
);
4861 event
.SetEventObject(this);
4863 bool rc
= HandleWindowEvent(event
);
4865 rect
= event
.GetRect();
4869 bool wxWindowMSW::HandleEnterSizeMove()
4871 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4872 event
.SetEventType(wxEVT_MOVE_START
);
4873 event
.SetEventObject(this);
4875 return HandleWindowEvent(event
);
4878 bool wxWindowMSW::HandleExitSizeMove()
4880 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4881 event
.SetEventType(wxEVT_MOVE_END
);
4882 event
.SetEventObject(this);
4884 return HandleWindowEvent(event
);
4887 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4889 #if USE_DEFERRED_SIZING
4890 // when we resize this window, its children are probably going to be
4891 // repositioned as well, prepare to use DeferWindowPos() for them
4892 int numChildren
= 0;
4893 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4895 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4900 // Protect against valid m_hDWP being overwritten
4901 bool useDefer
= false;
4903 if ( numChildren
> 1 )
4907 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4910 wxLogLastError(_T("BeginDeferWindowPos"));
4916 #endif // USE_DEFERRED_SIZING
4918 // update this window size
4919 bool processed
= false;
4923 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4924 // fall through nevertheless
4928 // we're not interested in these messages at all
4931 case SIZE_MINIMIZED
:
4932 processed
= HandleMinimize();
4935 case SIZE_MAXIMIZED
:
4936 /* processed = */ HandleMaximize();
4937 // fall through to send a normal size event as well
4940 // don't use w and h parameters as they specify the client size
4941 // while according to the docs EVT_SIZE handler is supposed to
4942 // receive the total size
4943 wxSizeEvent
event(GetSize(), m_windowId
);
4944 event
.SetEventObject(this);
4946 processed
= HandleWindowEvent(event
);
4949 #if USE_DEFERRED_SIZING
4950 // and finally change the positions of all child windows at once
4951 if ( useDefer
&& m_hDWP
)
4953 // reset m_hDWP to NULL so that child windows don't try to use our
4954 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4955 // happen anyhow normally but who knows what weird flow of control we
4956 // may have depending on what the users EVT_SIZE handler does...)
4957 HDWP hDWP
= (HDWP
)m_hDWP
;
4960 // do put all child controls in place at once
4961 if ( !::EndDeferWindowPos(hDWP
) )
4963 wxLogLastError(_T("EndDeferWindowPos"));
4966 // Reset our children's pending pos/size values.
4967 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4969 node
= node
->GetNext() )
4971 wxWindowMSW
*child
= node
->GetData();
4972 child
->m_pendingPosition
= wxDefaultPosition
;
4973 child
->m_pendingSize
= wxDefaultSize
;
4976 #endif // USE_DEFERRED_SIZING
4981 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4983 wxSizeEvent
event(rect
, m_windowId
);
4984 event
.SetEventObject(this);
4986 bool rc
= HandleWindowEvent(event
);
4988 rect
= event
.GetRect();
4992 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4997 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5001 int minWidth
= GetMinWidth(),
5002 minHeight
= GetMinHeight(),
5003 maxWidth
= GetMaxWidth(),
5004 maxHeight
= GetMaxHeight();
5006 if ( minWidth
!= wxDefaultCoord
)
5008 info
->ptMinTrackSize
.x
= minWidth
;
5012 if ( minHeight
!= wxDefaultCoord
)
5014 info
->ptMinTrackSize
.y
= minHeight
;
5018 if ( maxWidth
!= wxDefaultCoord
)
5020 info
->ptMaxTrackSize
.x
= maxWidth
;
5024 if ( maxHeight
!= wxDefaultCoord
)
5026 info
->ptMaxTrackSize
.y
= maxHeight
;
5034 // ---------------------------------------------------------------------------
5036 // ---------------------------------------------------------------------------
5038 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5040 // sign extend to int from short before comparing with the other int ids
5041 int id
= (signed short)id_
;
5043 #if wxUSE_MENUS_NATIVE
5044 if ( !cmd
&& wxCurrentPopupMenu
)
5046 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5047 wxCurrentPopupMenu
= NULL
;
5049 return popupMenu
->MSWCommand(cmd
, id
);
5051 #endif // wxUSE_MENUS_NATIVE
5053 wxWindow
*win
= NULL
;
5055 // first try to find it from HWND - this works even with the broken
5056 // programs using the same ids for different controls
5059 win
= wxFindWinFromHandle(control
);
5070 return win
->MSWCommand(cmd
, id
);
5073 // the messages sent from the in-place edit control used by the treectrl
5074 // for label editing have id == 0, but they should _not_ be treated as menu
5075 // messages (they are EN_XXX ones, in fact) so don't translate anything
5076 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5079 // If no child window, it may be an accelerator, e.g. for a popup menu
5082 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
5083 event
.SetEventObject(this);
5087 return HandleWindowEvent(event
);
5091 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5092 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5093 // notifications to its parent which we want to reflect back to
5095 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5096 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5098 #endif // wxUSE_SPINCTRL
5100 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5101 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5102 // notifications to its parent which we want to reflect back to
5104 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5105 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5113 // ---------------------------------------------------------------------------
5115 // ---------------------------------------------------------------------------
5117 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5121 // our client coords are not quite the same as Windows ones
5122 wxPoint pt
= GetClientAreaOrigin();
5123 event
.m_x
= x
- pt
.x
;
5124 event
.m_y
= y
- pt
.y
;
5126 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5127 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5128 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5129 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5130 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5131 #ifdef wxHAS_XBUTTON
5132 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5133 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5134 #endif // wxHAS_XBUTTON
5135 event
.m_altDown
= ::wxIsAltDown();
5138 event
.SetTimestamp(::GetMessageTime());
5141 event
.SetEventObject(this);
5142 event
.SetId(GetId());
5144 #if wxUSE_MOUSEEVENT_HACK
5145 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5146 gs_lastMouseEvent
.type
= event
.GetEventType();
5147 #endif // wxUSE_MOUSEEVENT_HACK
5151 // Windows doesn't send the mouse events to the static controls (which are
5152 // transparent in the sense that their WM_NCHITTEST handler returns
5153 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5154 // and so we manually check if we don't have a child window under mouse and if
5155 // we do, send the event to it instead of the window Windows had sent WM_XXX
5158 // Notice that this is not done for the mouse move events because this could
5159 // (would?) be too slow, but only for clicks which means that the static texts
5160 // still don't get move, enter nor leave events.
5161 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5163 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
5165 // first try to find a non transparent child: this allows us to send events
5166 // to a static text which is inside a static box, for example
5167 POINT pt
= { *x
, *y
};
5168 HWND hwnd
= GetHwndOf(win
),
5172 hwndUnderMouse
= ::ChildWindowFromPoint
5178 hwndUnderMouse
= ::ChildWindowFromPointEx
5188 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5190 // now try any child window at all
5191 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5194 // check that we have a child window which is susceptible to receive mouse
5195 // events: for this it must be shown and enabled
5196 if ( hwndUnderMouse
&&
5197 hwndUnderMouse
!= hwnd
&&
5198 ::IsWindowVisible(hwndUnderMouse
) &&
5199 ::IsWindowEnabled(hwndUnderMouse
) )
5201 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
5202 if ( winUnderMouse
)
5204 // translate the mouse coords to the other window coords
5205 win
->ClientToScreen(x
, y
);
5206 winUnderMouse
->ScreenToClient(x
, y
);
5208 win
= winUnderMouse
;
5214 #endif // __WXWINCE__
5216 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5218 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5219 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5220 // from the message id and take the value in the table to get wxWin event
5222 static const wxEventType eventsMouse
[] =
5233 wxEVT_MIDDLE_DCLICK
,
5234 0, // this one is for wxEVT_MOTION which is not used here
5243 #ifdef wxHAS_XBUTTON
5244 // the same messages are used for both auxillary mouse buttons so we need
5245 // to adjust the index manually
5248 case WM_XBUTTONDOWN
:
5250 case WM_XBUTTONDBLCLK
:
5251 if ( flags
& MK_XBUTTON2
)
5252 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5254 #endif // wxHAS_XBUTTON
5256 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5257 InitMouseEvent(event
, x
, y
, flags
);
5259 return HandleWindowEvent(event
);
5262 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5264 if ( !m_mouseInWindow
)
5266 // it would be wrong to assume that just because we get a mouse move
5267 // event that the mouse is inside the window: although this is usually
5268 // true, it is not if we had captured the mouse, so we need to check
5269 // the mouse coordinates here
5270 if ( !HasCapture() || IsMouseInWindow() )
5272 // Generate an ENTER event
5273 m_mouseInWindow
= true;
5275 #ifdef HAVE_TRACKMOUSEEVENT
5276 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5278 static const _TrackMouseEvent_t
5279 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5280 #else // !__WXWINCE__
5281 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5282 static bool s_initDone
= false;
5287 wxDynamicLibrary
dllComCtl32(_T("comctl32.dll"), wxDL_VERBATIM
);
5288 if ( dllComCtl32
.IsLoaded() )
5290 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5291 dllComCtl32
.GetSymbol(_T("_TrackMouseEvent"));
5296 // notice that it's ok to unload comctl32.dll here as it won't
5297 // be really unloaded, being still in use because we link to it
5301 if ( s_pfn_TrackMouseEvent
)
5302 #endif // __WXWINCE__/!__WXWINCE__
5304 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5306 trackinfo
.dwFlags
= TME_LEAVE
;
5307 trackinfo
.hwndTrack
= GetHwnd();
5309 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5311 #endif // HAVE_TRACKMOUSEEVENT
5313 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5314 InitMouseEvent(event
, x
, y
, flags
);
5316 (void)HandleWindowEvent(event
);
5319 #ifdef HAVE_TRACKMOUSEEVENT
5320 else // mouse not in window
5322 // Check if we need to send a LEAVE event
5323 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5324 // send it here if we are using native mouse leave tracking
5325 if ( HasCapture() && !IsMouseInWindow() )
5327 GenerateMouseLeave();
5330 #endif // HAVE_TRACKMOUSEEVENT
5332 #if wxUSE_MOUSEEVENT_HACK
5333 // Windows often generates mouse events even if mouse position hasn't
5334 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5336 // Filter this out as it can result in unexpected behaviour compared to
5338 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5339 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5340 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5341 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5343 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5345 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5350 #endif // wxUSE_MOUSEEVENT_HACK
5352 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5356 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5358 #if wxUSE_MOUSEWHEEL
5359 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5360 // forwarded up to the parent by DefWindowProc()) and not in the client
5361 // ones as all the other messages, translate them to the client coords for
5364 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5365 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5366 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5367 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5368 event
.m_wheelDelta
= WHEEL_DELTA
;
5370 static int s_linesPerRotation
= -1;
5371 if ( s_linesPerRotation
== -1 )
5373 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5374 &s_linesPerRotation
, 0))
5376 // this is not supposed to happen
5377 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5379 // the default is 3, so use it if SystemParametersInfo() failed
5380 s_linesPerRotation
= 3;
5384 event
.m_linesPerAction
= s_linesPerRotation
;
5385 return HandleWindowEvent(event
);
5387 #else // !wxUSE_MOUSEWHEEL
5388 wxUnusedVar(wParam
);
5389 wxUnusedVar(lParam
);
5392 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5395 void wxWindowMSW::GenerateMouseLeave()
5397 m_mouseInWindow
= false;
5400 if ( wxIsShiftDown() )
5402 if ( wxIsCtrlDown() )
5403 state
|= MK_CONTROL
;
5405 // Only the high-order bit should be tested
5406 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5407 state
|= MK_LBUTTON
;
5408 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5409 state
|= MK_MBUTTON
;
5410 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5411 state
|= MK_RBUTTON
;
5415 if ( !::GetCursorPosWinCE(&pt
) )
5417 if ( !::GetCursorPos(&pt
) )
5420 wxLogLastError(_T("GetCursorPos"));
5423 // we need to have client coordinates here for symmetry with
5424 // wxEVT_ENTER_WINDOW
5425 RECT rect
= wxGetWindowRect(GetHwnd());
5429 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5430 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5432 (void)HandleWindowEvent(event
);
5435 // ---------------------------------------------------------------------------
5436 // keyboard handling
5437 // ---------------------------------------------------------------------------
5439 // create the key event of the given type for the given key - used by
5440 // HandleChar and HandleKeyDown/Up
5441 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5444 WXWPARAM wParam
) const
5446 wxKeyEvent
event(evType
);
5447 event
.SetId(GetId());
5448 event
.m_shiftDown
= wxIsShiftDown();
5449 event
.m_controlDown
= wxIsCtrlDown();
5450 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5452 event
.SetEventObject((wxWindow
*)this); // const_cast
5453 event
.m_keyCode
= id
;
5455 event
.m_uniChar
= (wxChar
) wParam
;
5457 event
.m_rawCode
= (wxUint32
) wParam
;
5458 event
.m_rawFlags
= (wxUint32
) lParam
;
5460 event
.SetTimestamp(::GetMessageTime());
5463 // translate the position to client coords
5466 GetCursorPosWinCE(&pt
);
5471 GetWindowRect(GetHwnd(),&rect
);
5481 // isASCII is true only when we're called from WM_CHAR handler and not from
5483 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5490 else // we're called from WM_KEYDOWN
5492 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5493 // to get numpad key codes: CHAR events should use the logical keys
5494 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5495 id
= wxCharCodeMSWToWX(wParam
);
5498 // it's ASCII and will be processed here only when called from
5499 // WM_CHAR (i.e. when isASCII = true), don't process it now
5504 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5506 // the alphanumeric keys produced by pressing AltGr+something on European
5507 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5508 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5509 // alphanumeric, so pretend that there are no modifiers at all (the
5510 // KEY_DOWN event would still have the correct modifiers if they're really
5512 if ( event
.m_controlDown
&& event
.m_altDown
&&
5513 (id
>= 32 && id
< 256) )
5515 event
.m_controlDown
=
5516 event
.m_altDown
= false;
5519 return HandleWindowEvent(event
);
5522 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5524 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5528 // normal ASCII char
5532 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5533 return HandleWindowEvent(event
);
5536 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5538 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5542 // normal ASCII char
5546 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5547 return HandleWindowEvent(event
);
5551 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5552 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5554 // FIXME: implement GetMenuItemCount for WinCE, possibly
5555 // in terms of GetMenuItemInfo
5557 const HMENU hmenu
= (HMENU
)lParam
;
5561 mii
.cbSize
= sizeof(MENUITEMINFO
);
5563 // we could use MIIM_FTYPE here as we only need to know if the item is
5564 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5565 // MIIM_FTYPE is not supported under Win95
5566 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5568 // find if we have this letter in any owner drawn item
5569 const int count
= ::GetMenuItemCount(hmenu
);
5570 for ( int i
= 0; i
< count
; i
++ )
5572 // previous loop iteration could modify it, reset it back before
5573 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5576 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5578 if ( mii
.fType
== MFT_OWNERDRAW
)
5580 // dwItemData member of the MENUITEMINFO is a
5581 // pointer to the associated wxMenuItem -- see the
5582 // menu creation code
5583 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5585 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), _T('&'));
5588 if ( *p
== _T('&') )
5590 // this is not the accel char, find the real one
5591 p
= wxStrchr(p
+ 1, _T('&'));
5593 else // got the accel char
5595 // FIXME-UNICODE: this comparison doesn't risk to work
5596 // for non ASCII accelerator characters I'm afraid, but
5598 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5604 // this one doesn't match
5611 else // failed to get the menu text?
5613 // it's not fatal, so don't show error, but still log it
5614 wxLogLastError(_T("GetMenuItemInfo"));
5621 bool wxWindowMSW::HandleClipboardEvent( WXUINT nMsg
)
5623 const wxEventType type
= ( nMsg
== WM_CUT
) ? wxEVT_COMMAND_TEXT_CUT
:
5624 ( nMsg
== WM_COPY
) ? wxEVT_COMMAND_TEXT_COPY
:
5625 /*( nMsg == WM_PASTE ) ? */ wxEVT_COMMAND_TEXT_PASTE
;
5626 wxClipboardTextEvent
evt(type
, GetId());
5628 evt
.SetEventObject(this);
5630 return HandleWindowEvent(evt
);
5632 #endif // wxUSE_MENUS
5634 // ---------------------------------------------------------------------------
5636 // ---------------------------------------------------------------------------
5638 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5642 if ( flags
& JOY_BUTTON1CHG
)
5643 change
= wxJOY_BUTTON1
;
5644 if ( flags
& JOY_BUTTON2CHG
)
5645 change
= wxJOY_BUTTON2
;
5646 if ( flags
& JOY_BUTTON3CHG
)
5647 change
= wxJOY_BUTTON3
;
5648 if ( flags
& JOY_BUTTON4CHG
)
5649 change
= wxJOY_BUTTON4
;
5652 if ( flags
& JOY_BUTTON1
)
5653 buttons
|= wxJOY_BUTTON1
;
5654 if ( flags
& JOY_BUTTON2
)
5655 buttons
|= wxJOY_BUTTON2
;
5656 if ( flags
& JOY_BUTTON3
)
5657 buttons
|= wxJOY_BUTTON3
;
5658 if ( flags
& JOY_BUTTON4
)
5659 buttons
|= wxJOY_BUTTON4
;
5661 // the event ids aren't consecutive so we can't use table based lookup
5663 wxEventType eventType
;
5668 eventType
= wxEVT_JOY_MOVE
;
5673 eventType
= wxEVT_JOY_MOVE
;
5678 eventType
= wxEVT_JOY_ZMOVE
;
5683 eventType
= wxEVT_JOY_ZMOVE
;
5686 case MM_JOY1BUTTONDOWN
:
5688 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5691 case MM_JOY2BUTTONDOWN
:
5693 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5696 case MM_JOY1BUTTONUP
:
5698 eventType
= wxEVT_JOY_BUTTON_UP
;
5701 case MM_JOY2BUTTONUP
:
5703 eventType
= wxEVT_JOY_BUTTON_UP
;
5707 wxFAIL_MSG(wxT("no such joystick event"));
5712 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5713 event
.SetPosition(wxPoint(x
, y
));
5714 event
.SetEventObject(this);
5716 return HandleWindowEvent(event
);
5726 // ---------------------------------------------------------------------------
5728 // ---------------------------------------------------------------------------
5730 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5731 WXWORD pos
, WXHWND control
)
5733 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5735 wxWindow
*child
= wxFindWinFromHandle(control
);
5737 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5740 wxScrollWinEvent event
;
5741 event
.SetPosition(pos
);
5742 event
.SetOrientation(orientation
);
5743 event
.SetEventObject(this);
5748 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5752 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5756 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5760 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5764 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5768 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5771 case SB_THUMBPOSITION
:
5773 // under Win32, the scrollbar range and position are 32 bit integers,
5774 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5775 // explicitly query the scrollbar for the correct position (this must
5776 // be done only for these two SB_ events as they are the only one
5777 // carrying the scrollbar position)
5779 WinStruct
<SCROLLINFO
> scrollInfo
;
5780 scrollInfo
.fMask
= SIF_TRACKPOS
;
5782 if ( !::GetScrollInfo(GetHwnd(),
5783 orientation
== wxHORIZONTAL
? SB_HORZ
5787 // Not necessarily an error, if there are no scrollbars yet.
5788 // wxLogLastError(_T("GetScrollInfo"));
5791 event
.SetPosition(scrollInfo
.nTrackPos
);
5794 event
.SetEventType( wParam
== SB_THUMBPOSITION
5795 ? wxEVT_SCROLLWIN_THUMBRELEASE
5796 : wxEVT_SCROLLWIN_THUMBTRACK
);
5803 return HandleWindowEvent(event
);
5806 // ----------------------------------------------------------------------------
5807 // custom message handlers
5808 // ----------------------------------------------------------------------------
5811 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5813 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5814 false, _T("registering handler for the same message twice") );
5816 gs_messageHandlers
[msg
] = handler
;
5821 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5823 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5824 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5825 _T("unregistering non-registered handler?") );
5827 gs_messageHandlers
.erase(i
);
5830 // ===========================================================================
5832 // ===========================================================================
5834 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5837 HDC dc
= ::GetDC((HWND
) wnd
);
5840 // the_font.UseResource();
5841 // the_font.RealizeResource();
5842 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5844 was
= (HFONT
) SelectObject(dc
,fnt
);
5846 GetTextMetrics(dc
, &tm
);
5849 SelectObject(dc
,was
);
5851 ReleaseDC((HWND
)wnd
, dc
);
5854 *x
= tm
.tmAveCharWidth
;
5856 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5858 // the_font.ReleaseResource();
5861 // use the "extended" bit (24) of lParam to distinguish extended keys
5862 // from normal keys as the same key is sent
5864 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5866 // except that if lParam is 0, it means we don't have real lParam from
5867 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5868 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5869 // non-numpad (hence extended) key as this is a more common case
5870 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5873 // this array contains the Windows virtual key codes which map one to one to
5874 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5876 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5877 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5878 static const struct wxKeyMapping
5882 } gs_specialKeys
[] =
5884 { VK_CANCEL
, WXK_CANCEL
},
5885 { VK_BACK
, WXK_BACK
},
5886 { VK_TAB
, WXK_TAB
},
5887 { VK_CLEAR
, WXK_CLEAR
},
5888 { VK_SHIFT
, WXK_SHIFT
},
5889 { VK_CONTROL
, WXK_CONTROL
},
5890 { VK_MENU
, WXK_ALT
},
5891 { VK_PAUSE
, WXK_PAUSE
},
5892 { VK_CAPITAL
, WXK_CAPITAL
},
5893 { VK_SPACE
, WXK_SPACE
},
5894 { VK_ESCAPE
, WXK_ESCAPE
},
5895 { VK_SELECT
, WXK_SELECT
},
5896 { VK_PRINT
, WXK_PRINT
},
5897 { VK_EXECUTE
, WXK_EXECUTE
},
5898 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5899 { VK_HELP
, WXK_HELP
},
5901 { VK_NUMPAD0
, WXK_NUMPAD0
},
5902 { VK_NUMPAD1
, WXK_NUMPAD1
},
5903 { VK_NUMPAD2
, WXK_NUMPAD2
},
5904 { VK_NUMPAD3
, WXK_NUMPAD3
},
5905 { VK_NUMPAD4
, WXK_NUMPAD4
},
5906 { VK_NUMPAD5
, WXK_NUMPAD5
},
5907 { VK_NUMPAD6
, WXK_NUMPAD6
},
5908 { VK_NUMPAD7
, WXK_NUMPAD7
},
5909 { VK_NUMPAD8
, WXK_NUMPAD8
},
5910 { VK_NUMPAD9
, WXK_NUMPAD9
},
5911 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5912 { VK_ADD
, WXK_NUMPAD_ADD
},
5913 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5914 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5915 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5926 { VK_F10
, WXK_F10
},
5927 { VK_F11
, WXK_F11
},
5928 { VK_F12
, WXK_F12
},
5929 { VK_F13
, WXK_F13
},
5930 { VK_F14
, WXK_F14
},
5931 { VK_F15
, WXK_F15
},
5932 { VK_F16
, WXK_F16
},
5933 { VK_F17
, WXK_F17
},
5934 { VK_F18
, WXK_F18
},
5935 { VK_F19
, WXK_F19
},
5936 { VK_F20
, WXK_F20
},
5937 { VK_F21
, WXK_F21
},
5938 { VK_F22
, WXK_F22
},
5939 { VK_F23
, WXK_F23
},
5940 { VK_F24
, WXK_F24
},
5942 { VK_NUMLOCK
, WXK_NUMLOCK
},
5943 { VK_SCROLL
, WXK_SCROLL
},
5946 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5947 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5948 { VK_APPS
, WXK_WINDOWS_MENU
},
5949 #endif // VK_APPS defined
5952 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5953 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5954 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5956 // check the table first
5957 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5959 if ( gs_specialKeys
[n
].vk
== vk
)
5960 return gs_specialKeys
[n
].wxk
;
5963 // keys requiring special handling
5967 // the mapping for these keys may be incorrect on non-US keyboards so
5968 // maybe we shouldn't map them to ASCII values at all
5969 case VK_OEM_1
: wxk
= ';'; break;
5970 case VK_OEM_PLUS
: wxk
= '+'; break;
5971 case VK_OEM_COMMA
: wxk
= ','; break;
5972 case VK_OEM_MINUS
: wxk
= '-'; break;
5973 case VK_OEM_PERIOD
: wxk
= '.'; break;
5974 case VK_OEM_2
: wxk
= '/'; break;
5975 case VK_OEM_3
: wxk
= '~'; break;
5976 case VK_OEM_4
: wxk
= '['; break;
5977 case VK_OEM_5
: wxk
= '\\'; break;
5978 case VK_OEM_6
: wxk
= ']'; break;
5979 case VK_OEM_7
: wxk
= '\''; break;
5981 // handle extended keys
5983 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5987 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
5991 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
5995 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
5999 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6003 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6007 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6011 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6015 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6019 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6023 // don't use ChooseNormalOrExtended() here as the keys are reversed
6024 // here: numpad enter is the extended one
6025 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6035 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
6040 // check the table first
6041 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6043 if ( gs_specialKeys
[n
].wxk
== wxk
)
6044 return gs_specialKeys
[n
].vk
;
6047 // and then check for special keys not included in the table
6052 case WXK_NUMPAD_PAGEUP
:
6057 case WXK_NUMPAD_PAGEDOWN
:
6062 case WXK_NUMPAD_END
:
6067 case WXK_NUMPAD_HOME
:
6072 case WXK_NUMPAD_LEFT
:
6082 case WXK_NUMPAD_RIGHT
:
6087 case WXK_NUMPAD_DOWN
:
6092 case WXK_NUMPAD_INSERT
:
6097 case WXK_NUMPAD_DELETE
:
6102 // check to see if its one of the OEM key codes.
6103 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6119 #ifndef SM_SWAPBUTTON
6120 #define SM_SWAPBUTTON 23
6123 // small helper for wxGetKeyState() and wxGetMouseState()
6124 static inline bool wxIsKeyDown(WXWORD vk
)
6129 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_RBUTTON
;
6132 if (GetSystemMetrics(SM_SWAPBUTTON
)) vk
= VK_LBUTTON
;
6135 // the low order bit indicates whether the key was pressed since the last
6136 // call and the high order one indicates whether it is down right now and
6137 // we only want that one
6138 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6141 bool wxGetKeyState(wxKeyCode key
)
6143 // although this does work under Windows, it is not supported under other
6144 // platforms so don't allow it, you must use wxGetMouseState() instead
6145 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6146 key
!= VK_RBUTTON
&&
6148 wxT("can't use wxGetKeyState() for mouse buttons") );
6150 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6152 // if the requested key is a LED key, return true if the led is pressed
6153 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6155 // low order bit means LED is highlighted and high order one means the
6156 // key is down; for compatibility with the other ports return true if
6157 // either one is set
6158 return GetKeyState(vk
) != 0;
6163 return wxIsKeyDown(vk
);
6168 wxMouseState
wxGetMouseState()
6172 GetCursorPos( &pt
);
6176 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6177 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6178 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6179 #ifdef wxHAS_XBUTTON
6180 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6181 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6182 #endif // wxHAS_XBUTTON
6184 ms
.SetControlDown(wxIsCtrlDown ());
6185 ms
.SetShiftDown (wxIsShiftDown());
6186 ms
.SetAltDown (wxIsAltDown ());
6187 // ms.SetMetaDown();
6193 wxWindow
*wxGetActiveWindow()
6195 HWND hWnd
= GetActiveWindow();
6198 return wxFindWinFromHandle((WXHWND
) hWnd
);
6203 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6205 HWND hwnd
= (HWND
)hWnd
;
6207 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6208 // by code in msw/radiobox.cpp), for all the others we just search up the
6210 wxWindow
*win
= (wxWindow
*)NULL
;
6213 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6217 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6218 // wxWindow class which overrides WM_GETDLGCODE processing to
6219 // do it as well, win would be already non NULL
6220 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6222 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6224 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6225 #endif // wxUSE_RADIOBOX
6227 // spin control text buddy window should be mapped to spin ctrl
6228 // itself so try it too
6229 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6232 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6234 #endif // wxUSE_SPINCTRL
6238 while ( hwnd
&& !win
)
6240 // this is a really ugly hack needed to avoid mistakenly returning the
6241 // parent frame wxWindow for the find/replace modeless dialog HWND -
6242 // this, in turn, is needed to call IsDialogMessage() from
6243 // wxApp::ProcessMessage() as for this we must return NULL from here
6245 // FIXME: this is clearly not the best way to do it but I think we'll
6246 // need to change HWND <-> wxWindow code more heavily than I can
6247 // do it now to fix it
6248 #ifndef __WXMICROWIN__
6249 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6251 // it's a dialog box, don't go upwards
6256 hwnd
= ::GetParent(hwnd
);
6257 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
6263 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6265 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6266 // in active frames and dialogs, regardless of where the focus is.
6267 static HHOOK wxTheKeyboardHook
= 0;
6268 static FARPROC wxTheKeyboardHookProc
= 0;
6269 int APIENTRY _EXPORT
6270 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
6272 void wxSetKeyboardHook(bool doIt
)
6276 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
6277 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
6279 GetCurrentThreadId()
6280 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
6285 UnhookWindowsHookEx(wxTheKeyboardHook
);
6289 int APIENTRY _EXPORT
6290 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6292 DWORD hiWord
= HIWORD(lParam
);
6293 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6295 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6298 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6299 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6300 event
.m_altDown
= true;
6302 event
.SetEventObject(NULL
);
6303 event
.m_keyCode
= id
;
6304 event
.m_shiftDown
= wxIsShiftDown();
6305 event
.m_controlDown
= wxIsCtrlDown();
6307 event
.SetTimestamp(::GetMessageTime());
6309 wxWindow
*win
= wxGetActiveWindow();
6310 wxEvtHandler
*handler
;
6313 handler
= win
->GetEventHandler();
6314 event
.SetId(win
->GetId());
6319 event
.SetId(wxID_ANY
);
6322 if ( handler
&& handler
->ProcessEvent(event
) )
6330 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6333 #endif // !__WXMICROWIN__
6336 const wxChar
*wxGetMessageName(int message
)
6340 case 0x0000: return wxT("WM_NULL");
6341 case 0x0001: return wxT("WM_CREATE");
6342 case 0x0002: return wxT("WM_DESTROY");
6343 case 0x0003: return wxT("WM_MOVE");
6344 case 0x0005: return wxT("WM_SIZE");
6345 case 0x0006: return wxT("WM_ACTIVATE");
6346 case 0x0007: return wxT("WM_SETFOCUS");
6347 case 0x0008: return wxT("WM_KILLFOCUS");
6348 case 0x000A: return wxT("WM_ENABLE");
6349 case 0x000B: return wxT("WM_SETREDRAW");
6350 case 0x000C: return wxT("WM_SETTEXT");
6351 case 0x000D: return wxT("WM_GETTEXT");
6352 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6353 case 0x000F: return wxT("WM_PAINT");
6354 case 0x0010: return wxT("WM_CLOSE");
6355 case 0x0011: return wxT("WM_QUERYENDSESSION");
6356 case 0x0012: return wxT("WM_QUIT");
6357 case 0x0013: return wxT("WM_QUERYOPEN");
6358 case 0x0014: return wxT("WM_ERASEBKGND");
6359 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6360 case 0x0016: return wxT("WM_ENDSESSION");
6361 case 0x0017: return wxT("WM_SYSTEMERROR");
6362 case 0x0018: return wxT("WM_SHOWWINDOW");
6363 case 0x0019: return wxT("WM_CTLCOLOR");
6364 case 0x001A: return wxT("WM_WININICHANGE");
6365 case 0x001B: return wxT("WM_DEVMODECHANGE");
6366 case 0x001C: return wxT("WM_ACTIVATEAPP");
6367 case 0x001D: return wxT("WM_FONTCHANGE");
6368 case 0x001E: return wxT("WM_TIMECHANGE");
6369 case 0x001F: return wxT("WM_CANCELMODE");
6370 case 0x0020: return wxT("WM_SETCURSOR");
6371 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6372 case 0x0022: return wxT("WM_CHILDACTIVATE");
6373 case 0x0023: return wxT("WM_QUEUESYNC");
6374 case 0x0024: return wxT("WM_GETMINMAXINFO");
6375 case 0x0026: return wxT("WM_PAINTICON");
6376 case 0x0027: return wxT("WM_ICONERASEBKGND");
6377 case 0x0028: return wxT("WM_NEXTDLGCTL");
6378 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6379 case 0x002B: return wxT("WM_DRAWITEM");
6380 case 0x002C: return wxT("WM_MEASUREITEM");
6381 case 0x002D: return wxT("WM_DELETEITEM");
6382 case 0x002E: return wxT("WM_VKEYTOITEM");
6383 case 0x002F: return wxT("WM_CHARTOITEM");
6384 case 0x0030: return wxT("WM_SETFONT");
6385 case 0x0031: return wxT("WM_GETFONT");
6386 case 0x0037: return wxT("WM_QUERYDRAGICON");
6387 case 0x0039: return wxT("WM_COMPAREITEM");
6388 case 0x0041: return wxT("WM_COMPACTING");
6389 case 0x0044: return wxT("WM_COMMNOTIFY");
6390 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6391 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6392 case 0x0048: return wxT("WM_POWER");
6394 case 0x004A: return wxT("WM_COPYDATA");
6395 case 0x004B: return wxT("WM_CANCELJOURNAL");
6396 case 0x004E: return wxT("WM_NOTIFY");
6397 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6398 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6399 case 0x0052: return wxT("WM_TCARD");
6400 case 0x0053: return wxT("WM_HELP");
6401 case 0x0054: return wxT("WM_USERCHANGED");
6402 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6403 case 0x007B: return wxT("WM_CONTEXTMENU");
6404 case 0x007C: return wxT("WM_STYLECHANGING");
6405 case 0x007D: return wxT("WM_STYLECHANGED");
6406 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6407 case 0x007F: return wxT("WM_GETICON");
6408 case 0x0080: return wxT("WM_SETICON");
6410 case 0x0081: return wxT("WM_NCCREATE");
6411 case 0x0082: return wxT("WM_NCDESTROY");
6412 case 0x0083: return wxT("WM_NCCALCSIZE");
6413 case 0x0084: return wxT("WM_NCHITTEST");
6414 case 0x0085: return wxT("WM_NCPAINT");
6415 case 0x0086: return wxT("WM_NCACTIVATE");
6416 case 0x0087: return wxT("WM_GETDLGCODE");
6417 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6418 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6419 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6420 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6421 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6422 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6423 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6424 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6425 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6426 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6428 case 0x00B0: return wxT("EM_GETSEL");
6429 case 0x00B1: return wxT("EM_SETSEL");
6430 case 0x00B2: return wxT("EM_GETRECT");
6431 case 0x00B3: return wxT("EM_SETRECT");
6432 case 0x00B4: return wxT("EM_SETRECTNP");
6433 case 0x00B5: return wxT("EM_SCROLL");
6434 case 0x00B6: return wxT("EM_LINESCROLL");
6435 case 0x00B7: return wxT("EM_SCROLLCARET");
6436 case 0x00B8: return wxT("EM_GETMODIFY");
6437 case 0x00B9: return wxT("EM_SETMODIFY");
6438 case 0x00BA: return wxT("EM_GETLINECOUNT");
6439 case 0x00BB: return wxT("EM_LINEINDEX");
6440 case 0x00BC: return wxT("EM_SETHANDLE");
6441 case 0x00BD: return wxT("EM_GETHANDLE");
6442 case 0x00BE: return wxT("EM_GETTHUMB");
6443 case 0x00C1: return wxT("EM_LINELENGTH");
6444 case 0x00C2: return wxT("EM_REPLACESEL");
6445 case 0x00C4: return wxT("EM_GETLINE");
6446 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6447 case 0x00C6: return wxT("EM_CANUNDO");
6448 case 0x00C7: return wxT("EM_UNDO");
6449 case 0x00C8: return wxT("EM_FMTLINES");
6450 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6451 case 0x00CB: return wxT("EM_SETTABSTOPS");
6452 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6453 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6454 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6455 case 0x00CF: return wxT("EM_SETREADONLY");
6456 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6457 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6458 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6459 case 0x00D3: return wxT("EM_SETMARGINS");
6460 case 0x00D4: return wxT("EM_GETMARGINS");
6461 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6462 case 0x00D6: return wxT("EM_POSFROMCHAR");
6463 case 0x00D7: return wxT("EM_CHARFROMPOS");
6464 case 0x00D8: return wxT("EM_SETIMESTATUS");
6465 case 0x00D9: return wxT("EM_GETIMESTATUS");
6467 case 0x0100: return wxT("WM_KEYDOWN");
6468 case 0x0101: return wxT("WM_KEYUP");
6469 case 0x0102: return wxT("WM_CHAR");
6470 case 0x0103: return wxT("WM_DEADCHAR");
6471 case 0x0104: return wxT("WM_SYSKEYDOWN");
6472 case 0x0105: return wxT("WM_SYSKEYUP");
6473 case 0x0106: return wxT("WM_SYSCHAR");
6474 case 0x0107: return wxT("WM_SYSDEADCHAR");
6475 case 0x0108: return wxT("WM_KEYLAST");
6477 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6478 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6479 case 0x010F: return wxT("WM_IME_COMPOSITION");
6481 case 0x0110: return wxT("WM_INITDIALOG");
6482 case 0x0111: return wxT("WM_COMMAND");
6483 case 0x0112: return wxT("WM_SYSCOMMAND");
6484 case 0x0113: return wxT("WM_TIMER");
6485 case 0x0114: return wxT("WM_HSCROLL");
6486 case 0x0115: return wxT("WM_VSCROLL");
6487 case 0x0116: return wxT("WM_INITMENU");
6488 case 0x0117: return wxT("WM_INITMENUPOPUP");
6489 case 0x011F: return wxT("WM_MENUSELECT");
6490 case 0x0120: return wxT("WM_MENUCHAR");
6491 case 0x0121: return wxT("WM_ENTERIDLE");
6493 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6494 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6495 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6496 case 0x0135: return wxT("WM_CTLCOLORBTN");
6497 case 0x0136: return wxT("WM_CTLCOLORDLG");
6498 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6499 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6500 case 0x01E1: return wxT("MN_GETHMENU");
6502 case 0x0200: return wxT("WM_MOUSEMOVE");
6503 case 0x0201: return wxT("WM_LBUTTONDOWN");
6504 case 0x0202: return wxT("WM_LBUTTONUP");
6505 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6506 case 0x0204: return wxT("WM_RBUTTONDOWN");
6507 case 0x0205: return wxT("WM_RBUTTONUP");
6508 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6509 case 0x0207: return wxT("WM_MBUTTONDOWN");
6510 case 0x0208: return wxT("WM_MBUTTONUP");
6511 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6512 case 0x020A: return wxT("WM_MOUSEWHEEL");
6513 case 0x020B: return wxT("WM_XBUTTONDOWN");
6514 case 0x020C: return wxT("WM_XBUTTONUP");
6515 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6516 case 0x0210: return wxT("WM_PARENTNOTIFY");
6517 case 0x0211: return wxT("WM_ENTERMENULOOP");
6518 case 0x0212: return wxT("WM_EXITMENULOOP");
6520 case 0x0213: return wxT("WM_NEXTMENU");
6521 case 0x0214: return wxT("WM_SIZING");
6522 case 0x0215: return wxT("WM_CAPTURECHANGED");
6523 case 0x0216: return wxT("WM_MOVING");
6524 case 0x0218: return wxT("WM_POWERBROADCAST");
6525 case 0x0219: return wxT("WM_DEVICECHANGE");
6527 case 0x0220: return wxT("WM_MDICREATE");
6528 case 0x0221: return wxT("WM_MDIDESTROY");
6529 case 0x0222: return wxT("WM_MDIACTIVATE");
6530 case 0x0223: return wxT("WM_MDIRESTORE");
6531 case 0x0224: return wxT("WM_MDINEXT");
6532 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6533 case 0x0226: return wxT("WM_MDITILE");
6534 case 0x0227: return wxT("WM_MDICASCADE");
6535 case 0x0228: return wxT("WM_MDIICONARRANGE");
6536 case 0x0229: return wxT("WM_MDIGETACTIVE");
6537 case 0x0230: return wxT("WM_MDISETMENU");
6538 case 0x0233: return wxT("WM_DROPFILES");
6540 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6541 case 0x0282: return wxT("WM_IME_NOTIFY");
6542 case 0x0283: return wxT("WM_IME_CONTROL");
6543 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6544 case 0x0285: return wxT("WM_IME_SELECT");
6545 case 0x0286: return wxT("WM_IME_CHAR");
6546 case 0x0290: return wxT("WM_IME_KEYDOWN");
6547 case 0x0291: return wxT("WM_IME_KEYUP");
6549 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6550 case 0x02A1: return wxT("WM_MOUSEHOVER");
6551 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6552 case 0x02A3: return wxT("WM_MOUSELEAVE");
6554 case 0x0300: return wxT("WM_CUT");
6555 case 0x0301: return wxT("WM_COPY");
6556 case 0x0302: return wxT("WM_PASTE");
6557 case 0x0303: return wxT("WM_CLEAR");
6558 case 0x0304: return wxT("WM_UNDO");
6559 case 0x0305: return wxT("WM_RENDERFORMAT");
6560 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6561 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6562 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6563 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6564 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6565 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6566 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6567 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6568 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6569 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6570 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6571 case 0x0311: return wxT("WM_PALETTECHANGED");
6572 case 0x0312: return wxT("WM_HOTKEY");
6574 case 0x0317: return wxT("WM_PRINT");
6575 case 0x0318: return wxT("WM_PRINTCLIENT");
6577 // common controls messages - although they're not strictly speaking
6578 // standard, it's nice to decode them nevertheless
6581 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6582 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6583 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6584 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6585 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6586 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6587 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6588 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6589 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6590 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6591 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6592 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6593 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6594 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6595 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6596 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6597 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6598 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6599 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6600 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6601 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6602 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6603 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6604 case 0x1000 + 18: return wxT("LVM_HITTEST");
6605 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6606 case 0x1000 + 20: return wxT("LVM_SCROLL");
6607 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6608 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6609 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6610 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6611 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6612 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6613 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6614 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6615 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6616 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6617 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6618 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6619 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6620 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6621 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6622 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6623 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6624 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6625 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6626 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6627 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6628 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6629 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6630 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6631 case 0x1000 + 42: return wxT("LVM_UPDATE");
6632 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6633 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6634 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6635 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6636 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6637 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6638 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6639 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6640 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6641 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6642 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6643 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6644 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6645 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6646 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6647 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6648 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6649 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6650 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6651 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6652 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6653 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6654 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6655 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6656 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6657 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6660 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6661 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6662 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6663 case 0x1100 + 2: return wxT("TVM_EXPAND");
6664 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6665 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6666 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6667 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6668 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6669 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6670 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6671 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6672 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6673 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6674 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6675 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6676 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6677 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6678 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6679 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6680 case 0x1100 + 17: return wxT("TVM_HITTEST");
6681 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6682 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6683 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6684 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6685 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6686 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6687 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6688 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6689 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6692 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6693 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6694 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6695 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6696 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6697 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6698 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6699 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6700 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6701 case 0x1200 + 6: return wxT("HDM_HITTEST");
6702 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6703 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6704 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6705 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6706 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6707 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6708 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6709 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6712 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6713 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6714 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6715 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6716 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6717 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6718 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6719 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6720 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6721 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6722 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6723 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6724 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6725 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6726 case 0x1300 + 13: return wxT("TCM_HITTEST");
6727 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6728 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6729 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6730 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6731 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6732 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6733 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6734 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6735 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6736 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6737 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6738 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6741 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6742 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6743 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6744 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6745 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6746 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6747 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6748 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6749 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6750 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6751 case WM_USER
+17: return wxT("TB_SETSTATE");
6752 case WM_USER
+18: return wxT("TB_GETSTATE");
6753 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6754 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6755 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6756 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6757 case WM_USER
+23: return wxT("TB_GETBUTTON");
6758 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6759 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6760 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6761 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6762 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6763 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6764 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6765 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6766 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6767 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6768 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6769 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6770 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6771 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6772 case WM_USER
+37: return wxT("TB_SETPARENT");
6773 case WM_USER
+39: return wxT("TB_SETROWS");
6774 case WM_USER
+40: return wxT("TB_GETROWS");
6775 case WM_USER
+42: return wxT("TB_SETCMDID");
6776 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6777 case WM_USER
+44: return wxT("TB_GETBITMAP");
6778 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6779 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6780 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6781 case WM_USER
+47: return wxT("TB_SETINDENT");
6782 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6783 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6784 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6785 case WM_USER
+51: return wxT("TB_GETRECT");
6786 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6787 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6788 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6789 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6790 case WM_USER
+56: return wxT("TB_SETSTYLE");
6791 case WM_USER
+57: return wxT("TB_GETSTYLE");
6792 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6793 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6794 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6795 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6796 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6799 static wxString s_szBuf
;
6800 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6801 return s_szBuf
.c_str();
6804 #endif //__WXDEBUG__
6806 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6810 HWND hwnd
= GetHwndOf(win
);
6811 HDC hdc
= ::GetDC(hwnd
);
6813 #if !wxDIALOG_UNIT_COMPATIBILITY
6814 // and select the current font into it
6815 HFONT hfont
= GetHfontOf(win
->GetFont());
6818 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6822 // finally retrieve the text metrics from it
6823 GetTextMetrics(hdc
, &tm
);
6825 #if !wxDIALOG_UNIT_COMPATIBILITY
6829 (void)::SelectObject(hdc
, hfont
);
6833 ::ReleaseDC(hwnd
, hdc
);
6838 // Find the wxWindow at the current mouse position, returning the mouse
6840 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6842 pt
= wxGetMousePosition();
6843 return wxFindWindowAtPoint(pt
);
6846 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6852 HWND hWnd
= ::WindowFromPoint(pt2
);
6854 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6857 // Get the current mouse position.
6858 wxPoint
wxGetMousePosition()
6862 GetCursorPosWinCE(&pt
);
6864 GetCursorPos( & pt
);
6867 return wxPoint(pt
.x
, pt
.y
);
6872 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6873 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6875 // Register hotkeys for the hardware buttons
6877 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6879 UnregisterFunc1Proc procUnregisterFunc
;
6880 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6883 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6884 if (procUnregisterFunc
)
6885 procUnregisterFunc(modifiers
, id
);
6886 FreeLibrary(hCoreDll
);
6891 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6893 UINT win_modifiers
=0;
6894 if ( modifiers
& wxMOD_ALT
)
6895 win_modifiers
|= MOD_ALT
;
6896 if ( modifiers
& wxMOD_SHIFT
)
6897 win_modifiers
|= MOD_SHIFT
;
6898 if ( modifiers
& wxMOD_CONTROL
)
6899 win_modifiers
|= MOD_CONTROL
;
6900 if ( modifiers
& wxMOD_WIN
)
6901 win_modifiers
|= MOD_WIN
;
6903 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6904 // Required for PPC and Smartphone hardware buttons
6905 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6906 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6909 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6911 wxLogLastError(_T("RegisterHotKey"));
6919 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6921 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6922 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6925 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6927 wxLogLastError(_T("UnregisterHotKey"));
6937 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6939 int hotkeyId
= wParam
;
6940 int virtualKey
= HIWORD(lParam
);
6941 int win_modifiers
= LOWORD(lParam
);
6943 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6944 event
.SetId(hotkeyId
);
6945 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6946 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6947 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6948 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6950 return HandleWindowEvent(event
);
6953 #endif // wxUSE_ACCEL
6955 #endif // wxUSE_HOTKEY
6957 // Not tested under WinCE
6960 // this class installs a message hook which really wakes up our idle processing
6961 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6962 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6963 // being dragged or even inside ::MessageBox()) and so don't control message
6964 // dispatching otherwise
6965 class wxIdleWakeUpModule
: public wxModule
6968 virtual bool OnInit()
6970 ms_hMsgHookProc
= ::SetWindowsHookEx
6973 &wxIdleWakeUpModule::MsgHookProc
,
6975 GetCurrentThreadId()
6978 if ( !ms_hMsgHookProc
)
6980 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6988 virtual void OnExit()
6990 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
6993 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6995 MSG
*msg
= (MSG
*)lParam
;
6997 // only process the message if it is actually going to be removed from
6998 // the message queue, this prevents that the same event from being
6999 // processed multiple times if now someone just called PeekMessage()
7000 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7002 wxTheApp
->ProcessPendingEvents();
7005 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7009 static HHOOK ms_hMsgHookProc
;
7011 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7014 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7016 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7018 #endif // __WXWINCE__
7023 static void wxAdjustZOrder(wxWindow
* parent
)
7025 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7027 // Set the z-order correctly
7028 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7031 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7034 wxWindow
*childWin
= current
->GetData();
7035 wxAdjustZOrder(childWin
);
7036 current
= current
->GetNext();
7041 // We need to adjust the z-order of static boxes in WinCE, to
7042 // make 'contained' controls visible
7043 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7046 wxAdjustZOrder(this);