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(wxT("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
)
417 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
421 // ===========================================================================
423 // ===========================================================================
425 // ---------------------------------------------------------------------------
426 // wxWindow utility functions
427 // ---------------------------------------------------------------------------
429 // Find an item given the MS Windows id
430 wxWindow
*wxWindowMSW::FindItem(long id
) const
433 wxControl
*item
= wxDynamicCastThis(wxControl
);
436 // is it us or one of our "internal" children?
437 if ( item
->GetId() == id
438 #ifndef __WXUNIVERSAL__
439 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
440 #endif // __WXUNIVERSAL__
446 #endif // wxUSE_CONTROLS
448 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
451 wxWindow
*childWin
= current
->GetData();
453 wxWindow
*wnd
= childWin
->FindItem(id
);
457 current
= current
->GetNext();
463 // Find an item given the MS Windows handle
464 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
466 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
469 wxWindow
*parent
= current
->GetData();
471 // Do a recursive search.
472 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
478 || parent
->IsKindOf(CLASSINFO(wxControl
))
479 #endif // wxUSE_CONTROLS
482 wxWindow
*item
= current
->GetData();
483 if ( item
->GetHWND() == hWnd
)
487 if ( item
->ContainsHWND(hWnd
) )
492 current
= current
->GetNext();
497 // Default command handler
498 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
503 // ----------------------------------------------------------------------------
504 // constructors and such
505 // ----------------------------------------------------------------------------
507 void wxWindowMSW::Init()
511 m_mouseInWindow
= false;
512 m_lastKeydownProcessed
= false;
519 #if wxUSE_DEFERRED_SIZING
521 m_pendingPosition
= wxDefaultPosition
;
522 m_pendingSize
= wxDefaultSize
;
523 #endif // wxUSE_DEFERRED_SIZING
526 m_contextMenuEnabled
= false;
531 wxWindowMSW::~wxWindowMSW()
535 #ifndef __WXUNIVERSAL__
536 // VS: make sure there's no wxFrame with last focus set to us:
537 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
539 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
542 if ( frame
->GetLastFocus() == this )
544 frame
->SetLastFocus(NULL
);
547 // apparently sometimes we can end up with our grand parent
548 // pointing to us as well: this is surely a bug in focus handling
549 // code but it's not clear where it happens so for now just try to
550 // fix it here by not breaking out of the loop
554 #endif // __WXUNIVERSAL__
556 // VS: destroy children first and _then_ detach *this from its parent.
557 // If we did it the other way around, children wouldn't be able
558 // find their parent frame (see above).
563 // VZ: test temp removed to understand what really happens here
564 //if (::IsWindow(GetHwnd()))
566 if ( !::DestroyWindow(GetHwnd()) )
568 wxLogLastError(wxT("DestroyWindow"));
572 // remove hWnd <-> wxWindow association
573 wxRemoveHandleAssociation(this);
579 const wxChar
*wxWindowMSW::MSWGetRegisteredClassName()
581 return wxApp::GetRegisteredClassName(wxT("wxWindow"), COLOR_BTNFACE
);
584 // real construction (Init() must have been called before!)
585 bool wxWindowMSW::Create(wxWindow
*parent
,
590 const wxString
& name
)
592 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
594 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
597 parent
->AddChild(this);
600 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
602 #ifdef __WXUNIVERSAL__
603 // no borders, we draw them ourselves
604 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
608 msflags
&= ~WS_BORDER
;
609 #endif // wxUniversal
613 msflags
|= WS_VISIBLE
;
616 if ( !MSWCreate(MSWGetRegisteredClassName(),
617 NULL
, pos
, size
, msflags
, exstyle
) )
625 // ---------------------------------------------------------------------------
627 // ---------------------------------------------------------------------------
629 void wxWindowMSW::SetFocus()
631 HWND hWnd
= GetHwnd();
632 wxCHECK_RET( hWnd
, wxT("can't set focus to invalid window") );
634 #if !defined(__WXWINCE__)
638 if ( !::SetFocus(hWnd
) )
640 // was there really an error?
641 DWORD dwRes
= ::GetLastError();
644 HWND hwndFocus
= ::GetFocus();
645 if ( hwndFocus
!= hWnd
)
647 wxLogApiError(wxT("SetFocus"), dwRes
);
653 void wxWindowMSW::SetFocusFromKbd()
655 // when the focus is given to the control with DLGC_HASSETSEL style from
656 // keyboard its contents should be entirely selected: this is what
657 // ::IsDialogMessage() does and so we should do it as well to provide the
658 // same LNF as the native programs
659 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
661 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
664 // do this after (maybe) setting the selection as like this when
665 // wxEVT_SET_FOCUS handler is called, the selection would have been already
666 // set correctly -- this may be important
667 wxWindowBase::SetFocusFromKbd();
670 // Get the window with the focus
671 wxWindow
*wxWindowBase::DoFindFocus()
673 HWND hWnd
= ::GetFocus();
676 return wxGetWindowFromHWND((WXHWND
)hWnd
);
682 void wxWindowMSW::DoEnable( bool enable
)
684 HWND hWnd
= GetHwnd();
686 ::EnableWindow(hWnd
, (BOOL
)enable
);
689 bool wxWindowMSW::Show(bool show
)
691 if ( !wxWindowBase::Show(show
) )
694 HWND hWnd
= GetHwnd();
696 // we could be called before the underlying window is created (this is
697 // actually useful to prevent it from being initially shown), e.g.
699 // wxFoo *foo = new wxFoo;
701 // foo->Create(parent, ...);
703 // should work without errors
706 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
711 // DoFreeze/DoThaw don't do anything if the window is not shown, so
712 // we have to call them from here now
723 wxWindowMSW::MSWShowWithEffect(bool show
,
727 if ( !wxWindowBase::Show(show
) )
730 typedef BOOL (WINAPI
*AnimateWindow_t
)(HWND
, DWORD
, DWORD
);
732 static AnimateWindow_t s_pfnAnimateWindow
= NULL
;
733 static bool s_initDone
= false;
736 wxDynamicLibrary
dllUser32(wxT("user32.dll"), wxDL_VERBATIM
| wxDL_QUIET
);
737 wxDL_INIT_FUNC(s_pfn
, AnimateWindow
, dllUser32
);
741 // notice that it's ok to unload user32.dll here as it won't be really
742 // unloaded, being still in use because we link to it statically too
745 if ( !s_pfnAnimateWindow
)
748 // Show() has a side effect of sending a WM_SIZE to the window, which helps
749 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
750 // this so send the event ourselves
753 // prepare to use AnimateWindow()
756 timeout
= 200; // this is the default animation timeout, per MSDN
758 DWORD dwFlags
= show
? 0 : AW_HIDE
;
762 case wxSHOW_EFFECT_ROLL_TO_LEFT
:
763 dwFlags
|= AW_HOR_NEGATIVE
;
766 case wxSHOW_EFFECT_ROLL_TO_RIGHT
:
767 dwFlags
|= AW_HOR_POSITIVE
;
770 case wxSHOW_EFFECT_ROLL_TO_TOP
:
771 dwFlags
|= AW_VER_NEGATIVE
;
774 case wxSHOW_EFFECT_ROLL_TO_BOTTOM
:
775 dwFlags
|= AW_VER_POSITIVE
;
778 case wxSHOW_EFFECT_SLIDE_TO_LEFT
:
779 dwFlags
|= AW_SLIDE
| AW_HOR_NEGATIVE
;
782 case wxSHOW_EFFECT_SLIDE_TO_RIGHT
:
783 dwFlags
|= AW_SLIDE
| AW_HOR_POSITIVE
;
786 case wxSHOW_EFFECT_SLIDE_TO_TOP
:
787 dwFlags
|= AW_SLIDE
| AW_VER_NEGATIVE
;
790 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM
:
791 dwFlags
|= AW_SLIDE
| AW_VER_POSITIVE
;
794 case wxSHOW_EFFECT_BLEND
:
798 case wxSHOW_EFFECT_EXPAND
:
799 dwFlags
|= AW_CENTER
;
803 case wxSHOW_EFFECT_MAX
:
804 wxFAIL_MSG( wxT("invalid window show effect") );
808 wxFAIL_MSG( wxT("unknown window show effect") );
812 if ( !(*s_pfnAnimateWindow
)(GetHwnd(), timeout
, dwFlags
) )
814 wxLogLastError(wxT("AnimateWindow"));
822 // Raise the window to the top of the Z order
823 void wxWindowMSW::Raise()
825 wxBringWindowToTop(GetHwnd());
828 // Lower the window to the bottom of the Z order
829 void wxWindowMSW::Lower()
831 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
832 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
835 void wxWindowMSW::DoCaptureMouse()
837 HWND hWnd
= GetHwnd();
844 void wxWindowMSW::DoReleaseMouse()
846 if ( !::ReleaseCapture() )
848 wxLogLastError(wxT("ReleaseCapture"));
852 /* static */ wxWindow
*wxWindowBase::GetCapture()
854 HWND hwnd
= ::GetCapture();
855 return hwnd
? wxFindWinFromHandle(hwnd
) : NULL
;
858 bool wxWindowMSW::SetFont(const wxFont
& font
)
860 if ( !wxWindowBase::SetFont(font
) )
866 HWND hWnd
= GetHwnd();
869 // note the use of GetFont() instead of m_font: our own font could have
870 // just been reset and in this case we need to change the font used by
871 // the native window to the default for this class, i.e. exactly what
873 WXHANDLE hFont
= GetFont().GetResourceHandle();
875 wxASSERT_MSG( hFont
, wxT("should have valid font") );
877 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
882 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
884 if ( !wxWindowBase::SetCursor(cursor
) )
890 // don't "overwrite" busy cursor
891 if ( m_cursor
.Ok() && !wxIsBusy() )
893 // normally we should change the cursor only if it's over this window
894 // but we should do it always if we capture the mouse currently
895 bool set
= HasCapture();
898 HWND hWnd
= GetHwnd();
902 ::GetCursorPosWinCE(&point
);
904 ::GetCursorPos(&point
);
907 RECT rect
= wxGetWindowRect(hWnd
);
909 set
= ::PtInRect(&rect
, point
) != 0;
914 ::SetCursor(GetHcursorOf(m_cursor
));
916 //else: will be set later when the mouse enters this window
922 void wxWindowMSW::WarpPointer(int x
, int y
)
924 ClientToScreen(&x
, &y
);
926 if ( !::SetCursorPos(x
, y
) )
928 wxLogLastError(wxT("SetCursorPos"));
932 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
934 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
935 // to use it on older systems -- and could possibly do some harm
936 static int s_needToUpdate
= -1;
937 if ( s_needToUpdate
== -1 )
940 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
944 if ( s_needToUpdate
)
946 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
947 // won't send WM_UPDATEUISTATE
948 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
952 // ---------------------------------------------------------------------------
954 // ---------------------------------------------------------------------------
959 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
961 #ifdef __WXMICROWIN__
962 return ::GetScrollPosWX(hWnd
, wOrient
);
964 WinStruct
<SCROLLINFO
> scrollInfo
;
965 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
966 scrollInfo
.fMask
= SIF_POS
;
967 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
969 return scrollInfo
.nPos
;
974 inline UINT
WXOrientToSB(int orient
)
976 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
979 } // anonymous namespace
981 int wxWindowMSW::GetScrollPos(int orient
) const
983 HWND hWnd
= GetHwnd();
984 wxCHECK_MSG( hWnd
, 0, wxT("no HWND in GetScrollPos") );
986 return GetScrollPosition(hWnd
, WXOrientToSB(orient
));
989 // This now returns the whole range, not just the number
990 // of positions that we can scroll.
991 int wxWindowMSW::GetScrollRange(int orient
) const
994 HWND hWnd
= GetHwnd();
997 WinStruct
<SCROLLINFO
> scrollInfo
;
998 scrollInfo
.fMask
= SIF_RANGE
;
999 if ( !::GetScrollInfo(hWnd
, WXOrientToSB(orient
), &scrollInfo
) )
1001 // Most of the time this is not really an error, since the return
1002 // value can also be zero when there is no scrollbar yet.
1003 // wxLogLastError(wxT("GetScrollInfo"));
1005 maxPos
= scrollInfo
.nMax
;
1007 // undo "range - 1" done in SetScrollbar()
1011 int wxWindowMSW::GetScrollThumb(int orient
) const
1013 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
1016 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
1018 HWND hWnd
= GetHwnd();
1019 wxCHECK_RET( hWnd
, wxT("SetScrollPos: no HWND") );
1021 WinStruct
<SCROLLINFO
> info
;
1025 info
.fMask
= SIF_POS
;
1026 if ( HasFlag(wxALWAYS_SHOW_SB
) )
1028 // disable scrollbar instead of removing it then
1029 info
.fMask
|= SIF_DISABLENOSCROLL
;
1032 ::SetScrollInfo(hWnd
, WXOrientToSB(orient
), &info
, refresh
);
1035 // New function that will replace some of the above.
1036 void wxWindowMSW::SetScrollbar(int orient
,
1042 // We have to set the variables here to make them valid in events
1043 // triggered by ::SetScrollInfo()
1044 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
1046 HWND hwnd
= GetHwnd();
1050 WinStruct
<SCROLLINFO
> info
;
1053 info
.nPage
= pageSize
;
1054 info
.nMin
= 0; // range is nMax - nMin + 1
1055 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
1058 // enable the scrollbar if it had been disabled before by specifying
1059 // SIF_DISABLENOSCROLL below: as we can't know whether this had been
1060 // done or not just do it always
1061 ::EnableScrollBar(hwnd
, WXOrientToSB(orient
), ESB_ENABLE_BOTH
);
1063 //else: leave all the fields to be 0
1065 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
1066 if ( HasFlag(wxALWAYS_SHOW_SB
) || range
== -1 )
1068 // disable scrollbar instead of removing it then
1069 info
.fMask
|= SIF_DISABLENOSCROLL
;
1072 ::SetScrollInfo(hwnd
, WXOrientToSB(orient
), &info
, refresh
);
1075 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
1081 wxCopyRectToRECT(*prect
, rect
);
1091 // FIXME: is this the exact equivalent of the line below?
1092 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
1094 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
1098 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
1100 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
1103 for ( int n
= 0; n
< count
; n
++ )
1105 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
1107 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1108 if ( posNew
== pos
)
1110 // don't bother to continue, we're already at top/bottom
1117 return pos
!= posStart
;
1120 bool wxWindowMSW::ScrollLines(int lines
)
1122 bool down
= lines
> 0;
1124 return ScrollVertically(GetHwnd(),
1125 down
? SB_LINEDOWN
: SB_LINEUP
,
1126 down
? lines
: -lines
);
1129 bool wxWindowMSW::ScrollPages(int pages
)
1131 bool down
= pages
> 0;
1133 return ScrollVertically(GetHwnd(),
1134 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1135 down
? pages
: -pages
);
1138 // ----------------------------------------------------------------------------
1140 // ----------------------------------------------------------------------------
1142 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1147 wxCHECK_RET( GetHwnd(),
1148 wxT("layout direction must be set after window creation") );
1150 LONG styleOld
= wxGetWindowExStyle(this);
1152 LONG styleNew
= styleOld
;
1155 case wxLayout_LeftToRight
:
1156 styleNew
&= ~WS_EX_LAYOUTRTL
;
1159 case wxLayout_RightToLeft
:
1160 styleNew
|= WS_EX_LAYOUTRTL
;
1164 wxFAIL_MSG(wxT("unsupported layout direction"));
1168 if ( styleNew
!= styleOld
)
1170 wxSetWindowExStyle(this, styleNew
);
1175 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1178 return wxLayout_Default
;
1180 wxCHECK_MSG( GetHwnd(), wxLayout_Default
, wxT("invalid window") );
1182 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL
) ? wxLayout_RightToLeft
1183 : wxLayout_LeftToRight
;
1188 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1189 wxCoord
WXUNUSED(width
),
1190 wxCoord
WXUNUSED(widthTotal
)) const
1192 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1193 // redo it ourselves
1197 // ---------------------------------------------------------------------------
1199 // ---------------------------------------------------------------------------
1201 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1203 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1205 HWND hwnd
= (HWND
)hWnd
;
1206 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1210 wxAssociateWinWithHandle(hwnd
, this);
1212 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1214 // we don't need to subclass the window of our own class (in the Windows
1215 // sense of the word)
1216 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1218 wxSetWindowProc(hwnd
, wxWndProc
);
1222 // don't bother restoring it either: this also makes it easy to
1223 // implement IsOfStandardClass() method which returns true for the
1224 // standard controls and false for the wxWidgets own windows as it can
1225 // simply check m_oldWndProc
1226 m_oldWndProc
= NULL
;
1229 // we're officially created now, send the event
1230 wxWindowCreateEvent
event((wxWindow
*)this);
1231 (void)HandleWindowEvent(event
);
1234 void wxWindowMSW::UnsubclassWin()
1236 wxRemoveHandleAssociation(this);
1238 // Restore old Window proc
1239 HWND hwnd
= GetHwnd();
1244 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1248 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1250 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1253 m_oldWndProc
= NULL
;
1258 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1262 if ( !::DestroyWindow(GetHwnd()) )
1264 wxLogLastError(wxT("DestroyWindow"));
1268 WXHWND wxhwnd
= (WXHWND
)handle
;
1270 // this also calls SetHWND(wxhwnd)
1271 SubclassWin(wxhwnd
);
1274 void wxWindowMSW::DissociateHandle()
1276 // this also calls SetHWND(0) for us
1281 bool wxCheckWindowWndProc(WXHWND hWnd
,
1282 WXFARPROC
WXUNUSED(wndProc
))
1284 const wxString
str(wxGetWindowClass(hWnd
));
1286 // TODO: get rid of wxTLWHiddenParent special case (currently it's not
1287 // registered by wxApp but using ad hoc code in msw/toplevel.cpp);
1288 // there is also a hidden window class used by sockets &c
1289 return wxApp::IsRegisteredClassName(str
) || str
== wxT("wxTLWHiddenParent");
1292 // ----------------------------------------------------------------------------
1294 // ----------------------------------------------------------------------------
1296 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1298 long flagsOld
= GetWindowStyleFlag();
1299 if ( flags
== flagsOld
)
1302 // update the internal variable
1303 wxWindowBase::SetWindowStyleFlag(flags
);
1305 // and the real window flags
1306 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1309 void wxWindowMSW::SetExtraStyle(long exflags
)
1311 long exflagsOld
= GetExtraStyle();
1312 if ( exflags
== exflagsOld
)
1315 // update the internal variable
1316 wxWindowBase::SetExtraStyle(exflags
);
1318 // and the real window flags
1319 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1322 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1324 // now update the Windows style as well if needed - and if the window had
1325 // been already created
1329 // we may need to call SetWindowPos() when we change some styles
1330 bool callSWP
= false;
1333 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1335 // this is quite a horrible hack but we need it because MSWGetStyle()
1336 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1337 // and so we have to modify the window exflags temporarily to get the
1338 // correct exstyleOld
1339 long exflagsNew
= GetExtraStyle();
1340 wxWindowBase::SetExtraStyle(exflagsOld
);
1343 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1345 wxWindowBase::SetExtraStyle(exflagsNew
);
1348 if ( style
!= styleOld
)
1350 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1351 // this function so instead of simply setting the style to the new
1352 // value we clear the bits which were set in styleOld but are set in
1353 // the new one and set the ones which were not set before
1354 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1355 styleReal
&= ~styleOld
;
1358 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1360 // we need to call SetWindowPos() if any of the styles affecting the
1361 // frame appearance have changed
1362 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1371 // and the extended style
1372 long exstyleReal
= wxGetWindowExStyle(this);
1374 if ( exstyle
!= exstyleOld
)
1376 exstyleReal
&= ~exstyleOld
;
1377 exstyleReal
|= exstyle
;
1379 wxSetWindowExStyle(this, exstyleReal
);
1381 // ex style changes don't take effect without calling SetWindowPos
1387 // we must call SetWindowPos() to flush the cached extended style and
1388 // also to make the change to wxSTAY_ON_TOP style take effect: just
1389 // setting the style simply doesn't work
1390 if ( !::SetWindowPos(GetHwnd(),
1391 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1394 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1396 wxLogLastError(wxT("SetWindowPos"));
1401 wxBorder
wxWindowMSW::GetDefaultBorderForControl() const
1403 return wxBORDER_THEME
;
1406 wxBorder
wxWindowMSW::GetDefaultBorder() const
1408 return wxWindowBase::GetDefaultBorder();
1411 // Translate wxBORDER_THEME (and other border styles if necessary) to the value
1412 // that makes most sense for this Windows environment
1413 wxBorder
wxWindowMSW::TranslateBorder(wxBorder border
) const
1415 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1416 if (border
== wxBORDER_THEME
|| border
== wxBORDER_SUNKEN
|| border
== wxBORDER_SIMPLE
)
1417 return wxBORDER_SIMPLE
;
1419 return wxBORDER_NONE
;
1422 if (border
== wxBORDER_THEME
)
1424 if (CanApplyThemeBorder())
1426 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
1428 return wxBORDER_THEME
;
1430 return wxBORDER_SUNKEN
;
1438 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1440 // translate common wxWidgets styles to Windows ones
1442 // most of windows are child ones, those which are not (such as
1443 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1444 WXDWORD style
= WS_CHILD
;
1446 // using this flag results in very significant reduction in flicker,
1447 // especially with controls inside the static boxes (as the interior of the
1448 // box is not redrawn twice), but sometimes results in redraw problems, so
1449 // optionally allow the old code to continue to use it provided a special
1450 // system option is turned on
1451 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1452 || (flags
& wxCLIP_CHILDREN
) )
1453 style
|= WS_CLIPCHILDREN
;
1455 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1456 // don't support overlapping windows and it only makes sense for them and,
1457 // presumably, gives the system some extra work (to manage more clipping
1458 // regions), so avoid it alltogether
1461 if ( flags
& wxVSCROLL
)
1462 style
|= WS_VSCROLL
;
1464 if ( flags
& wxHSCROLL
)
1465 style
|= WS_HSCROLL
;
1467 const wxBorder border
= TranslateBorder(GetBorder(flags
));
1469 // After translation, border is now optimized for the specific version of Windows
1470 // and theme engine presence.
1472 // WS_BORDER is only required for wxBORDER_SIMPLE
1473 if ( border
== wxBORDER_SIMPLE
)
1476 // now deal with ext style if the caller wants it
1482 if ( flags
& wxTRANSPARENT_WINDOW
)
1483 *exstyle
|= WS_EX_TRANSPARENT
;
1489 case wxBORDER_DEFAULT
:
1490 wxFAIL_MSG( wxT("unknown border style") );
1494 case wxBORDER_SIMPLE
:
1495 case wxBORDER_THEME
:
1498 case wxBORDER_STATIC
:
1499 *exstyle
|= WS_EX_STATICEDGE
;
1502 case wxBORDER_RAISED
:
1503 *exstyle
|= WS_EX_DLGMODALFRAME
;
1506 case wxBORDER_SUNKEN
:
1507 *exstyle
|= WS_EX_CLIENTEDGE
;
1508 style
&= ~WS_BORDER
;
1511 // case wxBORDER_DOUBLE:
1512 // *exstyle |= WS_EX_DLGMODALFRAME;
1516 // wxUniv doesn't use Windows dialog navigation functions at all
1517 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1518 // to make the dialog navigation work with the nested panels we must
1519 // use this style (top level windows such as dialogs don't need it)
1520 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1522 *exstyle
|= WS_EX_CONTROLPARENT
;
1524 #endif // __WXUNIVERSAL__
1530 // Setup background and foreground colours correctly
1531 void wxWindowMSW::SetupColours()
1534 SetBackgroundColour(GetParent()->GetBackgroundColour());
1537 bool wxWindowMSW::IsMouseInWindow() const
1539 // get the mouse position
1542 ::GetCursorPosWinCE(&pt
);
1544 ::GetCursorPos(&pt
);
1547 // find the window which currently has the cursor and go up the window
1548 // chain until we find this window - or exhaust it
1549 HWND hwnd
= ::WindowFromPoint(pt
);
1550 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1551 hwnd
= ::GetParent(hwnd
);
1553 return hwnd
!= NULL
;
1556 void wxWindowMSW::OnInternalIdle()
1558 #ifndef HAVE_TRACKMOUSEEVENT
1559 // Check if we need to send a LEAVE event
1560 if ( m_mouseInWindow
)
1562 // note that we should generate the leave event whether the window has
1563 // or doesn't have mouse capture
1564 if ( !IsMouseInWindow() )
1566 GenerateMouseLeave();
1569 #endif // !HAVE_TRACKMOUSEEVENT
1571 if (wxUpdateUIEvent::CanUpdate(this) && IsShownOnScreen())
1572 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1575 // Set this window to be the child of 'parent'.
1576 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1578 if ( !wxWindowBase::Reparent(parent
) )
1581 HWND hWndChild
= GetHwnd();
1582 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1584 ::SetParent(hWndChild
, hWndParent
);
1587 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT
) )
1589 EnsureParentHasControlParentStyle(GetParent());
1591 #endif // !__WXWINCE__
1596 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1598 #ifndef __WXMICROWIN__
1599 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1603 void wxWindowMSW::DoFreeze()
1606 return; // no point in freezing hidden window
1608 SendSetRedraw(GetHwnd(), false);
1611 void wxWindowMSW::DoThaw()
1614 return; // hidden windows aren't frozen by DoFreeze
1616 SendSetRedraw(GetHwnd(), true);
1618 // we need to refresh everything or otherwise the invalidated area
1619 // is not going to be repainted
1623 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1625 HWND hWnd
= GetHwnd();
1632 wxCopyRectToRECT(*rect
, mswRect
);
1640 // RedrawWindow not available on SmartPhone or eVC++ 3
1641 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1642 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1646 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1648 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1653 void wxWindowMSW::Update()
1655 if ( !::UpdateWindow(GetHwnd()) )
1657 wxLogLastError(wxT("UpdateWindow"));
1660 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1661 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1662 // handler needs to be really drawn right now
1667 // ---------------------------------------------------------------------------
1669 // ---------------------------------------------------------------------------
1671 #if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1675 // we need to lower the sibling static boxes so controls contained within can be
1677 static void AdjustStaticBoxZOrder(wxWindow
*parent
)
1679 // no sibling static boxes if we have no parent (ie TLW)
1683 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1685 node
= node
->GetNext() )
1687 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1690 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1691 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1696 #else // !wxUSE_STATBOX
1698 static inline void AdjustStaticBoxZOrder(wxWindow
* WXUNUSED(parent
))
1702 #endif // wxUSE_STATBOX/!wxUSE_STATBOX
1704 #endif // drag and drop is used
1706 #if wxUSE_DRAG_AND_DROP
1707 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1709 if ( m_dropTarget
!= 0 ) {
1710 m_dropTarget
->Revoke(m_hWnd
);
1711 delete m_dropTarget
;
1714 m_dropTarget
= pDropTarget
;
1715 if ( m_dropTarget
!= 0 )
1717 AdjustStaticBoxZOrder(GetParent());
1718 m_dropTarget
->Register(m_hWnd
);
1721 #endif // wxUSE_DRAG_AND_DROP
1723 // old-style file manager drag&drop support: we retain the old-style
1724 // DragAcceptFiles in parallel with SetDropTarget.
1725 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1728 HWND hWnd
= GetHwnd();
1731 AdjustStaticBoxZOrder(GetParent());
1732 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1737 // ----------------------------------------------------------------------------
1739 // ----------------------------------------------------------------------------
1743 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1745 wxWindowBase::DoSetToolTip(tooltip
);
1748 m_tooltip
->SetWindow((wxWindow
*)this);
1751 #endif // wxUSE_TOOLTIPS
1753 // ---------------------------------------------------------------------------
1754 // moving and resizing
1755 // ---------------------------------------------------------------------------
1757 bool wxWindowMSW::IsSizeDeferred() const
1759 #if wxUSE_DEFERRED_SIZING
1760 if ( m_pendingPosition
!= wxDefaultPosition
||
1761 m_pendingSize
!= wxDefaultSize
)
1763 #endif // wxUSE_DEFERRED_SIZING
1769 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1771 #if wxUSE_DEFERRED_SIZING
1772 // if SetSize() had been called at wx level but not realized at Windows
1773 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1774 // the new and not the old position to the other wx code
1775 if ( m_pendingSize
!= wxDefaultSize
)
1778 *x
= m_pendingSize
.x
;
1780 *y
= m_pendingSize
.y
;
1782 else // use current size
1783 #endif // wxUSE_DEFERRED_SIZING
1785 RECT rect
= wxGetWindowRect(GetHwnd());
1788 *x
= rect
.right
- rect
.left
;
1790 *y
= rect
.bottom
- rect
.top
;
1794 // Get size *available for subwindows* i.e. excluding menu bar etc.
1795 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1797 #if wxUSE_DEFERRED_SIZING
1798 if ( m_pendingSize
!= wxDefaultSize
)
1800 // we need to calculate the client size corresponding to pending size
1802 rect
.left
= m_pendingPosition
.x
;
1803 rect
.top
= m_pendingPosition
.y
;
1804 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1805 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1807 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1810 *x
= rect
.right
- rect
.left
;
1812 *y
= rect
.bottom
- rect
.top
;
1815 #endif // wxUSE_DEFERRED_SIZING
1817 RECT rect
= wxGetClientRect(GetHwnd());
1826 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1828 wxWindow
* const parent
= GetParent();
1831 if ( m_pendingPosition
!= wxDefaultPosition
)
1833 pos
= m_pendingPosition
;
1835 else // use current position
1837 RECT rect
= wxGetWindowRect(GetHwnd());
1840 point
.x
= rect
.left
;
1843 // we do the adjustments with respect to the parent only for the "real"
1844 // children, not for the dialogs/frames
1845 if ( !IsTopLevel() )
1847 if ( wxTheApp
->GetLayoutDirection() == wxLayout_RightToLeft
)
1849 // In RTL mode, we want the logical left x-coordinate,
1850 // which would be the physical right x-coordinate.
1851 point
.x
= rect
.right
;
1854 // Since we now have the absolute screen coords, if there's a
1855 // parent we must subtract its top left corner
1858 ::ScreenToClient(GetHwndOf(parent
), &point
);
1866 // we also must adjust by the client area offset: a control which is just
1867 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1868 if ( parent
&& !IsTopLevel() )
1870 const wxPoint
pt(parent
->GetClientAreaOrigin());
1881 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1889 ::ScreenToClient(GetHwnd(), &pt
);
1897 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1905 ::ClientToScreen(GetHwnd(), &pt
);
1914 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1916 #if wxUSE_DEFERRED_SIZING
1917 // if our parent had prepared a defer window handle for us, use it (unless
1918 // we are a top level window)
1919 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1921 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1924 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1925 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1928 wxLogLastError(wxT("DeferWindowPos"));
1934 // hdwp must be updated as it may have been changed
1935 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1940 // did deferred move, remember new coordinates of the window as they're
1941 // different from what Windows would return for it
1945 // otherwise (or if deferring failed) move the window in place immediately
1946 #endif // wxUSE_DEFERRED_SIZING
1947 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1949 wxLogLastError(wxT("MoveWindow"));
1952 // if wxUSE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1953 // ignored otherwise
1957 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1959 // TODO: is this consistent with other platforms?
1960 // Still, negative width or height shouldn't be allowed
1966 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1968 #if wxUSE_DEFERRED_SIZING
1969 m_pendingPosition
= wxPoint(x
, y
);
1970 m_pendingSize
= wxSize(width
, height
);
1972 else // window was moved immediately, without deferring it
1974 m_pendingPosition
= wxDefaultPosition
;
1975 m_pendingSize
= wxDefaultSize
;
1976 #endif // wxUSE_DEFERRED_SIZING
1980 // set the size of the window: if the dimensions are positive, just use them,
1981 // but if any of them is equal to -1, it means that we must find the value for
1982 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1983 // which case -1 is a valid value for x and y)
1985 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1986 // the width/height to best suit our contents, otherwise we reuse the current
1988 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1990 // get the current size and position...
1991 int currentX
, currentY
;
1992 int currentW
, currentH
;
1994 GetPosition(¤tX
, ¤tY
);
1995 GetSize(¤tW
, ¤tH
);
1997 // ... and don't do anything (avoiding flicker) if it's already ok unless
1998 // we're forced to resize the window
1999 if ( x
== currentX
&& y
== currentY
&&
2000 width
== currentW
&& height
== currentH
&&
2001 !(sizeFlags
& wxSIZE_FORCE
) )
2003 if (sizeFlags
& wxSIZE_FORCE_EVENT
)
2005 wxSizeEvent
event( wxSize(width
,height
), GetId() );
2006 event
.SetEventObject( this );
2007 HandleWindowEvent( event
);
2012 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2014 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
2017 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
2019 wxSize size
= wxDefaultSize
;
2020 if ( width
== wxDefaultCoord
)
2022 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
2024 size
= GetBestSize();
2029 // just take the current one
2034 if ( height
== wxDefaultCoord
)
2036 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
2038 if ( size
.x
== wxDefaultCoord
)
2040 size
= GetBestSize();
2042 //else: already called GetBestSize() above
2048 // just take the current one
2053 DoMoveWindow(x
, y
, width
, height
);
2056 void wxWindowMSW::DoSetClientSize(int width
, int height
)
2058 // setting the client size is less obvious than it could have been
2059 // because in the result of changing the total size the window scrollbar
2060 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2061 // doesn't take neither into account) and so the client size will not be
2062 // correct as the difference between the total and client size changes --
2063 // so we keep changing it until we get it right
2065 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2066 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2067 // may become 3 if the window had 0 size originally and so we didn't
2068 // calculate the scrollbar correction correctly during the first iteration)
2069 // but just to be on the safe side we check for it instead of making it an
2070 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2071 for ( int i
= 0; i
< 4; i
++ )
2074 ::GetClientRect(GetHwnd(), &rectClient
);
2076 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2077 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
2078 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
2083 // Find the difference between the entire window (title bar and all)
2084 // and the client area; add this to the new client size to move the
2087 ::GetWindowRect(GetHwnd(), &rectWin
);
2089 const int widthWin
= rectWin
.right
- rectWin
.left
,
2090 heightWin
= rectWin
.bottom
- rectWin
.top
;
2092 // MoveWindow positions the child windows relative to the parent, so
2093 // adjust if necessary
2094 if ( !IsTopLevel() )
2096 wxWindow
*parent
= GetParent();
2099 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
2103 // don't call DoMoveWindow() because we want to move window immediately
2104 // and not defer it here as otherwise the value returned by
2105 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2107 if ( !::MoveWindow(GetHwnd(),
2110 width
+ widthWin
- rectClient
.right
,
2111 height
+ heightWin
- rectClient
.bottom
,
2114 wxLogLastError(wxT("MoveWindow"));
2119 wxSize
wxWindowMSW::DoGetBorderSize() const
2122 switch ( GetBorder() )
2124 case wxBORDER_STATIC
:
2125 case wxBORDER_SIMPLE
:
2129 case wxBORDER_SUNKEN
:
2133 case wxBORDER_RAISED
:
2134 case wxBORDER_DOUBLE
:
2139 wxFAIL_MSG( wxT("unknown border style") );
2146 return 2*wxSize(border
, border
);
2149 // ---------------------------------------------------------------------------
2151 // ---------------------------------------------------------------------------
2153 int wxWindowMSW::GetCharHeight() const
2155 return wxGetTextMetrics(this).tmHeight
;
2158 int wxWindowMSW::GetCharWidth() const
2160 // +1 is needed because Windows apparently adds it when calculating the
2161 // dialog units size in pixels
2162 #if wxDIALOG_UNIT_COMPATIBILITY
2163 return wxGetTextMetrics(this).tmAveCharWidth
;
2165 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
2169 void wxWindowMSW::DoGetTextExtent(const wxString
& string
,
2172 int *externalLeading
,
2173 const wxFont
*fontToUse
) const
2175 wxASSERT_MSG( !fontToUse
|| fontToUse
->Ok(),
2176 wxT("invalid font in GetTextExtent()") );
2180 hfontToUse
= GetHfontOf(*fontToUse
);
2182 hfontToUse
= GetHfontOf(GetFont());
2184 WindowHDC
hdc(GetHwnd());
2185 SelectInHDC
selectFont(hdc
, hfontToUse
);
2189 ::GetTextExtentPoint32(hdc
, string
.wx_str(), string
.length(), &sizeRect
);
2190 GetTextMetrics(hdc
, &tm
);
2197 *descent
= tm
.tmDescent
;
2198 if ( externalLeading
)
2199 *externalLeading
= tm
.tmExternalLeading
;
2202 // ---------------------------------------------------------------------------
2204 // ---------------------------------------------------------------------------
2206 #if wxUSE_MENUS_NATIVE
2208 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2209 // immediately, without waiting for the next event loop iteration
2211 // NB: this function should probably be made public later as it can almost
2212 // surely replace wxYield() elsewhere as well
2213 static void wxYieldForCommandsOnly()
2215 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2216 // want to process it here)
2218 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2220 if ( msg
.message
== WM_QUIT
)
2222 // if we retrieved a WM_QUIT, insert back into the message queue.
2223 ::PostQuitMessage(0);
2227 // luckily (as we don't have access to wxEventLoopImpl method from here
2228 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2230 ::TranslateMessage(&msg
);
2231 ::DispatchMessage(&msg
);
2235 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2237 menu
->SetInvokingWindow(this);
2240 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2242 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2243 x
= mouse
.x
; y
= mouse
.y
;
2246 HWND hWnd
= GetHwnd();
2247 HMENU hMenu
= GetHmenuOf(menu
);
2251 ::ClientToScreen(hWnd
, &point
);
2252 #if defined(__WXWINCE__)
2253 static const UINT flags
= 0;
2254 #else // !__WXWINCE__
2255 UINT flags
= TPM_RIGHTBUTTON
;
2256 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2257 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2258 // side and not to use it there neither -- modify the test if it does work
2260 if ( wxGetWinVersion() >= wxWinVersion_5
)
2262 // using TPM_RECURSE allows us to show a popup menu while another menu
2263 // is opened which can be useful and is supported by the other
2264 // platforms, so allow it under Windows too
2265 flags
|= TPM_RECURSE
;
2267 #endif // __WXWINCE__/!__WXWINCE__
2269 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2271 // we need to do it right now as otherwise the events are never going to be
2272 // sent to wxCurrentPopupMenu from HandleCommand()
2274 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2275 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2276 // destroyed as soon as we return (it can be a local variable in the caller
2277 // for example) and so we do need to process the event immediately
2278 wxYieldForCommandsOnly();
2280 menu
->SetInvokingWindow(NULL
);
2285 #endif // wxUSE_MENUS_NATIVE
2287 // ===========================================================================
2288 // pre/post message processing
2289 // ===========================================================================
2291 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2294 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2296 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2299 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2301 // wxUniversal implements tab traversal itself
2302 #ifndef __WXUNIVERSAL__
2303 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2305 // intercept dialog navigation keys
2306 MSG
*msg
= (MSG
*)pMsg
;
2308 // here we try to do all the job which ::IsDialogMessage() usually does
2310 if ( msg
->message
== WM_KEYDOWN
)
2312 bool bCtrlDown
= wxIsCtrlDown();
2313 bool bShiftDown
= wxIsShiftDown();
2315 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2316 // don't process it if it's the case (except for Ctrl-Tab/Enter
2317 // combinations which are always processed)
2318 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2320 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2321 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2322 // it, of course, implies them
2323 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2325 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2328 bool bForward
= true,
2329 bWindowChange
= false,
2332 // should we process this message specially?
2333 bool bProcess
= true;
2334 switch ( msg
->wParam
)
2337 if ( (lDlgCode
& DLGC_WANTTAB
) && !bCtrlDown
)
2339 // let the control have the TAB
2342 else // use it for navigation
2344 // Ctrl-Tab cycles thru notebook pages
2345 bWindowChange
= bCtrlDown
;
2346 bForward
= !bShiftDown
;
2353 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2361 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2370 // we treat PageUp/Dn as arrows because chances are that
2371 // a control which needs arrows also needs them for
2372 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2373 if ( (lDlgCode
& DLGC_WANTARROWS
) && !bCtrlDown
)
2375 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2376 bWindowChange
= true;
2382 // currently active button should get enter press even
2383 // if there is a default button elsewhere so check if
2384 // this window is a button first
2385 wxWindow
*btn
= NULL
;
2386 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2388 // let IsDialogMessage() handle this for all
2389 // buttons except the owner-drawn ones which it
2390 // just seems to ignore
2391 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2392 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2394 // emulate the button click
2395 btn
= wxFindWinFromHandle(msg
->hwnd
);
2400 else // not a button itself, do we have default button?
2402 // check if this window or any of its ancestors
2403 // wants the message for itself (we always reserve
2404 // Ctrl-Enter for dialog navigation though)
2405 wxWindow
*win
= this;
2408 // this will contain the dialog code of this
2409 // window and all of its parent windows in turn
2410 LONG lDlgCode2
= lDlgCode
;
2414 if ( lDlgCode2
& DLGC_WANTMESSAGE
)
2416 // as it wants to process Enter itself,
2417 // don't call IsDialogMessage() which
2422 // don't propagate keyboard messages beyond
2423 // the first top level window parent
2424 if ( win
->IsTopLevel() )
2427 win
= win
->GetParent();
2429 lDlgCode2
= ::SendMessage
2440 win
= wxGetTopLevelParent(win
);
2443 wxTopLevelWindow
* const
2444 tlw
= wxDynamicCast(win
, wxTopLevelWindow
);
2447 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2452 if ( btn
&& btn
->IsEnabled() )
2454 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2458 #endif // wxUSE_BUTTON
2461 // map Enter presses into button presses on PDAs
2462 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2463 event
.SetEventObject(this);
2464 if ( HandleWindowEvent(event
) )
2466 #endif // __WXWINCE__
2476 wxNavigationKeyEvent event
;
2477 event
.SetDirection(bForward
);
2478 event
.SetWindowChange(bWindowChange
);
2479 event
.SetFromTab(bFromTab
);
2480 event
.SetEventObject(this);
2482 if ( HandleWindowEvent(event
) )
2484 // as we don't call IsDialogMessage(), which would take of
2485 // this by default, we need to manually send this message
2486 // so that controls can change their UI state if needed
2487 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2494 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2496 // IsDialogMessage() did something...
2500 #endif // __WXUNIVERSAL__
2505 // relay mouse move events to the tooltip control
2506 MSG
*msg
= (MSG
*)pMsg
;
2507 if ( msg
->message
== WM_MOUSEMOVE
)
2508 wxToolTip::RelayEvent(pMsg
);
2510 #endif // wxUSE_TOOLTIPS
2515 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2517 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2518 return m_acceleratorTable
.Translate(this, pMsg
);
2522 #endif // wxUSE_ACCEL
2525 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* msg
)
2527 // all tests below have to deal with various bugs/misfeatures of
2528 // IsDialogMessage(): we have to prevent it from being called from our
2529 // MSWProcessMessage() in some situations
2531 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2532 // message even when there is no cancel button and when the message is
2533 // needed by the control itself: in particular, it prevents the tree in
2534 // place edit control from being closed with Escape in a dialog
2535 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2540 // ::IsDialogMessage() is broken and may sometimes hang the application by
2541 // going into an infinite loop when it tries to find the control to give
2542 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2543 // situations when this may happen and not call it then
2544 if ( msg
->message
!= WM_SYSCHAR
)
2547 // assume we can call it by default
2548 bool canSafelyCallIsDlgMsg
= true;
2550 HWND hwndFocus
= ::GetFocus();
2552 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2553 // ::IsDialogMessage() will also enter an infinite loop, because it will
2554 // recursively check the child windows but not the window itself and so if
2555 // none of the children accepts focus it loops forever (as it only stops
2556 // when it gets back to the window it started from)
2558 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2559 // style has the focus, it can happen. One such possibility is if
2560 // all windows are either toplevel, wxDialog, wxPanel or static
2561 // controls and no window can actually accept keyboard input.
2562 #if !defined(__WXWINCE__)
2563 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2565 // pessimistic by default
2566 canSafelyCallIsDlgMsg
= false;
2567 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2569 node
= node
->GetNext() )
2571 wxWindow
* const win
= node
->GetData();
2572 if ( win
->CanAcceptFocus() &&
2573 !wxHasWindowExStyle(win
, WS_EX_CONTROLPARENT
) )
2575 // it shouldn't hang...
2576 canSafelyCallIsDlgMsg
= true;
2582 #endif // !__WXWINCE__
2584 if ( canSafelyCallIsDlgMsg
)
2586 // ::IsDialogMessage() can enter in an infinite loop when the
2587 // currently focused window is disabled or hidden and its
2588 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2592 if ( !::IsWindowEnabled(hwndFocus
) ||
2593 !::IsWindowVisible(hwndFocus
) )
2595 // it would enter an infinite loop if we do this!
2596 canSafelyCallIsDlgMsg
= false;
2601 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2603 // it's a top level window, don't go further -- e.g. even
2604 // if the parent of a dialog is disabled, this doesn't
2605 // break navigation inside the dialog
2609 hwndFocus
= ::GetParent(hwndFocus
);
2613 return canSafelyCallIsDlgMsg
;
2616 // ---------------------------------------------------------------------------
2617 // message params unpackers
2618 // ---------------------------------------------------------------------------
2620 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2621 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2623 *id
= LOWORD(wParam
);
2624 *hwnd
= (WXHWND
)lParam
;
2625 *cmd
= HIWORD(wParam
);
2628 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2629 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2631 *state
= LOWORD(wParam
);
2632 *minimized
= HIWORD(wParam
);
2633 *hwnd
= (WXHWND
)lParam
;
2636 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2637 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2639 *code
= LOWORD(wParam
);
2640 *pos
= HIWORD(wParam
);
2641 *hwnd
= (WXHWND
)lParam
;
2644 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2645 WXHDC
*hdc
, WXHWND
*hwnd
)
2647 *hwnd
= (WXHWND
)lParam
;
2648 *hdc
= (WXHDC
)wParam
;
2651 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2652 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2654 *item
= (WXWORD
)wParam
;
2655 *flags
= HIWORD(wParam
);
2656 *hmenu
= (WXHMENU
)lParam
;
2659 // ---------------------------------------------------------------------------
2660 // Main wxWidgets window proc and the window proc for wxWindow
2661 // ---------------------------------------------------------------------------
2663 // Hook for new window just as it's being created, when the window isn't yet
2664 // associated with the handle
2665 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2667 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2668 // window being created and insures that it's always unset back later
2669 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2671 gs_winBeingCreated
= winBeingCreated
;
2674 wxWindowCreationHook::~wxWindowCreationHook()
2676 gs_winBeingCreated
= NULL
;
2680 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2682 // trace all messages: useful for the debugging but noticeably slows down
2683 // the code so don't do it by default
2684 #if wxDEBUG_LEVEL >= 2
2685 wxLogTrace(wxTraceMessages
,
2686 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2687 wxGetMessageName(message
), hWnd
, (long)wParam
, lParam
);
2688 #endif // wxDEBUG_LEVEL >= 2
2690 wxWindowMSW
*wnd
= wxFindWinFromHandle(hWnd
);
2692 // when we get the first message for the HWND we just created, we associate
2693 // it with wxWindow stored in gs_winBeingCreated
2694 if ( !wnd
&& gs_winBeingCreated
)
2696 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2697 wnd
= gs_winBeingCreated
;
2698 gs_winBeingCreated
= NULL
;
2699 wnd
->SetHWND((WXHWND
)hWnd
);
2704 if ( wnd
&& wxGUIEventLoop::AllowProcessing(wnd
) )
2705 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2707 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2712 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2714 // did we process the message?
2715 bool processed
= false;
2725 // for most messages we should return 0 when we do process the message
2733 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2736 // return 0 to allow window creation
2737 rc
.result
= mayCreate
? 0 : -1;
2743 // never set processed to true and *always* pass WM_DESTROY to
2744 // DefWindowProc() as Windows may do some internal cleanup when
2745 // processing it and failing to pass the message along may cause
2746 // memory and resource leaks!
2747 (void)HandleDestroy();
2751 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2755 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2758 #if !defined(__WXWINCE__)
2761 LPRECT pRect
= (LPRECT
)lParam
;
2763 rc
.SetLeft(pRect
->left
);
2764 rc
.SetTop(pRect
->top
);
2765 rc
.SetRight(pRect
->right
);
2766 rc
.SetBottom(pRect
->bottom
);
2767 processed
= HandleMoving(rc
);
2769 pRect
->left
= rc
.GetLeft();
2770 pRect
->top
= rc
.GetTop();
2771 pRect
->right
= rc
.GetRight();
2772 pRect
->bottom
= rc
.GetBottom();
2777 case WM_ENTERSIZEMOVE
:
2779 processed
= HandleEnterSizeMove();
2783 case WM_EXITSIZEMOVE
:
2785 processed
= HandleExitSizeMove();
2791 LPRECT pRect
= (LPRECT
)lParam
;
2793 rc
.SetLeft(pRect
->left
);
2794 rc
.SetTop(pRect
->top
);
2795 rc
.SetRight(pRect
->right
);
2796 rc
.SetBottom(pRect
->bottom
);
2797 processed
= HandleSizing(rc
);
2799 pRect
->left
= rc
.GetLeft();
2800 pRect
->top
= rc
.GetTop();
2801 pRect
->right
= rc
.GetRight();
2802 pRect
->bottom
= rc
.GetBottom();
2806 #endif // !__WXWINCE__
2808 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2809 case WM_ACTIVATEAPP
:
2810 // This implicitly sends a wxEVT_ACTIVATE_APP event
2811 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2817 WXWORD state
, minimized
;
2819 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2821 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2826 processed
= HandleSetFocus((WXHWND
)wParam
);
2830 processed
= HandleKillFocus((WXHWND
)wParam
);
2833 case WM_PRINTCLIENT
:
2834 processed
= HandlePrintClient((WXHDC
)wParam
);
2840 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2842 processed
= HandlePaint();
2846 processed
= HandlePaint();
2851 #ifdef __WXUNIVERSAL__
2852 // Universal uses its own wxFrame/wxDialog, so we don't receive
2853 // close events unless we have this.
2855 #endif // __WXUNIVERSAL__
2857 // don't let the DefWindowProc() destroy our window - we'll do it
2858 // ourselves in ~wxWindow
2864 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2868 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2869 GET_Y_LPARAM(lParam
),
2873 #ifdef HAVE_TRACKMOUSEEVENT
2875 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2877 if ( m_mouseInWindow
)
2879 GenerateMouseLeave();
2882 // always pass processed back as false, this allows the window
2883 // manager to process the message too. This is needed to
2884 // ensure windows XP themes work properly as the mouse moves
2885 // over widgets like buttons. So don't set processed to true here.
2887 #endif // HAVE_TRACKMOUSEEVENT
2889 #if wxUSE_MOUSEWHEEL
2891 processed
= HandleMouseWheel(wParam
, lParam
);
2895 case WM_LBUTTONDOWN
:
2897 case WM_LBUTTONDBLCLK
:
2898 case WM_RBUTTONDOWN
:
2900 case WM_RBUTTONDBLCLK
:
2901 case WM_MBUTTONDOWN
:
2903 case WM_MBUTTONDBLCLK
:
2904 #ifdef wxHAS_XBUTTON
2905 case WM_XBUTTONDOWN
:
2907 case WM_XBUTTONDBLCLK
:
2908 #endif // wxHAS_XBUTTON
2910 #ifdef __WXMICROWIN__
2911 // MicroWindows seems to ignore the fact that a window is
2912 // disabled. So catch mouse events and throw them away if
2914 wxWindowMSW
* win
= this;
2917 if (!win
->IsEnabled())
2923 win
= win
->GetParent();
2924 if ( !win
|| win
->IsTopLevel() )
2931 #endif // __WXMICROWIN__
2932 int x
= GET_X_LPARAM(lParam
),
2933 y
= GET_Y_LPARAM(lParam
);
2936 // redirect the event to a static control if necessary by
2937 // finding one under mouse because under CE the static controls
2938 // don't generate mouse events (even with SS_NOTIFY)
2940 if ( GetCapture() == this )
2942 // but don't do it if the mouse is captured by this window
2943 // because then it should really get this event itself
2948 win
= FindWindowForMouseEvent(this, &x
, &y
);
2950 // this should never happen
2951 wxCHECK_MSG( win
, 0,
2952 wxT("FindWindowForMouseEvent() returned NULL") );
2955 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2957 SHRGINFO shrgi
= {0};
2959 shrgi
.cbSize
= sizeof(SHRGINFO
);
2960 shrgi
.hwndClient
= (HWND
) GetHWND();
2964 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2965 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2967 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2970 pt
= ClientToScreen(pt
);
2972 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2974 evtCtx
.SetEventObject(this);
2975 if (HandleWindowEvent(evtCtx
))
2984 #else // !__WXWINCE__
2985 wxWindowMSW
*win
= this;
2986 #endif // __WXWINCE__/!__WXWINCE__
2988 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2990 // if the app didn't eat the event, handle it in the default
2991 // way, that is by giving this window the focus
2994 // for the standard classes their WndProc sets the focus to
2995 // them anyhow and doing it from here results in some weird
2996 // problems, so don't do it for them (unnecessary anyhow)
2997 if ( !win
->IsOfStandardClass() )
2999 if ( message
== WM_LBUTTONDOWN
&& win
->IsFocusable() )
3011 case MM_JOY1BUTTONDOWN
:
3012 case MM_JOY2BUTTONDOWN
:
3013 case MM_JOY1BUTTONUP
:
3014 case MM_JOY2BUTTONUP
:
3015 processed
= HandleJoystickEvent(message
,
3016 GET_X_LPARAM(lParam
),
3017 GET_Y_LPARAM(lParam
),
3020 #endif // __WXMICROWIN__
3026 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
3028 processed
= HandleCommand(id
, cmd
, hwnd
);
3033 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
3036 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3037 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3038 // apparently doesn't always behave properly and needs some help
3039 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3040 case WM_NOTIFYFORMAT
:
3041 if ( lParam
== NF_QUERY
)
3044 rc
.result
= NFR_UNICODE
;
3047 #endif // wxUSE_UNICODE_MSLU
3049 // for these messages we must return true if process the message
3052 processed
= MSWOnDrawItem(wParam
, (WXDRAWITEMSTRUCT
*)lParam
);
3057 case WM_MEASUREITEM
:
3058 processed
= MSWOnMeasureItem(wParam
, (WXMEASUREITEMSTRUCT
*)lParam
);
3062 #endif // defined(WM_DRAWITEM)
3065 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS
) )
3067 // we always want to get the char events
3068 rc
.result
= DLGC_WANTCHARS
;
3070 if ( HasFlag(wxWANTS_CHARS
) )
3072 // in fact, we want everything
3073 rc
.result
|= DLGC_WANTARROWS
|
3080 //else: get the dlg code from the DefWindowProc()
3085 // If this has been processed by an event handler, return 0 now
3086 // (we've handled it).
3087 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
3088 if ( m_lastKeydownProcessed
)
3097 // we consider these messages "not interesting" to OnChar, so
3098 // just don't do anything more with them
3108 // avoid duplicate messages to OnChar for these ASCII keys:
3109 // they will be translated by TranslateMessage() and received
3142 // but set processed to false, not true to still pass them
3143 // to the control's default window proc - otherwise
3144 // built-in keyboard handling won't work
3149 // special case of VK_APPS: treat it the same as right mouse
3150 // click because both usually pop up a context menu
3152 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
3157 // do generate a CHAR event
3158 processed
= HandleChar((WORD
)wParam
, lParam
);
3161 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
3168 // special case of VK_APPS: treat it the same as right mouse button
3169 if ( wParam
== VK_APPS
)
3171 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
3176 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
3181 case WM_CHAR
: // Always an ASCII character
3182 if ( m_lastKeydownProcessed
)
3184 // The key was handled in the EVT_KEY_DOWN and handling
3185 // a key in an EVT_KEY_DOWN handler is meant, by
3186 // design, to prevent EVT_CHARs from happening
3187 m_lastKeydownProcessed
= false;
3192 processed
= HandleChar((WORD
)wParam
, lParam
, true);
3198 processed
= HandleHotKey((WORD
)wParam
, lParam
);
3200 #endif // wxUSE_HOTKEY
3205 processed
= HandleClipboardEvent(message
);
3213 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
3215 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
3221 // CTLCOLOR messages are sent by children to query the parent for their
3223 #ifndef __WXMICROWIN__
3224 case WM_CTLCOLORMSGBOX
:
3225 case WM_CTLCOLOREDIT
:
3226 case WM_CTLCOLORLISTBOX
:
3227 case WM_CTLCOLORBTN
:
3228 case WM_CTLCOLORDLG
:
3229 case WM_CTLCOLORSCROLLBAR
:
3230 case WM_CTLCOLORSTATIC
:
3234 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
3236 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
3239 #endif // !__WXMICROWIN__
3241 case WM_SYSCOLORCHANGE
:
3242 // the return value for this message is ignored
3243 processed
= HandleSysColorChange();
3246 #if !defined(__WXWINCE__)
3247 case WM_DISPLAYCHANGE
:
3248 processed
= HandleDisplayChange();
3252 case WM_PALETTECHANGED
:
3253 processed
= HandlePaletteChanged((WXHWND
)wParam
);
3256 case WM_CAPTURECHANGED
:
3257 processed
= HandleCaptureChanged((WXHWND
)lParam
);
3260 case WM_SETTINGCHANGE
:
3261 processed
= HandleSettingChange(wParam
, lParam
);
3264 case WM_QUERYNEWPALETTE
:
3265 processed
= HandleQueryNewPalette();
3269 processed
= HandleEraseBkgnd((WXHDC
)wParam
);
3272 // we processed the message, i.e. erased the background
3277 #if !defined(__WXWINCE__)
3279 processed
= HandleDropFiles(wParam
);
3284 processed
= HandleInitDialog((WXHWND
)wParam
);
3288 // we never set focus from here
3293 #if !defined(__WXWINCE__)
3294 case WM_QUERYENDSESSION
:
3295 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3299 processed
= HandleEndSession(wParam
!= 0, lParam
);
3302 case WM_GETMINMAXINFO
:
3303 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3308 processed
= HandleSetCursor((WXHWND
)wParam
,
3309 LOWORD(lParam
), // hit test
3310 HIWORD(lParam
)); // mouse msg
3314 // returning TRUE stops the DefWindowProc() from further
3315 // processing this message - exactly what we need because we've
3316 // just set the cursor.
3321 #if wxUSE_ACCESSIBILITY
3324 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3325 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3327 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3329 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3335 #if defined(WM_HELP)
3338 // by default, WM_HELP is propagated by DefWindowProc() upwards
3339 // to the window parent but as we do it ourselves already
3340 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3341 // to get the other events if we process this message at all
3344 // WM_HELP doesn't use lParam under CE
3346 HELPINFO
* info
= (HELPINFO
*) lParam
;
3347 if ( info
->iContextType
== HELPINFO_WINDOW
)
3349 #endif // !__WXWINCE__
3350 wxHelpEvent helpEvent
3355 wxGetMousePosition() // what else?
3357 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3361 helpEvent
.SetEventObject(this);
3362 HandleWindowEvent(helpEvent
);
3365 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3367 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3368 helpEvent
.SetEventObject(this);
3369 HandleWindowEvent(helpEvent
);
3372 else // unknown help event?
3376 #endif // !__WXWINCE__
3381 #if !defined(__WXWINCE__)
3382 case WM_CONTEXTMENU
:
3384 // we don't convert from screen to client coordinates as
3385 // the event may be handled by a parent window
3386 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3388 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3390 // we could have got an event from our child, reflect it back
3391 // to it if this is the case
3392 wxWindowMSW
*win
= NULL
;
3393 WXHWND hWnd
= (WXHWND
)wParam
;
3394 if ( hWnd
!= m_hWnd
)
3396 win
= FindItemByHWND(hWnd
);
3402 evtCtx
.SetEventObject(win
);
3403 processed
= win
->HandleWindowEvent(evtCtx
);
3410 // we're only interested in our own menus, not MF_SYSMENU
3411 if ( HIWORD(wParam
) == MF_POPUP
)
3413 // handle menu chars for ownerdrawn menu items
3414 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3415 if ( i
!= wxNOT_FOUND
)
3417 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3422 #endif // wxUSE_MENUS
3425 case WM_POWERBROADCAST
:
3428 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3429 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3432 #endif // __WXWINCE__
3435 // If we want the default themed border then we need to draw it ourselves
3438 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3439 const wxBorder border
= TranslateBorder(GetBorder());
3440 if (theme
&& border
== wxBORDER_THEME
)
3442 // first ask the widget to calculate the border size
3443 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3446 // now alter the client size making room for drawing a
3451 NCCALCSIZE_PARAMS
*csparam
= (NCCALCSIZE_PARAMS
*)lParam
;
3452 rect
= &csparam
->rgrc
[0];
3456 rect
= (RECT
*)lParam
;
3459 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3460 RECT rcClient
= { 0, 0, 0, 0 };
3461 wxClientDC
dc((wxWindow
*)this);
3462 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3464 if ( theme
->GetThemeBackgroundContentRect
3471 &rcClient
) == S_OK
)
3473 InflateRect(&rcClient
, -1, -1);
3475 rc
.result
= WVR_REDRAW
;
3483 wxUxThemeEngine
* theme
= wxUxThemeEngine::GetIfActive();
3484 const wxBorder border
= TranslateBorder(GetBorder());
3485 if (theme
&& border
== wxBORDER_THEME
)
3487 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3488 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3491 wxUxThemeHandle
hTheme((const wxWindow
*)this, L
"EDIT");
3492 wxWindowDC
dc((wxWindow
*)this);
3493 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
3495 // Clip the DC so that you only draw on the non-client area
3497 wxCopyRectToRECT(GetSize(), rcBorder
);
3500 theme
->GetThemeBackgroundContentRect(
3501 hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, ETS_NORMAL
, &rcBorder
, &rcClient
);
3502 InflateRect(&rcClient
, -1, -1);
3504 ::ExcludeClipRect(GetHdcOf(*impl
), rcClient
.left
, rcClient
.top
,
3505 rcClient
.right
, rcClient
.bottom
);
3507 // Make sure the background is in a proper state
3508 if (theme
->IsThemeBackgroundPartiallyTransparent(hTheme
, EP_EDITTEXT
, ETS_NORMAL
))
3510 theme
->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl
), &rcBorder
);
3516 nState
= ETS_DISABLED
;
3517 // should we check this?
3518 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3519 // nState = ETS_READONLY;
3521 nState
= ETS_NORMAL
;
3522 theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), EP_EDITTEXT
, nState
, &rcBorder
, NULL
);
3527 #endif // wxUSE_UXTHEME
3530 // try a custom message handler
3531 const MSWMessageHandlers::const_iterator
3532 i
= gs_messageHandlers
.find(message
);
3533 if ( i
!= gs_messageHandlers
.end() )
3535 processed
= (*i
->second
)(this, message
, wParam
, lParam
);
3541 #if wxDEBUG_LEVEL >= 2
3542 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3543 wxGetMessageName(message
));
3544 #endif // wxDEBUG_LEVEL >= 2
3545 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3551 // ----------------------------------------------------------------------------
3552 // wxWindow <-> HWND map
3553 // ----------------------------------------------------------------------------
3555 wxWindow
*wxFindWinFromHandle(HWND hwnd
)
3557 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3558 return i
== gs_windowHandles
.end() ? NULL
: i
->second
;
3561 void wxAssociateWinWithHandle(HWND hwnd
, wxWindowMSW
*win
)
3563 // adding NULL hwnd is (first) surely a result of an error and
3564 // (secondly) breaks menu command processing
3565 wxCHECK_RET( hwnd
!= (HWND
)NULL
,
3566 wxT("attempt to add a NULL hwnd to window list ignored") );
3569 WindowHandles::const_iterator i
= gs_windowHandles
.find(hwnd
);
3570 if ( i
!= gs_windowHandles
.end() )
3572 if ( i
->second
!= win
)
3576 wxT("HWND %p already associated with another window (%s)"),
3577 hwnd
, win
->GetClassInfo()->GetClassName()
3581 //else: this actually happens currently because we associate the window
3582 // with its HWND during creation (if we create it) and also when
3583 // SubclassWin() is called later, this is ok
3585 #endif // wxDEBUG_LEVEL
3587 gs_windowHandles
[hwnd
] = (wxWindow
*)win
;
3590 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3592 gs_windowHandles
.erase(GetHwndOf(win
));
3595 // ----------------------------------------------------------------------------
3596 // various MSW speciic class dependent functions
3597 // ----------------------------------------------------------------------------
3599 // Default destroyer - override if you destroy it in some other way
3600 // (e.g. with MDI child windows)
3601 void wxWindowMSW::MSWDestroyWindow()
3605 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3608 int& w
, int& h
) const
3610 // yes, those are just some arbitrary hardcoded numbers
3611 static const int DEFAULT_Y
= 200;
3613 bool nonDefault
= false;
3615 if ( pos
.x
== wxDefaultCoord
)
3617 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3618 // can just as well set it to CW_USEDEFAULT as well
3624 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3625 // neither because it is not handled as a special value by Windows then
3626 // and so we have to choose some default value for it
3628 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3634 NB: there used to be some code here which set the initial size of the
3635 window to the client size of the parent if no explicit size was
3636 specified. This was wrong because wxWidgets programs often assume
3637 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3638 it. To see why, you should understand that Windows sends WM_SIZE from
3639 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3640 from some base class ctor and so this WM_SIZE is not processed in the
3641 real class' OnSize() (because it's not fully constructed yet and the
3642 event goes to some base class OnSize() instead). So the WM_SIZE we
3643 rely on is the one sent when the parent frame resizes its children
3644 but here is the problem: if the child already has just the right
3645 size, nothing will happen as both wxWidgets and Windows check for
3646 this and ignore any attempts to change the window size to the size it
3647 already has - so no WM_SIZE would be sent.
3651 // we don't use CW_USEDEFAULT here for several reasons:
3653 // 1. it results in huge frames on modern screens (1000*800 is not
3654 // uncommon on my 1280*1024 screen) which is way too big for a half
3655 // empty frame of most of wxWidgets samples for example)
3657 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3658 // the default is for whatever reason 8*8 which breaks client <->
3659 // window size calculations (it would be nice if it didn't, but it
3660 // does and the simplest way to fix it seemed to change the broken
3661 // default size anyhow)
3663 // 3. there is just no advantage in doing it: with x and y it is
3664 // possible that [future versions of] Windows position the new top
3665 // level window in some smart way which we can't do, but we can
3666 // guess a reasonably good size for a new window just as well
3669 // However, on PocketPC devices, we must use the default
3670 // size if possible.
3672 if (size
.x
== wxDefaultCoord
)
3676 if (size
.y
== wxDefaultCoord
)
3681 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3685 w
= WidthDefault(size
.x
);
3686 h
= HeightDefault(size
.y
);
3689 AdjustForParentClientOrigin(x
, y
);
3694 WXHWND
wxWindowMSW::MSWGetParent() const
3696 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3699 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3700 const wxChar
*title
,
3704 WXDWORD extendedStyle
)
3706 // check a common bug in the user code: if the window is created with a
3707 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3708 // single wxWindow object and this results in all sorts of trouble,
3709 // especially for wxTLWs
3710 wxCHECK_MSG( !m_hWnd
, true, "window can't be recreated" );
3712 // this can happen if this function is called using the return value of
3713 // wxApp::GetRegisteredClassName() which failed
3714 wxCHECK_MSG( wclass
, false, "failed to register window class?" );
3717 // choose the position/size for the new window
3719 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3721 // controlId is menu handle for the top level windows, so set it to 0
3722 // unless we're creating a child window
3723 int controlId
= style
& WS_CHILD
? GetId() : 0;
3725 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3726 // which is the same but without CS_[HV]REDRAW class styles so using it
3727 // ensures that the window is not fully repainted on each resize
3728 wxString
className(wclass
);
3729 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3731 className
+= wxApp::GetNoRedrawClassSuffix();
3734 // do create the window
3735 wxWindowCreationHook
hook(this);
3737 m_hWnd
= (WXHWND
)::CreateWindowEx
3741 title
? title
: m_windowName
.wx_str(),
3744 (HWND
)MSWGetParent(),
3745 (HMENU
)wxUIntToPtr(controlId
),
3747 NULL
// no extra data
3752 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3757 SubclassWin(m_hWnd
);
3762 // ===========================================================================
3763 // MSW message handlers
3764 // ===========================================================================
3766 // ---------------------------------------------------------------------------
3768 // ---------------------------------------------------------------------------
3770 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3772 #ifndef __WXMICROWIN__
3773 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3774 HWND hWnd
= hdr
->hwndFrom
;
3775 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
3777 // if the control is one of our windows, let it handle the message itself
3780 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3783 // VZ: why did we do it? normally this is unnecessary and, besides, it
3784 // breaks the message processing for the toolbars because the tooltip
3785 // notifications were being forwarded to the toolbar child controls
3786 // (if it had any) before being passed to the toolbar itself, so in my
3787 // example the tooltip for the combobox was always shown instead of the
3788 // correct button tooltips
3790 // try all our children
3791 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3794 wxWindow
*child
= node
->GetData();
3795 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3800 node
= node
->GetNext();
3804 // by default, handle it ourselves
3805 return MSWOnNotify(idCtrl
, lParam
, result
);
3806 #else // __WXMICROWIN__
3813 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3815 const wxString
& ttip
)
3817 // I don't know why it happens, but the versions of comctl32.dll starting
3818 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3819 // this message is supposed to be sent to Unicode programs only) -- hence
3820 // we need to handle it as well, otherwise no tooltips will be shown in
3823 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3826 // not a tooltip message or no tooltip to show anyhow
3831 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3833 // We don't want to use the szText buffer because it has a limit of 80
3834 // bytes and this is not enough, especially for Unicode build where it
3835 // limits the tooltip string length to only 40 characters
3837 // The best would be, of course, to not impose any length limitations at
3838 // all but then the buffer would have to be dynamic and someone would have
3839 // to free it and we don't have the tooltip owner object here any more, so
3840 // for now use our own static buffer with a higher fixed max length.
3842 // Note that using a static buffer should not be a problem as only a single
3843 // tooltip can be shown at the same time anyhow.
3845 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3847 // We need to convert tooltip from multi byte to Unicode on the fly.
3848 static wchar_t buf
[513];
3850 // Truncate tooltip length if needed as otherwise we might not have
3851 // enough space for it in the buffer and MultiByteToWideChar() would
3853 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3855 // Convert to WideChar without adding the NULL character. The NULL
3856 // character is added afterwards (this is more efficient).
3857 int len
= ::MultiByteToWideChar
3869 wxLogLastError(wxT("MultiByteToWideChar()"));
3873 ttText
->lpszText
= (LPSTR
) buf
;
3875 else // TTN_NEEDTEXTA
3876 #endif // !wxUSE_UNICODE
3878 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3879 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3880 // to copy the string we have into the buffer
3881 static wxChar buf
[513];
3882 wxStrlcpy(buf
, ttip
.c_str(), WXSIZEOF(buf
));
3883 ttText
->lpszText
= buf
;
3889 #endif // wxUSE_TOOLTIPS
3891 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3893 WXLPARAM
* WXUNUSED(result
))
3898 NMHDR
* hdr
= (NMHDR
*)lParam
;
3899 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3906 wxUnusedVar(lParam
);
3907 #endif // wxUSE_TOOLTIPS
3912 // ---------------------------------------------------------------------------
3913 // end session messages
3914 // ---------------------------------------------------------------------------
3916 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3918 #ifdef ENDSESSION_LOGOFF
3919 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3920 event
.SetEventObject(wxTheApp
);
3921 event
.SetCanVeto(true);
3922 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3924 bool rc
= wxTheApp
->ProcessEvent(event
);
3928 // we may end only if the app didn't veto session closing (double
3930 *mayEnd
= !event
.GetVeto();
3935 wxUnusedVar(logOff
);
3936 wxUnusedVar(mayEnd
);
3941 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3943 #ifdef ENDSESSION_LOGOFF
3944 // do nothing if the session isn't ending
3949 if ( (this != wxTheApp
->GetTopWindow()) )
3952 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3953 event
.SetEventObject(wxTheApp
);
3954 event
.SetCanVeto(false);
3955 event
.SetLoggingOff((logOff
& ENDSESSION_LOGOFF
) != 0);
3957 return wxTheApp
->ProcessEvent(event
);
3959 wxUnusedVar(endSession
);
3960 wxUnusedVar(logOff
);
3965 // ---------------------------------------------------------------------------
3966 // window creation/destruction
3967 // ---------------------------------------------------------------------------
3969 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3972 // VZ: why is this commented out for WinCE? If it doesn't support
3973 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3974 // not with multiple #ifdef's!
3976 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3977 EnsureParentHasControlParentStyle(GetParent());
3978 #endif // !__WXWINCE__
3985 bool wxWindowMSW::HandleDestroy()
3987 // delete our drop target if we've got one
3988 #if wxUSE_DRAG_AND_DROP
3989 if ( m_dropTarget
!= NULL
)
3991 m_dropTarget
->Revoke(m_hWnd
);
3993 delete m_dropTarget
;
3994 m_dropTarget
= NULL
;
3996 #endif // wxUSE_DRAG_AND_DROP
3998 // WM_DESTROY handled
4002 // ---------------------------------------------------------------------------
4004 // ---------------------------------------------------------------------------
4006 bool wxWindowMSW::HandleActivate(int state
,
4007 bool WXUNUSED(minimized
),
4008 WXHWND
WXUNUSED(activate
))
4010 wxActivateEvent
event(wxEVT_ACTIVATE
,
4011 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
4013 event
.SetEventObject(this);
4015 return HandleWindowEvent(event
);
4018 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
4020 // Strangly enough, some controls get set focus events when they are being
4021 // deleted, even if they already had focus before.
4022 if ( m_isBeingDeleted
)
4027 // notify the parent keeping track of focus for the kbd navigation
4028 // purposes that we got it
4029 wxChildFocusEvent
eventFocus((wxWindow
*)this);
4030 (void)HandleWindowEvent(eventFocus
);
4036 m_caret
->OnSetFocus();
4038 #endif // wxUSE_CARET
4040 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
4041 event
.SetEventObject(this);
4043 // wxFindWinFromHandle() may return NULL, it is ok
4044 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4046 return HandleWindowEvent(event
);
4049 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
4055 m_caret
->OnKillFocus();
4057 #endif // wxUSE_CARET
4059 // Don't send the event when in the process of being deleted. This can
4060 // only cause problems if the event handler tries to access the object.
4061 if ( m_isBeingDeleted
)
4066 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
4067 event
.SetEventObject(this);
4069 // wxFindWinFromHandle() may return NULL, it is ok
4070 event
.SetWindow(wxFindWinFromHandle(hwnd
));
4072 return HandleWindowEvent(event
);
4075 // ---------------------------------------------------------------------------
4077 // ---------------------------------------------------------------------------
4079 void wxWindowMSW::SetLabel( const wxString
& label
)
4081 SetWindowText(GetHwnd(), label
.c_str());
4084 wxString
wxWindowMSW::GetLabel() const
4086 return wxGetWindowText(GetHWND());
4089 // ---------------------------------------------------------------------------
4091 // ---------------------------------------------------------------------------
4093 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
4095 wxShowEvent
event(GetId(), show
);
4096 event
.SetEventObject(this);
4098 return HandleWindowEvent(event
);
4101 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
4103 wxInitDialogEvent
event(GetId());
4104 event
.SetEventObject(this);
4106 return HandleWindowEvent(event
);
4109 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
4111 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4112 wxUnusedVar(wParam
);
4114 #else // __WXMICROWIN__
4115 HDROP hFilesInfo
= (HDROP
) wParam
;
4117 // Get the total number of files dropped
4118 UINT gwFilesDropped
= ::DragQueryFile
4126 wxString
*files
= new wxString
[gwFilesDropped
];
4127 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
4129 // first get the needed buffer length (+1 for terminating NUL)
4130 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
4132 // and now get the file name
4133 ::DragQueryFile(hFilesInfo
, wIndex
,
4134 wxStringBuffer(files
[wIndex
], len
), len
);
4137 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
4138 event
.SetEventObject(this);
4141 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
4142 event
.m_pos
.x
= dropPoint
.x
;
4143 event
.m_pos
.y
= dropPoint
.y
;
4145 DragFinish(hFilesInfo
);
4147 return HandleWindowEvent(event
);
4152 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
4154 int WXUNUSED(mouseMsg
))
4156 #ifndef __WXMICROWIN__
4157 // the logic is as follows:
4158 // 0. if we're busy, set the busy cursor (even for non client elements)
4159 // 1. don't set custom cursor for non client area of enabled windows
4160 // 2. ask user EVT_SET_CURSOR handler for the cursor
4161 // 3. if still no cursor but we're in a TLW, set the global cursor
4163 HCURSOR hcursor
= 0;
4166 hcursor
= wxGetCurrentBusyCursor();
4170 if ( nHitTest
!= HTCLIENT
)
4173 // first ask the user code - it may wish to set the cursor in some very
4174 // specific way (for example, depending on the current position)
4177 if ( !::GetCursorPosWinCE(&pt
))
4179 if ( !::GetCursorPos(&pt
) )
4182 wxLogLastError(wxT("GetCursorPos"));
4187 ScreenToClient(&x
, &y
);
4188 wxSetCursorEvent
event(x
, y
);
4190 bool processedEvtSetCursor
= HandleWindowEvent(event
);
4191 if ( processedEvtSetCursor
&& event
.HasCursor() )
4193 hcursor
= GetHcursorOf(event
.GetCursor());
4198 // the test for processedEvtSetCursor is here to prevent using
4199 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4200 // nothing from it - this is a way to say that our cursor shouldn't
4201 // be used for this point
4202 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
4204 hcursor
= GetHcursorOf(m_cursor
);
4207 if ( !hcursor
&& !GetParent() )
4209 const wxCursor
*cursor
= wxGetGlobalCursor();
4210 if ( cursor
&& cursor
->Ok() )
4212 hcursor
= GetHcursorOf(*cursor
);
4221 ::SetCursor(hcursor
);
4223 // cursor set, stop here
4226 #endif // __WXMICROWIN__
4228 // pass up the window chain
4232 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
4233 WXLPARAM
WXUNUSED(lParam
),
4234 bool *WXUNUSED_IN_WINCE(vetoed
))
4240 wxEventType evtType
;
4243 case PBT_APMQUERYSUSPEND
:
4244 evtType
= wxEVT_POWER_SUSPENDING
;
4247 case PBT_APMQUERYSUSPENDFAILED
:
4248 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
4251 case PBT_APMSUSPEND
:
4252 evtType
= wxEVT_POWER_SUSPENDED
;
4255 case PBT_APMRESUMESUSPEND
:
4256 evtType
= wxEVT_POWER_RESUME
;
4260 wxLogDebug(wxT("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
4263 // these messages are currently not mapped to wx events
4264 case PBT_APMQUERYSTANDBY
:
4265 case PBT_APMQUERYSTANDBYFAILED
:
4266 case PBT_APMSTANDBY
:
4267 case PBT_APMRESUMESTANDBY
:
4268 case PBT_APMBATTERYLOW
:
4269 case PBT_APMPOWERSTATUSCHANGE
:
4270 case PBT_APMOEMEVENT
:
4271 case PBT_APMRESUMECRITICAL
:
4272 #ifdef PBT_APMRESUMEAUTOMATIC
4273 case PBT_APMRESUMEAUTOMATIC
:
4275 evtType
= wxEVT_NULL
;
4279 // don't handle unknown messages
4280 if ( evtType
== wxEVT_NULL
)
4283 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4285 wxPowerEvent
event(evtType
);
4286 if ( !HandleWindowEvent(event
) )
4289 *vetoed
= event
.IsVetoed();
4295 bool wxWindowMSW::IsDoubleBuffered() const
4297 for ( const wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4299 if ( wxHasWindowExStyle(win
, WS_EX_COMPOSITED
) )
4302 if ( win
->IsTopLevel() )
4309 void wxWindowMSW::SetDoubleBuffered(bool on
)
4311 // Get the current extended style bits
4312 long exstyle
= wxGetWindowExStyle(this);
4314 // Twiddle the bit as needed
4316 exstyle
|= WS_EX_COMPOSITED
;
4318 exstyle
&= ~WS_EX_COMPOSITED
;
4321 wxSetWindowExStyle(this, exstyle
);
4324 // ---------------------------------------------------------------------------
4325 // owner drawn stuff
4326 // ---------------------------------------------------------------------------
4328 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4329 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4330 #define WXUNUSED_UNLESS_ODRAWN(param) param
4332 #define WXUNUSED_UNLESS_ODRAWN(param)
4336 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
4337 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
4339 #if wxUSE_OWNER_DRAWN
4341 #if wxUSE_MENUS_NATIVE
4342 // is it a menu item?
4343 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
4344 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
4346 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
4348 // see comment before the same test in MSWOnMeasureItem() below
4352 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4353 false, wxT("MSWOnDrawItem: bad wxMenuItem pointer") );
4355 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4356 // the DC from being released
4357 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
4358 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
4359 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
4360 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
4362 return pMenuItem
->OnDrawItem
4366 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
4367 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
4370 #endif // wxUSE_MENUS_NATIVE
4372 #endif // USE_OWNER_DRAWN
4374 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4376 #if wxUSE_OWNER_DRAWN
4377 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4378 #else // !wxUSE_OWNER_DRAWN
4379 // we may still have owner-drawn buttons internally because we have to make
4380 // them owner-drawn to support colour change
4383 wxDynamicCast(FindItem(id
), wxButton
)
4388 #endif // USE_OWNER_DRAWN
4392 return item
->MSWOnDraw(itemStruct
);
4395 #endif // wxUSE_CONTROLS
4401 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4403 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4404 // is it a menu item?
4405 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4406 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4408 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4410 // according to Carsten Fuchs the pointer may be NULL under XP if an
4411 // MDI child frame is initially maximized, see this for more info:
4412 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4414 // so silently ignore it instead of asserting
4418 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4419 false, wxT("MSWOnMeasureItem: bad wxMenuItem pointer") );
4422 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4424 pMeasureStruct
->itemWidth
= w
;
4425 pMeasureStruct
->itemHeight
= h
;
4430 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4433 return item
->MSWOnMeasure(itemStruct
);
4437 wxUnusedVar(itemStruct
);
4438 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4443 // ---------------------------------------------------------------------------
4444 // colours and palettes
4445 // ---------------------------------------------------------------------------
4447 bool wxWindowMSW::HandleSysColorChange()
4449 wxSysColourChangedEvent event
;
4450 event
.SetEventObject(this);
4452 (void)HandleWindowEvent(event
);
4454 // always let the system carry on the default processing to allow the
4455 // native controls to react to the colours update
4459 bool wxWindowMSW::HandleDisplayChange()
4461 wxDisplayChangedEvent event
;
4462 event
.SetEventObject(this);
4464 return HandleWindowEvent(event
);
4467 #ifndef __WXMICROWIN__
4469 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4471 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4475 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4478 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4480 #endif // wxUSE_CONTROLS
4483 return *brush
!= NULL
;
4486 #endif // __WXMICROWIN__
4488 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4491 // same as below except we don't respond to our own messages
4492 if ( hWndPalChange
!= GetHWND() )
4494 // check to see if we our our parents have a custom palette
4495 wxWindowMSW
*win
= this;
4496 while ( win
&& !win
->HasCustomPalette() )
4498 win
= win
->GetParent();
4501 if ( win
&& win
->HasCustomPalette() )
4503 // realize the palette to see whether redrawing is needed
4504 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4505 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4506 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4508 int result
= ::RealizePalette(hdc
);
4510 // restore the palette (before releasing the DC)
4511 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4512 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4513 ::RealizePalette(hdc
);
4514 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4516 // now check for the need to redraw
4518 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4522 #endif // wxUSE_PALETTE
4524 wxPaletteChangedEvent
event(GetId());
4525 event
.SetEventObject(this);
4526 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4528 return HandleWindowEvent(event
);
4531 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4533 // notify windows on the capture stack about lost capture
4534 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4535 wxWindowBase::NotifyCaptureLost();
4537 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4538 wxMouseCaptureChangedEvent
event(GetId(), win
);
4539 event
.SetEventObject(this);
4540 return HandleWindowEvent(event
);
4543 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4545 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4546 // we need to send this to child windows (it is only sent to top-level
4547 // windows) so {list,tree}ctrls can adjust their font size if necessary
4548 // this is exactly how explorer does it to enable the font size changes
4550 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4553 // top-level windows already get this message from the system
4554 wxWindow
*win
= node
->GetData();
4555 if ( !win
->IsTopLevel() )
4557 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4560 node
= node
->GetNext();
4563 // let the system handle it
4567 bool wxWindowMSW::HandleQueryNewPalette()
4571 // check to see if we our our parents have a custom palette
4572 wxWindowMSW
*win
= this;
4573 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4574 if (win
->HasCustomPalette()) {
4575 /* realize the palette to see whether redrawing is needed */
4576 HDC hdc
= ::GetDC((HWND
) GetHWND());
4577 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4578 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4580 int result
= ::RealizePalette(hdc
);
4581 /* restore the palette (before releasing the DC) */
4582 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4583 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4584 ::RealizePalette(hdc
);
4585 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4586 /* now check for the need to redraw */
4588 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4590 #endif // wxUSE_PALETTE
4592 wxQueryNewPaletteEvent
event(GetId());
4593 event
.SetEventObject(this);
4595 return HandleWindowEvent(event
) && event
.GetPaletteRealized();
4598 // Responds to colour changes: passes event on to children.
4599 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4601 // the top level window also reset the standard colour map as it might have
4602 // changed (there is no need to do it for the non top level windows as we
4603 // only have to do it once)
4607 gs_hasStdCmap
= false;
4609 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4612 // Only propagate to non-top-level windows because Windows already
4613 // sends this event to all top-level ones
4614 wxWindow
*win
= node
->GetData();
4615 if ( !win
->IsTopLevel() )
4617 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4618 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4619 // the standard controls
4620 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4623 node
= node
->GetNext();
4627 extern wxCOLORMAP
*wxGetStdColourMap()
4629 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4630 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4632 if ( !gs_hasStdCmap
)
4634 static bool s_coloursInit
= false;
4636 if ( !s_coloursInit
)
4638 // When a bitmap is loaded, the RGB values can change (apparently
4639 // because Windows adjusts them to care for the old programs always
4640 // using 0xc0c0c0 while the transparent colour for the new Windows
4641 // versions is different). But we do this adjustment ourselves so
4642 // we want to avoid Windows' "help" and for this we need to have a
4643 // reference bitmap which can tell us what the RGB values change
4645 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4646 wxBitmap
stdColourBitmap(wxT("wxBITMAP_STD_COLOURS"));
4647 if ( stdColourBitmap
.Ok() )
4649 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4650 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4651 wxT("forgot to update wxBITMAP_STD_COLOURS!") );
4654 memDC
.SelectObject(stdColourBitmap
);
4657 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4659 memDC
.GetPixel(i
, 0, &colour
);
4660 s_stdColours
[i
] = wxColourToRGB(colour
);
4663 else // wxBITMAP_STD_COLOURS couldn't be loaded
4665 s_stdColours
[0] = RGB(000,000,000); // black
4666 s_stdColours
[1] = RGB(128,128,128); // dark grey
4667 s_stdColours
[2] = RGB(192,192,192); // light grey
4668 s_stdColours
[3] = RGB(255,255,255); // white
4669 //s_stdColours[4] = RGB(000,000,255); // blue
4670 //s_stdColours[5] = RGB(255,000,255); // magenta
4673 s_coloursInit
= true;
4676 gs_hasStdCmap
= true;
4678 // create the colour map
4679 #define INIT_CMAP_ENTRY(col) \
4680 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4681 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4683 INIT_CMAP_ENTRY(BTNTEXT
);
4684 INIT_CMAP_ENTRY(BTNSHADOW
);
4685 INIT_CMAP_ENTRY(BTNFACE
);
4686 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4688 #undef INIT_CMAP_ENTRY
4694 // ---------------------------------------------------------------------------
4696 // ---------------------------------------------------------------------------
4698 bool wxWindowMSW::HandlePaint()
4700 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4703 wxLogLastError(wxT("CreateRectRgn"));
4705 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4707 wxLogLastError(wxT("GetUpdateRgn"));
4710 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4712 wxPaintEvent
event(m_windowId
);
4713 event
.SetEventObject(this);
4715 bool processed
= HandleWindowEvent(event
);
4717 // note that we must generate NC event after the normal one as otherwise
4718 // BeginPaint() will happily overwrite our decorations with the background
4720 wxNcPaintEvent
eventNc(m_windowId
);
4721 eventNc
.SetEventObject(this);
4722 HandleWindowEvent(eventNc
);
4724 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4725 // be called from inside the event handlers called above)
4726 m_updateRegion
.Clear();
4731 // Can be called from an application's OnPaint handler
4732 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4734 #ifdef __WXUNIVERSAL__
4737 HDC hDC
= (HDC
) wxPaintDCImpl::FindDCInCache((wxWindow
*) event
.GetEventObject());
4740 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4745 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4747 // standard non top level controls (i.e. except the dialogs) always erase
4748 // their background themselves in HandleCtlColor() or have some control-
4749 // specific ways to set the colours (common controls)
4750 if ( IsOfStandardClass() && !IsTopLevel() )
4753 switch ( GetBackgroundStyle() )
4755 case wxBG_STYLE_ERASE
:
4756 // we need to generate an erase background event
4758 wxDCTemp
dc(hdc
, GetClientSize());
4759 wxDCTempImpl
*impl
= (wxDCTempImpl
*) dc
.GetImpl();
4762 impl
->SetWindow((wxWindow
*)this);
4764 wxEraseEvent
event(m_windowId
, &dc
);
4765 event
.SetEventObject(this);
4766 bool rc
= HandleWindowEvent(event
);
4768 // must be called manually as ~wxDC doesn't do anything for
4770 impl
->SelectOldObjects(hdc
);
4774 // background erase by the user-defined handler
4780 case wxBG_STYLE_SYSTEM
:
4781 if ( !DoEraseBackground(hdc
) )
4783 // let the default processing to take place if we didn't erase
4784 // the background ourselves
4789 case wxBG_STYLE_PAINT
:
4790 // no need to do anything here at all, background will be entirely
4791 // redrawn in WM_PAINT handler
4795 wxFAIL_MSG( "unknown background style" );
4801 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4803 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4807 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4813 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4817 // our background colour applies to:
4818 // 1. this window itself, always
4819 // 2. all children unless the colour is "not inheritable"
4820 // 3. even if it is not inheritable, our immediate transparent
4821 // children should still inherit it -- but not any transparent
4822 // children because it would look wrong if a child of non
4823 // transparent child would show our bg colour when the child itself
4825 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4828 (win
&& win
->HasTransparentBackground() &&
4829 win
->GetParent() == this) )
4831 // draw children with the same colour as the parent
4833 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4835 return (WXHBRUSH
)GetHbrushOf(*brush
);
4842 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4845 hWndToPaint
= GetHWND();
4847 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4849 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4853 // background is not inherited beyond top level windows
4854 if ( win
->IsTopLevel() )
4861 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4863 // we receive this message when DrawThemeParentBackground() is
4864 // called from def window proc of several controls under XP and we
4865 // must draw properly themed background here
4867 // note that naively I'd expect filling the client rect with the
4868 // brush returned by MSWGetBgBrush() work -- but for some reason it
4869 // doesn't and we have to call parents MSWPrintChild() which is
4870 // supposed to call DrawThemeBackground() with appropriate params
4872 // also note that in this case lParam == PRF_CLIENT but we're
4873 // clearly expected to paint the background and nothing else!
4875 if ( IsTopLevel() || InheritsBackgroundColour() )
4878 // sometimes we don't want the parent to handle it at all, instead
4879 // return whatever value this window wants
4880 if ( !MSWShouldPropagatePrintChild() )
4881 return MSWPrintChild(hDC
, (wxWindow
*)this);
4883 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4885 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4888 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4895 // ---------------------------------------------------------------------------
4896 // moving and resizing
4897 // ---------------------------------------------------------------------------
4899 bool wxWindowMSW::HandleMinimize()
4901 wxIconizeEvent
event(m_windowId
);
4902 event
.SetEventObject(this);
4904 return HandleWindowEvent(event
);
4907 bool wxWindowMSW::HandleMaximize()
4909 wxMaximizeEvent
event(m_windowId
);
4910 event
.SetEventObject(this);
4912 return HandleWindowEvent(event
);
4915 bool wxWindowMSW::HandleMove(int x
, int y
)
4918 wxMoveEvent
event(point
, m_windowId
);
4919 event
.SetEventObject(this);
4921 return HandleWindowEvent(event
);
4924 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4926 wxMoveEvent
event(rect
, m_windowId
);
4927 event
.SetEventObject(this);
4929 bool rc
= HandleWindowEvent(event
);
4931 rect
= event
.GetRect();
4935 bool wxWindowMSW::HandleEnterSizeMove()
4937 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4938 event
.SetEventType(wxEVT_MOVE_START
);
4939 event
.SetEventObject(this);
4941 return HandleWindowEvent(event
);
4944 bool wxWindowMSW::HandleExitSizeMove()
4946 wxMoveEvent
event(wxPoint(0,0), m_windowId
);
4947 event
.SetEventType(wxEVT_MOVE_END
);
4948 event
.SetEventObject(this);
4950 return HandleWindowEvent(event
);
4953 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4955 #if wxUSE_DEFERRED_SIZING
4956 // when we resize this window, its children are probably going to be
4957 // repositioned as well, prepare to use DeferWindowPos() for them
4958 int numChildren
= 0;
4959 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4961 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4966 // Protect against valid m_hDWP being overwritten
4967 bool useDefer
= false;
4969 if ( numChildren
> 1 )
4973 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4976 wxLogLastError(wxT("BeginDeferWindowPos"));
4982 #endif // wxUSE_DEFERRED_SIZING
4984 // update this window size
4985 bool processed
= false;
4989 wxFAIL_MSG( wxT("unexpected WM_SIZE parameter") );
4990 // fall through nevertheless
4994 // we're not interested in these messages at all
4997 case SIZE_MINIMIZED
:
4998 processed
= HandleMinimize();
5001 case SIZE_MAXIMIZED
:
5002 /* processed = */ HandleMaximize();
5003 // fall through to send a normal size event as well
5006 // don't use w and h parameters as they specify the client size
5007 // while according to the docs EVT_SIZE handler is supposed to
5008 // receive the total size
5009 wxSizeEvent
event(GetSize(), m_windowId
);
5010 event
.SetEventObject(this);
5012 processed
= HandleWindowEvent(event
);
5015 #if wxUSE_DEFERRED_SIZING
5016 // and finally change the positions of all child windows at once
5017 if ( useDefer
&& m_hDWP
)
5019 // reset m_hDWP to NULL so that child windows don't try to use our
5020 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
5021 // happen anyhow normally but who knows what weird flow of control we
5022 // may have depending on what the users EVT_SIZE handler does...)
5023 HDWP hDWP
= (HDWP
)m_hDWP
;
5026 // do put all child controls in place at once
5027 if ( !::EndDeferWindowPos(hDWP
) )
5029 wxLogLastError(wxT("EndDeferWindowPos"));
5032 // Reset our children's pending pos/size values.
5033 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
5035 node
= node
->GetNext() )
5037 wxWindowMSW
* const child
= node
->GetData();
5038 child
->MSWEndDeferWindowPos();
5041 #endif // wxUSE_DEFERRED_SIZING
5046 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
5048 wxSizeEvent
event(rect
, m_windowId
);
5049 event
.SetEventObject(this);
5051 bool rc
= HandleWindowEvent(event
);
5053 rect
= event
.GetRect();
5057 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
5062 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
5066 int minWidth
= GetMinWidth(),
5067 minHeight
= GetMinHeight(),
5068 maxWidth
= GetMaxWidth(),
5069 maxHeight
= GetMaxHeight();
5071 if ( minWidth
!= wxDefaultCoord
)
5073 info
->ptMinTrackSize
.x
= minWidth
;
5077 if ( minHeight
!= wxDefaultCoord
)
5079 info
->ptMinTrackSize
.y
= minHeight
;
5083 if ( maxWidth
!= wxDefaultCoord
)
5085 info
->ptMaxTrackSize
.x
= maxWidth
;
5089 if ( maxHeight
!= wxDefaultCoord
)
5091 info
->ptMaxTrackSize
.y
= maxHeight
;
5099 // ---------------------------------------------------------------------------
5101 // ---------------------------------------------------------------------------
5103 bool wxWindowMSW::HandleCommand(WXWORD id_
, WXWORD cmd
, WXHWND control
)
5105 // sign extend to int from short before comparing with the other int ids
5106 int id
= (signed short)id_
;
5108 #if wxUSE_MENUS_NATIVE
5109 if ( !cmd
&& wxCurrentPopupMenu
)
5111 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
5112 wxCurrentPopupMenu
= NULL
;
5114 return popupMenu
->MSWCommand(cmd
, id
);
5116 #endif // wxUSE_MENUS_NATIVE
5118 wxWindow
*win
= NULL
;
5120 // first try to find it from HWND - this works even with the broken
5121 // programs using the same ids for different controls
5124 win
= wxFindWinFromHandle(control
);
5135 return win
->MSWCommand(cmd
, id
);
5138 // the messages sent from the in-place edit control used by the treectrl
5139 // for label editing have id == 0, but they should _not_ be treated as menu
5140 // messages (they are EN_XXX ones, in fact) so don't translate anything
5141 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5144 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
, id
);
5145 event
.SetEventObject(this);
5148 return HandleWindowEvent(event
);
5152 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5153 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5154 // notifications to its parent which we want to reflect back to
5156 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
5157 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
5159 #endif // wxUSE_SPINCTRL
5161 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
5162 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5163 // notifications to its parent which we want to reflect back to
5165 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
5166 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
5174 // ---------------------------------------------------------------------------
5176 // ---------------------------------------------------------------------------
5178 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
5182 // our client coords are not quite the same as Windows ones
5183 wxPoint pt
= GetClientAreaOrigin();
5184 event
.m_x
= x
- pt
.x
;
5185 event
.m_y
= y
- pt
.y
;
5187 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
5188 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
5189 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
5190 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
5191 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
5192 #ifdef wxHAS_XBUTTON
5193 event
.m_aux1Down
= (flags
& MK_XBUTTON1
) != 0;
5194 event
.m_aux2Down
= (flags
& MK_XBUTTON2
) != 0;
5195 #endif // wxHAS_XBUTTON
5196 event
.m_altDown
= ::wxIsAltDown();
5199 event
.SetTimestamp(::GetMessageTime());
5202 event
.SetEventObject(this);
5203 event
.SetId(GetId());
5205 #if wxUSE_MOUSEEVENT_HACK
5206 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
5207 gs_lastMouseEvent
.type
= event
.GetEventType();
5208 #endif // wxUSE_MOUSEEVENT_HACK
5212 // Windows doesn't send the mouse events to the static controls (which are
5213 // transparent in the sense that their WM_NCHITTEST handler returns
5214 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
5215 // and so we manually check if we don't have a child window under mouse and if
5216 // we do, send the event to it instead of the window Windows had sent WM_XXX
5219 // Notice that this is not done for the mouse move events because this could
5220 // (would?) be too slow, but only for clicks which means that the static texts
5221 // still don't get move, enter nor leave events.
5222 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
5224 wxCHECK_MSG( x
&& y
, win
, wxT("NULL pointer in FindWindowForMouseEvent") );
5226 // first try to find a non transparent child: this allows us to send events
5227 // to a static text which is inside a static box, for example
5228 POINT pt
= { *x
, *y
};
5229 HWND hwnd
= GetHwndOf(win
),
5233 hwndUnderMouse
= ::ChildWindowFromPoint
5239 hwndUnderMouse
= ::ChildWindowFromPointEx
5249 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
5251 // now try any child window at all
5252 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
5255 // check that we have a child window which is susceptible to receive mouse
5256 // events: for this it must be shown and enabled
5257 if ( hwndUnderMouse
&&
5258 hwndUnderMouse
!= hwnd
&&
5259 ::IsWindowVisible(hwndUnderMouse
) &&
5260 ::IsWindowEnabled(hwndUnderMouse
) )
5262 wxWindow
*winUnderMouse
= wxFindWinFromHandle(hwndUnderMouse
);
5263 if ( winUnderMouse
)
5265 // translate the mouse coords to the other window coords
5266 win
->ClientToScreen(x
, y
);
5267 winUnderMouse
->ScreenToClient(x
, y
);
5269 win
= winUnderMouse
;
5275 #endif // __WXWINCE__
5277 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5279 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5280 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5281 // from the message id and take the value in the table to get wxWin event
5283 static const wxEventType eventsMouse
[] =
5294 wxEVT_MIDDLE_DCLICK
,
5295 0, // this one is for wxEVT_MOTION which is not used here
5304 #ifdef wxHAS_XBUTTON
5305 // the same messages are used for both auxillary mouse buttons so we need
5306 // to adjust the index manually
5309 case WM_XBUTTONDOWN
:
5311 case WM_XBUTTONDBLCLK
:
5312 if ( flags
& MK_XBUTTON2
)
5313 msg
+= wxEVT_AUX2_DOWN
- wxEVT_AUX1_DOWN
;
5315 #endif // wxHAS_XBUTTON
5317 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
5318 InitMouseEvent(event
, x
, y
, flags
);
5320 return HandleWindowEvent(event
);
5323 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
5325 if ( !m_mouseInWindow
)
5327 // it would be wrong to assume that just because we get a mouse move
5328 // event that the mouse is inside the window: although this is usually
5329 // true, it is not if we had captured the mouse, so we need to check
5330 // the mouse coordinates here
5331 if ( !HasCapture() || IsMouseInWindow() )
5333 // Generate an ENTER event
5334 m_mouseInWindow
= true;
5336 #ifdef HAVE_TRACKMOUSEEVENT
5337 typedef BOOL (WINAPI
*_TrackMouseEvent_t
)(LPTRACKMOUSEEVENT
);
5339 static const _TrackMouseEvent_t
5340 s_pfn_TrackMouseEvent
= _TrackMouseEvent
;
5341 #else // !__WXWINCE__
5342 static _TrackMouseEvent_t s_pfn_TrackMouseEvent
;
5343 static bool s_initDone
= false;
5346 // see comment in wxApp::GetComCtl32Version() explaining the
5347 // use of wxLoadedDLL
5348 wxLoadedDLL
dllComCtl32(wxT("comctl32.dll"));
5349 if ( dllComCtl32
.IsLoaded() )
5351 s_pfn_TrackMouseEvent
= (_TrackMouseEvent_t
)
5352 dllComCtl32
.RawGetSymbol(wxT("_TrackMouseEvent"));
5358 if ( s_pfn_TrackMouseEvent
)
5359 #endif // __WXWINCE__/!__WXWINCE__
5361 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
5363 trackinfo
.dwFlags
= TME_LEAVE
;
5364 trackinfo
.hwndTrack
= GetHwnd();
5366 (*s_pfn_TrackMouseEvent
)(&trackinfo
);
5368 #endif // HAVE_TRACKMOUSEEVENT
5370 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
5371 InitMouseEvent(event
, x
, y
, flags
);
5373 (void)HandleWindowEvent(event
);
5376 #ifdef HAVE_TRACKMOUSEEVENT
5377 else // mouse not in window
5379 // Check if we need to send a LEAVE event
5380 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5381 // send it here if we are using native mouse leave tracking
5382 if ( HasCapture() && !IsMouseInWindow() )
5384 GenerateMouseLeave();
5387 #endif // HAVE_TRACKMOUSEEVENT
5389 #if wxUSE_MOUSEEVENT_HACK
5390 // Windows often generates mouse events even if mouse position hasn't
5391 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5393 // Filter this out as it can result in unexpected behaviour compared to
5395 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
5396 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
5397 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
5398 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
5400 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
5402 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
5407 #endif // wxUSE_MOUSEEVENT_HACK
5409 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
5413 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
5415 #if wxUSE_MOUSEWHEEL
5416 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5417 // forwarded up to the parent by DefWindowProc()) and not in the client
5418 // ones as all the other messages, translate them to the client coords for
5421 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
5422 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
5423 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
5424 event
.m_wheelRotation
= (short)HIWORD(wParam
);
5425 event
.m_wheelDelta
= WHEEL_DELTA
;
5427 static int s_linesPerRotation
= -1;
5428 if ( s_linesPerRotation
== -1 )
5430 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
5431 &s_linesPerRotation
, 0))
5433 // this is not supposed to happen
5434 wxLogLastError(wxT("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5436 // the default is 3, so use it if SystemParametersInfo() failed
5437 s_linesPerRotation
= 3;
5441 event
.m_linesPerAction
= s_linesPerRotation
;
5442 return HandleWindowEvent(event
);
5444 #else // !wxUSE_MOUSEWHEEL
5445 wxUnusedVar(wParam
);
5446 wxUnusedVar(lParam
);
5449 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5452 void wxWindowMSW::GenerateMouseLeave()
5454 m_mouseInWindow
= false;
5457 if ( wxIsShiftDown() )
5459 if ( wxIsCtrlDown() )
5460 state
|= MK_CONTROL
;
5462 // Only the high-order bit should be tested
5463 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
5464 state
|= MK_LBUTTON
;
5465 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
5466 state
|= MK_MBUTTON
;
5467 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
5468 state
|= MK_RBUTTON
;
5472 if ( !::GetCursorPosWinCE(&pt
) )
5474 if ( !::GetCursorPos(&pt
) )
5477 wxLogLastError(wxT("GetCursorPos"));
5480 // we need to have client coordinates here for symmetry with
5481 // wxEVT_ENTER_WINDOW
5482 RECT rect
= wxGetWindowRect(GetHwnd());
5486 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5487 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5489 (void)HandleWindowEvent(event
);
5492 // ---------------------------------------------------------------------------
5493 // keyboard handling
5494 // ---------------------------------------------------------------------------
5496 // create the key event of the given type for the given key - used by
5497 // HandleChar and HandleKeyDown/Up
5498 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5501 WXWPARAM wParam
) const
5503 wxKeyEvent
event(evType
);
5504 event
.SetId(GetId());
5505 event
.m_shiftDown
= wxIsShiftDown();
5506 event
.m_controlDown
= wxIsCtrlDown();
5507 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5509 event
.SetEventObject((wxWindow
*)this); // const_cast
5510 event
.m_keyCode
= id
;
5512 event
.m_uniChar
= (wxChar
) wParam
;
5514 event
.m_rawCode
= (wxUint32
) wParam
;
5515 event
.m_rawFlags
= (wxUint32
) lParam
;
5517 event
.SetTimestamp(::GetMessageTime());
5520 // translate the position to client coords
5523 GetCursorPosWinCE(&pt
);
5528 GetWindowRect(GetHwnd(),&rect
);
5538 // isASCII is true only when we're called from WM_CHAR handler and not from
5540 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5547 else // we're called from WM_KEYDOWN
5549 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5550 // to get numpad key codes: CHAR events should use the logical keys
5551 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5552 id
= wxCharCodeMSWToWX(wParam
);
5555 // it's ASCII and will be processed here only when called from
5556 // WM_CHAR (i.e. when isASCII = true), don't process it now
5561 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5563 // the alphanumeric keys produced by pressing AltGr+something on European
5564 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5565 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5566 // alphanumeric, so pretend that there are no modifiers at all (the
5567 // KEY_DOWN event would still have the correct modifiers if they're really
5569 if ( event
.m_controlDown
&& event
.m_altDown
&&
5570 (id
>= 32 && id
< 256) )
5572 event
.m_controlDown
=
5573 event
.m_altDown
= false;
5576 return HandleWindowEvent(event
);
5579 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5581 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5585 // normal ASCII char
5589 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5590 return HandleWindowEvent(event
);
5593 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5595 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5599 // normal ASCII char
5603 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5604 return HandleWindowEvent(event
);
5608 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5609 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5611 // FIXME: implement GetMenuItemCount for WinCE, possibly
5612 // in terms of GetMenuItemInfo
5614 const HMENU hmenu
= (HMENU
)lParam
;
5618 mii
.cbSize
= sizeof(MENUITEMINFO
);
5620 // we could use MIIM_FTYPE here as we only need to know if the item is
5621 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5622 // MIIM_FTYPE is not supported under Win95
5623 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5625 // find if we have this letter in any owner drawn item
5626 const int count
= ::GetMenuItemCount(hmenu
);
5627 for ( int i
= 0; i
< count
; i
++ )
5629 // previous loop iteration could modify it, reset it back before
5630 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5633 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5635 if ( mii
.fType
== MFT_OWNERDRAW
)
5637 // dwItemData member of the MENUITEMINFO is a
5638 // pointer to the associated wxMenuItem -- see the
5639 // menu creation code
5640 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5642 const wxChar
*p
= wxStrchr(item
->GetItemLabel().wx_str(), wxT('&'));
5645 if ( *p
== wxT('&') )
5647 // this is not the accel char, find the real one
5648 p
= wxStrchr(p
+ 1, wxT('&'));
5650 else // got the accel char
5652 // FIXME-UNICODE: this comparison doesn't risk to work
5653 // for non ASCII accelerator characters I'm afraid, but
5655 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5661 // this one doesn't match
5668 else // failed to get the menu text?
5670 // it's not fatal, so don't show error, but still log it
5671 wxLogLastError(wxT("GetMenuItemInfo"));
5678 #endif // wxUSE_MENUS
5680 bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg
)
5682 const wxEventType type
= nMsg
== WM_CUT
? wxEVT_COMMAND_TEXT_CUT
5683 : nMsg
== WM_COPY
? wxEVT_COMMAND_TEXT_COPY
5684 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE
;
5685 wxClipboardTextEvent
evt(type
, GetId());
5687 evt
.SetEventObject(this);
5689 return HandleWindowEvent(evt
);
5692 // ---------------------------------------------------------------------------
5694 // ---------------------------------------------------------------------------
5696 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5700 if ( flags
& JOY_BUTTON1CHG
)
5701 change
= wxJOY_BUTTON1
;
5702 if ( flags
& JOY_BUTTON2CHG
)
5703 change
= wxJOY_BUTTON2
;
5704 if ( flags
& JOY_BUTTON3CHG
)
5705 change
= wxJOY_BUTTON3
;
5706 if ( flags
& JOY_BUTTON4CHG
)
5707 change
= wxJOY_BUTTON4
;
5710 if ( flags
& JOY_BUTTON1
)
5711 buttons
|= wxJOY_BUTTON1
;
5712 if ( flags
& JOY_BUTTON2
)
5713 buttons
|= wxJOY_BUTTON2
;
5714 if ( flags
& JOY_BUTTON3
)
5715 buttons
|= wxJOY_BUTTON3
;
5716 if ( flags
& JOY_BUTTON4
)
5717 buttons
|= wxJOY_BUTTON4
;
5719 // the event ids aren't consecutive so we can't use table based lookup
5721 wxEventType eventType
;
5726 eventType
= wxEVT_JOY_MOVE
;
5731 eventType
= wxEVT_JOY_MOVE
;
5736 eventType
= wxEVT_JOY_ZMOVE
;
5741 eventType
= wxEVT_JOY_ZMOVE
;
5744 case MM_JOY1BUTTONDOWN
:
5746 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5749 case MM_JOY2BUTTONDOWN
:
5751 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5754 case MM_JOY1BUTTONUP
:
5756 eventType
= wxEVT_JOY_BUTTON_UP
;
5759 case MM_JOY2BUTTONUP
:
5761 eventType
= wxEVT_JOY_BUTTON_UP
;
5765 wxFAIL_MSG(wxT("no such joystick event"));
5770 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5771 event
.SetPosition(wxPoint(x
, y
));
5772 event
.SetEventObject(this);
5774 return HandleWindowEvent(event
);
5784 // ---------------------------------------------------------------------------
5786 // ---------------------------------------------------------------------------
5788 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5789 WXWORD pos
, WXHWND control
)
5791 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5793 wxWindow
*child
= wxFindWinFromHandle(control
);
5795 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5798 wxScrollWinEvent event
;
5799 event
.SetPosition(pos
);
5800 event
.SetOrientation(orientation
);
5801 event
.SetEventObject(this);
5806 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5810 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5814 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5818 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5822 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5826 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5829 case SB_THUMBPOSITION
:
5831 // under Win32, the scrollbar range and position are 32 bit integers,
5832 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5833 // explicitly query the scrollbar for the correct position (this must
5834 // be done only for these two SB_ events as they are the only one
5835 // carrying the scrollbar position)
5837 WinStruct
<SCROLLINFO
> scrollInfo
;
5838 scrollInfo
.fMask
= SIF_TRACKPOS
;
5840 if ( !::GetScrollInfo(GetHwnd(),
5841 WXOrientToSB(orientation
),
5844 // Not necessarily an error, if there are no scrollbars yet.
5845 // wxLogLastError(wxT("GetScrollInfo"));
5848 event
.SetPosition(scrollInfo
.nTrackPos
);
5851 event
.SetEventType( wParam
== SB_THUMBPOSITION
5852 ? wxEVT_SCROLLWIN_THUMBRELEASE
5853 : wxEVT_SCROLLWIN_THUMBTRACK
);
5860 return HandleWindowEvent(event
);
5863 // ----------------------------------------------------------------------------
5864 // custom message handlers
5865 // ----------------------------------------------------------------------------
5868 wxWindowMSW::MSWRegisterMessageHandler(int msg
, MSWMessageHandler handler
)
5870 wxCHECK_MSG( gs_messageHandlers
.find(msg
) == gs_messageHandlers
.end(),
5871 false, wxT("registering handler for the same message twice") );
5873 gs_messageHandlers
[msg
] = handler
;
5878 wxWindowMSW::MSWUnregisterMessageHandler(int msg
, MSWMessageHandler handler
)
5880 const MSWMessageHandlers::iterator i
= gs_messageHandlers
.find(msg
);
5881 wxCHECK_RET( i
!= gs_messageHandlers
.end() && i
->second
== handler
,
5882 wxT("unregistering non-registered handler?") );
5884 gs_messageHandlers
.erase(i
);
5887 // ===========================================================================
5889 // ===========================================================================
5891 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5894 HDC dc
= ::GetDC((HWND
) wnd
);
5897 // the_font.UseResource();
5898 // the_font.RealizeResource();
5899 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5901 was
= (HFONT
) SelectObject(dc
,fnt
);
5903 GetTextMetrics(dc
, &tm
);
5906 SelectObject(dc
,was
);
5908 ReleaseDC((HWND
)wnd
, dc
);
5911 *x
= tm
.tmAveCharWidth
;
5913 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5915 // the_font.ReleaseResource();
5918 // use the "extended" bit (24) of lParam to distinguish extended keys
5919 // from normal keys as the same key is sent
5921 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5923 // except that if lParam is 0, it means we don't have real lParam from
5924 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5925 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5926 // non-numpad (hence extended) key as this is a more common case
5927 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5930 // this array contains the Windows virtual key codes which map one to one to
5931 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5933 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5934 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5935 static const struct wxKeyMapping
5939 } gs_specialKeys
[] =
5941 { VK_CANCEL
, WXK_CANCEL
},
5942 { VK_BACK
, WXK_BACK
},
5943 { VK_TAB
, WXK_TAB
},
5944 { VK_CLEAR
, WXK_CLEAR
},
5945 { VK_SHIFT
, WXK_SHIFT
},
5946 { VK_CONTROL
, WXK_CONTROL
},
5947 { VK_MENU
, WXK_ALT
},
5948 { VK_PAUSE
, WXK_PAUSE
},
5949 { VK_CAPITAL
, WXK_CAPITAL
},
5950 { VK_SPACE
, WXK_SPACE
},
5951 { VK_ESCAPE
, WXK_ESCAPE
},
5952 { VK_SELECT
, WXK_SELECT
},
5953 { VK_PRINT
, WXK_PRINT
},
5954 { VK_EXECUTE
, WXK_EXECUTE
},
5955 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5956 { VK_HELP
, WXK_HELP
},
5958 { VK_NUMPAD0
, WXK_NUMPAD0
},
5959 { VK_NUMPAD1
, WXK_NUMPAD1
},
5960 { VK_NUMPAD2
, WXK_NUMPAD2
},
5961 { VK_NUMPAD3
, WXK_NUMPAD3
},
5962 { VK_NUMPAD4
, WXK_NUMPAD4
},
5963 { VK_NUMPAD5
, WXK_NUMPAD5
},
5964 { VK_NUMPAD6
, WXK_NUMPAD6
},
5965 { VK_NUMPAD7
, WXK_NUMPAD7
},
5966 { VK_NUMPAD8
, WXK_NUMPAD8
},
5967 { VK_NUMPAD9
, WXK_NUMPAD9
},
5968 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5969 { VK_ADD
, WXK_NUMPAD_ADD
},
5970 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5971 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5972 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5983 { VK_F10
, WXK_F10
},
5984 { VK_F11
, WXK_F11
},
5985 { VK_F12
, WXK_F12
},
5986 { VK_F13
, WXK_F13
},
5987 { VK_F14
, WXK_F14
},
5988 { VK_F15
, WXK_F15
},
5989 { VK_F16
, WXK_F16
},
5990 { VK_F17
, WXK_F17
},
5991 { VK_F18
, WXK_F18
},
5992 { VK_F19
, WXK_F19
},
5993 { VK_F20
, WXK_F20
},
5994 { VK_F21
, WXK_F21
},
5995 { VK_F22
, WXK_F22
},
5996 { VK_F23
, WXK_F23
},
5997 { VK_F24
, WXK_F24
},
5999 { VK_NUMLOCK
, WXK_NUMLOCK
},
6000 { VK_SCROLL
, WXK_SCROLL
},
6003 { VK_LWIN
, WXK_WINDOWS_LEFT
},
6004 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
6005 { VK_APPS
, WXK_WINDOWS_MENU
},
6006 #endif // VK_APPS defined
6009 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
6010 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
6011 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
6013 // check the table first
6014 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6016 if ( gs_specialKeys
[n
].vk
== vk
)
6017 return gs_specialKeys
[n
].wxk
;
6020 // keys requiring special handling
6024 // the mapping for these keys may be incorrect on non-US keyboards so
6025 // maybe we shouldn't map them to ASCII values at all
6026 case VK_OEM_1
: wxk
= ';'; break;
6027 case VK_OEM_PLUS
: wxk
= '+'; break;
6028 case VK_OEM_COMMA
: wxk
= ','; break;
6029 case VK_OEM_MINUS
: wxk
= '-'; break;
6030 case VK_OEM_PERIOD
: wxk
= '.'; break;
6031 case VK_OEM_2
: wxk
= '/'; break;
6032 case VK_OEM_3
: wxk
= '~'; break;
6033 case VK_OEM_4
: wxk
= '['; break;
6034 case VK_OEM_5
: wxk
= '\\'; break;
6035 case VK_OEM_6
: wxk
= ']'; break;
6036 case VK_OEM_7
: wxk
= '\''; break;
6038 // handle extended keys
6040 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
6044 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
6048 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
6052 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
6056 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
6060 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
6064 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
6068 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
6072 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
6076 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
6080 // don't use ChooseNormalOrExtended() here as the keys are reversed
6081 // here: numpad enter is the extended one
6082 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
6092 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
6097 // check the table first
6098 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
6100 if ( gs_specialKeys
[n
].wxk
== wxk
)
6101 return gs_specialKeys
[n
].vk
;
6104 // and then check for special keys not included in the table
6109 case WXK_NUMPAD_PAGEUP
:
6114 case WXK_NUMPAD_PAGEDOWN
:
6119 case WXK_NUMPAD_END
:
6124 case WXK_NUMPAD_HOME
:
6129 case WXK_NUMPAD_LEFT
:
6139 case WXK_NUMPAD_RIGHT
:
6144 case WXK_NUMPAD_DOWN
:
6149 case WXK_NUMPAD_INSERT
:
6154 case WXK_NUMPAD_DELETE
:
6159 // no VkKeyScan() under CE unfortunately, we need to test how does
6160 // it handle OEM keys
6162 // check to see if its one of the OEM key codes.
6163 BYTE vks
= LOBYTE(VkKeyScan(wxk
));
6169 #endif // !__WXWINCE__
6180 // small helper for wxGetKeyState() and wxGetMouseState()
6181 static inline bool wxIsKeyDown(WXWORD vk
)
6183 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6184 #ifdef SM_SWAPBUTTON
6185 if ( vk
== VK_LBUTTON
|| vk
== VK_RBUTTON
)
6187 if ( ::GetSystemMetrics(SM_SWAPBUTTON
) )
6189 if ( vk
== VK_LBUTTON
)
6191 else // vk == VK_RBUTTON
6195 #endif // SM_SWAPBUTTON
6197 // the low order bit indicates whether the key was pressed since the last
6198 // call and the high order one indicates whether it is down right now and
6199 // we only want that one
6200 return (GetAsyncKeyState(vk
) & (1<<15)) != 0;
6203 bool wxGetKeyState(wxKeyCode key
)
6205 // although this does work under Windows, it is not supported under other
6206 // platforms so don't allow it, you must use wxGetMouseState() instead
6207 wxASSERT_MSG( key
!= VK_LBUTTON
&&
6208 key
!= VK_RBUTTON
&&
6210 wxT("can't use wxGetKeyState() for mouse buttons") );
6212 const WXWORD vk
= wxCharCodeWXToMSW(key
);
6214 // if the requested key is a LED key, return true if the led is pressed
6215 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
6217 // low order bit means LED is highlighted and high order one means the
6218 // key is down; for compatibility with the other ports return true if
6219 // either one is set
6220 return GetKeyState(vk
) != 0;
6225 return wxIsKeyDown(vk
);
6230 wxMouseState
wxGetMouseState()
6234 GetCursorPos( &pt
);
6238 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
6239 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
6240 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
6241 #ifdef wxHAS_XBUTTON
6242 ms
.SetAux1Down(wxIsKeyDown(VK_XBUTTON1
));
6243 ms
.SetAux2Down(wxIsKeyDown(VK_XBUTTON2
));
6244 #endif // wxHAS_XBUTTON
6246 ms
.SetControlDown(wxIsCtrlDown ());
6247 ms
.SetShiftDown (wxIsShiftDown());
6248 ms
.SetAltDown (wxIsAltDown ());
6249 // ms.SetMetaDown();
6255 wxWindow
*wxGetActiveWindow()
6257 HWND hWnd
= GetActiveWindow();
6260 return wxFindWinFromHandle(hWnd
);
6265 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
6267 HWND hwnd
= (HWND
)hWnd
;
6269 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6270 // by code in msw/radiobox.cpp), for all the others we just search up the
6272 wxWindow
*win
= NULL
;
6275 win
= wxFindWinFromHandle(hwnd
);
6279 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6280 // wxWindow class which overrides WM_GETDLGCODE processing to
6281 // do it as well, win would be already non NULL
6282 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
6284 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
6286 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6287 #endif // wxUSE_RADIOBOX
6289 // spin control text buddy window should be mapped to spin ctrl
6290 // itself so try it too
6291 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6294 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
6296 #endif // wxUSE_SPINCTRL
6300 while ( hwnd
&& !win
)
6302 // this is a really ugly hack needed to avoid mistakenly returning the
6303 // parent frame wxWindow for the find/replace modeless dialog HWND -
6304 // this, in turn, is needed to call IsDialogMessage() from
6305 // wxApp::ProcessMessage() as for this we must return NULL from here
6307 // FIXME: this is clearly not the best way to do it but I think we'll
6308 // need to change HWND <-> wxWindow code more heavily than I can
6309 // do it now to fix it
6310 #ifndef __WXMICROWIN__
6311 if ( ::GetWindow(hwnd
, GW_OWNER
) )
6313 // it's a dialog box, don't go upwards
6318 hwnd
= ::GetParent(hwnd
);
6319 win
= wxFindWinFromHandle(hwnd
);
6325 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6327 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6328 // in active frames and dialogs, regardless of where the focus is.
6329 static HHOOK wxTheKeyboardHook
= 0;
6332 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
6334 DWORD hiWord
= HIWORD(lParam
);
6335 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
6337 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
6340 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
6341 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
6342 event
.m_altDown
= true;
6344 event
.SetEventObject(NULL
);
6345 event
.m_keyCode
= id
;
6346 event
.m_shiftDown
= wxIsShiftDown();
6347 event
.m_controlDown
= wxIsCtrlDown();
6349 event
.SetTimestamp(::GetMessageTime());
6351 wxWindow
*win
= wxGetActiveWindow();
6352 wxEvtHandler
*handler
;
6355 handler
= win
->GetEventHandler();
6356 event
.SetId(win
->GetId());
6361 event
.SetId(wxID_ANY
);
6364 if ( handler
&& handler
->ProcessEvent(event
) )
6372 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
6375 void wxSetKeyboardHook(bool doIt
)
6379 wxTheKeyboardHook
= ::SetWindowsHookEx
6382 (HOOKPROC
)wxKeyboardHook
,
6383 NULL
, // must be NULL for process hook
6384 ::GetCurrentThreadId()
6386 if ( !wxTheKeyboardHook
)
6388 wxLogLastError(wxT("SetWindowsHookEx(wxKeyboardHook)"));
6393 if ( wxTheKeyboardHook
)
6394 ::UnhookWindowsHookEx(wxTheKeyboardHook
);
6398 #endif // !__WXMICROWIN__
6400 #if wxDEBUG_LEVEL >= 2
6401 const wxChar
*wxGetMessageName(int message
)
6405 case 0x0000: return wxT("WM_NULL");
6406 case 0x0001: return wxT("WM_CREATE");
6407 case 0x0002: return wxT("WM_DESTROY");
6408 case 0x0003: return wxT("WM_MOVE");
6409 case 0x0005: return wxT("WM_SIZE");
6410 case 0x0006: return wxT("WM_ACTIVATE");
6411 case 0x0007: return wxT("WM_SETFOCUS");
6412 case 0x0008: return wxT("WM_KILLFOCUS");
6413 case 0x000A: return wxT("WM_ENABLE");
6414 case 0x000B: return wxT("WM_SETREDRAW");
6415 case 0x000C: return wxT("WM_SETTEXT");
6416 case 0x000D: return wxT("WM_GETTEXT");
6417 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6418 case 0x000F: return wxT("WM_PAINT");
6419 case 0x0010: return wxT("WM_CLOSE");
6420 case 0x0011: return wxT("WM_QUERYENDSESSION");
6421 case 0x0012: return wxT("WM_QUIT");
6422 case 0x0013: return wxT("WM_QUERYOPEN");
6423 case 0x0014: return wxT("WM_ERASEBKGND");
6424 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6425 case 0x0016: return wxT("WM_ENDSESSION");
6426 case 0x0017: return wxT("WM_SYSTEMERROR");
6427 case 0x0018: return wxT("WM_SHOWWINDOW");
6428 case 0x0019: return wxT("WM_CTLCOLOR");
6429 case 0x001A: return wxT("WM_WININICHANGE");
6430 case 0x001B: return wxT("WM_DEVMODECHANGE");
6431 case 0x001C: return wxT("WM_ACTIVATEAPP");
6432 case 0x001D: return wxT("WM_FONTCHANGE");
6433 case 0x001E: return wxT("WM_TIMECHANGE");
6434 case 0x001F: return wxT("WM_CANCELMODE");
6435 case 0x0020: return wxT("WM_SETCURSOR");
6436 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6437 case 0x0022: return wxT("WM_CHILDACTIVATE");
6438 case 0x0023: return wxT("WM_QUEUESYNC");
6439 case 0x0024: return wxT("WM_GETMINMAXINFO");
6440 case 0x0026: return wxT("WM_PAINTICON");
6441 case 0x0027: return wxT("WM_ICONERASEBKGND");
6442 case 0x0028: return wxT("WM_NEXTDLGCTL");
6443 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6444 case 0x002B: return wxT("WM_DRAWITEM");
6445 case 0x002C: return wxT("WM_MEASUREITEM");
6446 case 0x002D: return wxT("WM_DELETEITEM");
6447 case 0x002E: return wxT("WM_VKEYTOITEM");
6448 case 0x002F: return wxT("WM_CHARTOITEM");
6449 case 0x0030: return wxT("WM_SETFONT");
6450 case 0x0031: return wxT("WM_GETFONT");
6451 case 0x0037: return wxT("WM_QUERYDRAGICON");
6452 case 0x0039: return wxT("WM_COMPAREITEM");
6453 case 0x0041: return wxT("WM_COMPACTING");
6454 case 0x0044: return wxT("WM_COMMNOTIFY");
6455 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6456 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6457 case 0x0048: return wxT("WM_POWER");
6459 case 0x004A: return wxT("WM_COPYDATA");
6460 case 0x004B: return wxT("WM_CANCELJOURNAL");
6461 case 0x004E: return wxT("WM_NOTIFY");
6462 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6463 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6464 case 0x0052: return wxT("WM_TCARD");
6465 case 0x0053: return wxT("WM_HELP");
6466 case 0x0054: return wxT("WM_USERCHANGED");
6467 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6468 case 0x007B: return wxT("WM_CONTEXTMENU");
6469 case 0x007C: return wxT("WM_STYLECHANGING");
6470 case 0x007D: return wxT("WM_STYLECHANGED");
6471 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6472 case 0x007F: return wxT("WM_GETICON");
6473 case 0x0080: return wxT("WM_SETICON");
6475 case 0x0081: return wxT("WM_NCCREATE");
6476 case 0x0082: return wxT("WM_NCDESTROY");
6477 case 0x0083: return wxT("WM_NCCALCSIZE");
6478 case 0x0084: return wxT("WM_NCHITTEST");
6479 case 0x0085: return wxT("WM_NCPAINT");
6480 case 0x0086: return wxT("WM_NCACTIVATE");
6481 case 0x0087: return wxT("WM_GETDLGCODE");
6482 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6483 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6484 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6485 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6486 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6487 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6488 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6489 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6490 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6491 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6493 case 0x00B0: return wxT("EM_GETSEL");
6494 case 0x00B1: return wxT("EM_SETSEL");
6495 case 0x00B2: return wxT("EM_GETRECT");
6496 case 0x00B3: return wxT("EM_SETRECT");
6497 case 0x00B4: return wxT("EM_SETRECTNP");
6498 case 0x00B5: return wxT("EM_SCROLL");
6499 case 0x00B6: return wxT("EM_LINESCROLL");
6500 case 0x00B7: return wxT("EM_SCROLLCARET");
6501 case 0x00B8: return wxT("EM_GETMODIFY");
6502 case 0x00B9: return wxT("EM_SETMODIFY");
6503 case 0x00BA: return wxT("EM_GETLINECOUNT");
6504 case 0x00BB: return wxT("EM_LINEINDEX");
6505 case 0x00BC: return wxT("EM_SETHANDLE");
6506 case 0x00BD: return wxT("EM_GETHANDLE");
6507 case 0x00BE: return wxT("EM_GETTHUMB");
6508 case 0x00C1: return wxT("EM_LINELENGTH");
6509 case 0x00C2: return wxT("EM_REPLACESEL");
6510 case 0x00C4: return wxT("EM_GETLINE");
6511 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6512 case 0x00C6: return wxT("EM_CANUNDO");
6513 case 0x00C7: return wxT("EM_UNDO");
6514 case 0x00C8: return wxT("EM_FMTLINES");
6515 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6516 case 0x00CB: return wxT("EM_SETTABSTOPS");
6517 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6518 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6519 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6520 case 0x00CF: return wxT("EM_SETREADONLY");
6521 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6522 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6523 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6524 case 0x00D3: return wxT("EM_SETMARGINS");
6525 case 0x00D4: return wxT("EM_GETMARGINS");
6526 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6527 case 0x00D6: return wxT("EM_POSFROMCHAR");
6528 case 0x00D7: return wxT("EM_CHARFROMPOS");
6529 case 0x00D8: return wxT("EM_SETIMESTATUS");
6530 case 0x00D9: return wxT("EM_GETIMESTATUS");
6532 case 0x0100: return wxT("WM_KEYDOWN");
6533 case 0x0101: return wxT("WM_KEYUP");
6534 case 0x0102: return wxT("WM_CHAR");
6535 case 0x0103: return wxT("WM_DEADCHAR");
6536 case 0x0104: return wxT("WM_SYSKEYDOWN");
6537 case 0x0105: return wxT("WM_SYSKEYUP");
6538 case 0x0106: return wxT("WM_SYSCHAR");
6539 case 0x0107: return wxT("WM_SYSDEADCHAR");
6540 case 0x0108: return wxT("WM_KEYLAST");
6542 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6543 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6544 case 0x010F: return wxT("WM_IME_COMPOSITION");
6546 case 0x0110: return wxT("WM_INITDIALOG");
6547 case 0x0111: return wxT("WM_COMMAND");
6548 case 0x0112: return wxT("WM_SYSCOMMAND");
6549 case 0x0113: return wxT("WM_TIMER");
6550 case 0x0114: return wxT("WM_HSCROLL");
6551 case 0x0115: return wxT("WM_VSCROLL");
6552 case 0x0116: return wxT("WM_INITMENU");
6553 case 0x0117: return wxT("WM_INITMENUPOPUP");
6554 case 0x011F: return wxT("WM_MENUSELECT");
6555 case 0x0120: return wxT("WM_MENUCHAR");
6556 case 0x0121: return wxT("WM_ENTERIDLE");
6558 case 0x0127: return wxT("WM_CHANGEUISTATE");
6559 case 0x0128: return wxT("WM_UPDATEUISTATE");
6560 case 0x0129: return wxT("WM_QUERYUISTATE");
6562 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6563 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6564 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6565 case 0x0135: return wxT("WM_CTLCOLORBTN");
6566 case 0x0136: return wxT("WM_CTLCOLORDLG");
6567 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6568 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6569 case 0x01E1: return wxT("MN_GETHMENU");
6571 case 0x0200: return wxT("WM_MOUSEMOVE");
6572 case 0x0201: return wxT("WM_LBUTTONDOWN");
6573 case 0x0202: return wxT("WM_LBUTTONUP");
6574 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6575 case 0x0204: return wxT("WM_RBUTTONDOWN");
6576 case 0x0205: return wxT("WM_RBUTTONUP");
6577 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6578 case 0x0207: return wxT("WM_MBUTTONDOWN");
6579 case 0x0208: return wxT("WM_MBUTTONUP");
6580 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6581 case 0x020A: return wxT("WM_MOUSEWHEEL");
6582 case 0x020B: return wxT("WM_XBUTTONDOWN");
6583 case 0x020C: return wxT("WM_XBUTTONUP");
6584 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6585 case 0x0210: return wxT("WM_PARENTNOTIFY");
6586 case 0x0211: return wxT("WM_ENTERMENULOOP");
6587 case 0x0212: return wxT("WM_EXITMENULOOP");
6589 case 0x0213: return wxT("WM_NEXTMENU");
6590 case 0x0214: return wxT("WM_SIZING");
6591 case 0x0215: return wxT("WM_CAPTURECHANGED");
6592 case 0x0216: return wxT("WM_MOVING");
6593 case 0x0218: return wxT("WM_POWERBROADCAST");
6594 case 0x0219: return wxT("WM_DEVICECHANGE");
6596 case 0x0220: return wxT("WM_MDICREATE");
6597 case 0x0221: return wxT("WM_MDIDESTROY");
6598 case 0x0222: return wxT("WM_MDIACTIVATE");
6599 case 0x0223: return wxT("WM_MDIRESTORE");
6600 case 0x0224: return wxT("WM_MDINEXT");
6601 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6602 case 0x0226: return wxT("WM_MDITILE");
6603 case 0x0227: return wxT("WM_MDICASCADE");
6604 case 0x0228: return wxT("WM_MDIICONARRANGE");
6605 case 0x0229: return wxT("WM_MDIGETACTIVE");
6606 case 0x0230: return wxT("WM_MDISETMENU");
6607 case 0x0233: return wxT("WM_DROPFILES");
6609 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6610 case 0x0282: return wxT("WM_IME_NOTIFY");
6611 case 0x0283: return wxT("WM_IME_CONTROL");
6612 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6613 case 0x0285: return wxT("WM_IME_SELECT");
6614 case 0x0286: return wxT("WM_IME_CHAR");
6615 case 0x0290: return wxT("WM_IME_KEYDOWN");
6616 case 0x0291: return wxT("WM_IME_KEYUP");
6618 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6619 case 0x02A1: return wxT("WM_MOUSEHOVER");
6620 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6621 case 0x02A3: return wxT("WM_MOUSELEAVE");
6623 case 0x0300: return wxT("WM_CUT");
6624 case 0x0301: return wxT("WM_COPY");
6625 case 0x0302: return wxT("WM_PASTE");
6626 case 0x0303: return wxT("WM_CLEAR");
6627 case 0x0304: return wxT("WM_UNDO");
6628 case 0x0305: return wxT("WM_RENDERFORMAT");
6629 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6630 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6631 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6632 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6633 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6634 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6635 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6636 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6637 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6638 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6639 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6640 case 0x0311: return wxT("WM_PALETTECHANGED");
6641 case 0x0312: return wxT("WM_HOTKEY");
6643 case 0x0317: return wxT("WM_PRINT");
6644 case 0x0318: return wxT("WM_PRINTCLIENT");
6646 // common controls messages - although they're not strictly speaking
6647 // standard, it's nice to decode them nevertheless
6650 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6651 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6652 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6653 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6654 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6655 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6656 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6657 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6658 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6659 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6660 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6661 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6662 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6663 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6664 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6665 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6666 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6667 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6668 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6669 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6670 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6671 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6672 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6673 case 0x1000 + 18: return wxT("LVM_HITTEST");
6674 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6675 case 0x1000 + 20: return wxT("LVM_SCROLL");
6676 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6677 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6678 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6679 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6680 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6681 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6682 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6683 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6684 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6685 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6686 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6687 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6688 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6689 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6690 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6691 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6692 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6693 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6694 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6695 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6696 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6697 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6698 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6699 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6700 case 0x1000 + 42: return wxT("LVM_UPDATE");
6701 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6702 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6703 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6704 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6705 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6706 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6707 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6708 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6709 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6710 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6711 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6712 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6713 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6714 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6715 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6716 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6717 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6718 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6719 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6720 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6721 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6722 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6723 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6724 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6725 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6726 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6729 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6730 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6731 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6732 case 0x1100 + 2: return wxT("TVM_EXPAND");
6733 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6734 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6735 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6736 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6737 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6738 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6739 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6740 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6741 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6742 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6743 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6744 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6745 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6746 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6747 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6748 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6749 case 0x1100 + 17: return wxT("TVM_HITTEST");
6750 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6751 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6752 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6753 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6754 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6755 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6756 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6757 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6758 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6761 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6762 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6763 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6764 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6765 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6766 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6767 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6768 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6769 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6770 case 0x1200 + 6: return wxT("HDM_HITTEST");
6771 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6772 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6773 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6774 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6775 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6776 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6777 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6778 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6781 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6782 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6783 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6784 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6785 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6786 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6787 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6788 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6789 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6790 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6791 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6792 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6793 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6794 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6795 case 0x1300 + 13: return wxT("TCM_HITTEST");
6796 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6797 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6798 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6799 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6800 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6801 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6802 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6803 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6804 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6805 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6806 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6807 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6810 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6811 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6812 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6813 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6814 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6815 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6816 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6817 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6818 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6819 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6820 case WM_USER
+17: return wxT("TB_SETSTATE");
6821 case WM_USER
+18: return wxT("TB_GETSTATE");
6822 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6823 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6824 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6825 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6826 case WM_USER
+23: return wxT("TB_GETBUTTON");
6827 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6828 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6829 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6830 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6831 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6832 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6833 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6834 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6835 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6836 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6837 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6838 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6839 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6840 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6841 case WM_USER
+37: return wxT("TB_SETPARENT");
6842 case WM_USER
+39: return wxT("TB_SETROWS");
6843 case WM_USER
+40: return wxT("TB_GETROWS");
6844 case WM_USER
+42: return wxT("TB_SETCMDID");
6845 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6846 case WM_USER
+44: return wxT("TB_GETBITMAP");
6847 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6848 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6849 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6850 case WM_USER
+47: return wxT("TB_SETINDENT");
6851 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6852 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6853 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6854 case WM_USER
+51: return wxT("TB_GETRECT");
6855 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6856 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6857 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6858 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6859 case WM_USER
+56: return wxT("TB_SETSTYLE");
6860 case WM_USER
+57: return wxT("TB_GETSTYLE");
6861 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6862 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6863 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6864 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6865 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6868 static wxString s_szBuf
;
6869 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6870 return s_szBuf
.c_str();
6873 #endif // wxDEBUG_LEVEL >= 2
6875 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6879 HWND hwnd
= GetHwndOf(win
);
6880 HDC hdc
= ::GetDC(hwnd
);
6882 #if !wxDIALOG_UNIT_COMPATIBILITY
6883 // and select the current font into it
6884 HFONT hfont
= GetHfontOf(win
->GetFont());
6887 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6891 // finally retrieve the text metrics from it
6892 GetTextMetrics(hdc
, &tm
);
6894 #if !wxDIALOG_UNIT_COMPATIBILITY
6898 (void)::SelectObject(hdc
, hfont
);
6902 ::ReleaseDC(hwnd
, hdc
);
6907 // Find the wxWindow at the current mouse position, returning the mouse
6909 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6911 pt
= wxGetMousePosition();
6912 return wxFindWindowAtPoint(pt
);
6915 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6921 HWND hWnd
= ::WindowFromPoint(pt2
);
6923 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6926 // Get the current mouse position.
6927 wxPoint
wxGetMousePosition()
6931 GetCursorPosWinCE(&pt
);
6933 GetCursorPos( & pt
);
6936 return wxPoint(pt
.x
, pt
.y
);
6941 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6942 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6944 // Register hotkeys for the hardware buttons
6946 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6948 UnregisterFunc1Proc procUnregisterFunc
;
6949 hCoreDll
= LoadLibrary(wxT("coredll.dll"));
6952 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, wxT("UnregisterFunc1"));
6953 if (procUnregisterFunc
)
6954 procUnregisterFunc(modifiers
, id
);
6955 FreeLibrary(hCoreDll
);
6960 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6962 UINT win_modifiers
=0;
6963 if ( modifiers
& wxMOD_ALT
)
6964 win_modifiers
|= MOD_ALT
;
6965 if ( modifiers
& wxMOD_SHIFT
)
6966 win_modifiers
|= MOD_SHIFT
;
6967 if ( modifiers
& wxMOD_CONTROL
)
6968 win_modifiers
|= MOD_CONTROL
;
6969 if ( modifiers
& wxMOD_WIN
)
6970 win_modifiers
|= MOD_WIN
;
6972 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6973 // Required for PPC and Smartphone hardware buttons
6974 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6975 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6978 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6980 wxLogLastError(wxT("RegisterHotKey"));
6988 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6990 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6991 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6994 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6996 wxLogLastError(wxT("UnregisterHotKey"));
7006 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
7008 int hotkeyId
= wParam
;
7009 int virtualKey
= HIWORD(lParam
);
7010 int win_modifiers
= LOWORD(lParam
);
7012 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
7013 event
.SetId(hotkeyId
);
7014 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
7015 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
7016 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
7017 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
7019 return HandleWindowEvent(event
);
7022 #endif // wxUSE_ACCEL
7024 #endif // wxUSE_HOTKEY
7026 // Not tested under WinCE
7029 // this class installs a message hook which really wakes up our idle processing
7030 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
7031 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
7032 // being dragged or even inside ::MessageBox()) and so don't control message
7033 // dispatching otherwise
7034 class wxIdleWakeUpModule
: public wxModule
7037 virtual bool OnInit()
7039 ms_hMsgHookProc
= ::SetWindowsHookEx
7042 &wxIdleWakeUpModule::MsgHookProc
,
7044 GetCurrentThreadId()
7047 if ( !ms_hMsgHookProc
)
7049 wxLogLastError(wxT("SetWindowsHookEx(WH_GETMESSAGE)"));
7057 virtual void OnExit()
7059 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
7062 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
7064 MSG
*msg
= (MSG
*)lParam
;
7066 // only process the message if it is actually going to be removed from
7067 // the message queue, this prevents that the same event from being
7068 // processed multiple times if now someone just called PeekMessage()
7069 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
7071 wxTheApp
->ProcessPendingEvents();
7074 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
7078 static HHOOK ms_hMsgHookProc
;
7080 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
7083 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
7085 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
7087 #endif // __WXWINCE__
7092 static void wxAdjustZOrder(wxWindow
* parent
)
7094 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
7096 // Set the z-order correctly
7097 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
7100 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
7103 wxWindow
*childWin
= current
->GetData();
7104 wxAdjustZOrder(childWin
);
7105 current
= current
->GetNext();
7110 // We need to adjust the z-order of static boxes in WinCE, to
7111 // make 'contained' controls visible
7112 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
7115 wxAdjustZOrder(this);