1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/window.cpp
3 // Purpose: wxWindowMSW
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #include "wx/window.h"
30 #include "wx/msw/wrapwin.h"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
56 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
60 #include "wx/hashmap.h"
61 #include "wx/evtloop.h"
63 #include "wx/sysopt.h"
65 #if wxUSE_DRAG_AND_DROP
69 #if wxUSE_ACCESSIBILITY
70 #include "wx/access.h"
74 #define WM_GETOBJECT 0x003D
77 #define OBJID_CLIENT 0xFFFFFFFC
81 #include "wx/msw/private.h"
82 #include "wx/msw/dcclient.h"
85 #include "wx/tooltip.h"
93 #include "wx/spinctrl.h"
94 #endif // wxUSE_SPINCTRL
96 #include "wx/notebook.h"
97 #include "wx/listctrl.h"
98 #include "wx/dynlib.h"
102 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
103 #include <shellapi.h>
104 #include <mmsystem.h>
108 #include <windowsx.h>
111 #if !defined __WXWINCE__ && !defined NEED_PBT_H
115 #if defined(__WXWINCE__)
116 #include "wx/msw/wince/missing.h"
119 #include <shellapi.h>
121 #include <aygshell.h>
126 #include "wx/msw/uxtheme.h"
127 #define EP_EDITTEXT 1
130 #define ETS_SELECTED 3
131 #define ETS_DISABLED 4
132 #define ETS_FOCUSED 5
133 #define ETS_READONLY 6
137 // define the constants used by AnimateWindow() if our SDK doesn't have them
139 #define AW_HOR_POSITIVE 0x00000001
140 #define AW_HOR_NEGATIVE 0x00000002
141 #define AW_VER_POSITIVE 0x00000004
142 #define AW_VER_NEGATIVE 0x00000008
143 #define AW_CENTER 0x00000010
144 #define AW_HIDE 0x00010000
145 #define AW_ACTIVATE 0x00020000
146 #define AW_SLIDE 0x00040000
147 #define AW_BLEND 0x00080000
150 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
151 #define HAVE_TRACKMOUSEEVENT
152 #endif // everything needed for TrackMouseEvent()
154 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
155 // when mouse position didnd't change
157 #define wxUSE_MOUSEEVENT_HACK 0
159 #define wxUSE_MOUSEEVENT_HACK 1
162 // not all compilers/platforms have X button related declarations (notably
163 // Windows CE doesn't, and probably some old SDKs don't neither)
164 #ifdef WM_XBUTTONDOWN
165 #define wxHAS_XBUTTON
168 // ---------------------------------------------------------------------------
170 // ---------------------------------------------------------------------------
172 #if wxUSE_MENUS_NATIVE
173 extern wxMenu
*wxCurrentPopupMenu
;
176 // true if we had already created the std colour map, used by
177 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
178 static bool gs_hasStdCmap
= false;
180 // last mouse event information we need to filter out the duplicates
181 #if wxUSE_MOUSEEVENT_HACK
182 static struct MouseEventInfoDummy
184 // mouse position (in screen coordinates)
187 // last mouse event type
190 #endif // wxUSE_MOUSEEVENT_HACK
192 // hash containing the registered handlers for the custom messages
193 WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler
,
194 wxIntegerHash
, wxIntegerEqual
,
197 static MSWMessageHandlers gs_messageHandlers
;
199 // hash containing all our windows, it uses HWND keys and wxWindow* values
200 WX_DECLARE_HASH_MAP(HWND
, wxWindow
*,
201 wxPointerHash
, wxPointerEqual
,
204 static WindowHandles gs_windowHandles
;
206 // ---------------------------------------------------------------------------
208 // ---------------------------------------------------------------------------
210 // the window proc for all our windows
211 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
212 WPARAM wParam
, LPARAM lParam
);
215 #if wxDEBUG_LEVEL >= 2
216 const wxChar
*wxGetMessageName(int message
);
217 #endif // wxDEBUG_LEVEL >= 2
219 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
220 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
222 // get the text metrics for the current font
223 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
226 // find the window for the mouse event at the specified position
227 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
228 #endif // __WXWINCE__
230 // wrapper around BringWindowToTop() API
231 static inline void wxBringWindowToTop(HWND hwnd
)
233 #ifdef __WXMICROWIN__
234 // It seems that MicroWindows brings the _parent_ of the window to the top,
235 // which can be the wrong one.
237 // activate (set focus to) specified window
241 // raise top level parent to top of z order
242 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
244 wxLogLastError(_T("SetWindowPos"));
250 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
251 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
254 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
255 parent as well as otherwise several Win32 functions using
256 GetNextDlgTabItem() to iterate over all controls such as
257 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
258 all of them iterate over all the controls starting from the currently
259 focused one and stop iterating when they get back to the focus but
260 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
261 get back to the initial (focused) window: as we do have this style,
262 GetNextDlgTabItem() will leave this window and continue in its parent,
263 but if the parent doesn't have it, it wouldn't recurse inside it later
264 on and so wouldn't have a chance of getting back to this window either.
266 while ( parent
&& !parent
->IsTopLevel() )
268 LONG exStyle
= wxGetWindowExStyle(parent
);
269 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
271 // force the parent to have this style
272 wxSetWindowExStyle(parent
, exStyle
| WS_EX_CONTROLPARENT
);
275 parent
= parent
->GetParent();
279 #endif // !__WXWINCE__
282 // On Windows CE, GetCursorPos can return an error, so use this function
284 bool GetCursorPosWinCE(POINT
* pt
)
286 if (!GetCursorPos(pt
))
288 DWORD pos
= GetMessagePos();
296 // ---------------------------------------------------------------------------
298 // ---------------------------------------------------------------------------
300 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
302 #ifdef __WXUNIVERSAL__
303 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
305 #if wxUSE_EXTENDED_RTTI
307 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
308 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
309 // windows with negative ids never can be recreated anyway
311 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
313 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
314 if ( win
&& win
->GetId() < 0 )
319 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
321 // make wxWindowList known before the property is used
323 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
325 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
327 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
330 WX_DEFINE_FLAGS( wxWindowStyle
)
332 wxBEGIN_FLAGS( wxWindowStyle
)
333 // new style border flags, we put them first to
334 // use them for streaming out
336 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
337 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
338 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
339 wxFLAGS_MEMBER(wxBORDER_RAISED
)
340 wxFLAGS_MEMBER(wxBORDER_STATIC
)
341 wxFLAGS_MEMBER(wxBORDER_NONE
)
343 // old style border flags
344 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
345 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
346 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
347 wxFLAGS_MEMBER(wxRAISED_BORDER
)
348 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
349 wxFLAGS_MEMBER(wxBORDER
)
351 // standard window styles
352 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
353 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
354 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
355 wxFLAGS_MEMBER(wxWANTS_CHARS
)
356 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
357 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
358 wxFLAGS_MEMBER(wxVSCROLL
)
359 wxFLAGS_MEMBER(wxHSCROLL
)
361 wxEND_FLAGS( wxWindowStyle
)
363 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
364 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
365 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
366 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
367 // Always constructor Properties first
369 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
370 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
371 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
372 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
373 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
375 // Then all relations of the object graph
377 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
379 // and finally all other properties
381 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
382 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
383 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
384 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
385 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
387 // possible property candidates (not in xrc) or not valid in all subclasses
388 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
389 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
390 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
391 // MaxHeight, Width , MinHeight , Width
392 // TODO switch label to control and title to toplevels
394 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
395 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
396 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
397 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
402 wxEND_PROPERTIES_TABLE()
404 wxBEGIN_HANDLERS_TABLE(wxWindow
)
405 wxEND_HANDLERS_TABLE()
407 wxCONSTRUCTOR_DUMMY(wxWindow
)
410 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
412 #endif // __WXUNIVERSAL__/__WXMSW__
414 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
415 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
416 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
418 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
422 // ===========================================================================
424 // ===========================================================================
426 // ---------------------------------------------------------------------------
427 // wxWindow utility functions
428 // ---------------------------------------------------------------------------
430 // Find an item given the MS Windows id
431 wxWindow
*wxWindowMSW::FindItem(long id
) const
434 wxControl
*item
= wxDynamicCastThis(wxControl
);
437 // is it us or one of our "internal" children?
438 if ( item
->GetId() == id
439 #ifndef __WXUNIVERSAL__
440 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
441 #endif // __WXUNIVERSAL__
447 #endif // wxUSE_CONTROLS
449 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
452 wxWindow
*childWin
= current
->GetData();
454 wxWindow
*wnd
= childWin
->FindItem(id
);
458 current
= current
->GetNext();
464 // Find an item given the MS Windows handle
465 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
467 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
470 wxWindow
*parent
= current
->GetData();
472 // Do a recursive search.
473 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
479 || parent
->IsKindOf(CLASSINFO(wxControl
))
480 #endif // wxUSE_CONTROLS
483 wxWindow
*item
= current
->GetData();
484 if ( item
->GetHWND() == hWnd
)
488 if ( item
->ContainsHWND(hWnd
) )
493 current
= current
->GetNext();
498 // Default command handler
499 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
504 // ----------------------------------------------------------------------------
505 // constructors and such
506 // ----------------------------------------------------------------------------
508 void wxWindowMSW::Init()
512 m_mouseInWindow
= false;
513 m_lastKeydownProcessed
= false;
521 m_pendingPosition
= wxDefaultPosition
;
522 m_pendingSize
= wxDefaultSize
;
525 m_contextMenuEnabled
= false;
530 wxWindowMSW::~wxWindowMSW()
534 #ifndef __WXUNIVERSAL__
535 // VS: make sure there's no wxFrame with last focus set to us:
536 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
538 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
541 if ( frame
->GetLastFocus() == this )
543 frame
->SetLastFocus(NULL
);
546 // apparently sometimes we can end up with our grand parent
547 // pointing to us as well: this is surely a bug in focus handling
548 // code but it's not clear where it happens so for now just try to
549 // fix it here by not breaking out of the loop
553 #endif // __WXUNIVERSAL__
555 // VS: destroy children first and _then_ detach *this from its parent.
556 // If we did it the other way around, children wouldn't be able
557 // find their parent frame (see above).
562 // VZ: test temp removed to understand what really happens here
563 //if (::IsWindow(GetHwnd()))
565 if ( !::DestroyWindow(GetHwnd()) )
566 wxLogLastError(wxT("DestroyWindow"));
569 // remove hWnd <-> wxWindow association
570 wxRemoveHandleAssociation(this);
576 const wxChar
*wxWindowMSW::MSWGetRegisteredClassName()
578 return wxApp::GetRegisteredClassName(_T("wxWindow"), COLOR_BTNFACE
);
581 // real construction (Init() must have been called before!)
582 bool wxWindowMSW::Create(wxWindow
*parent
,
587 const wxString
& name
)
589 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
591 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
594 parent
->AddChild(this);
597 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
599 #ifdef __WXUNIVERSAL__
600 // no borders, we draw them ourselves
601 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
605 msflags
&= ~WS_BORDER
;
606 #endif // wxUniversal
610 msflags
|= WS_VISIBLE
;
613 if ( !MSWCreate(MSWGetRegisteredClassName(),
614 NULL
, pos
, size
, msflags
, exstyle
) )
622 // ---------------------------------------------------------------------------
624 // ---------------------------------------------------------------------------
626 void wxWindowMSW::SetFocus()
628 HWND hWnd
= GetHwnd();
629 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
631 #if !defined(__WXWINCE__)
635 if ( !::SetFocus(hWnd
) )
637 // was there really an error?
638 DWORD dwRes
= ::GetLastError();
641 HWND hwndFocus
= ::GetFocus();
642 if ( hwndFocus
!= hWnd
)
644 wxLogApiError(_T("SetFocus"), dwRes
);
650 void wxWindowMSW::SetFocusFromKbd()
652 // when the focus is given to the control with DLGC_HASSETSEL style from
653 // keyboard its contents should be entirely selected: this is what
654 // ::IsDialogMessage() does and so we should do it as well to provide the
655 // same LNF as the native programs
656 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
658 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
661 // do this after (maybe) setting the selection as like this when
662 // wxEVT_SET_FOCUS handler is called, the selection would have been already
663 // set correctly -- this may be important
664 wxWindowBase::SetFocusFromKbd();
667 // Get the window with the focus
668 wxWindow
*wxWindowBase::DoFindFocus()
670 HWND hWnd
= ::GetFocus();
673 return wxGetWindowFromHWND((WXHWND
)hWnd
);
679 void wxWindowMSW::DoEnable( bool enable
)
681 HWND hWnd
= GetHwnd();
683 ::EnableWindow(hWnd
, (BOOL
)enable
);
686 bool wxWindowMSW::Show(bool show
)
688 if ( !wxWindowBase::Show(show
) )
691 HWND hWnd
= GetHwnd();
693 // we could be called before the underlying window is created (this is
694 // actually useful to prevent it from being initially shown), e.g.
696 // wxFoo *foo = new wxFoo;
698 // foo->Create(parent, ...);
700 // should work without errors
703 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
708 // DoFreeze/DoThaw don't do anything if the window is not shown, so
709 // we have to call them from here now
720 wxWindowMSW::MSWShowWithEffect(bool show
,
724 if ( !wxWindowBase::Show(show
) )
727 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
729 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
730 static bool s_initDone
= false;
733 wxDynamicLibrary
dllUser32(_T("user32.dll"), wxDL_VERBATIM
| wxDL_QUIET
);
734 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
738 // notice that it's ok to unload user32.dll here as it won't be really
739 // unloaded, being still in use because we link to it statically too
742 if ( !s_pfnAnimateWindow
)
745 // Show() has a side effect of sending a WM_SIZE to the window, which helps
746 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
747 // this so send the event ourselves
750 // prepare to use AnimateWindow()
753 timeout
= 200; // this is the default animation timeout, per MSDN
755 DWORD dwFlags
= show
? 0 : AW_HIDE
;
759 case wxSHOW_EFFECT_ROLL_TO_LEFT
:
760 dwFlags
|= AW_HOR_NEGATIVE
;
763 case wxSHOW_EFFECT_ROLL_TO_RIGHT
:
764 dwFlags
|= AW_HOR_POSITIVE
;
767 case wxSHOW_EFFECT_ROLL_TO_TOP
:
768 dwFlags
|= AW_VER_NEGATIVE
;
771 case wxSHOW_EFFECT_ROLL_TO_BOTTOM
:
772 dwFlags
|= AW_VER_POSITIVE
;
775 case wxSHOW_EFFECT_SLIDE_TO_LEFT
:
776 dwFlags
|= AW_SLIDE
| AW_HOR_NEGATIVE
;
779 case wxSHOW_EFFECT_SLIDE_TO_RIGHT
:
780 dwFlags
|= AW_SLIDE
| AW_HOR_POSITIVE
;
783 case wxSHOW_EFFECT_SLIDE_TO_TOP
:
784 dwFlags
|= AW_SLIDE
| AW_VER_NEGATIVE
;
787 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM
:
788 dwFlags
|= AW_SLIDE
| AW_VER_POSITIVE
;
791 case wxSHOW_EFFECT_BLEND
:
795 case wxSHOW_EFFECT_EXPAND
:
796 dwFlags
|= AW_CENTER
;
800 case wxSHOW_EFFECT_MAX
:
801 wxFAIL_MSG( _T("invalid window show effect") );
805 wxFAIL_MSG( _T("unknown window show effect") );
809 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
811 wxLogLastError(_T("AnimateWindow"));
819 // Raise the window to the top of the Z order
820 void wxWindowMSW::Raise()
822 wxBringWindowToTop(GetHwnd());
825 // Lower the window to the bottom of the Z order
826 void wxWindowMSW::Lower()
828 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
829 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
832 void wxWindowMSW::DoCaptureMouse()
834 HWND hWnd
= GetHwnd();
841 void wxWindowMSW::DoReleaseMouse()
843 if ( !::ReleaseCapture() )
845 wxLogLastError(_T("ReleaseCapture"));
849 /* static */ wxWindow
*wxWindowBase::GetCapture()
851 HWND hwnd
= ::GetCapture();
852 return hwnd
? wxFindWinFromHandle(hwnd
) : NULL
;
855 bool wxWindowMSW::SetFont(const wxFont
& font
)
857 if ( !wxWindowBase::SetFont(font
) )
863 HWND hWnd
= GetHwnd();
866 // note the use of GetFont() instead of m_font: our own font could have
867 // just been reset and in this case we need to change the font used by
868 // the native window to the default for this class, i.e. exactly what
870 WXHANDLE hFont
= GetFont().GetResourceHandle();
872 wxASSERT_MSG( hFont
, wxT("should have valid font") );
874 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
879 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
881 if ( !wxWindowBase::SetCursor(cursor
) )
887 // don't "overwrite" busy cursor
888 if ( m_cursor
.Ok() && !wxIsBusy() )
890 // normally we should change the cursor only if it's over this window
891 // but we should do it always if we capture the mouse currently
892 bool set
= HasCapture();
895 HWND hWnd
= GetHwnd();
899 ::GetCursorPosWinCE(&point
);
901 ::GetCursorPos(&point
);
904 RECT rect
= wxGetWindowRect(hWnd
);
906 set
= ::PtInRect(&rect
, point
) != 0;
911 ::SetCursor(GetHcursorOf(m_cursor
));
913 //else: will be set later when the mouse enters this window
919 void wxWindowMSW::WarpPointer(int x
, int y
)
921 ClientToScreen(&x
, &y
);
923 if ( !::SetCursorPos(x
, y
) )
925 wxLogLastError(_T("SetCursorPos"));
929 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
931 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
932 // to use it on older systems -- and could possibly do some harm
933 static int s_needToUpdate
= -1;
934 if ( s_needToUpdate
== -1 )
937 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
941 if ( s_needToUpdate
)
943 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
944 // won't send WM_UPDATEUISTATE
945 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
949 // ---------------------------------------------------------------------------
951 // ---------------------------------------------------------------------------
956 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
958 #ifdef __WXMICROWIN__
959 return ::GetScrollPosWX(hWnd
, wOrient
);
961 WinStruct
<SCROLLINFO
> scrollInfo
;
962 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
963 scrollInfo
.fMask
= SIF_POS
;
964 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
966 return scrollInfo
.nPos
;
971 inline UINT
WXOrientToSB(int orient
)
973 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
976 } // anonymous namespace
978 int wxWindowMSW::GetScrollPos(int orient
) const
980 HWND hWnd
= GetHwnd();
981 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
983 return GetScrollPosition(hWnd
, WXOrientToSB(orient
));
986 // This now returns the whole range, not just the number
987 // of positions that we can scroll.
988 int wxWindowMSW::GetScrollRange(int orient
) const
991 HWND hWnd
= GetHwnd();
994 WinStruct
<SCROLLINFO
> scrollInfo
;
995 scrollInfo
.fMask
= SIF_RANGE
;
996 if ( !::GetScrollInfo(hWnd
, WXOrientToSB(orient
), &scrollInfo
) )
998 // Most of the time this is not really an error, since the return
999 // value can also be zero when there is no scrollbar yet.
1000 // wxLogLastError(_T("GetScrollInfo"));
1002 maxPos
= scrollInfo
.nMax
;
1004 // undo "range - 1" done in SetScrollbar()
1008 int wxWindowMSW::GetScrollThumb(int orient
) const
1010 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
1013 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
1015 HWND hWnd
= GetHwnd();
1016 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
1018 WinStruct
<SCROLLINFO
> info
;
1022 info
.fMask
= SIF_POS
;
1023 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1025 // disable scrollbar instead of removing it then
1026 info
.fMask
|= SIF_DISABLENOSCROLL
;
1029 ::SetScrollInfo(hWnd
, WXOrientToSB(orient
), &info
, refresh
);
1032 // New function that will replace some of the above.
1033 void wxWindowMSW::SetScrollbar(int orient
,
1039 // We have to set the variables here to make them valid in events
1040 // triggered by ::SetScrollInfo()
1041 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1043 HWND hwnd
= GetHwnd();
1047 WinStruct
<SCROLLINFO
> info
;
1050 info
.nPage
= pageSize
;
1051 info
.nMin
= 0; // range is nMax - nMin + 1
1052 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1055 // enable the scrollbar if it had been disabled before by specifying
1056 // SIF_DISABLENOSCROLL below: as we can't know whether this had been
1057 // done or not just do it always
1058 ::EnableScrollBar(hwnd
, WXOrientToSB(orient
), ESB_ENABLE_BOTH
);
1060 //else: leave all the fields to be 0
1062 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1063 if ( HasFlag(wxALWAYS_SHOW_SB
) || range
== -1 )
1065 // disable scrollbar instead of removing it then
1066 info
.fMask
|= SIF_DISABLENOSCROLL
;
1069 ::SetScrollInfo(hwnd
, WXOrientToSB(orient
), &info
, refresh
);
1072 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1078 wxCopyRectToRECT(*prect
, rect
);
1088 // FIXME: is this the exact equivalent of the line below?
1089 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1091 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1095 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1097 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1100 for ( int n
= 0; n
< count
; n
++ )
1102 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1104 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1105 if ( posNew
== pos
)
1107 // don't bother to continue, we're already at top/bottom
1114 return pos
!= posStart
;
1117 bool wxWindowMSW::ScrollLines(int lines
)
1119 bool down
= lines
> 0;
1121 return ScrollVertically(GetHwnd(),
1122 down
? SB_LINEDOWN
: SB_LINEUP
,
1123 down
? lines
: -lines
);
1126 bool wxWindowMSW::ScrollPages(int pages
)
1128 bool down
= pages
> 0;
1130 return ScrollVertically(GetHwnd(),
1131 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1132 down
? pages
: -pages
);
1135 // ----------------------------------------------------------------------------
1137 // ----------------------------------------------------------------------------
1139 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1144 wxCHECK_RET( GetHwnd(),
1145 _T("layout direction must be set after window creation") );
1147 LONG styleOld
= wxGetWindowExStyle(this);
1149 LONG styleNew
= styleOld
;
1152 case wxLayout_LeftToRight
:
1153 styleNew
&= ~WS_EX_LAYOUTRTL
;
1156 case wxLayout_RightToLeft
:
1157 styleNew
|= WS_EX_LAYOUTRTL
;
1161 wxFAIL_MSG(_T("unsupported layout direction"));
1165 if ( styleNew
!= styleOld
)
1167 wxSetWindowExStyle(this, styleNew
);
1172 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1175 return wxLayout_Default
;
1177 wxCHECK_MSG( GetHwnd(), wxLayout_Default
, _T("invalid window") );
1179 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL
) ? wxLayout_RightToLeft
1180 : wxLayout_LeftToRight
;
1185 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1186 wxCoord
WXUNUSED(width
),
1187 wxCoord
WXUNUSED(widthTotal
)) const
1189 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1190 // redo it ourselves
1194 // ---------------------------------------------------------------------------
1196 // ---------------------------------------------------------------------------
1198 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1200 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1202 HWND hwnd
= (HWND
)hWnd
;
1203 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1207 wxAssociateWinWithHandle(hwnd
, this);
1209 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1211 // we don't need to subclass the window of our own class (in the Windows
1212 // sense of the word)
1213 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1215 wxSetWindowProc(hwnd
, wxWndProc
);
1219 // don't bother restoring it either: this also makes it easy to
1220 // implement IsOfStandardClass() method which returns true for the
1221 // standard controls and false for the wxWidgets own windows as it can
1222 // simply check m_oldWndProc
1223 m_oldWndProc
= NULL
;
1226 // we're officially created now, send the event
1227 wxWindowCreateEvent
event((wxWindow
*)this);
1228 (void)HandleWindowEvent(event
);
1231 void wxWindowMSW::UnsubclassWin()
1233 wxRemoveHandleAssociation(this);
1235 // Restore old Window proc
1236 HWND hwnd
= GetHwnd();
1241 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1245 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1247 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1250 m_oldWndProc
= NULL
;
1255 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1259 if ( !::DestroyWindow(GetHwnd()) )
1260 wxLogLastError(wxT("DestroyWindow"));
1263 WXHWND wxhwnd
= (WXHWND
)handle
;
1265 // this also calls SetHWND(wxhwnd)
1266 SubclassWin(wxhwnd
);
1269 void wxWindowMSW::DissociateHandle()
1271 // this also calls SetHWND(0) for us
1276 bool wxCheckWindowWndProc(WXHWND hWnd
,
1277 WXFARPROC
WXUNUSED(wndProc
))
1279 const wxString
str(wxGetWindowClass(hWnd
));
1281 // TODO: get rid of wxTLWHiddenParent special case (currently it's not
1282 // registered by wxApp but using ad hoc code in msw/toplevel.cpp);
1283 // there is also a hidden window class used by sockets &c
1284 return wxApp::IsRegisteredClassName(str
) || str
== _T("wxTLWHiddenParent");
1287 // ----------------------------------------------------------------------------
1289 // ----------------------------------------------------------------------------
1291 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1293 long flagsOld
= GetWindowStyleFlag();
1294 if ( flags
== flagsOld
)
1297 // update the internal variable
1298 wxWindowBase::SetWindowStyleFlag(flags
);
1300 // and the real window flags
1301 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1304 void wxWindowMSW::SetExtraStyle(long exflags
)
1306 long exflagsOld
= GetExtraStyle();
1307 if ( exflags
== exflagsOld
)
1310 // update the internal variable
1311 wxWindowBase::SetExtraStyle(exflags
);
1313 // and the real window flags
1314 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1317 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1319 // now update the Windows style as well if needed - and if the window had
1320 // been already created
1324 // we may need to call SetWindowPos() when we change some styles
1325 bool callSWP
= false;
1328 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1330 // this is quite a horrible hack but we need it because MSWGetStyle()
1331 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1332 // and so we have to modify the window exflags temporarily to get the
1333 // correct exstyleOld
1334 long exflagsNew
= GetExtraStyle();
1335 wxWindowBase::SetExtraStyle(exflagsOld
);
1338 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1340 wxWindowBase::SetExtraStyle(exflagsNew
);
1343 if ( style
!= styleOld
)
1345 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1346 // this function so instead of simply setting the style to the new
1347 // value we clear the bits which were set in styleOld but are set in
1348 // the new one and set the ones which were not set before
1349 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1350 styleReal
&= ~styleOld
;
1353 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1355 // we need to call SetWindowPos() if any of the styles affecting the
1356 // frame appearance have changed
1357 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1366 // and the extended style
1367 long exstyleReal
= wxGetWindowExStyle(this);
1369 if ( exstyle
!= exstyleOld
)
1371 exstyleReal
&= ~exstyleOld
;
1372 exstyleReal
|= exstyle
;
1374 wxSetWindowExStyle(this, exstyleReal
);
1376 // ex style changes don't take effect without calling SetWindowPos
1382 // we must call SetWindowPos() to flush the cached extended style and
1383 // also to make the change to wxSTAY_ON_TOP style take effect: just
1384 // setting the style simply doesn't work
1385 if ( !::SetWindowPos(GetHwnd(),
1386 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1389 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1391 wxLogLastError(_T("SetWindowPos"));
1396 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1398 return wxBORDER_THEME
;
1401 wxBorder
wxWindowMSW::GetDefaultBorder() const
1403 return wxWindowBase::GetDefaultBorder();
1406 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1407 // that makes most sense for this Windows environment
1408 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1410 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1411 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1412 return wxBORDER_SIMPLE
;
1414 return wxBORDER_NONE
;
1417 if (border
== wxBORDER_THEME
)
1419 if (CanApplyThemeBorder())
1421 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1423 return wxBORDER_THEME
;
1425 return wxBORDER_SUNKEN
;
1433 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1435 // translate common wxWidgets styles to Windows ones
1437 // most of windows are child ones, those which are not (such as
1438 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1439 WXDWORD style
= WS_CHILD
;
1441 // using this flag results in very significant reduction in flicker,
1442 // especially with controls inside the static boxes (as the interior of the
1443 // box is not redrawn twice), but sometimes results in redraw problems, so
1444 // optionally allow the old code to continue to use it provided a special
1445 // system option is turned on
1446 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1447 || (flags
& wxCLIP_CHILDREN
) )
1448 style
|= WS_CLIPCHILDREN
;
1450 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1451 // don't support overlapping windows and it only makes sense for them and,
1452 // presumably, gives the system some extra work (to manage more clipping
1453 // regions), so avoid it alltogether
1456 if ( flags
& wxVSCROLL
)
1457 style
|= WS_VSCROLL
;
1459 if ( flags
& wxHSCROLL
)
1460 style
|= WS_HSCROLL
;
1462 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1464 // After translation, border is now optimized for the specific version of Windows
1465 // and theme engine presence.
1467 // WS_BORDER is only required for wxBORDER_SIMPLE
1468 if ( border
== wxBORDER_SIMPLE
)
1471 // now deal with ext style if the caller wants it
1477 if ( flags
& wxTRANSPARENT_WINDOW
)
1478 *exstyle
|= WS_EX_TRANSPARENT
;
1484 case wxBORDER_DEFAULT
:
1485 wxFAIL_MSG( _T("unknown border style") );
1489 case wxBORDER_SIMPLE
:
1490 case wxBORDER_THEME
:
1493 case wxBORDER_STATIC
:
1494 *exstyle
|= WS_EX_STATICEDGE
;
1497 case wxBORDER_RAISED
:
1498 *exstyle
|= WS_EX_DLGMODALFRAME
;
1501 case wxBORDER_SUNKEN
:
1502 *exstyle
|= WS_EX_CLIENTEDGE
;
1503 style
&= ~WS_BORDER
;
1506 // case wxBORDER_DOUBLE:
1507 // *exstyle |= WS_EX_DLGMODALFRAME;
1511 // wxUniv doesn't use Windows dialog navigation functions at all
1512 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1513 // to make the dialog navigation work with the nested panels we must
1514 // use this style (top level windows such as dialogs don't need it)
1515 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1517 *exstyle
|= WS_EX_CONTROLPARENT
;
1519 #endif // __WXUNIVERSAL__
1525 // Setup background and foreground colours correctly
1526 void wxWindowMSW::SetupColours()
1529 SetBackgroundColour(GetParent()->GetBackgroundColour());
1532 bool wxWindowMSW::IsMouseInWindow() const
1534 // get the mouse position
1537 ::GetCursorPosWinCE(&pt
);
1539 ::GetCursorPos(&pt
);
1542 // find the window which currently has the cursor and go up the window
1543 // chain until we find this window - or exhaust it
1544 HWND hwnd
= ::WindowFromPoint(pt
);
1545 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1546 hwnd
= ::GetParent(hwnd
);
1548 return hwnd
!= NULL
;
1551 void wxWindowMSW::OnInternalIdle()
1553 #ifndef HAVE_TRACKMOUSEEVENT
1554 // Check if we need to send a LEAVE event
1555 if ( m_mouseInWindow
)
1557 // note that we should generate the leave event whether the window has
1558 // or doesn't have mouse capture
1559 if ( !IsMouseInWindow() )
1561 GenerateMouseLeave();
1564 #endif // !HAVE_TRACKMOUSEEVENT
1566 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1567 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1570 // Set this window to be the child of 'parent'.
1571 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1573 if ( !wxWindowBase::Reparent(parent
) )
1576 HWND hWndChild
= GetHwnd();
1577 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1579 ::SetParent(hWndChild
, hWndParent
);
1582 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT
) )
1584 EnsureParentHasControlParentStyle(GetParent());
1586 #endif // !__WXWINCE__
1591 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1593 #ifndef __WXMICROWIN__
1594 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1598 void wxWindowMSW::DoFreeze()
1601 return; // no point in freezing hidden window
1603 SendSetRedraw(GetHwnd(), false);
1606 void wxWindowMSW::DoThaw()
1609 return; // hidden windows aren't frozen by DoFreeze
1611 SendSetRedraw(GetHwnd(), true);
1613 // we need to refresh everything or otherwise the invalidated area
1614 // is not going to be repainted
1618 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1620 HWND hWnd
= GetHwnd();
1627 wxCopyRectToRECT(*rect
, mswRect
);
1635 // RedrawWindow not available on SmartPhone or eVC++ 3
1636 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1637 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1641 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1643 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1648 void wxWindowMSW::Update()
1650 if ( !::UpdateWindow(GetHwnd()) )
1652 wxLogLastError(_T("UpdateWindow"));
1655 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1656 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1657 // handler needs to be really drawn right now
1662 // ---------------------------------------------------------------------------
1664 // ---------------------------------------------------------------------------
1666 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1670 // we need to lower the sibling static boxes so controls contained within can be
1672 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1674 // no sibling static boxes if we have no parent (ie TLW)
1678 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1680 node
= node
->GetNext() )
1682 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1685 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1686 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1691 #else // !wxUSE_STATBOX
1693 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1697 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1699 #endif // drag and drop is used
1701 #if wxUSE_DRAG_AND_DROP
1702 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1704 if ( m_dropTarget
!= 0 ) {
1705 m_dropTarget
->Revoke(m_hWnd
);
1706 delete m_dropTarget
;
1709 m_dropTarget
= pDropTarget
;
1710 if ( m_dropTarget
!= 0 )
1712 AdjustStaticBoxZOrder(GetParent());
1713 m_dropTarget
->Register(m_hWnd
);
1716 #endif // wxUSE_DRAG_AND_DROP
1718 // old-style file manager drag&drop support: we retain the old-style
1719 // DragAcceptFiles in parallel with SetDropTarget.
1720 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1723 HWND hWnd
= GetHwnd();
1726 AdjustStaticBoxZOrder(GetParent());
1727 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1732 // ----------------------------------------------------------------------------
1734 // ----------------------------------------------------------------------------
1738 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1740 wxWindowBase::DoSetToolTip(tooltip
);
1743 m_tooltip
->SetWindow((wxWindow
*)this);
1746 #endif // wxUSE_TOOLTIPS
1748 // ---------------------------------------------------------------------------
1749 // moving and resizing
1750 // ---------------------------------------------------------------------------
1752 bool wxWindowMSW::IsSizeDeferred() const
1754 #if wxUSE_DEFERRED_SIZING
1755 if ( m_pendingPosition
!= wxDefaultPosition
||
1756 m_pendingSize
!= wxDefaultSize
)
1758 #endif // wxUSE_DEFERRED_SIZING
1764 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1766 #if wxUSE_DEFERRED_SIZING
1767 // if SetSize() had been called at wx level but not realized at Windows
1768 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1769 // the new and not the old position to the other wx code
1770 if ( m_pendingSize
!= wxDefaultSize
)
1773 *x
= m_pendingSize
.x
;
1775 *y
= m_pendingSize
.y
;
1777 else // use current size
1778 #endif // wxUSE_DEFERRED_SIZING
1780 RECT rect
= wxGetWindowRect(GetHwnd());
1783 *x
= rect
.right
- rect
.left
;
1785 *y
= rect
.bottom
- rect
.top
;
1789 // Get size *available for subwindows* i.e. excluding menu bar etc.
1790 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1792 #if wxUSE_DEFERRED_SIZING
1793 if ( m_pendingSize
!= wxDefaultSize
)
1795 // we need to calculate the client size corresponding to pending size
1797 rect
.left
= m_pendingPosition
.x
;
1798 rect
.top
= m_pendingPosition
.y
;
1799 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1800 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1802 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1805 *x
= rect
.right
- rect
.left
;
1807 *y
= rect
.bottom
- rect
.top
;
1810 #endif // wxUSE_DEFERRED_SIZING
1812 RECT rect
= wxGetClientRect(GetHwnd());
1821 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1823 wxWindow
* const parent
= GetParent();
1826 if ( m_pendingPosition
!= wxDefaultPosition
)
1828 pos
= m_pendingPosition
;
1830 else // use current position
1832 RECT rect
= wxGetWindowRect(GetHwnd());
1835 point
.x
= rect
.left
;
1838 // we do the adjustments with respect to the parent only for the "real"
1839 // children, not for the dialogs/frames
1840 if ( !IsTopLevel() )
1842 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1844 // In RTL mode, we want the logical left x-coordinate,
1845 // which would be the physical right x-coordinate.
1846 point
.x
= rect
.right
;
1849 // Since we now have the absolute screen coords, if there's a
1850 // parent we must subtract its top left corner
1853 ::ScreenToClient(GetHwndOf(parent
), &point
);
1861 // we also must adjust by the client area offset: a control which is just
1862 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1863 if ( parent
&& !IsTopLevel() )
1865 const wxPoint
pt(parent
->GetClientAreaOrigin());
1876 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1884 ::ScreenToClient(GetHwnd(), &pt
);
1892 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1900 ::ClientToScreen(GetHwnd(), &pt
);
1909 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1911 #if wxUSE_DEFERRED_SIZING
1912 // if our parent had prepared a defer window handle for us, use it (unless
1913 // we are a top level window)
1914 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1916 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1919 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1920 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1923 wxLogLastError(_T("DeferWindowPos"));
1929 // hdwp must be updated as it may have been changed
1930 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1935 // did deferred move, remember new coordinates of the window as they're
1936 // different from what Windows would return for it
1940 // otherwise (or if deferring failed) move the window in place immediately
1941 #endif // wxUSE_DEFERRED_SIZING
1942 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1944 wxLogLastError(wxT("MoveWindow"));
1947 // if wxUSE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1948 // ignored otherwise
1952 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1954 // TODO: is this consistent with other platforms?
1955 // Still, negative width or height shouldn't be allowed
1961 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1963 #if wxUSE_DEFERRED_SIZING
1964 m_pendingPosition
= wxPoint(x
, y
);
1965 m_pendingSize
= wxSize(width
, height
);
1967 else // window was moved immediately, without deferring it
1969 m_pendingPosition
= wxDefaultPosition
;
1970 m_pendingSize
= wxDefaultSize
;
1971 #endif // wxUSE_DEFERRED_SIZING
1975 // set the size of the window: if the dimensions are positive, just use them,
1976 // but if any of them is equal to -1, it means that we must find the value for
1977 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1978 // which case -1 is a valid value for x and y)
1980 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1981 // the width/height to best suit our contents, otherwise we reuse the current
1983 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1985 // get the current size and position...
1986 int currentX
, currentY
;
1987 int currentW
, currentH
;
1989 GetPosition(¤tX
, ¤tY
);
1990 GetSize(¤tW
, ¤tH
);
1992 // ... and don't do anything (avoiding flicker) if it's already ok unless
1993 // we're forced to resize the window
1994 if ( x
== currentX
&& y
== currentY
&&
1995 width
== currentW
&& height
== currentH
&&
1996 !(sizeFlags
& wxSIZE_FORCE
) )
1998 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2000 wxSizeEvent
event( wxSize(width
,height
), GetId() );
2001 event
.SetEventObject( this );
2002 HandleWindowEvent( event
);
2007 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2009 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2012 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2014 wxSize size
= wxDefaultSize
;
2015 if ( width
== wxDefaultCoord
)
2017 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2019 size
= DoGetBestSize();
2024 // just take the current one
2029 if ( height
== wxDefaultCoord
)
2031 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2033 if ( size
.x
== wxDefaultCoord
)
2035 size
= DoGetBestSize();
2037 //else: already called DoGetBestSize() above
2043 // just take the current one
2048 DoMoveWindow(x
, y
, width
, height
);
2051 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2053 // setting the client size is less obvious than it could have been
2054 // because in the result of changing the total size the window scrollbar
2055 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2056 // doesn't take neither into account) and so the client size will not be
2057 // correct as the difference between the total and client size changes --
2058 // so we keep changing it until we get it right
2060 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2061 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2062 // may become 3 if the window had 0 size originally and so we didn't
2063 // calculate the scrollbar correction correctly during the first iteration)
2064 // but just to be on the safe side we check for it instead of making it an
2065 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2066 for ( int i
= 0; i
< 4; i
++ )
2069 ::GetClientRect(GetHwnd(), &rectClient
);
2071 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2072 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2073 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2078 // Find the difference between the entire window (title bar and all)
2079 // and the client area; add this to the new client size to move the
2082 ::GetWindowRect(GetHwnd(), &rectWin
);
2084 const int widthWin
= rectWin
.right
- rectWin
.left
,
2085 heightWin
= rectWin
.bottom
- rectWin
.top
;
2087 // MoveWindow positions the child windows relative to the parent, so
2088 // adjust if necessary
2089 if ( !IsTopLevel() )
2091 wxWindow
*parent
= GetParent();
2094 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2098 // don't call DoMoveWindow() because we want to move window immediately
2099 // and not defer it here as otherwise the value returned by
2100 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2102 if ( !::MoveWindow(GetHwnd(),
2105 width
+ widthWin
- rectClient
.right
,
2106 height
+ heightWin
- rectClient
.bottom
,
2109 wxLogLastError(_T("MoveWindow"));
2114 // ---------------------------------------------------------------------------
2116 // ---------------------------------------------------------------------------
2118 int wxWindowMSW::GetCharHeight() const
2120 return wxGetTextMetrics(this).tmHeight
;
2123 int wxWindowMSW::GetCharWidth() const
2125 // +1 is needed because Windows apparently adds it when calculating the
2126 // dialog units size in pixels
2127 #if wxDIALOG_UNIT_COMPATIBILITY
2128 return wxGetTextMetrics(this).tmAveCharWidth
;
2130 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2134 void wxWindowMSW::GetTextExtent(const wxString
& string
,
2136 int *descent
, int *externalLeading
,
2137 const wxFont
*fontToUse
) const
2139 wxASSERT_MSG( !fontToUse
|| fontToUse
->Ok(),
2140 _T("invalid font in GetTextExtent()") );
2144 hfontToUse
= GetHfontOf(*fontToUse
);
2146 hfontToUse
= GetHfontOf(GetFont());
2148 WindowHDC
hdc(GetHwnd());
2149 SelectInHDC
selectFont(hdc
, hfontToUse
);
2153 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2154 GetTextMetrics(hdc
, &tm
);
2161 *descent
= tm
.tmDescent
;
2162 if ( externalLeading
)
2163 *externalLeading
= tm
.tmExternalLeading
;
2166 // ---------------------------------------------------------------------------
2168 // ---------------------------------------------------------------------------
2170 #if wxUSE_MENUS_NATIVE
2172 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2173 // immediately, without waiting for the next event loop iteration
2175 // NB: this function should probably be made public later as it can almost
2176 // surely replace wxYield() elsewhere as well
2177 static void wxYieldForCommandsOnly()
2179 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2180 // want to process it here)
2182 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2184 if ( msg
.message
== WM_QUIT
)
2186 // if we retrieved a WM_QUIT, insert back into the message queue.
2187 ::PostQuitMessage(0);
2191 // luckily (as we don't have access to wxEventLoopImpl method from here
2192 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2194 ::TranslateMessage(&msg
);
2195 ::DispatchMessage(&msg
);
2199 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2201 menu
->SetInvokingWindow(this);
2204 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2206 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2207 x
= mouse
.x
; y
= mouse
.y
;
2210 HWND hWnd
= GetHwnd();
2211 HMENU hMenu
= GetHmenuOf(menu
);
2215 ::ClientToScreen(hWnd
, &point
);
2216 #if defined(__WXWINCE__)
2217 static const UINT flags
= 0;
2218 #else // !__WXWINCE__
2219 UINT flags
= TPM_RIGHTBUTTON
;
2220 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2221 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2222 // side and not to use it there neither -- modify the test if it does work
2224 if ( wxGetWinVersion() >= wxWinVersion_5
)
2226 // using TPM_RECURSE allows us to show a popup menu while another menu
2227 // is opened which can be useful and is supported by the other
2228 // platforms, so allow it under Windows too
2229 flags
|= TPM_RECURSE
;
2231 #endif // __WXWINCE__/!__WXWINCE__
2233 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2235 // we need to do it right now as otherwise the events are never going to be
2236 // sent to wxCurrentPopupMenu from HandleCommand()
2238 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2239 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2240 // destroyed as soon as we return (it can be a local variable in the caller
2241 // for example) and so we do need to process the event immediately
2242 wxYieldForCommandsOnly();
2244 menu
->SetInvokingWindow(NULL
);
2249 #endif // wxUSE_MENUS_NATIVE
2251 // ===========================================================================
2252 // pre/post message processing
2253 // ===========================================================================
2255 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2258 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2260 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2263 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2265 // wxUniversal implements tab traversal itself
2266 #ifndef __WXUNIVERSAL__
2267 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2269 // intercept dialog navigation keys
2270 MSG
*msg
= (MSG
*)pMsg
;
2272 // here we try to do all the job which ::IsDialogMessage() usually does
2274 if ( msg
->message
== WM_KEYDOWN
)
2276 bool bCtrlDown
= wxIsCtrlDown();
2277 bool bShiftDown
= wxIsShiftDown();
2279 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2280 // don't process it if it's the case (except for Ctrl-Tab/Enter
2281 // combinations which are always processed)
2282 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2284 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2285 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2286 // it, of course, implies them
2287 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2289 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2292 bool bForward
= true,
2293 bWindowChange
= false,
2296 // should we process this message specially?
2297 bool bProcess
= true;
2298 switch ( msg
->wParam
)
2301 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2303 // let the control have the TAB
2306 else // use it for navigation
2308 // Ctrl-Tab cycles thru notebook pages
2309 bWindowChange
= bCtrlDown
;
2310 bForward
= !bShiftDown
;
2317 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2325 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2334 // we treat PageUp/Dn as arrows because chances are that
2335 // a control which needs arrows also needs them for
2336 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2337 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2339 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2340 bWindowChange
= true;
2346 // currently active button should get enter press even
2347 // if there is a default button elsewhere so check if
2348 // this window is a button first
2349 wxWindow
*btn
= NULL
;
2350 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2352 // let IsDialogMessage() handle this for all
2353 // buttons except the owner-drawn ones which it
2354 // just seems to ignore
2355 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2356 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2358 // emulate the button click
2359 btn
= wxFindWinFromHandle(msg
->hwnd
);
2364 else // not a button itself, do we have default button?
2366 // check if this window or any of its ancestors
2367 // wants the message for itself (we always reserve
2368 // Ctrl-Enter for dialog navigation though)
2369 wxWindow
*win
= this;
2372 // this will contain the dialog code of this
2373 // window and all of its parent windows in turn
2374 LONG lDlgCode2
= lDlgCode
;
2378 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2380 // as it wants to process Enter itself,
2381 // don't call IsDialogMessage() which
2386 // don't propagate keyboard messages beyond
2387 // the first top level window parent
2388 if ( win
->IsTopLevel() )
2391 win
= win
->GetParent();
2393 lDlgCode2
= ::SendMessage
2404 win
= wxGetTopLevelParent(win
);
2407 wxTopLevelWindow
* const
2408 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2411 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2416 if ( btn
&& btn
->IsEnabled() )
2418 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2422 #endif // wxUSE_BUTTON
2425 // map Enter presses into button presses on PDAs
2426 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2427 event
.SetEventObject(this);
2428 if ( HandleWindowEvent(event
) )
2430 #endif // __WXWINCE__
2440 wxNavigationKeyEvent event
;
2441 event
.SetDirection(bForward
);
2442 event
.SetWindowChange(bWindowChange
);
2443 event
.SetFromTab(bFromTab
);
2444 event
.SetEventObject(this);
2446 if ( HandleWindowEvent(event
) )
2448 // as we don't call IsDialogMessage(), which would take of
2449 // this by default, we need to manually send this message
2450 // so that controls can change their UI state if needed
2451 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2458 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2460 // IsDialogMessage() did something...
2464 #endif // __WXUNIVERSAL__
2469 // relay mouse move events to the tooltip control
2470 MSG
*msg
= (MSG
*)pMsg
;
2471 if ( msg
->message
== WM_MOUSEMOVE
)
2472 wxToolTip::RelayEvent(pMsg
);
2474 #endif // wxUSE_TOOLTIPS
2479 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2481 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2482 return m_acceleratorTable
.Translate(this, pMsg
);
2486 #endif // wxUSE_ACCEL
2489 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2491 // all tests below have to deal with various bugs/misfeatures of
2492 // IsDialogMessage(): we have to prevent it from being called from our
2493 // MSWProcessMessage() in some situations
2495 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2496 // message even when there is no cancel button and when the message is
2497 // needed by the control itself: in particular, it prevents the tree in
2498 // place edit control from being closed with Escape in a dialog
2499 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2504 // ::IsDialogMessage() is broken and may sometimes hang the application by
2505 // going into an infinite loop when it tries to find the control to give
2506 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2507 // situations when this may happen and not call it then
2508 if ( msg
->message
!= WM_SYSCHAR
)
2511 // assume we can call it by default
2512 bool canSafelyCallIsDlgMsg
= true;
2514 HWND hwndFocus
= ::GetFocus();
2516 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2517 // ::IsDialogMessage() will also enter an infinite loop, because it will
2518 // recursively check the child windows but not the window itself and so if
2519 // none of the children accepts focus it loops forever (as it only stops
2520 // when it gets back to the window it started from)
2522 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2523 // style has the focus, it can happen. One such possibility is if
2524 // all windows are either toplevel, wxDialog, wxPanel or static
2525 // controls and no window can actually accept keyboard input.
2526 #if !defined(__WXWINCE__)
2527 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2529 // pessimistic by default
2530 canSafelyCallIsDlgMsg
= false;
2531 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2533 node
= node
->GetNext() )
2535 wxWindow
* const win
= node
->GetData();
2536 if ( win
->CanAcceptFocus() &&
2537 !wxHasWindowExStyle(win
, WS_EX_CONTROLPARENT
) )
2539 // it shouldn't hang...
2540 canSafelyCallIsDlgMsg
= true;
2546 #endif // !__WXWINCE__
2548 if ( canSafelyCallIsDlgMsg
)
2550 // ::IsDialogMessage() can enter in an infinite loop when the
2551 // currently focused window is disabled or hidden and its
2552 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2556 if ( !::IsWindowEnabled(hwndFocus
) ||
2557 !::IsWindowVisible(hwndFocus
) )
2559 // it would enter an infinite loop if we do this!
2560 canSafelyCallIsDlgMsg
= false;
2565 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2567 // it's a top level window, don't go further -- e.g. even
2568 // if the parent of a dialog is disabled, this doesn't
2569 // break navigation inside the dialog
2573 hwndFocus
= ::GetParent(hwndFocus
);
2577 return canSafelyCallIsDlgMsg
;
2580 // ---------------------------------------------------------------------------
2581 // message params unpackers
2582 // ---------------------------------------------------------------------------
2584 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2585 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2587 *id
= LOWORD(wParam
);
2588 *hwnd
= (WXHWND
)lParam
;
2589 *cmd
= HIWORD(wParam
);
2592 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2593 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2595 *state
= LOWORD(wParam
);
2596 *minimized
= HIWORD(wParam
);
2597 *hwnd
= (WXHWND
)lParam
;
2600 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2601 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2603 *code
= LOWORD(wParam
);
2604 *pos
= HIWORD(wParam
);
2605 *hwnd
= (WXHWND
)lParam
;
2608 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2609 WXHDC
*hdc
, WXHWND
*hwnd
)
2611 *hwnd
= (WXHWND
)lParam
;
2612 *hdc
= (WXHDC
)wParam
;
2615 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2616 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2618 *item
= (WXWORD
)wParam
;
2619 *flags
= HIWORD(wParam
);
2620 *hmenu
= (WXHMENU
)lParam
;
2623 // ---------------------------------------------------------------------------
2624 // Main wxWidgets window proc and the window proc for wxWindow
2625 // ---------------------------------------------------------------------------
2627 // Hook for new window just as it's being created, when the window isn't yet
2628 // associated with the handle
2629 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2631 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2632 // window being created and insures that it's always unset back later
2633 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2635 gs_winBeingCreated
= winBeingCreated
;
2638 wxWindowCreationHook::~wxWindowCreationHook()
2640 gs_winBeingCreated
= NULL
;
2644 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2646 // trace all messages: useful for the debugging but noticeably slows down
2647 // the code so don't do it by default
2648 #if wxDEBUG_LEVEL >= 2
2649 wxLogTrace(wxTraceMessages
,
2650 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2651 wxGetMessageName(message
), hWnd
, (long)wParam
, lParam
);
2652 #endif // wxDEBUG_LEVEL >= 2
2654 wxWindowMSW
*wnd
= wxFindWinFromHandle(hWnd
);
2656 // when we get the first message for the HWND we just created, we associate
2657 // it with wxWindow stored in gs_winBeingCreated
2658 if ( !wnd
&& gs_winBeingCreated
)
2660 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2661 wnd
= gs_winBeingCreated
;
2662 gs_winBeingCreated
= NULL
;
2663 wnd
->SetHWND((WXHWND
)hWnd
);
2668 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2669 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2671 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2676 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2678 // did we process the message?
2679 bool processed
= false;
2689 // for most messages we should return 0 when we do process the message
2697 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2700 // return 0 to allow window creation
2701 rc
.result
= mayCreate
? 0 : -1;
2707 // never set processed to true and *always* pass WM_DESTROY to
2708 // DefWindowProc() as Windows may do some internal cleanup when
2709 // processing it and failing to pass the message along may cause
2710 // memory and resource leaks!
2711 (void)HandleDestroy();
2715 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2719 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2722 #if !defined(__WXWINCE__)
2725 LPRECT pRect
= (LPRECT
)lParam
;
2727 rc
.SetLeft(pRect
->left
);
2728 rc
.SetTop(pRect
->top
);
2729 rc
.SetRight(pRect
->right
);
2730 rc
.SetBottom(pRect
->bottom
);
2731 processed
= HandleMoving(rc
);
2733 pRect
->left
= rc
.GetLeft();
2734 pRect
->top
= rc
.GetTop();
2735 pRect
->right
= rc
.GetRight();
2736 pRect
->bottom
= rc
.GetBottom();
2741 case WM_ENTERSIZEMOVE
:
2743 processed
= HandleEnterSizeMove();
2747 case WM_EXITSIZEMOVE
:
2749 processed
= HandleExitSizeMove();
2755 LPRECT pRect
= (LPRECT
)lParam
;
2757 rc
.SetLeft(pRect
->left
);
2758 rc
.SetTop(pRect
->top
);
2759 rc
.SetRight(pRect
->right
);
2760 rc
.SetBottom(pRect
->bottom
);
2761 processed
= HandleSizing(rc
);
2763 pRect
->left
= rc
.GetLeft();
2764 pRect
->top
= rc
.GetTop();
2765 pRect
->right
= rc
.GetRight();
2766 pRect
->bottom
= rc
.GetBottom();
2770 #endif // !__WXWINCE__
2772 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2773 case WM_ACTIVATEAPP
:
2774 // This implicitly sends a wxEVT_ACTIVATE_APP event
2775 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2781 WXWORD state
, minimized
;
2783 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2785 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2790 processed
= HandleSetFocus((WXHWND
)wParam
);
2794 processed
= HandleKillFocus((WXHWND
)wParam
);
2797 case WM_PRINTCLIENT
:
2798 processed
= HandlePrintClient((WXHDC
)wParam
);
2804 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2806 processed
= HandlePaint();
2810 processed
= HandlePaint();
2815 #ifdef __WXUNIVERSAL__
2816 // Universal uses its own wxFrame/wxDialog, so we don't receive
2817 // close events unless we have this.
2819 #endif // __WXUNIVERSAL__
2821 // don't let the DefWindowProc() destroy our window - we'll do it
2822 // ourselves in ~wxWindow
2828 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2832 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2833 GET_Y_LPARAM(lParam
),
2837 #ifdef HAVE_TRACKMOUSEEVENT
2839 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2841 if ( m_mouseInWindow
)
2843 GenerateMouseLeave();
2846 // always pass processed back as false, this allows the window
2847 // manager to process the message too. This is needed to
2848 // ensure windows XP themes work properly as the mouse moves
2849 // over widgets like buttons. So don't set processed to true here.
2851 #endif // HAVE_TRACKMOUSEEVENT
2853 #if wxUSE_MOUSEWHEEL
2855 processed
= HandleMouseWheel(wParam
, lParam
);
2859 case WM_LBUTTONDOWN
:
2861 case WM_LBUTTONDBLCLK
:
2862 case WM_RBUTTONDOWN
:
2864 case WM_RBUTTONDBLCLK
:
2865 case WM_MBUTTONDOWN
:
2867 case WM_MBUTTONDBLCLK
:
2868 #ifdef wxHAS_XBUTTON
2869 case WM_XBUTTONDOWN
:
2871 case WM_XBUTTONDBLCLK
:
2872 #endif // wxHAS_XBUTTON
2874 #ifdef __WXMICROWIN__
2875 // MicroWindows seems to ignore the fact that a window is
2876 // disabled. So catch mouse events and throw them away if
2878 wxWindowMSW
* win
= this;
2881 if (!win
->IsEnabled())
2887 win
= win
->GetParent();
2888 if ( !win
|| win
->IsTopLevel() )
2895 #endif // __WXMICROWIN__
2896 int x
= GET_X_LPARAM(lParam
),
2897 y
= GET_Y_LPARAM(lParam
);
2900 // redirect the event to a static control if necessary by
2901 // finding one under mouse because under CE the static controls
2902 // don't generate mouse events (even with SS_NOTIFY)
2904 if ( GetCapture() == this )
2906 // but don't do it if the mouse is captured by this window
2907 // because then it should really get this event itself
2912 win
= FindWindowForMouseEvent(this, &x
, &y
);
2914 // this should never happen
2915 wxCHECK_MSG( win
, 0,
2916 _T("FindWindowForMouseEvent() returned NULL") );
2919 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2921 SHRGINFO shrgi
= {0};
2923 shrgi
.cbSize
= sizeof(SHRGINFO
);
2924 shrgi
.hwndClient
= (HWND
) GetHWND();
2928 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2929 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2931 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2934 pt
= ClientToScreen(pt
);
2936 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2938 evtCtx
.SetEventObject(this);
2939 if (HandleWindowEvent(evtCtx
))
2948 #else // !__WXWINCE__
2949 wxWindowMSW
*win
= this;
2950 #endif // __WXWINCE__/!__WXWINCE__
2952 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2954 // if the app didn't eat the event, handle it in the default
2955 // way, that is by giving this window the focus
2958 // for the standard classes their WndProc sets the focus to
2959 // them anyhow and doing it from here results in some weird
2960 // problems, so don't do it for them (unnecessary anyhow)
2961 if ( !win
->IsOfStandardClass() )
2963 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
2975 case MM_JOY1BUTTONDOWN
:
2976 case MM_JOY2BUTTONDOWN
:
2977 case MM_JOY1BUTTONUP
:
2978 case MM_JOY2BUTTONUP
:
2979 processed
= HandleJoystickEvent(message
,
2980 GET_X_LPARAM(lParam
),
2981 GET_Y_LPARAM(lParam
),
2984 #endif // __WXMICROWIN__
2990 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2992 processed
= HandleCommand(id
, cmd
, hwnd
);
2997 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
3000 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3001 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3002 // apparently doesn't always behave properly and needs some help
3003 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3004 case WM_NOTIFYFORMAT
:
3005 if ( lParam
== NF_QUERY
)
3008 rc
.result
= NFR_UNICODE
;
3011 #endif // wxUSE_UNICODE_MSLU
3013 // for these messages we must return true if process the message
3016 processed
= MSWOnDrawItem(wParam
, (WXDRAWITEMSTRUCT
*)lParam
);
3021 case WM_MEASUREITEM
:
3022 processed
= MSWOnMeasureItem(wParam
, (WXMEASUREITEMSTRUCT
*)lParam
);
3026 #endif // defined(WM_DRAWITEM)
3029 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3031 // we always want to get the char events
3032 rc
.result
= DLGC_WANTCHARS
;
3034 if ( HasFlag(wxWANTS_CHARS
) )
3036 // in fact, we want everything
3037 rc
.result
|= DLGC_WANTARROWS
|
3044 //else: get the dlg code from the DefWindowProc()
3049 // If this has been processed by an event handler, return 0 now
3050 // (we've handled it).
3051 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3052 if ( m_lastKeydownProcessed
)
3061 // we consider these messages "not interesting" to OnChar, so
3062 // just don't do anything more with them
3072 // avoid duplicate messages to OnChar for these ASCII keys:
3073 // they will be translated by TranslateMessage() and received
3105 // but set processed to false, not true to still pass them
3106 // to the control's default window proc - otherwise
3107 // built-in keyboard handling won't work
3112 // special case of VK_APPS: treat it the same as right mouse
3113 // click because both usually pop up a context menu
3115 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3120 // do generate a CHAR event
3121 processed
= HandleChar((WORD
)wParam
, lParam
);
3124 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3131 // special case of VK_APPS: treat it the same as right mouse button
3132 if ( wParam
== VK_APPS
)
3134 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3139 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3144 case WM_CHAR
: // Always an ASCII character
3145 if ( m_lastKeydownProcessed
)
3147 // The key was handled in the EVT_KEY_DOWN and handling
3148 // a key in an EVT_KEY_DOWN handler is meant, by
3149 // design, to prevent EVT_CHARs from happening
3150 m_lastKeydownProcessed
= false;
3155 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3161 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3163 #endif // wxUSE_HOTKEY
3168 processed
= HandleClipboardEvent(message
);
3176 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3178 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3184 // CTLCOLOR messages are sent by children to query the parent for their
3186 #ifndef __WXMICROWIN__
3187 case WM_CTLCOLORMSGBOX
:
3188 case WM_CTLCOLOREDIT
:
3189 case WM_CTLCOLORLISTBOX
:
3190 case WM_CTLCOLORBTN
:
3191 case WM_CTLCOLORDLG
:
3192 case WM_CTLCOLORSCROLLBAR
:
3193 case WM_CTLCOLORSTATIC
:
3197 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3199 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3202 #endif // !__WXMICROWIN__
3204 case WM_SYSCOLORCHANGE
:
3205 // the return value for this message is ignored
3206 processed
= HandleSysColorChange();
3209 #if !defined(__WXWINCE__)
3210 case WM_DISPLAYCHANGE
:
3211 processed
= HandleDisplayChange();
3215 case WM_PALETTECHANGED
:
3216 processed
= HandlePaletteChanged((WXHWND
)wParam
);
3219 case WM_CAPTURECHANGED
:
3220 processed
= HandleCaptureChanged((WXHWND
)lParam
);
3223 case WM_SETTINGCHANGE
:
3224 processed
= HandleSettingChange(wParam
, lParam
);
3227 case WM_QUERYNEWPALETTE
:
3228 processed
= HandleQueryNewPalette();
3232 processed
= HandleEraseBkgnd((WXHDC
)wParam
);
3235 // we processed the message, i.e. erased the background
3240 #if !defined(__WXWINCE__)
3242 processed
= HandleDropFiles(wParam
);
3247 processed
= HandleInitDialog((WXHWND
)wParam
);
3251 // we never set focus from here
3256 #if !defined(__WXWINCE__)
3257 case WM_QUERYENDSESSION
:
3258 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3262 processed
= HandleEndSession(wParam
!= 0, lParam
);
3265 case WM_GETMINMAXINFO
:
3266 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3271 processed
= HandleSetCursor((WXHWND
)wParam
,
3272 LOWORD(lParam
), // hit test
3273 HIWORD(lParam
)); // mouse msg
3277 // returning TRUE stops the DefWindowProc() from further
3278 // processing this message - exactly what we need because we've
3279 // just set the cursor.
3284 #if wxUSE_ACCESSIBILITY
3287 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3288 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3290 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3292 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3298 #if defined(WM_HELP)
3301 // by default, WM_HELP is propagated by DefWindowProc() upwards
3302 // to the window parent but as we do it ourselves already
3303 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3304 // to get the other events if we process this message at all
3307 // WM_HELP doesn't use lParam under CE
3309 HELPINFO
* info
= (HELPINFO
*) lParam
;
3310 if ( info
->iContextType
== HELPINFO_WINDOW
)
3312 #endif // !__WXWINCE__
3313 wxHelpEvent helpEvent
3318 wxGetMousePosition() // what else?
3320 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3324 helpEvent
.SetEventObject(this);
3325 HandleWindowEvent(helpEvent
);
3328 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3330 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3331 helpEvent
.SetEventObject(this);
3332 HandleWindowEvent(helpEvent
);
3335 else // unknown help event?
3339 #endif // !__WXWINCE__
3344 #if !defined(__WXWINCE__)
3345 case WM_CONTEXTMENU
:
3347 // we don't convert from screen to client coordinates as
3348 // the event may be handled by a parent window
3349 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3351 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3353 // we could have got an event from our child, reflect it back
3354 // to it if this is the case
3355 wxWindowMSW
*win
= NULL
;
3356 WXHWND hWnd
= (WXHWND
)wParam
;
3357 if ( hWnd
!= m_hWnd
)
3359 win
= FindItemByHWND(hWnd
);
3365 evtCtx
.SetEventObject(win
);
3366 processed
= win
->HandleWindowEvent(evtCtx
);
3373 // we're only interested in our own menus, not MF_SYSMENU
3374 if ( HIWORD(wParam
) == MF_POPUP
)
3376 // handle menu chars for ownerdrawn menu items
3377 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3378 if ( i
!= wxNOT_FOUND
)
3380 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3385 #endif // wxUSE_MENUS
3388 case WM_POWERBROADCAST
:
3391 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3392 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3395 #endif // __WXWINCE__
3398 // If we want the default themed border then we need to draw it ourselves
3401 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3402 const wxBorder border
= TranslateBorder(GetBorder());
3403 if (theme
&& border
== wxBORDER_THEME
)
3405 // first ask the widget to calculate the border size
3406 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3409 // now alter the client size making room for drawing a
3414 NCCALCSIZE_PARAMS
*csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3415 rect
= &csparam
->rgrc
[0];
3419 rect
= (RECT
*)lParam
;
3422 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3423 RECT rcClient
= { 0, 0, 0, 0 };
3424 wxClientDC
dc((wxWindow
*)this);
3425 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3427 if ( theme
->GetThemeBackgroundContentRect
3434 &rcClient
) == S_OK
)
3436 InflateRect(&rcClient
, -1, -1);
3438 rc
.result
= WVR_REDRAW
;
3446 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3447 const wxBorder border
= TranslateBorder(GetBorder());
3448 if (theme
&& border
== wxBORDER_THEME
)
3450 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3451 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3454 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3455 wxWindowDC
dc((wxWindow
*)this);
3456 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3458 // Clip the DC so that you only draw on the non-client area
3460 wxCopyRectToRECT(GetSize(), rcBorder
);
3463 theme
->GetThemeBackgroundContentRect(
3464 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3465 InflateRect(&rcClient
, -1, -1);
3467 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3468 rcClient
.right
, rcClient
.bottom
);
3470 // Make sure the background is in a proper state
3471 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3473 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3479 nState
= ETS_DISABLED
;
3480 // should we check this?
3481 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3482 // nState = ETS_READONLY;
3484 nState
= ETS_NORMAL
;
3485 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3490 #endif // wxUSE_UXTHEME
3493 // try a custom message handler
3494 const MSWMessageHandlers::const_iterator
3495 i
= gs_messageHandlers
.find(message
);
3496 if ( i
!= gs_messageHandlers
.end() )
3498 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3504 #if wxDEBUG_LEVEL >= 2
3505 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3506 wxGetMessageName(message
));
3507 #endif // wxDEBUG_LEVEL >= 2
3508 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3514 // ----------------------------------------------------------------------------
3515 // wxWindow <-> HWND map
3516 // ----------------------------------------------------------------------------
3518 wxWindow
*wxFindWinFromHandle(HWND hwnd
)
3520 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3521 return i
== gs_windowHandles
.end() ? NULL
: i
->second
;
3524 void wxAssociateWinWithHandle(HWND hwnd
, wxWindowMSW
*win
)
3526 // adding NULL hwnd is (first) surely a result of an error and
3527 // (secondly) breaks menu command processing
3528 wxCHECK_RET( hwnd
!= (HWND
)NULL
,
3529 wxT("attempt to add a NULL hwnd to window list ignored") );
3532 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3533 if ( i
!= gs_windowHandles
.end() )
3535 if ( i
->second
!= win
)
3539 wxT("HWND %p already associated with another window (%s)"),
3540 hwnd
, win
->GetClassInfo()->GetClassName()
3544 //else: this actually happens currently because we associate the window
3545 // with its HWND during creation (if we create it) and also when
3546 // SubclassWin() is called later, this is ok
3548 #endif // wxDEBUG_LEVEL
3550 gs_windowHandles
[hwnd
] = (wxWindow
*)win
;
3553 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3555 gs_windowHandles
.erase(GetHwndOf(win
));
3558 // ----------------------------------------------------------------------------
3559 // various MSW speciic class dependent functions
3560 // ----------------------------------------------------------------------------
3562 // Default destroyer - override if you destroy it in some other way
3563 // (e.g. with MDI child windows)
3564 void wxWindowMSW::MSWDestroyWindow()
3568 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3571 int& w
, int& h
) const
3573 // yes, those are just some arbitrary hardcoded numbers
3574 static const int DEFAULT_Y
= 200;
3576 bool nonDefault
= false;
3578 if ( pos
.x
== wxDefaultCoord
)
3580 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3581 // can just as well set it to CW_USEDEFAULT as well
3587 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3588 // neither because it is not handled as a special value by Windows then
3589 // and so we have to choose some default value for it
3591 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3597 NB: there used to be some code here which set the initial size of the
3598 window to the client size of the parent if no explicit size was
3599 specified. This was wrong because wxWidgets programs often assume
3600 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3601 it. To see why, you should understand that Windows sends WM_SIZE from
3602 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3603 from some base class ctor and so this WM_SIZE is not processed in the
3604 real class' OnSize() (because it's not fully constructed yet and the
3605 event goes to some base class OnSize() instead). So the WM_SIZE we
3606 rely on is the one sent when the parent frame resizes its children
3607 but here is the problem: if the child already has just the right
3608 size, nothing will happen as both wxWidgets and Windows check for
3609 this and ignore any attempts to change the window size to the size it
3610 already has - so no WM_SIZE would be sent.
3614 // we don't use CW_USEDEFAULT here for several reasons:
3616 // 1. it results in huge frames on modern screens (1000*800 is not
3617 // uncommon on my 1280*1024 screen) which is way too big for a half
3618 // empty frame of most of wxWidgets samples for example)
3620 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3621 // the default is for whatever reason 8*8 which breaks client <->
3622 // window size calculations (it would be nice if it didn't, but it
3623 // does and the simplest way to fix it seemed to change the broken
3624 // default size anyhow)
3626 // 3. there is just no advantage in doing it: with x and y it is
3627 // possible that [future versions of] Windows position the new top
3628 // level window in some smart way which we can't do, but we can
3629 // guess a reasonably good size for a new window just as well
3632 // However, on PocketPC devices, we must use the default
3633 // size if possible.
3635 if (size
.x
== wxDefaultCoord
)
3639 if (size
.y
== wxDefaultCoord
)
3644 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3648 w
= WidthDefault(size
.x
);
3649 h
= HeightDefault(size
.y
);
3652 AdjustForParentClientOrigin(x
, y
);
3657 WXHWND
wxWindowMSW::MSWGetParent() const
3659 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3662 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3663 const wxChar
*title
,
3667 WXDWORD extendedStyle
)
3669 // check a common bug in the user code: if the window is created with a
3670 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3671 // single wxWindow object and this results in all sorts of trouble,
3672 // especially for wxTLWs
3673 wxCHECK_MSG( !m_hWnd
, true, "window can't be recreated" );
3675 // this can happen if this function is called using the return value of
3676 // wxApp::GetRegisteredClassName() which failed
3677 wxCHECK_MSG( wclass
, false, "failed to register window class?" );
3680 // choose the position/size for the new window
3682 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3684 // controlId is menu handle for the top level windows, so set it to 0
3685 // unless we're creating a child window
3686 int controlId
= style
& WS_CHILD
? GetId() : 0;
3688 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3689 // which is the same but without CS_[HV]REDRAW class styles so using it
3690 // ensures that the window is not fully repainted on each resize
3691 wxString
className(wclass
);
3692 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3694 className
+= wxApp::GetNoRedrawClassSuffix();
3697 // do create the window
3698 wxWindowCreationHook
hook(this);
3700 m_hWnd
= (WXHWND
)::CreateWindowEx
3704 title
? title
: m_windowName
.wx_str(),
3707 (HWND
)MSWGetParent(),
3708 (HMENU
)wxUIntToPtr(controlId
),
3710 NULL
// no extra data
3715 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3720 SubclassWin(m_hWnd
);
3725 // ===========================================================================
3726 // MSW message handlers
3727 // ===========================================================================
3729 // ---------------------------------------------------------------------------
3731 // ---------------------------------------------------------------------------
3733 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3735 #ifndef __WXMICROWIN__
3736 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3737 HWND hWnd
= hdr
->hwndFrom
;
3738 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
3740 // if the control is one of our windows, let it handle the message itself
3743 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3746 // VZ: why did we do it? normally this is unnecessary and, besides, it
3747 // breaks the message processing for the toolbars because the tooltip
3748 // notifications were being forwarded to the toolbar child controls
3749 // (if it had any) before being passed to the toolbar itself, so in my
3750 // example the tooltip for the combobox was always shown instead of the
3751 // correct button tooltips
3753 // try all our children
3754 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3757 wxWindow
*child
= node
->GetData();
3758 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3763 node
= node
->GetNext();
3767 // by default, handle it ourselves
3768 return MSWOnNotify(idCtrl
, lParam
, result
);
3769 #else // __WXMICROWIN__
3776 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3778 const wxString
& ttip
)
3780 // I don't know why it happens, but the versions of comctl32.dll starting
3781 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3782 // this message is supposed to be sent to Unicode programs only) -- hence
3783 // we need to handle it as well, otherwise no tooltips will be shown in
3786 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3789 // not a tooltip message or no tooltip to show anyhow
3794 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3796 // We don't want to use the szText buffer because it has a limit of 80
3797 // bytes and this is not enough, especially for Unicode build where it
3798 // limits the tooltip string length to only 40 characters
3800 // The best would be, of course, to not impose any length limitations at
3801 // all but then the buffer would have to be dynamic and someone would have
3802 // to free it and we don't have the tooltip owner object here any more, so
3803 // for now use our own static buffer with a higher fixed max length.
3805 // Note that using a static buffer should not be a problem as only a single
3806 // tooltip can be shown at the same time anyhow.
3808 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3810 // We need to convert tooltip from multi byte to Unicode on the fly.
3811 static wchar_t buf
[513];
3813 // Truncate tooltip length if needed as otherwise we might not have
3814 // enough space for it in the buffer and MultiByteToWideChar() would
3816 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3818 // Convert to WideChar without adding the NULL character. The NULL
3819 // character is added afterwards (this is more efficient).
3820 int len
= ::MultiByteToWideChar
3832 wxLogLastError(_T("MultiByteToWideChar()"));
3836 ttText
->lpszText
= (LPSTR
) buf
;
3838 else // TTN_NEEDTEXTA
3839 #endif // !wxUSE_UNICODE
3841 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3842 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3843 // to copy the string we have into the buffer
3844 static wxChar buf
[513];
3845 wxStrlcpy(buf
, ttip
.c_str(), WXSIZEOF(buf
));
3846 ttText
->lpszText
= buf
;
3852 #endif // wxUSE_TOOLTIPS
3854 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3856 WXLPARAM
* WXUNUSED(result
))
3861 NMHDR
* hdr
= (NMHDR
*)lParam
;
3862 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3869 wxUnusedVar(lParam
);
3870 #endif // wxUSE_TOOLTIPS
3875 // ---------------------------------------------------------------------------
3876 // end session messages
3877 // ---------------------------------------------------------------------------
3879 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3881 #ifdef ENDSESSION_LOGOFF
3882 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3883 event
.SetEventObject(wxTheApp
);
3884 event
.SetCanVeto(true);
3885 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3887 bool rc
= wxTheApp
->ProcessEvent(event
);
3891 // we may end only if the app didn't veto session closing (double
3893 *mayEnd
= !event
.GetVeto();
3898 wxUnusedVar(logOff
);
3899 wxUnusedVar(mayEnd
);
3904 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3906 #ifdef ENDSESSION_LOGOFF
3907 // do nothing if the session isn't ending
3912 if ( (this != wxTheApp
->GetTopWindow()) )
3915 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3916 event
.SetEventObject(wxTheApp
);
3917 event
.SetCanVeto(false);
3918 event
.SetLoggingOff((logOff
& ENDSESSION_LOGOFF
) != 0);
3920 return wxTheApp
->ProcessEvent(event
);
3922 wxUnusedVar(endSession
);
3923 wxUnusedVar(logOff
);
3928 // ---------------------------------------------------------------------------
3929 // window creation/destruction
3930 // ---------------------------------------------------------------------------
3932 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3935 // VZ: why is this commented out for WinCE? If it doesn't support
3936 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3937 // not with multiple #ifdef's!
3939 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3940 EnsureParentHasControlParentStyle(GetParent());
3941 #endif // !__WXWINCE__
3948 bool wxWindowMSW::HandleDestroy()
3950 // delete our drop target if we've got one
3951 #if wxUSE_DRAG_AND_DROP
3952 if ( m_dropTarget
!= NULL
)
3954 m_dropTarget
->Revoke(m_hWnd
);
3956 delete m_dropTarget
;
3957 m_dropTarget
= NULL
;
3959 #endif // wxUSE_DRAG_AND_DROP
3961 // WM_DESTROY handled
3965 // ---------------------------------------------------------------------------
3967 // ---------------------------------------------------------------------------
3969 bool wxWindowMSW::HandleActivate(int state
,
3970 bool WXUNUSED(minimized
),
3971 WXHWND
WXUNUSED(activate
))
3973 wxActivateEvent
event(wxEVT_ACTIVATE
,
3974 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3976 event
.SetEventObject(this);
3978 return HandleWindowEvent(event
);
3981 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3983 // Strangly enough, some controls get set focus events when they are being
3984 // deleted, even if they already had focus before.
3985 if ( m_isBeingDeleted
)
3990 // notify the parent keeping track of focus for the kbd navigation
3991 // purposes that we got it
3992 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3993 (void)HandleWindowEvent(eventFocus
);
3999 m_caret
->OnSetFocus();
4001 #endif // wxUSE_CARET
4003 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
4004 event
.SetEventObject(this);
4006 // wxFindWinFromHandle() may return NULL, it is ok
4007 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4009 return HandleWindowEvent(event
);
4012 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4018 m_caret
->OnKillFocus();
4020 #endif // wxUSE_CARET
4022 // Don't send the event when in the process of being deleted. This can
4023 // only cause problems if the event handler tries to access the object.
4024 if ( m_isBeingDeleted
)
4029 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4030 event
.SetEventObject(this);
4032 // wxFindWinFromHandle() may return NULL, it is ok
4033 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4035 return HandleWindowEvent(event
);
4038 // ---------------------------------------------------------------------------
4040 // ---------------------------------------------------------------------------
4042 void wxWindowMSW::SetLabel( const wxString
& label
)
4044 SetWindowText(GetHwnd(), label
.c_str());
4047 wxString
wxWindowMSW::GetLabel() const
4049 return wxGetWindowText(GetHWND());
4052 // ---------------------------------------------------------------------------
4054 // ---------------------------------------------------------------------------
4056 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4058 wxShowEvent
event(GetId(), show
);
4059 event
.SetEventObject(this);
4061 return HandleWindowEvent(event
);
4064 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4066 wxInitDialogEvent
event(GetId());
4067 event
.SetEventObject(this);
4069 return HandleWindowEvent(event
);
4072 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4074 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4075 wxUnusedVar(wParam
);
4077 #else // __WXMICROWIN__
4078 HDROP hFilesInfo
= (HDROP
) wParam
;
4080 // Get the total number of files dropped
4081 UINT gwFilesDropped
= ::DragQueryFile
4089 wxString
*files
= new wxString
[gwFilesDropped
];
4090 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4092 // first get the needed buffer length (+1 for terminating NUL)
4093 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4095 // and now get the file name
4096 ::DragQueryFile(hFilesInfo
, wIndex
,
4097 wxStringBuffer(files
[wIndex
], len
), len
);
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 DragFinish(hFilesInfo
);
4110 return HandleWindowEvent(event
);
4115 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4117 int WXUNUSED(mouseMsg
))
4119 #ifndef __WXMICROWIN__
4120 // the logic is as follows:
4121 // 0. if we're busy, set the busy cursor (even for non client elements)
4122 // 1. don't set custom cursor for non client area of enabled windows
4123 // 2. ask user EVT_SET_CURSOR handler for the cursor
4124 // 3. if still no cursor but we're in a TLW, set the global cursor
4126 HCURSOR hcursor
= 0;
4129 hcursor
= wxGetCurrentBusyCursor();
4133 if ( nHitTest
!= HTCLIENT
)
4136 // first ask the user code - it may wish to set the cursor in some very
4137 // specific way (for example, depending on the current position)
4140 if ( !::GetCursorPosWinCE(&pt
))
4142 if ( !::GetCursorPos(&pt
) )
4145 wxLogLastError(wxT("GetCursorPos"));
4150 ScreenToClient(&x
, &y
);
4151 wxSetCursorEvent
event(x
, y
);
4153 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4154 if ( processedEvtSetCursor
&& event
.HasCursor() )
4156 hcursor
= GetHcursorOf(event
.GetCursor());
4161 // the test for processedEvtSetCursor is here to prevent using
4162 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4163 // nothing from it - this is a way to say that our cursor shouldn't
4164 // be used for this point
4165 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4167 hcursor
= GetHcursorOf(m_cursor
);
4170 if ( !hcursor
&& !GetParent() )
4172 const wxCursor
*cursor
= wxGetGlobalCursor();
4173 if ( cursor
&& cursor
->Ok() )
4175 hcursor
= GetHcursorOf(*cursor
);
4184 ::SetCursor(hcursor
);
4186 // cursor set, stop here
4189 #endif // __WXMICROWIN__
4191 // pass up the window chain
4195 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4196 WXLPARAM
WXUNUSED(lParam
),
4197 bool *WXUNUSED_IN_WINCE(vetoed
))
4203 wxEventType evtType
;
4206 case PBT_APMQUERYSUSPEND
:
4207 evtType
= wxEVT_POWER_SUSPENDING
;
4210 case PBT_APMQUERYSUSPENDFAILED
:
4211 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4214 case PBT_APMSUSPEND
:
4215 evtType
= wxEVT_POWER_SUSPENDED
;
4218 case PBT_APMRESUMESUSPEND
:
4219 evtType
= wxEVT_POWER_RESUME
;
4223 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4226 // these messages are currently not mapped to wx events
4227 case PBT_APMQUERYSTANDBY
:
4228 case PBT_APMQUERYSTANDBYFAILED
:
4229 case PBT_APMSTANDBY
:
4230 case PBT_APMRESUMESTANDBY
:
4231 case PBT_APMBATTERYLOW
:
4232 case PBT_APMPOWERSTATUSCHANGE
:
4233 case PBT_APMOEMEVENT
:
4234 case PBT_APMRESUMECRITICAL
:
4235 #ifdef PBT_APMRESUMEAUTOMATIC
4236 case PBT_APMRESUMEAUTOMATIC
:
4238 evtType
= wxEVT_NULL
;
4242 // don't handle unknown messages
4243 if ( evtType
== wxEVT_NULL
)
4246 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4248 wxPowerEvent
event(evtType
);
4249 if ( !HandleWindowEvent(event
) )
4252 *vetoed
= event
.IsVetoed();
4258 bool wxWindowMSW::IsDoubleBuffered() const
4260 for ( const wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4262 if ( wxHasWindowExStyle(win
, WS_EX_COMPOSITED
) )
4265 if ( win
->IsTopLevel() )
4272 void wxWindowMSW::SetDoubleBuffered(bool on
)
4274 // Get the current extended style bits
4275 long exstyle
= wxGetWindowExStyle(this);
4277 // Twiddle the bit as needed
4279 exstyle
|= WS_EX_COMPOSITED
;
4281 exstyle
&= ~WS_EX_COMPOSITED
;
4284 wxSetWindowExStyle(this, exstyle
);
4287 // ---------------------------------------------------------------------------
4288 // owner drawn stuff
4289 // ---------------------------------------------------------------------------
4291 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4292 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4293 #define WXUNUSED_UNLESS_ODRAWN(param) param
4295 #define WXUNUSED_UNLESS_ODRAWN(param)
4299 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4300 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4302 #if wxUSE_OWNER_DRAWN
4304 #if wxUSE_MENUS_NATIVE
4305 // is it a menu item?
4306 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4307 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4309 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4311 // see comment before the same test in MSWOnMeasureItem() below
4315 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4316 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
4318 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4319 // the DC from being released
4320 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4321 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4322 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4323 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4325 return pMenuItem
->OnDrawItem
4329 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4330 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4333 #endif // wxUSE_MENUS_NATIVE
4335 #endif // USE_OWNER_DRAWN
4337 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4339 #if wxUSE_OWNER_DRAWN
4340 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4341 #else // !wxUSE_OWNER_DRAWN
4342 // we may still have owner-drawn buttons internally because we have to make
4343 // them owner-drawn to support colour change
4346 wxDynamicCast(FindItem(id
), wxButton
)
4351 #endif // USE_OWNER_DRAWN
4355 return item
->MSWOnDraw(itemStruct
);
4358 #endif // wxUSE_CONTROLS
4364 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4366 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4367 // is it a menu item?
4368 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4369 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4371 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4373 // according to Carsten Fuchs the pointer may be NULL under XP if an
4374 // MDI child frame is initially maximized, see this for more info:
4375 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4377 // so silently ignore it instead of asserting
4381 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4382 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4385 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4387 pMeasureStruct
->itemWidth
= w
;
4388 pMeasureStruct
->itemHeight
= h
;
4393 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4396 return item
->MSWOnMeasure(itemStruct
);
4400 wxUnusedVar(itemStruct
);
4401 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4406 // ---------------------------------------------------------------------------
4407 // colours and palettes
4408 // ---------------------------------------------------------------------------
4410 bool wxWindowMSW::HandleSysColorChange()
4412 wxSysColourChangedEvent event
;
4413 event
.SetEventObject(this);
4415 (void)HandleWindowEvent(event
);
4417 // always let the system carry on the default processing to allow the
4418 // native controls to react to the colours update
4422 bool wxWindowMSW::HandleDisplayChange()
4424 wxDisplayChangedEvent event
;
4425 event
.SetEventObject(this);
4427 return HandleWindowEvent(event
);
4430 #ifndef __WXMICROWIN__
4432 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4434 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4438 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4441 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4443 #endif // wxUSE_CONTROLS
4446 return *brush
!= NULL
;
4449 #endif // __WXMICROWIN__
4451 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4454 // same as below except we don't respond to our own messages
4455 if ( hWndPalChange
!= GetHWND() )
4457 // check to see if we our our parents have a custom palette
4458 wxWindowMSW
*win
= this;
4459 while ( win
&& !win
->HasCustomPalette() )
4461 win
= win
->GetParent();
4464 if ( win
&& win
->HasCustomPalette() )
4466 // realize the palette to see whether redrawing is needed
4467 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4468 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4469 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4471 int result
= ::RealizePalette(hdc
);
4473 // restore the palette (before releasing the DC)
4474 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4475 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4476 ::RealizePalette(hdc
);
4477 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4479 // now check for the need to redraw
4481 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4485 #endif // wxUSE_PALETTE
4487 wxPaletteChangedEvent
event(GetId());
4488 event
.SetEventObject(this);
4489 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4491 return HandleWindowEvent(event
);
4494 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4496 // notify windows on the capture stack about lost capture
4497 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4498 wxWindowBase::NotifyCaptureLost();
4500 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4501 wxMouseCaptureChangedEvent
event(GetId(), win
);
4502 event
.SetEventObject(this);
4503 return HandleWindowEvent(event
);
4506 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4508 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4509 // we need to send this to child windows (it is only sent to top-level
4510 // windows) so {list,tree}ctrls can adjust their font size if necessary
4511 // this is exactly how explorer does it to enable the font size changes
4513 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4516 // top-level windows already get this message from the system
4517 wxWindow
*win
= node
->GetData();
4518 if ( !win
->IsTopLevel() )
4520 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4523 node
= node
->GetNext();
4526 // let the system handle it
4530 bool wxWindowMSW::HandleQueryNewPalette()
4534 // check to see if we our our parents have a custom palette
4535 wxWindowMSW
*win
= this;
4536 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4537 if (win
->HasCustomPalette()) {
4538 /* realize the palette to see whether redrawing is needed */
4539 HDC hdc
= ::GetDC((HWND
) GetHWND());
4540 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4541 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4543 int result
= ::RealizePalette(hdc
);
4544 /* restore the palette (before releasing the DC) */
4545 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4546 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4547 ::RealizePalette(hdc
);
4548 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4549 /* now check for the need to redraw */
4551 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4553 #endif // wxUSE_PALETTE
4555 wxQueryNewPaletteEvent
event(GetId());
4556 event
.SetEventObject(this);
4558 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4561 // Responds to colour changes: passes event on to children.
4562 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4564 // the top level window also reset the standard colour map as it might have
4565 // changed (there is no need to do it for the non top level windows as we
4566 // only have to do it once)
4570 gs_hasStdCmap
= false;
4572 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4575 // Only propagate to non-top-level windows because Windows already
4576 // sends this event to all top-level ones
4577 wxWindow
*win
= node
->GetData();
4578 if ( !win
->IsTopLevel() )
4580 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4581 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4582 // the standard controls
4583 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4586 node
= node
->GetNext();
4590 extern wxCOLORMAP
*wxGetStdColourMap()
4592 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4593 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4595 if ( !gs_hasStdCmap
)
4597 static bool s_coloursInit
= false;
4599 if ( !s_coloursInit
)
4601 // When a bitmap is loaded, the RGB values can change (apparently
4602 // because Windows adjusts them to care for the old programs always
4603 // using 0xc0c0c0 while the transparent colour for the new Windows
4604 // versions is different). But we do this adjustment ourselves so
4605 // we want to avoid Windows' "help" and for this we need to have a
4606 // reference bitmap which can tell us what the RGB values change
4608 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4609 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4610 if ( stdColourBitmap
.Ok() )
4612 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4613 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4614 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4617 memDC
.SelectObject(stdColourBitmap
);
4620 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4622 memDC
.GetPixel(i
, 0, &colour
);
4623 s_stdColours
[i
] = wxColourToRGB(colour
);
4626 else // wxBITMAP_STD_COLOURS couldn't be loaded
4628 s_stdColours
[0] = RGB(000,000,000); // black
4629 s_stdColours
[1] = RGB(128,128,128); // dark grey
4630 s_stdColours
[2] = RGB(192,192,192); // light grey
4631 s_stdColours
[3] = RGB(255,255,255); // white
4632 //s_stdColours[4] = RGB(000,000,255); // blue
4633 //s_stdColours[5] = RGB(255,000,255); // magenta
4636 s_coloursInit
= true;
4639 gs_hasStdCmap
= true;
4641 // create the colour map
4642 #define INIT_CMAP_ENTRY(col) \
4643 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4644 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4646 INIT_CMAP_ENTRY(BTNTEXT
);
4647 INIT_CMAP_ENTRY(BTNSHADOW
);
4648 INIT_CMAP_ENTRY(BTNFACE
);
4649 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4651 #undef INIT_CMAP_ENTRY
4657 // ---------------------------------------------------------------------------
4659 // ---------------------------------------------------------------------------
4661 bool wxWindowMSW::HandlePaint()
4663 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4665 wxLogLastError(wxT("CreateRectRgn"));
4666 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4667 wxLogLastError(wxT("GetUpdateRgn"));
4669 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4671 wxPaintEvent
event(m_windowId
);
4672 event
.SetEventObject(this);
4674 bool processed
= HandleWindowEvent(event
);
4676 // note that we must generate NC event after the normal one as otherwise
4677 // BeginPaint() will happily overwrite our decorations with the background
4679 wxNcPaintEvent
eventNc(m_windowId
);
4680 eventNc
.SetEventObject(this);
4681 HandleWindowEvent(eventNc
);
4683 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4684 // be called from inside the event handlers called above)
4685 m_updateRegion
.Clear();
4690 // Can be called from an application's OnPaint handler
4691 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4693 #ifdef __WXUNIVERSAL__
4696 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4699 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4704 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4706 wxDCTemp
dc(hdc
, GetClientSize());
4707 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4710 impl
->SetWindow((wxWindow
*)this);
4712 wxEraseEvent
event(m_windowId
, &dc
);
4713 event
.SetEventObject(this);
4714 bool rc
= HandleWindowEvent(event
);
4716 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4717 impl
->SelectOldObjects(hdc
);
4722 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4724 // standard non top level controls (i.e. except the dialogs) always erase
4725 // their background themselves in HandleCtlColor() or have some control-
4726 // specific ways to set the colours (common controls)
4727 if ( IsOfStandardClass() && !IsTopLevel() )
4733 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4735 // don't skip the event here, custom background means that the app
4736 // is drawing it itself in its OnPaint(), so don't draw it at all
4737 // now to avoid flicker
4741 wxDC
*dc
= event
.GetDC();
4743 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
->GetImpl();
4745 // do default background painting
4746 if ( !DoEraseBackground(GetHdcOf(*impl
)) )
4748 // let the system paint the background
4753 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4755 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4759 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4765 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4769 // our background colour applies to:
4770 // 1. this window itself, always
4771 // 2. all children unless the colour is "not inheritable"
4772 // 3. even if it is not inheritable, our immediate transparent
4773 // children should still inherit it -- but not any transparent
4774 // children because it would look wrong if a child of non
4775 // transparent child would show our bg colour when the child itself
4777 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4780 (win
&& win
->HasTransparentBackground() &&
4781 win
->GetParent() == this) )
4783 // draw children with the same colour as the parent
4785 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4787 return (WXHBRUSH
)GetHbrushOf(*brush
);
4794 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4797 hWndToPaint
= GetHWND();
4799 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4801 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4805 // background is not inherited beyond top level windows
4806 if ( win
->IsTopLevel() )
4813 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4815 // we receive this message when DrawThemeParentBackground() is
4816 // called from def window proc of several controls under XP and we
4817 // must draw properly themed background here
4819 // note that naively I'd expect filling the client rect with the
4820 // brush returned by MSWGetBgBrush() work -- but for some reason it
4821 // doesn't and we have to call parents MSWPrintChild() which is
4822 // supposed to call DrawThemeBackground() with appropriate params
4824 // also note that in this case lParam == PRF_CLIENT but we're
4825 // clearly expected to paint the background and nothing else!
4827 if ( IsTopLevel() || InheritsBackgroundColour() )
4830 // sometimes we don't want the parent to handle it at all, instead
4831 // return whatever value this window wants
4832 if ( !MSWShouldPropagatePrintChild() )
4833 return MSWPrintChild(hDC
, (wxWindow
*)this);
4835 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4837 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4840 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4847 // ---------------------------------------------------------------------------
4848 // moving and resizing
4849 // ---------------------------------------------------------------------------
4851 bool wxWindowMSW::HandleMinimize()
4853 wxIconizeEvent
event(m_windowId
);
4854 event
.SetEventObject(this);
4856 return HandleWindowEvent(event
);
4859 bool wxWindowMSW::HandleMaximize()
4861 wxMaximizeEvent
event(m_windowId
);
4862 event
.SetEventObject(this);
4864 return HandleWindowEvent(event
);
4867 bool wxWindowMSW::HandleMove(int x
, int y
)
4870 wxMoveEvent
event(point
, m_windowId
);
4871 event
.SetEventObject(this);
4873 return HandleWindowEvent(event
);
4876 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4878 wxMoveEvent
event(rect
, m_windowId
);
4879 event
.SetEventObject(this);
4881 bool rc
= HandleWindowEvent(event
);
4883 rect
= event
.GetRect();
4887 bool wxWindowMSW::HandleEnterSizeMove()
4889 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4890 event
.SetEventType(wxEVT_MOVE_START
);
4891 event
.SetEventObject(this);
4893 return HandleWindowEvent(event
);
4896 bool wxWindowMSW::HandleExitSizeMove()
4898 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4899 event
.SetEventType(wxEVT_MOVE_END
);
4900 event
.SetEventObject(this);
4902 return HandleWindowEvent(event
);
4905 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4907 #if wxUSE_DEFERRED_SIZING
4908 // when we resize this window, its children are probably going to be
4909 // repositioned as well, prepare to use DeferWindowPos() for them
4910 int numChildren
= 0;
4911 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4913 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4918 // Protect against valid m_hDWP being overwritten
4919 bool useDefer
= false;
4921 if ( numChildren
> 1 )
4925 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4928 wxLogLastError(_T("BeginDeferWindowPos"));
4934 #endif // wxUSE_DEFERRED_SIZING
4936 // update this window size
4937 bool processed
= false;
4941 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4942 // fall through nevertheless
4946 // we're not interested in these messages at all
4949 case SIZE_MINIMIZED
:
4950 processed
= HandleMinimize();
4953 case SIZE_MAXIMIZED
:
4954 /* processed = */ HandleMaximize();
4955 // fall through to send a normal size event as well
4958 // don't use w and h parameters as they specify the client size
4959 // while according to the docs EVT_SIZE handler is supposed to
4960 // receive the total size
4961 wxSizeEvent
event(GetSize(), m_windowId
);
4962 event
.SetEventObject(this);
4964 processed
= HandleWindowEvent(event
);
4967 #if wxUSE_DEFERRED_SIZING
4968 // and finally change the positions of all child windows at once
4969 if ( useDefer
&& m_hDWP
)
4971 // reset m_hDWP to NULL so that child windows don't try to use our
4972 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4973 // happen anyhow normally but who knows what weird flow of control we
4974 // may have depending on what the users EVT_SIZE handler does...)
4975 HDWP hDWP
= (HDWP
)m_hDWP
;
4978 // do put all child controls in place at once
4979 if ( !::EndDeferWindowPos(hDWP
) )
4981 wxLogLastError(_T("EndDeferWindowPos"));
4984 // Reset our children's pending pos/size values.
4985 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4987 node
= node
->GetNext() )
4989 wxWindowMSW
* const child
= node
->GetData();
4990 child
->MSWEndDeferWindowPos();
4993 #endif // wxUSE_DEFERRED_SIZING
4998 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
5000 wxSizeEvent
event(rect
, m_windowId
);
5001 event
.SetEventObject(this);
5003 bool rc
= HandleWindowEvent(event
);
5005 rect
= event
.GetRect();
5009 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5014 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5018 int minWidth
= GetMinWidth(),
5019 minHeight
= GetMinHeight(),
5020 maxWidth
= GetMaxWidth(),
5021 maxHeight
= GetMaxHeight();
5023 if ( minWidth
!= wxDefaultCoord
)
5025 info
->ptMinTrackSize
.x
= minWidth
;
5029 if ( minHeight
!= wxDefaultCoord
)
5031 info
->ptMinTrackSize
.y
= minHeight
;
5035 if ( maxWidth
!= wxDefaultCoord
)
5037 info
->ptMaxTrackSize
.x
= maxWidth
;
5041 if ( maxHeight
!= wxDefaultCoord
)
5043 info
->ptMaxTrackSize
.y
= maxHeight
;
5051 // ---------------------------------------------------------------------------
5053 // ---------------------------------------------------------------------------
5055 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5057 // sign extend to int from short before comparing with the other int ids
5058 int id
= (signed short)id_
;
5060 #if wxUSE_MENUS_NATIVE
5061 if ( !cmd
&& wxCurrentPopupMenu
)
5063 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5064 wxCurrentPopupMenu
= NULL
;
5066 return popupMenu
->MSWCommand(cmd
, id
);
5068 #endif // wxUSE_MENUS_NATIVE
5070 wxWindow
*win
= NULL
;
5072 // first try to find it from HWND - this works even with the broken
5073 // programs using the same ids for different controls
5076 win
= wxFindWinFromHandle(control
);
5087 return win
->MSWCommand(cmd
, id
);
5090 // the messages sent from the in-place edit control used by the treectrl
5091 // for label editing have id == 0, but they should _not_ be treated as menu
5092 // messages (they are EN_XXX ones, in fact) so don't translate anything
5093 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5096 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, id
);
5097 event
.SetEventObject(this);
5100 return HandleWindowEvent(event
);
5104 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5105 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5106 // notifications to its parent which we want to reflect back to
5108 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5109 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5111 #endif // wxUSE_SPINCTRL
5113 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5114 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5115 // notifications to its parent which we want to reflect back to
5117 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5118 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5126 // ---------------------------------------------------------------------------
5128 // ---------------------------------------------------------------------------
5130 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5134 // our client coords are not quite the same as Windows ones
5135 wxPoint pt
= GetClientAreaOrigin();
5136 event
.m_x
= x
- pt
.x
;
5137 event
.m_y
= y
- pt
.y
;
5139 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5140 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5141 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5142 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5143 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5144 #ifdef wxHAS_XBUTTON
5145 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5146 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5147 #endif // wxHAS_XBUTTON
5148 event
.m_altDown
= ::wxIsAltDown();
5151 event
.SetTimestamp(::GetMessageTime());
5154 event
.SetEventObject(this);
5155 event
.SetId(GetId());
5157 #if wxUSE_MOUSEEVENT_HACK
5158 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5159 gs_lastMouseEvent
.type
= event
.GetEventType();
5160 #endif // wxUSE_MOUSEEVENT_HACK
5164 // Windows doesn't send the mouse events to the static controls (which are
5165 // transparent in the sense that their WM_NCHITTEST handler returns
5166 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5167 // and so we manually check if we don't have a child window under mouse and if
5168 // we do, send the event to it instead of the window Windows had sent WM_XXX
5171 // Notice that this is not done for the mouse move events because this could
5172 // (would?) be too slow, but only for clicks which means that the static texts
5173 // still don't get move, enter nor leave events.
5174 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5176 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
5178 // first try to find a non transparent child: this allows us to send events
5179 // to a static text which is inside a static box, for example
5180 POINT pt
= { *x
, *y
};
5181 HWND hwnd
= GetHwndOf(win
),
5185 hwndUnderMouse
= ::ChildWindowFromPoint
5191 hwndUnderMouse
= ::ChildWindowFromPointEx
5201 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5203 // now try any child window at all
5204 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5207 // check that we have a child window which is susceptible to receive mouse
5208 // events: for this it must be shown and enabled
5209 if ( hwndUnderMouse
&&
5210 hwndUnderMouse
!= hwnd
&&
5211 ::IsWindowVisible(hwndUnderMouse
) &&
5212 ::IsWindowEnabled(hwndUnderMouse
) )
5214 wxWindow
*winUnderMouse
= wxFindWinFromHandle(hwndUnderMouse
);
5215 if ( winUnderMouse
)
5217 // translate the mouse coords to the other window coords
5218 win
->ClientToScreen(x
, y
);
5219 winUnderMouse
->ScreenToClient(x
, y
);
5221 win
= winUnderMouse
;
5227 #endif // __WXWINCE__
5229 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5231 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5232 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5233 // from the message id and take the value in the table to get wxWin event
5235 static const wxEventType eventsMouse
[] =
5246 wxEVT_MIDDLE_DCLICK
,
5247 0, // this one is for wxEVT_MOTION which is not used here
5256 #ifdef wxHAS_XBUTTON
5257 // the same messages are used for both auxillary mouse buttons so we need
5258 // to adjust the index manually
5261 case WM_XBUTTONDOWN
:
5263 case WM_XBUTTONDBLCLK
:
5264 if ( flags
& MK_XBUTTON2
)
5265 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5267 #endif // wxHAS_XBUTTON
5269 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5270 InitMouseEvent(event
, x
, y
, flags
);
5272 return HandleWindowEvent(event
);
5275 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5277 if ( !m_mouseInWindow
)
5279 // it would be wrong to assume that just because we get a mouse move
5280 // event that the mouse is inside the window: although this is usually
5281 // true, it is not if we had captured the mouse, so we need to check
5282 // the mouse coordinates here
5283 if ( !HasCapture() || IsMouseInWindow() )
5285 // Generate an ENTER event
5286 m_mouseInWindow
= true;
5288 #ifdef HAVE_TRACKMOUSEEVENT
5289 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5291 static const _TrackMouseEvent_t
5292 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5293 #else // !__WXWINCE__
5294 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5295 static bool s_initDone
= false;
5298 // see comment in wxApp::GetComCtl32Version() explaining the
5299 // use of wxLoadedDLL
5300 wxLoadedDLL
dllComCtl32(_T("comctl32.dll"));
5301 if ( dllComCtl32
.IsLoaded() )
5303 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5304 dllComCtl32
.RawGetSymbol(_T("_TrackMouseEvent"));
5310 if ( s_pfn_TrackMouseEvent
)
5311 #endif // __WXWINCE__/!__WXWINCE__
5313 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5315 trackinfo
.dwFlags
= TME_LEAVE
;
5316 trackinfo
.hwndTrack
= GetHwnd();
5318 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5320 #endif // HAVE_TRACKMOUSEEVENT
5322 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5323 InitMouseEvent(event
, x
, y
, flags
);
5325 (void)HandleWindowEvent(event
);
5328 #ifdef HAVE_TRACKMOUSEEVENT
5329 else // mouse not in window
5331 // Check if we need to send a LEAVE event
5332 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5333 // send it here if we are using native mouse leave tracking
5334 if ( HasCapture() && !IsMouseInWindow() )
5336 GenerateMouseLeave();
5339 #endif // HAVE_TRACKMOUSEEVENT
5341 #if wxUSE_MOUSEEVENT_HACK
5342 // Windows often generates mouse events even if mouse position hasn't
5343 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5345 // Filter this out as it can result in unexpected behaviour compared to
5347 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5348 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5349 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5350 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5352 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5354 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5359 #endif // wxUSE_MOUSEEVENT_HACK
5361 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5365 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5367 #if wxUSE_MOUSEWHEEL
5368 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5369 // forwarded up to the parent by DefWindowProc()) and not in the client
5370 // ones as all the other messages, translate them to the client coords for
5373 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5374 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5375 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5376 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5377 event
.m_wheelDelta
= WHEEL_DELTA
;
5379 static int s_linesPerRotation
= -1;
5380 if ( s_linesPerRotation
== -1 )
5382 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5383 &s_linesPerRotation
, 0))
5385 // this is not supposed to happen
5386 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5388 // the default is 3, so use it if SystemParametersInfo() failed
5389 s_linesPerRotation
= 3;
5393 event
.m_linesPerAction
= s_linesPerRotation
;
5394 return HandleWindowEvent(event
);
5396 #else // !wxUSE_MOUSEWHEEL
5397 wxUnusedVar(wParam
);
5398 wxUnusedVar(lParam
);
5401 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5404 void wxWindowMSW::GenerateMouseLeave()
5406 m_mouseInWindow
= false;
5409 if ( wxIsShiftDown() )
5411 if ( wxIsCtrlDown() )
5412 state
|= MK_CONTROL
;
5414 // Only the high-order bit should be tested
5415 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5416 state
|= MK_LBUTTON
;
5417 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5418 state
|= MK_MBUTTON
;
5419 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5420 state
|= MK_RBUTTON
;
5424 if ( !::GetCursorPosWinCE(&pt
) )
5426 if ( !::GetCursorPos(&pt
) )
5429 wxLogLastError(_T("GetCursorPos"));
5432 // we need to have client coordinates here for symmetry with
5433 // wxEVT_ENTER_WINDOW
5434 RECT rect
= wxGetWindowRect(GetHwnd());
5438 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5439 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5441 (void)HandleWindowEvent(event
);
5444 // ---------------------------------------------------------------------------
5445 // keyboard handling
5446 // ---------------------------------------------------------------------------
5448 // create the key event of the given type for the given key - used by
5449 // HandleChar and HandleKeyDown/Up
5450 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5453 WXWPARAM wParam
) const
5455 wxKeyEvent
event(evType
);
5456 event
.SetId(GetId());
5457 event
.m_shiftDown
= wxIsShiftDown();
5458 event
.m_controlDown
= wxIsCtrlDown();
5459 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5461 event
.SetEventObject((wxWindow
*)this); // const_cast
5462 event
.m_keyCode
= id
;
5464 event
.m_uniChar
= (wxChar
) wParam
;
5466 event
.m_rawCode
= (wxUint32
) wParam
;
5467 event
.m_rawFlags
= (wxUint32
) lParam
;
5469 event
.SetTimestamp(::GetMessageTime());
5472 // translate the position to client coords
5475 GetCursorPosWinCE(&pt
);
5480 GetWindowRect(GetHwnd(),&rect
);
5490 // isASCII is true only when we're called from WM_CHAR handler and not from
5492 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5499 else // we're called from WM_KEYDOWN
5501 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5502 // to get numpad key codes: CHAR events should use the logical keys
5503 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5504 id
= wxCharCodeMSWToWX(wParam
);
5507 // it's ASCII and will be processed here only when called from
5508 // WM_CHAR (i.e. when isASCII = true), don't process it now
5513 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5515 // the alphanumeric keys produced by pressing AltGr+something on European
5516 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5517 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5518 // alphanumeric, so pretend that there are no modifiers at all (the
5519 // KEY_DOWN event would still have the correct modifiers if they're really
5521 if ( event
.m_controlDown
&& event
.m_altDown
&&
5522 (id
>= 32 && id
< 256) )
5524 event
.m_controlDown
=
5525 event
.m_altDown
= false;
5528 return HandleWindowEvent(event
);
5531 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5533 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5537 // normal ASCII char
5541 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5542 return HandleWindowEvent(event
);
5545 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5547 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5551 // normal ASCII char
5555 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5556 return HandleWindowEvent(event
);
5560 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5561 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5563 // FIXME: implement GetMenuItemCount for WinCE, possibly
5564 // in terms of GetMenuItemInfo
5566 const HMENU hmenu
= (HMENU
)lParam
;
5570 mii
.cbSize
= sizeof(MENUITEMINFO
);
5572 // we could use MIIM_FTYPE here as we only need to know if the item is
5573 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5574 // MIIM_FTYPE is not supported under Win95
5575 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5577 // find if we have this letter in any owner drawn item
5578 const int count
= ::GetMenuItemCount(hmenu
);
5579 for ( int i
= 0; i
< count
; i
++ )
5581 // previous loop iteration could modify it, reset it back before
5582 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5585 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5587 if ( mii
.fType
== MFT_OWNERDRAW
)
5589 // dwItemData member of the MENUITEMINFO is a
5590 // pointer to the associated wxMenuItem -- see the
5591 // menu creation code
5592 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5594 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), _T('&'));
5597 if ( *p
== _T('&') )
5599 // this is not the accel char, find the real one
5600 p
= wxStrchr(p
+ 1, _T('&'));
5602 else // got the accel char
5604 // FIXME-UNICODE: this comparison doesn't risk to work
5605 // for non ASCII accelerator characters I'm afraid, but
5607 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5613 // this one doesn't match
5620 else // failed to get the menu text?
5622 // it's not fatal, so don't show error, but still log it
5623 wxLogLastError(_T("GetMenuItemInfo"));
5630 #endif // wxUSE_MENUS
5632 bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg
)
5634 const wxEventType type
= nMsg
== WM_CUT
? wxEVT_COMMAND_TEXT_CUT
5635 : nMsg
== WM_COPY
? wxEVT_COMMAND_TEXT_COPY
5636 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE
;
5637 wxClipboardTextEvent
evt(type
, GetId());
5639 evt
.SetEventObject(this);
5641 return HandleWindowEvent(evt
);
5644 // ---------------------------------------------------------------------------
5646 // ---------------------------------------------------------------------------
5648 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5652 if ( flags
& JOY_BUTTON1CHG
)
5653 change
= wxJOY_BUTTON1
;
5654 if ( flags
& JOY_BUTTON2CHG
)
5655 change
= wxJOY_BUTTON2
;
5656 if ( flags
& JOY_BUTTON3CHG
)
5657 change
= wxJOY_BUTTON3
;
5658 if ( flags
& JOY_BUTTON4CHG
)
5659 change
= wxJOY_BUTTON4
;
5662 if ( flags
& JOY_BUTTON1
)
5663 buttons
|= wxJOY_BUTTON1
;
5664 if ( flags
& JOY_BUTTON2
)
5665 buttons
|= wxJOY_BUTTON2
;
5666 if ( flags
& JOY_BUTTON3
)
5667 buttons
|= wxJOY_BUTTON3
;
5668 if ( flags
& JOY_BUTTON4
)
5669 buttons
|= wxJOY_BUTTON4
;
5671 // the event ids aren't consecutive so we can't use table based lookup
5673 wxEventType eventType
;
5678 eventType
= wxEVT_JOY_MOVE
;
5683 eventType
= wxEVT_JOY_MOVE
;
5688 eventType
= wxEVT_JOY_ZMOVE
;
5693 eventType
= wxEVT_JOY_ZMOVE
;
5696 case MM_JOY1BUTTONDOWN
:
5698 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5701 case MM_JOY2BUTTONDOWN
:
5703 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5706 case MM_JOY1BUTTONUP
:
5708 eventType
= wxEVT_JOY_BUTTON_UP
;
5711 case MM_JOY2BUTTONUP
:
5713 eventType
= wxEVT_JOY_BUTTON_UP
;
5717 wxFAIL_MSG(wxT("no such joystick event"));
5722 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5723 event
.SetPosition(wxPoint(x
, y
));
5724 event
.SetEventObject(this);
5726 return HandleWindowEvent(event
);
5736 // ---------------------------------------------------------------------------
5738 // ---------------------------------------------------------------------------
5740 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5741 WXWORD pos
, WXHWND control
)
5743 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5745 wxWindow
*child
= wxFindWinFromHandle(control
);
5747 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5750 wxScrollWinEvent event
;
5751 event
.SetPosition(pos
);
5752 event
.SetOrientation(orientation
);
5753 event
.SetEventObject(this);
5758 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5762 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5766 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5770 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5774 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5778 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5781 case SB_THUMBPOSITION
:
5783 // under Win32, the scrollbar range and position are 32 bit integers,
5784 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5785 // explicitly query the scrollbar for the correct position (this must
5786 // be done only for these two SB_ events as they are the only one
5787 // carrying the scrollbar position)
5789 WinStruct
<SCROLLINFO
> scrollInfo
;
5790 scrollInfo
.fMask
= SIF_TRACKPOS
;
5792 if ( !::GetScrollInfo(GetHwnd(),
5793 WXOrientToSB(orientation
),
5796 // Not necessarily an error, if there are no scrollbars yet.
5797 // wxLogLastError(_T("GetScrollInfo"));
5800 event
.SetPosition(scrollInfo
.nTrackPos
);
5803 event
.SetEventType( wParam
== SB_THUMBPOSITION
5804 ? wxEVT_SCROLLWIN_THUMBRELEASE
5805 : wxEVT_SCROLLWIN_THUMBTRACK
);
5812 return HandleWindowEvent(event
);
5815 // ----------------------------------------------------------------------------
5816 // custom message handlers
5817 // ----------------------------------------------------------------------------
5820 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5822 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5823 false, _T("registering handler for the same message twice") );
5825 gs_messageHandlers
[msg
] = handler
;
5830 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5832 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5833 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5834 _T("unregistering non-registered handler?") );
5836 gs_messageHandlers
.erase(i
);
5839 // ===========================================================================
5841 // ===========================================================================
5843 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5846 HDC dc
= ::GetDC((HWND
) wnd
);
5849 // the_font.UseResource();
5850 // the_font.RealizeResource();
5851 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5853 was
= (HFONT
) SelectObject(dc
,fnt
);
5855 GetTextMetrics(dc
, &tm
);
5858 SelectObject(dc
,was
);
5860 ReleaseDC((HWND
)wnd
, dc
);
5863 *x
= tm
.tmAveCharWidth
;
5865 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5867 // the_font.ReleaseResource();
5870 // use the "extended" bit (24) of lParam to distinguish extended keys
5871 // from normal keys as the same key is sent
5873 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5875 // except that if lParam is 0, it means we don't have real lParam from
5876 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5877 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5878 // non-numpad (hence extended) key as this is a more common case
5879 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5882 // this array contains the Windows virtual key codes which map one to one to
5883 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5885 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5886 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5887 static const struct wxKeyMapping
5891 } gs_specialKeys
[] =
5893 { VK_CANCEL
, WXK_CANCEL
},
5894 { VK_BACK
, WXK_BACK
},
5895 { VK_TAB
, WXK_TAB
},
5896 { VK_CLEAR
, WXK_CLEAR
},
5897 { VK_SHIFT
, WXK_SHIFT
},
5898 { VK_CONTROL
, WXK_CONTROL
},
5899 { VK_MENU
, WXK_ALT
},
5900 { VK_PAUSE
, WXK_PAUSE
},
5901 { VK_CAPITAL
, WXK_CAPITAL
},
5902 { VK_SPACE
, WXK_SPACE
},
5903 { VK_ESCAPE
, WXK_ESCAPE
},
5904 { VK_SELECT
, WXK_SELECT
},
5905 { VK_PRINT
, WXK_PRINT
},
5906 { VK_EXECUTE
, WXK_EXECUTE
},
5907 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5908 { VK_HELP
, WXK_HELP
},
5910 { VK_NUMPAD0
, WXK_NUMPAD0
},
5911 { VK_NUMPAD1
, WXK_NUMPAD1
},
5912 { VK_NUMPAD2
, WXK_NUMPAD2
},
5913 { VK_NUMPAD3
, WXK_NUMPAD3
},
5914 { VK_NUMPAD4
, WXK_NUMPAD4
},
5915 { VK_NUMPAD5
, WXK_NUMPAD5
},
5916 { VK_NUMPAD6
, WXK_NUMPAD6
},
5917 { VK_NUMPAD7
, WXK_NUMPAD7
},
5918 { VK_NUMPAD8
, WXK_NUMPAD8
},
5919 { VK_NUMPAD9
, WXK_NUMPAD9
},
5920 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5921 { VK_ADD
, WXK_NUMPAD_ADD
},
5922 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5923 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5924 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5935 { VK_F10
, WXK_F10
},
5936 { VK_F11
, WXK_F11
},
5937 { VK_F12
, WXK_F12
},
5938 { VK_F13
, WXK_F13
},
5939 { VK_F14
, WXK_F14
},
5940 { VK_F15
, WXK_F15
},
5941 { VK_F16
, WXK_F16
},
5942 { VK_F17
, WXK_F17
},
5943 { VK_F18
, WXK_F18
},
5944 { VK_F19
, WXK_F19
},
5945 { VK_F20
, WXK_F20
},
5946 { VK_F21
, WXK_F21
},
5947 { VK_F22
, WXK_F22
},
5948 { VK_F23
, WXK_F23
},
5949 { VK_F24
, WXK_F24
},
5951 { VK_NUMLOCK
, WXK_NUMLOCK
},
5952 { VK_SCROLL
, WXK_SCROLL
},
5955 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5956 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5957 { VK_APPS
, WXK_WINDOWS_MENU
},
5958 #endif // VK_APPS defined
5961 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5962 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5963 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5965 // check the table first
5966 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5968 if ( gs_specialKeys
[n
].vk
== vk
)
5969 return gs_specialKeys
[n
].wxk
;
5972 // keys requiring special handling
5976 // the mapping for these keys may be incorrect on non-US keyboards so
5977 // maybe we shouldn't map them to ASCII values at all
5978 case VK_OEM_1
: wxk
= ';'; break;
5979 case VK_OEM_PLUS
: wxk
= '+'; break;
5980 case VK_OEM_COMMA
: wxk
= ','; break;
5981 case VK_OEM_MINUS
: wxk
= '-'; break;
5982 case VK_OEM_PERIOD
: wxk
= '.'; break;
5983 case VK_OEM_2
: wxk
= '/'; break;
5984 case VK_OEM_3
: wxk
= '~'; break;
5985 case VK_OEM_4
: wxk
= '['; break;
5986 case VK_OEM_5
: wxk
= '\\'; break;
5987 case VK_OEM_6
: wxk
= ']'; break;
5988 case VK_OEM_7
: wxk
= '\''; break;
5990 // handle extended keys
5992 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5996 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
6000 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6004 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6008 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6012 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6016 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6020 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6024 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6028 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6032 // don't use ChooseNormalOrExtended() here as the keys are reversed
6033 // here: numpad enter is the extended one
6034 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6044 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
6049 // check the table first
6050 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6052 if ( gs_specialKeys
[n
].wxk
== wxk
)
6053 return gs_specialKeys
[n
].vk
;
6056 // and then check for special keys not included in the table
6061 case WXK_NUMPAD_PAGEUP
:
6066 case WXK_NUMPAD_PAGEDOWN
:
6071 case WXK_NUMPAD_END
:
6076 case WXK_NUMPAD_HOME
:
6081 case WXK_NUMPAD_LEFT
:
6091 case WXK_NUMPAD_RIGHT
:
6096 case WXK_NUMPAD_DOWN
:
6101 case WXK_NUMPAD_INSERT
:
6106 case WXK_NUMPAD_DELETE
:
6111 // no VkKeyScan() under CE unfortunately, we need to test how does
6112 // it handle OEM keys
6114 // check to see if its one of the OEM key codes.
6115 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6121 #endif // !__WXWINCE__
6132 // small helper for wxGetKeyState() and wxGetMouseState()
6133 static inline bool wxIsKeyDown(WXWORD vk
)
6135 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6136 #ifdef SM_SWAPBUTTON
6137 if ( vk
== VK_LBUTTON
|| vk
== VK_RBUTTON
)
6139 if ( ::GetSystemMetrics(SM_SWAPBUTTON
) )
6141 if ( vk
== VK_LBUTTON
)
6143 else // vk == VK_RBUTTON
6147 #endif // SM_SWAPBUTTON
6149 // the low order bit indicates whether the key was pressed since the last
6150 // call and the high order one indicates whether it is down right now and
6151 // we only want that one
6152 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6155 bool wxGetKeyState(wxKeyCode key
)
6157 // although this does work under Windows, it is not supported under other
6158 // platforms so don't allow it, you must use wxGetMouseState() instead
6159 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6160 key
!= VK_RBUTTON
&&
6162 wxT("can't use wxGetKeyState() for mouse buttons") );
6164 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6166 // if the requested key is a LED key, return true if the led is pressed
6167 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6169 // low order bit means LED is highlighted and high order one means the
6170 // key is down; for compatibility with the other ports return true if
6171 // either one is set
6172 return GetKeyState(vk
) != 0;
6177 return wxIsKeyDown(vk
);
6182 wxMouseState
wxGetMouseState()
6186 GetCursorPos( &pt
);
6190 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6191 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6192 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6193 #ifdef wxHAS_XBUTTON
6194 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6195 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6196 #endif // wxHAS_XBUTTON
6198 ms
.SetControlDown(wxIsCtrlDown ());
6199 ms
.SetShiftDown (wxIsShiftDown());
6200 ms
.SetAltDown (wxIsAltDown ());
6201 // ms.SetMetaDown();
6207 wxWindow
*wxGetActiveWindow()
6209 HWND hWnd
= GetActiveWindow();
6212 return wxFindWinFromHandle(hWnd
);
6217 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6219 HWND hwnd
= (HWND
)hWnd
;
6221 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6222 // by code in msw/radiobox.cpp), for all the others we just search up the
6224 wxWindow
*win
= NULL
;
6227 win
= wxFindWinFromHandle(hwnd
);
6231 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6232 // wxWindow class which overrides WM_GETDLGCODE processing to
6233 // do it as well, win would be already non NULL
6234 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6236 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6238 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6239 #endif // wxUSE_RADIOBOX
6241 // spin control text buddy window should be mapped to spin ctrl
6242 // itself so try it too
6243 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6246 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6248 #endif // wxUSE_SPINCTRL
6252 while ( hwnd
&& !win
)
6254 // this is a really ugly hack needed to avoid mistakenly returning the
6255 // parent frame wxWindow for the find/replace modeless dialog HWND -
6256 // this, in turn, is needed to call IsDialogMessage() from
6257 // wxApp::ProcessMessage() as for this we must return NULL from here
6259 // FIXME: this is clearly not the best way to do it but I think we'll
6260 // need to change HWND <-> wxWindow code more heavily than I can
6261 // do it now to fix it
6262 #ifndef __WXMICROWIN__
6263 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6265 // it's a dialog box, don't go upwards
6270 hwnd
= ::GetParent(hwnd
);
6271 win
= wxFindWinFromHandle(hwnd
);
6277 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6279 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6280 // in active frames and dialogs, regardless of where the focus is.
6281 static HHOOK wxTheKeyboardHook
= 0;
6284 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6286 DWORD hiWord
= HIWORD(lParam
);
6287 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6289 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6292 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6293 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6294 event
.m_altDown
= true;
6296 event
.SetEventObject(NULL
);
6297 event
.m_keyCode
= id
;
6298 event
.m_shiftDown
= wxIsShiftDown();
6299 event
.m_controlDown
= wxIsCtrlDown();
6301 event
.SetTimestamp(::GetMessageTime());
6303 wxWindow
*win
= wxGetActiveWindow();
6304 wxEvtHandler
*handler
;
6307 handler
= win
->GetEventHandler();
6308 event
.SetId(win
->GetId());
6313 event
.SetId(wxID_ANY
);
6316 if ( handler
&& handler
->ProcessEvent(event
) )
6324 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6327 void wxSetKeyboardHook(bool doIt
)
6331 wxTheKeyboardHook
= ::SetWindowsHookEx
6334 (HOOKPROC
)wxKeyboardHook
,
6335 NULL
, // must be NULL for process hook
6336 ::GetCurrentThreadId()
6338 if ( !wxTheKeyboardHook
)
6340 wxLogLastError(_T("SetWindowsHookEx(wxKeyboardHook)"));
6345 if ( wxTheKeyboardHook
)
6346 ::UnhookWindowsHookEx(wxTheKeyboardHook
);
6350 #endif // !__WXMICROWIN__
6352 #if wxDEBUG_LEVEL >= 2
6353 const wxChar
*wxGetMessageName(int message
)
6357 case 0x0000: return wxT("WM_NULL");
6358 case 0x0001: return wxT("WM_CREATE");
6359 case 0x0002: return wxT("WM_DESTROY");
6360 case 0x0003: return wxT("WM_MOVE");
6361 case 0x0005: return wxT("WM_SIZE");
6362 case 0x0006: return wxT("WM_ACTIVATE");
6363 case 0x0007: return wxT("WM_SETFOCUS");
6364 case 0x0008: return wxT("WM_KILLFOCUS");
6365 case 0x000A: return wxT("WM_ENABLE");
6366 case 0x000B: return wxT("WM_SETREDRAW");
6367 case 0x000C: return wxT("WM_SETTEXT");
6368 case 0x000D: return wxT("WM_GETTEXT");
6369 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6370 case 0x000F: return wxT("WM_PAINT");
6371 case 0x0010: return wxT("WM_CLOSE");
6372 case 0x0011: return wxT("WM_QUERYENDSESSION");
6373 case 0x0012: return wxT("WM_QUIT");
6374 case 0x0013: return wxT("WM_QUERYOPEN");
6375 case 0x0014: return wxT("WM_ERASEBKGND");
6376 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6377 case 0x0016: return wxT("WM_ENDSESSION");
6378 case 0x0017: return wxT("WM_SYSTEMERROR");
6379 case 0x0018: return wxT("WM_SHOWWINDOW");
6380 case 0x0019: return wxT("WM_CTLCOLOR");
6381 case 0x001A: return wxT("WM_WININICHANGE");
6382 case 0x001B: return wxT("WM_DEVMODECHANGE");
6383 case 0x001C: return wxT("WM_ACTIVATEAPP");
6384 case 0x001D: return wxT("WM_FONTCHANGE");
6385 case 0x001E: return wxT("WM_TIMECHANGE");
6386 case 0x001F: return wxT("WM_CANCELMODE");
6387 case 0x0020: return wxT("WM_SETCURSOR");
6388 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6389 case 0x0022: return wxT("WM_CHILDACTIVATE");
6390 case 0x0023: return wxT("WM_QUEUESYNC");
6391 case 0x0024: return wxT("WM_GETMINMAXINFO");
6392 case 0x0026: return wxT("WM_PAINTICON");
6393 case 0x0027: return wxT("WM_ICONERASEBKGND");
6394 case 0x0028: return wxT("WM_NEXTDLGCTL");
6395 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6396 case 0x002B: return wxT("WM_DRAWITEM");
6397 case 0x002C: return wxT("WM_MEASUREITEM");
6398 case 0x002D: return wxT("WM_DELETEITEM");
6399 case 0x002E: return wxT("WM_VKEYTOITEM");
6400 case 0x002F: return wxT("WM_CHARTOITEM");
6401 case 0x0030: return wxT("WM_SETFONT");
6402 case 0x0031: return wxT("WM_GETFONT");
6403 case 0x0037: return wxT("WM_QUERYDRAGICON");
6404 case 0x0039: return wxT("WM_COMPAREITEM");
6405 case 0x0041: return wxT("WM_COMPACTING");
6406 case 0x0044: return wxT("WM_COMMNOTIFY");
6407 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6408 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6409 case 0x0048: return wxT("WM_POWER");
6411 case 0x004A: return wxT("WM_COPYDATA");
6412 case 0x004B: return wxT("WM_CANCELJOURNAL");
6413 case 0x004E: return wxT("WM_NOTIFY");
6414 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6415 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6416 case 0x0052: return wxT("WM_TCARD");
6417 case 0x0053: return wxT("WM_HELP");
6418 case 0x0054: return wxT("WM_USERCHANGED");
6419 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6420 case 0x007B: return wxT("WM_CONTEXTMENU");
6421 case 0x007C: return wxT("WM_STYLECHANGING");
6422 case 0x007D: return wxT("WM_STYLECHANGED");
6423 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6424 case 0x007F: return wxT("WM_GETICON");
6425 case 0x0080: return wxT("WM_SETICON");
6427 case 0x0081: return wxT("WM_NCCREATE");
6428 case 0x0082: return wxT("WM_NCDESTROY");
6429 case 0x0083: return wxT("WM_NCCALCSIZE");
6430 case 0x0084: return wxT("WM_NCHITTEST");
6431 case 0x0085: return wxT("WM_NCPAINT");
6432 case 0x0086: return wxT("WM_NCACTIVATE");
6433 case 0x0087: return wxT("WM_GETDLGCODE");
6434 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6435 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6436 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6437 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6438 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6439 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6440 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6441 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6442 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6443 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6445 case 0x00B0: return wxT("EM_GETSEL");
6446 case 0x00B1: return wxT("EM_SETSEL");
6447 case 0x00B2: return wxT("EM_GETRECT");
6448 case 0x00B3: return wxT("EM_SETRECT");
6449 case 0x00B4: return wxT("EM_SETRECTNP");
6450 case 0x00B5: return wxT("EM_SCROLL");
6451 case 0x00B6: return wxT("EM_LINESCROLL");
6452 case 0x00B7: return wxT("EM_SCROLLCARET");
6453 case 0x00B8: return wxT("EM_GETMODIFY");
6454 case 0x00B9: return wxT("EM_SETMODIFY");
6455 case 0x00BA: return wxT("EM_GETLINECOUNT");
6456 case 0x00BB: return wxT("EM_LINEINDEX");
6457 case 0x00BC: return wxT("EM_SETHANDLE");
6458 case 0x00BD: return wxT("EM_GETHANDLE");
6459 case 0x00BE: return wxT("EM_GETTHUMB");
6460 case 0x00C1: return wxT("EM_LINELENGTH");
6461 case 0x00C2: return wxT("EM_REPLACESEL");
6462 case 0x00C4: return wxT("EM_GETLINE");
6463 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6464 case 0x00C6: return wxT("EM_CANUNDO");
6465 case 0x00C7: return wxT("EM_UNDO");
6466 case 0x00C8: return wxT("EM_FMTLINES");
6467 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6468 case 0x00CB: return wxT("EM_SETTABSTOPS");
6469 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6470 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6471 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6472 case 0x00CF: return wxT("EM_SETREADONLY");
6473 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6474 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6475 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6476 case 0x00D3: return wxT("EM_SETMARGINS");
6477 case 0x00D4: return wxT("EM_GETMARGINS");
6478 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6479 case 0x00D6: return wxT("EM_POSFROMCHAR");
6480 case 0x00D7: return wxT("EM_CHARFROMPOS");
6481 case 0x00D8: return wxT("EM_SETIMESTATUS");
6482 case 0x00D9: return wxT("EM_GETIMESTATUS");
6484 case 0x0100: return wxT("WM_KEYDOWN");
6485 case 0x0101: return wxT("WM_KEYUP");
6486 case 0x0102: return wxT("WM_CHAR");
6487 case 0x0103: return wxT("WM_DEADCHAR");
6488 case 0x0104: return wxT("WM_SYSKEYDOWN");
6489 case 0x0105: return wxT("WM_SYSKEYUP");
6490 case 0x0106: return wxT("WM_SYSCHAR");
6491 case 0x0107: return wxT("WM_SYSDEADCHAR");
6492 case 0x0108: return wxT("WM_KEYLAST");
6494 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6495 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6496 case 0x010F: return wxT("WM_IME_COMPOSITION");
6498 case 0x0110: return wxT("WM_INITDIALOG");
6499 case 0x0111: return wxT("WM_COMMAND");
6500 case 0x0112: return wxT("WM_SYSCOMMAND");
6501 case 0x0113: return wxT("WM_TIMER");
6502 case 0x0114: return wxT("WM_HSCROLL");
6503 case 0x0115: return wxT("WM_VSCROLL");
6504 case 0x0116: return wxT("WM_INITMENU");
6505 case 0x0117: return wxT("WM_INITMENUPOPUP");
6506 case 0x011F: return wxT("WM_MENUSELECT");
6507 case 0x0120: return wxT("WM_MENUCHAR");
6508 case 0x0121: return wxT("WM_ENTERIDLE");
6510 case 0x0127: return wxT("WM_CHANGEUISTATE");
6511 case 0x0128: return wxT("WM_UPDATEUISTATE");
6512 case 0x0129: return wxT("WM_QUERYUISTATE");
6514 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6515 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6516 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6517 case 0x0135: return wxT("WM_CTLCOLORBTN");
6518 case 0x0136: return wxT("WM_CTLCOLORDLG");
6519 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6520 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6521 case 0x01E1: return wxT("MN_GETHMENU");
6523 case 0x0200: return wxT("WM_MOUSEMOVE");
6524 case 0x0201: return wxT("WM_LBUTTONDOWN");
6525 case 0x0202: return wxT("WM_LBUTTONUP");
6526 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6527 case 0x0204: return wxT("WM_RBUTTONDOWN");
6528 case 0x0205: return wxT("WM_RBUTTONUP");
6529 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6530 case 0x0207: return wxT("WM_MBUTTONDOWN");
6531 case 0x0208: return wxT("WM_MBUTTONUP");
6532 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6533 case 0x020A: return wxT("WM_MOUSEWHEEL");
6534 case 0x020B: return wxT("WM_XBUTTONDOWN");
6535 case 0x020C: return wxT("WM_XBUTTONUP");
6536 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6537 case 0x0210: return wxT("WM_PARENTNOTIFY");
6538 case 0x0211: return wxT("WM_ENTERMENULOOP");
6539 case 0x0212: return wxT("WM_EXITMENULOOP");
6541 case 0x0213: return wxT("WM_NEXTMENU");
6542 case 0x0214: return wxT("WM_SIZING");
6543 case 0x0215: return wxT("WM_CAPTURECHANGED");
6544 case 0x0216: return wxT("WM_MOVING");
6545 case 0x0218: return wxT("WM_POWERBROADCAST");
6546 case 0x0219: return wxT("WM_DEVICECHANGE");
6548 case 0x0220: return wxT("WM_MDICREATE");
6549 case 0x0221: return wxT("WM_MDIDESTROY");
6550 case 0x0222: return wxT("WM_MDIACTIVATE");
6551 case 0x0223: return wxT("WM_MDIRESTORE");
6552 case 0x0224: return wxT("WM_MDINEXT");
6553 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6554 case 0x0226: return wxT("WM_MDITILE");
6555 case 0x0227: return wxT("WM_MDICASCADE");
6556 case 0x0228: return wxT("WM_MDIICONARRANGE");
6557 case 0x0229: return wxT("WM_MDIGETACTIVE");
6558 case 0x0230: return wxT("WM_MDISETMENU");
6559 case 0x0233: return wxT("WM_DROPFILES");
6561 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6562 case 0x0282: return wxT("WM_IME_NOTIFY");
6563 case 0x0283: return wxT("WM_IME_CONTROL");
6564 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6565 case 0x0285: return wxT("WM_IME_SELECT");
6566 case 0x0286: return wxT("WM_IME_CHAR");
6567 case 0x0290: return wxT("WM_IME_KEYDOWN");
6568 case 0x0291: return wxT("WM_IME_KEYUP");
6570 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6571 case 0x02A1: return wxT("WM_MOUSEHOVER");
6572 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6573 case 0x02A3: return wxT("WM_MOUSELEAVE");
6575 case 0x0300: return wxT("WM_CUT");
6576 case 0x0301: return wxT("WM_COPY");
6577 case 0x0302: return wxT("WM_PASTE");
6578 case 0x0303: return wxT("WM_CLEAR");
6579 case 0x0304: return wxT("WM_UNDO");
6580 case 0x0305: return wxT("WM_RENDERFORMAT");
6581 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6582 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6583 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6584 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6585 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6586 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6587 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6588 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6589 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6590 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6591 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6592 case 0x0311: return wxT("WM_PALETTECHANGED");
6593 case 0x0312: return wxT("WM_HOTKEY");
6595 case 0x0317: return wxT("WM_PRINT");
6596 case 0x0318: return wxT("WM_PRINTCLIENT");
6598 // common controls messages - although they're not strictly speaking
6599 // standard, it's nice to decode them nevertheless
6602 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6603 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6604 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6605 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6606 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6607 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6608 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6609 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6610 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6611 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6612 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6613 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6614 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6615 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6616 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6617 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6618 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6619 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6620 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6621 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6622 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6623 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6624 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6625 case 0x1000 + 18: return wxT("LVM_HITTEST");
6626 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6627 case 0x1000 + 20: return wxT("LVM_SCROLL");
6628 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6629 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6630 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6631 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6632 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6633 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6634 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6635 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6636 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6637 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6638 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6639 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6640 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6641 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6642 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6643 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6644 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6645 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6646 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6647 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6648 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6649 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6650 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6651 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6652 case 0x1000 + 42: return wxT("LVM_UPDATE");
6653 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6654 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6655 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6656 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6657 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6658 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6659 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6660 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6661 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6662 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6663 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6664 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6665 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6666 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6667 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6668 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6669 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6670 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6671 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6672 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6673 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6674 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6675 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6676 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6677 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6678 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6681 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6682 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6683 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6684 case 0x1100 + 2: return wxT("TVM_EXPAND");
6685 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6686 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6687 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6688 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6689 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6690 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6691 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6692 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6693 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6694 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6695 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6696 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6697 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6698 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6699 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6700 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6701 case 0x1100 + 17: return wxT("TVM_HITTEST");
6702 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6703 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6704 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6705 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6706 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6707 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6708 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6709 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6710 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6713 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6714 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6715 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6716 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6717 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6718 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6719 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6720 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6721 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6722 case 0x1200 + 6: return wxT("HDM_HITTEST");
6723 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6724 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6725 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6726 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6727 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6728 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6729 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6730 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6733 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6734 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6735 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6736 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6737 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6738 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6739 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6740 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6741 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6742 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6743 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6744 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6745 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6746 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6747 case 0x1300 + 13: return wxT("TCM_HITTEST");
6748 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6749 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6750 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6751 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6752 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6753 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6754 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6755 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6756 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6757 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6758 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6759 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6762 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6763 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6764 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6765 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6766 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6767 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6768 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6769 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6770 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6771 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6772 case WM_USER
+17: return wxT("TB_SETSTATE");
6773 case WM_USER
+18: return wxT("TB_GETSTATE");
6774 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6775 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6776 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6777 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6778 case WM_USER
+23: return wxT("TB_GETBUTTON");
6779 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6780 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6781 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6782 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6783 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6784 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6785 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6786 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6787 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6788 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6789 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6790 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6791 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6792 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6793 case WM_USER
+37: return wxT("TB_SETPARENT");
6794 case WM_USER
+39: return wxT("TB_SETROWS");
6795 case WM_USER
+40: return wxT("TB_GETROWS");
6796 case WM_USER
+42: return wxT("TB_SETCMDID");
6797 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6798 case WM_USER
+44: return wxT("TB_GETBITMAP");
6799 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6800 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6801 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6802 case WM_USER
+47: return wxT("TB_SETINDENT");
6803 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6804 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6805 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6806 case WM_USER
+51: return wxT("TB_GETRECT");
6807 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6808 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6809 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6810 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6811 case WM_USER
+56: return wxT("TB_SETSTYLE");
6812 case WM_USER
+57: return wxT("TB_GETSTYLE");
6813 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6814 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6815 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6816 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6817 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6820 static wxString s_szBuf
;
6821 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6822 return s_szBuf
.c_str();
6825 #endif // wxDEBUG_LEVEL >= 2
6827 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6831 HWND hwnd
= GetHwndOf(win
);
6832 HDC hdc
= ::GetDC(hwnd
);
6834 #if !wxDIALOG_UNIT_COMPATIBILITY
6835 // and select the current font into it
6836 HFONT hfont
= GetHfontOf(win
->GetFont());
6839 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6843 // finally retrieve the text metrics from it
6844 GetTextMetrics(hdc
, &tm
);
6846 #if !wxDIALOG_UNIT_COMPATIBILITY
6850 (void)::SelectObject(hdc
, hfont
);
6854 ::ReleaseDC(hwnd
, hdc
);
6859 // Find the wxWindow at the current mouse position, returning the mouse
6861 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6863 pt
= wxGetMousePosition();
6864 return wxFindWindowAtPoint(pt
);
6867 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6873 HWND hWnd
= ::WindowFromPoint(pt2
);
6875 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6878 // Get the current mouse position.
6879 wxPoint
wxGetMousePosition()
6883 GetCursorPosWinCE(&pt
);
6885 GetCursorPos( & pt
);
6888 return wxPoint(pt
.x
, pt
.y
);
6893 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6894 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6896 // Register hotkeys for the hardware buttons
6898 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6900 UnregisterFunc1Proc procUnregisterFunc
;
6901 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6904 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6905 if (procUnregisterFunc
)
6906 procUnregisterFunc(modifiers
, id
);
6907 FreeLibrary(hCoreDll
);
6912 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6914 UINT win_modifiers
=0;
6915 if ( modifiers
& wxMOD_ALT
)
6916 win_modifiers
|= MOD_ALT
;
6917 if ( modifiers
& wxMOD_SHIFT
)
6918 win_modifiers
|= MOD_SHIFT
;
6919 if ( modifiers
& wxMOD_CONTROL
)
6920 win_modifiers
|= MOD_CONTROL
;
6921 if ( modifiers
& wxMOD_WIN
)
6922 win_modifiers
|= MOD_WIN
;
6924 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6925 // Required for PPC and Smartphone hardware buttons
6926 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6927 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6930 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6932 wxLogLastError(_T("RegisterHotKey"));
6940 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6942 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6943 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6946 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6948 wxLogLastError(_T("UnregisterHotKey"));
6958 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6960 int hotkeyId
= wParam
;
6961 int virtualKey
= HIWORD(lParam
);
6962 int win_modifiers
= LOWORD(lParam
);
6964 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6965 event
.SetId(hotkeyId
);
6966 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6967 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6968 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6969 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6971 return HandleWindowEvent(event
);
6974 #endif // wxUSE_ACCEL
6976 #endif // wxUSE_HOTKEY
6978 // Not tested under WinCE
6981 // this class installs a message hook which really wakes up our idle processing
6982 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6983 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6984 // being dragged or even inside ::MessageBox()) and so don't control message
6985 // dispatching otherwise
6986 class wxIdleWakeUpModule
: public wxModule
6989 virtual bool OnInit()
6991 ms_hMsgHookProc
= ::SetWindowsHookEx
6994 &wxIdleWakeUpModule::MsgHookProc
,
6996 GetCurrentThreadId()
6999 if ( !ms_hMsgHookProc
)
7001 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
7009 virtual void OnExit()
7011 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
7014 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
7016 MSG
*msg
= (MSG
*)lParam
;
7018 // only process the message if it is actually going to be removed from
7019 // the message queue, this prevents that the same event from being
7020 // processed multiple times if now someone just called PeekMessage()
7021 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7023 wxTheApp
->ProcessPendingEvents();
7026 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7030 static HHOOK ms_hMsgHookProc
;
7032 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7035 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7037 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7039 #endif // __WXWINCE__
7044 static void wxAdjustZOrder(wxWindow
* parent
)
7046 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7048 // Set the z-order correctly
7049 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7052 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7055 wxWindow
*childWin
= current
->GetData();
7056 wxAdjustZOrder(childWin
);
7057 current
= current
->GetNext();
7062 // We need to adjust the z-order of static boxes in WinCE, to
7063 // make 'contained' controls visible
7064 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7067 wxAdjustZOrder(this);