1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
38 #include "wx/dcclient.h"
39 #include "wx/dcmemory.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
47 #include "wx/msgdlg.h"
48 #include "wx/settings.h"
49 #include "wx/statbox.h"
52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
53 #include "wx/ownerdrw.h"
56 #include "wx/module.h"
58 #if wxUSE_DRAG_AND_DROP
62 #if wxUSE_ACCESSIBILITY
63 #include "wx/access.h"
67 #define WM_GETOBJECT 0x003D
70 #define OBJID_CLIENT 0xFFFFFFFC
74 #include "wx/menuitem.h"
77 #include "wx/msw/private.h"
80 #include "wx/tooltip.h"
88 #include "wx/spinctrl.h"
89 #endif // wxUSE_SPINCTRL
94 #include "wx/textctrl.h"
95 #include "wx/notebook.h"
96 #include "wx/listctrl.h"
100 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
101 #include <shellapi.h>
102 #include <mmsystem.h>
106 #include <windowsx.h>
109 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
111 #include <commctrl.h>
113 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
114 #include "wx/msw/gnuwin32/extra.h"
117 #include "wx/msw/missing.h"
119 #if defined(__WXWINCE__)
120 #include "wx/msw/wince/missing.h"
123 // ---------------------------------------------------------------------------
125 // ---------------------------------------------------------------------------
127 #if wxUSE_MENUS_NATIVE
128 wxMenu
*wxCurrentPopupMenu
= NULL
;
129 #endif // wxUSE_MENUS_NATIVE
132 extern wxChar
*wxCanvasClassName
;
134 extern const wxChar
*wxCanvasClassName
;
137 // true if we had already created the std colour map, used by
138 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
139 static bool gs_hasStdCmap
= false;
141 // ---------------------------------------------------------------------------
143 // ---------------------------------------------------------------------------
145 // the window proc for all our windows
146 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
147 WPARAM wParam
, LPARAM lParam
);
151 const char *wxGetMessageName(int message
);
154 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
155 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
156 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
158 // get the text metrics for the current font
159 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
161 // find the window for the mouse event at the specified position
162 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
164 // wrapper around BringWindowToTop() API
165 static inline void wxBringWindowToTop(HWND hwnd
)
167 #ifdef __WXMICROWIN__
168 // It seems that MicroWindows brings the _parent_ of the window to the top,
169 // which can be the wrong one.
171 // activate (set focus to) specified window
175 // raise top level parent to top of z order
176 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
178 wxLogLastError(_T("SetWindowPos"));
184 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
185 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
188 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
189 parent as well as otherwise several Win32 functions using
190 GetNextDlgTabItem() to iterate over all controls such as
191 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
192 all of them iterate over all the controls starting from the currently
193 focused one and stop iterating when they get back to the focus but
194 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
195 get back to the initial (focused) window: as we do have this style,
196 GetNextDlgTabItem() will leave this window and continue in its parent,
197 but if the parent doesn't have it, it wouldn't recurse inside it later
198 on and so wouldn't have a chance of getting back to this window neither.
200 while ( parent
&& !parent
->IsTopLevel() )
202 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
203 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
205 // force the parent to have this style
206 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
207 exStyle
| WS_EX_CONTROLPARENT
);
210 parent
= parent
->GetParent();
214 #endif // !__WXWINCE__
216 // ---------------------------------------------------------------------------
218 // ---------------------------------------------------------------------------
220 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
222 #ifdef __WXUNIVERSAL__
223 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
225 #if wxUSE_EXTENDED_RTTI
227 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
228 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
229 // windows with negative ids never can be recreated anyway
231 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
233 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
234 if ( win
&& win
->GetId() < 0 )
239 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
241 // make wxWindowList known before the property is used
243 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
245 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
247 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
250 WX_DEFINE_FLAGS( wxWindowStyle
)
252 wxBEGIN_FLAGS( wxWindowStyle
)
253 // new style border flags, we put them first to
254 // use them for streaming out
256 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
257 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
258 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
259 wxFLAGS_MEMBER(wxBORDER_RAISED
)
260 wxFLAGS_MEMBER(wxBORDER_STATIC
)
261 wxFLAGS_MEMBER(wxBORDER_NONE
)
263 // old style border flags
264 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
265 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
266 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
267 wxFLAGS_MEMBER(wxRAISED_BORDER
)
268 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
269 wxFLAGS_MEMBER(wxBORDER
)
271 // standard window styles
272 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
273 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
274 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
275 wxFLAGS_MEMBER(wxWANTS_CHARS
)
276 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
277 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
278 wxFLAGS_MEMBER(wxVSCROLL
)
279 wxFLAGS_MEMBER(wxHSCROLL
)
281 wxEND_FLAGS( wxWindowStyle
)
283 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
284 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
285 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
286 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
287 // Always constructor Properties first
289 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
290 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, wxID_ANY
, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
291 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
292 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
293 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
295 // Then all relations of the object graph
297 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
299 // and finally all other properties
301 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
302 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
303 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
304 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
305 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
307 // possible property candidates (not in xrc) or not valid in all subclasses
308 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxT("") )
309 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
310 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxT("") )
311 // MaxHeight, Width , MinHeight , Width
312 // TODO switch label to control and title to toplevels
314 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
315 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
316 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
317 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
322 wxEND_PROPERTIES_TABLE()
324 wxBEGIN_HANDLERS_TABLE(wxWindow
)
325 wxEND_HANDLERS_TABLE()
327 wxCONSTRUCTOR_DUMMY(wxWindow
)
330 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
332 #endif // __WXUNIVERSAL__/__WXMSW__
334 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
335 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
337 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
341 // ===========================================================================
343 // ===========================================================================
345 // ---------------------------------------------------------------------------
346 // wxWindow utility functions
347 // ---------------------------------------------------------------------------
349 // Find an item given the MS Windows id
350 wxWindow
*wxWindowMSW::FindItem(long id
) const
353 wxControl
*item
= wxDynamicCastThis(wxControl
);
356 // is it we or one of our "internal" children?
357 if ( item
->GetId() == id
358 #ifndef __WXUNIVERSAL__
359 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
360 #endif // __WXUNIVERSAL__
366 #endif // wxUSE_CONTROLS
368 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
371 wxWindow
*childWin
= current
->GetData();
373 wxWindow
*wnd
= childWin
->FindItem(id
);
377 current
= current
->GetNext();
383 // Find an item given the MS Windows handle
384 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
386 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
389 wxWindow
*parent
= current
->GetData();
391 // Do a recursive search.
392 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
398 || parent
->IsKindOf(CLASSINFO(wxControl
))
399 #endif // wxUSE_CONTROLS
402 wxWindow
*item
= current
->GetData();
403 if ( item
->GetHWND() == hWnd
)
407 if ( item
->ContainsHWND(hWnd
) )
412 current
= current
->GetNext();
417 // Default command handler
418 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
423 // ----------------------------------------------------------------------------
424 // constructors and such
425 // ----------------------------------------------------------------------------
427 void wxWindowMSW::Init()
430 m_isBeingDeleted
= false;
432 m_mouseInWindow
= false;
433 m_lastKeydownProcessed
= false;
435 m_childrenDisabled
= NULL
;
446 #if wxUSE_MOUSEEVENT_HACK
449 m_lastMouseEvent
= -1;
450 #endif // wxUSE_MOUSEEVENT_HACK
454 wxWindowMSW::~wxWindowMSW()
456 m_isBeingDeleted
= true;
458 #ifndef __WXUNIVERSAL__
459 // VS: make sure there's no wxFrame with last focus set to us:
460 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
462 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
465 if ( frame
->GetLastFocus() == this )
467 frame
->SetLastFocus(NULL
);
472 #endif // __WXUNIVERSAL__
474 // VS: destroy children first and _then_ detach *this from its parent.
475 // If we'd do it the other way around, children wouldn't be able
476 // find their parent frame (see above).
481 // VZ: test temp removed to understand what really happens here
482 //if (::IsWindow(GetHwnd()))
484 if ( !::DestroyWindow(GetHwnd()) )
485 wxLogLastError(wxT("DestroyWindow"));
488 // remove hWnd <-> wxWindow association
489 wxRemoveHandleAssociation(this);
492 delete m_childrenDisabled
;
495 // real construction (Init() must have been called before!)
496 bool wxWindowMSW::Create(wxWindow
*parent
,
501 const wxString
& name
)
503 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
505 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
508 parent
->AddChild(this);
511 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
513 #ifdef __WXUNIVERSAL__
514 // no borders, we draw them ourselves
515 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
519 msflags
&= ~WS_BORDER
;
520 #endif // wxUniversal
524 msflags
|= WS_VISIBLE
;
527 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
535 // ---------------------------------------------------------------------------
537 // ---------------------------------------------------------------------------
539 void wxWindowMSW::SetFocus()
541 HWND hWnd
= GetHwnd();
542 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
544 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
548 if ( !::SetFocus(hWnd
) )
550 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
551 // was there really an error?
552 DWORD dwRes
= ::GetLastError();
555 HWND hwndFocus
= ::GetFocus();
556 if ( hwndFocus
!= hWnd
)
558 wxLogApiError(_T("SetFocus"), dwRes
);
565 void wxWindowMSW::SetFocusFromKbd()
567 // when the focus is given to the control with DLGC_HASSETSEL style from
568 // keyboard its contents should be entirely selected: this is what
569 // ::IsDialogMessage() does and so we should do it as well to provide the
570 // same LNF as the native programs
571 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
573 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
576 // do this after (maybe) setting the selection as like this when
577 // wxEVT_SET_FOCUS handler is called, the selection would have been already
578 // set correctly -- this may be important
579 wxWindowBase::SetFocusFromKbd();
582 // Get the window with the focus
583 wxWindow
*wxWindowBase::DoFindFocus()
585 HWND hWnd
= ::GetFocus();
588 return wxGetWindowFromHWND((WXHWND
)hWnd
);
594 bool wxWindowMSW::Enable(bool enable
)
596 if ( !wxWindowBase::Enable(enable
) )
599 HWND hWnd
= GetHwnd();
601 ::EnableWindow(hWnd
, (BOOL
)enable
);
603 // the logic below doesn't apply to the top level windows -- otherwise
604 // showing a modal dialog would result in total greying out (and ungreying
605 // out later) of everything which would be really ugly
609 // when the parent is disabled, all of its children should be disabled as
610 // well but when it is enabled back, only those of the children which
611 // hadn't been already disabled in the beginning should be enabled again,
612 // so we have to keep the list of those children
613 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
615 node
= node
->GetNext() )
617 wxWindow
*child
= node
->GetData();
618 if ( child
->IsTopLevel() )
620 // the logic below doesn't apply to top level children
626 // enable the child back unless it had been disabled before us
627 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
630 else // we're being disabled
632 if ( child
->IsEnabled() )
634 // disable it as children shouldn't stay enabled while the
638 else // child already disabled, remember it
640 // have we created the list of disabled children already?
641 if ( !m_childrenDisabled
)
642 m_childrenDisabled
= new wxWindowList
;
644 m_childrenDisabled
->Append(child
);
649 if ( enable
&& m_childrenDisabled
)
651 // we don't need this list any more, don't keep unused memory
652 delete m_childrenDisabled
;
653 m_childrenDisabled
= NULL
;
659 bool wxWindowMSW::Show(bool show
)
661 if ( !wxWindowBase::Show(show
) )
664 HWND hWnd
= GetHwnd();
665 int cshow
= show
? SW_SHOW
: SW_HIDE
;
666 ::ShowWindow(hWnd
, cshow
);
668 if ( show
&& IsTopLevel() )
670 wxBringWindowToTop(hWnd
);
676 // Raise the window to the top of the Z order
677 void wxWindowMSW::Raise()
679 wxBringWindowToTop(GetHwnd());
682 // Lower the window to the bottom of the Z order
683 void wxWindowMSW::Lower()
685 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
686 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
689 void wxWindowMSW::SetTitle( const wxString
& title
)
691 SetWindowText(GetHwnd(), title
.c_str());
694 wxString
wxWindowMSW::GetTitle() const
696 return wxGetWindowText(GetHWND());
699 void wxWindowMSW::DoCaptureMouse()
701 HWND hWnd
= GetHwnd();
708 void wxWindowMSW::DoReleaseMouse()
710 if ( !::ReleaseCapture() )
712 wxLogLastError(_T("ReleaseCapture"));
716 /* static */ wxWindow
*wxWindowBase::GetCapture()
718 HWND hwnd
= ::GetCapture();
719 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
722 bool wxWindowMSW::SetFont(const wxFont
& font
)
724 if ( !wxWindowBase::SetFont(font
) )
730 HWND hWnd
= GetHwnd();
733 WXHANDLE hFont
= m_font
.GetResourceHandle();
735 wxASSERT_MSG( hFont
, wxT("should have valid font") );
737 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
742 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
744 if ( !wxWindowBase::SetCursor(cursor
) )
752 HWND hWnd
= GetHwnd();
754 // Change the cursor NOW if we're within the correct window
756 ::GetCursorPos(&point
);
758 RECT rect
= wxGetWindowRect(hWnd
);
760 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
761 ::SetCursor(GetHcursorOf(m_cursor
));
767 void wxWindowMSW::WarpPointer (int x
, int y
)
769 ClientToScreen(&x
, &y
);
771 if ( !::SetCursorPos(x
, y
) )
773 wxLogLastError(_T("SetCursorPos"));
777 // ---------------------------------------------------------------------------
779 // ---------------------------------------------------------------------------
781 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
782 static inline int wxDirToWinStyle(int orient
)
784 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
787 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
789 #ifdef __WXMICROWIN__
790 return ::GetScrollPosWX(hWnd
, wOrient
);
792 WinStruct
<SCROLLINFO
> scrollInfo
;
793 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
794 scrollInfo
.fMask
= SIF_POS
;
795 if ( !::GetScrollInfo(hWnd
,
799 // Not neccessarily an error, if there are no scrollbars yet.
800 // wxLogLastError(_T("GetScrollInfo"));
802 return scrollInfo
.nPos
;
803 // return ::GetScrollPos(hWnd, wOrient);
807 int wxWindowMSW::GetScrollPos(int orient
) const
809 HWND hWnd
= GetHwnd();
810 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
812 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
815 // This now returns the whole range, not just the number
816 // of positions that we can scroll.
817 int wxWindowMSW::GetScrollRange(int orient
) const
820 HWND hWnd
= GetHwnd();
824 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
827 WinStruct
<SCROLLINFO
> scrollInfo
;
828 scrollInfo
.fMask
= SIF_RANGE
;
829 if ( !::GetScrollInfo(hWnd
,
830 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
833 // Most of the time this is not really an error, since the return
834 // value can also be zero when there is no scrollbar yet.
835 // wxLogLastError(_T("GetScrollInfo"));
837 maxPos
= scrollInfo
.nMax
;
839 // undo "range - 1" done in SetScrollbar()
843 int wxWindowMSW::GetScrollThumb(int orient
) const
845 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
848 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
850 HWND hWnd
= GetHwnd();
851 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
853 WinStruct
<SCROLLINFO
> info
;
857 info
.fMask
= SIF_POS
;
858 if ( HasFlag(wxALWAYS_SHOW_SB
) )
860 // disable scrollbar instead of removing it then
861 info
.fMask
|= SIF_DISABLENOSCROLL
;
864 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
868 // New function that will replace some of the above.
869 void wxWindowMSW::SetScrollbar(int orient
,
875 WinStruct
<SCROLLINFO
> info
;
876 info
.nPage
= pageSize
;
877 info
.nMin
= 0; // range is nMax - nMin + 1
878 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
880 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
881 if ( HasFlag(wxALWAYS_SHOW_SB
) )
883 // disable scrollbar instead of removing it then
884 info
.fMask
|= SIF_DISABLENOSCROLL
;
887 HWND hWnd
= GetHwnd();
890 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
894 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
897 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
903 rect
.left
= prect
->x
;
905 rect
.right
= prect
->x
+ prect
->width
;
906 rect
.bottom
= prect
->y
+ prect
->height
;
916 // FIXME: is this the exact equivalent of the line below?
917 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
919 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
923 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
925 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
928 for ( int n
= 0; n
< count
; n
++ )
930 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
932 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
935 // don't bother to continue, we're already at top/bottom
942 return pos
!= posStart
;
945 bool wxWindowMSW::ScrollLines(int lines
)
947 bool down
= lines
> 0;
949 return ScrollVertically(GetHwnd(),
950 down
? SB_LINEDOWN
: SB_LINEUP
,
951 down
? lines
: -lines
);
954 bool wxWindowMSW::ScrollPages(int pages
)
956 bool down
= pages
> 0;
958 return ScrollVertically(GetHwnd(),
959 down
? SB_PAGEDOWN
: SB_PAGEUP
,
960 down
? pages
: -pages
);
963 // ---------------------------------------------------------------------------
965 // ---------------------------------------------------------------------------
967 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
969 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
971 HWND hwnd
= (HWND
)hWnd
;
972 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
974 wxAssociateWinWithHandle(hwnd
, this);
976 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
978 // we don't need to subclass the window of our own class (in the Windows
979 // sense of the word)
980 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
982 wxSetWindowProc(hwnd
, wxWndProc
);
986 // don't bother restoring it neither: this also makes it easy to
987 // implement IsOfStandardClass() method which returns true for the
988 // standard controls and false for the wxWidgets own windows as it can
989 // simply check m_oldWndProc
994 void wxWindowMSW::UnsubclassWin()
996 wxRemoveHandleAssociation(this);
998 // Restore old Window proc
999 HWND hwnd
= GetHwnd();
1004 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1008 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1010 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1013 m_oldWndProc
= NULL
;
1018 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1022 if ( !::DestroyWindow(GetHwnd()) )
1023 wxLogLastError(wxT("DestroyWindow"));
1026 WXHWND wxhwnd
= (WXHWND
)handle
;
1029 SubclassWin(wxhwnd
);
1032 void wxWindowMSW::DissociateHandle()
1034 // this also calls SetHWND(0) for us
1039 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1041 // Unicows note: the code below works, but only because WNDCLASS contains
1042 // original window handler rather that the unicows fake one. This may not
1043 // be on purpose, though; if it stops working with future versions of
1044 // unicows.dll, we can override unicows hooks by setting
1045 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1046 // versions that keep track of fake<->real wnd proc mapping.
1048 // On WinCE (at least), the wndproc comparison doesn't work,
1049 // so have to use something like this.
1051 extern wxChar
*wxCanvasClassName
;
1052 extern wxChar
*wxCanvasClassNameNR
;
1053 extern const wxChar
*wxMDIFrameClassName
;
1054 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1055 extern const wxChar
*wxMDIChildFrameClassName
;
1056 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1057 wxString
str(wxGetWindowClass(hWnd
));
1058 if (str
== wxCanvasClassName
||
1059 str
== wxCanvasClassNameNR
||
1060 str
== wxMDIFrameClassName
||
1061 str
== wxMDIFrameClassNameNoRedraw
||
1062 str
== wxMDIChildFrameClassName
||
1063 str
== wxMDIChildFrameClassNameNoRedraw
||
1064 str
== _T("wxTLWHiddenParent"))
1065 return true; // Effectively means don't subclass
1070 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1072 wxLogLastError(_T("GetClassInfo"));
1077 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1081 // ----------------------------------------------------------------------------
1083 // ----------------------------------------------------------------------------
1085 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1087 long flagsOld
= GetWindowStyleFlag();
1088 if ( flags
== flagsOld
)
1091 // update the internal variable
1092 wxWindowBase::SetWindowStyleFlag(flags
);
1094 // now update the Windows style as well if needed - and if the window had
1095 // been already created
1099 WXDWORD exstyle
, exstyleOld
;
1100 long style
= MSWGetStyle(flags
, &exstyle
),
1101 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1103 if ( style
!= styleOld
)
1105 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1106 // this function so instead of simply setting the style to the new
1107 // value we clear the bits which were set in styleOld but are set in
1108 // the new one and set the ones which were not set before
1109 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1110 styleReal
&= ~styleOld
;
1113 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1116 // and the extended style
1117 if ( exstyle
!= exstyleOld
)
1119 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1120 exstyleReal
&= ~exstyleOld
;
1121 exstyleReal
|= exstyle
;
1123 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1125 // we must call SetWindowPos() to flash the cached extended style and
1126 // also to make the change to wxSTAY_ON_TOP style take effect: just
1127 // setting the style simply doesn't work
1128 if ( !::SetWindowPos(GetHwnd(),
1129 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1132 SWP_NOMOVE
| SWP_NOSIZE
) )
1134 wxLogLastError(_T("SetWindowPos"));
1139 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1141 // translate common wxWidgets styles to Windows ones
1143 // most of windows are child ones, those which are not (such as
1144 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1145 WXDWORD style
= WS_CHILD
;
1147 if ( flags
& wxCLIP_CHILDREN
)
1148 style
|= WS_CLIPCHILDREN
;
1150 if ( flags
& wxCLIP_SIBLINGS
)
1151 style
|= WS_CLIPSIBLINGS
;
1153 if ( flags
& wxVSCROLL
)
1154 style
|= WS_VSCROLL
;
1156 if ( flags
& wxHSCROLL
)
1157 style
|= WS_HSCROLL
;
1159 const wxBorder border
= GetBorder(flags
);
1161 // WS_BORDER is only required for wxBORDER_SIMPLE
1162 if ( border
== wxBORDER_SIMPLE
)
1165 // now deal with ext style if the caller wants it
1171 if ( flags
& wxTRANSPARENT_WINDOW
)
1172 *exstyle
|= WS_EX_TRANSPARENT
;
1178 case wxBORDER_DEFAULT
:
1179 wxFAIL_MSG( _T("unknown border style") );
1183 case wxBORDER_SIMPLE
:
1186 case wxBORDER_STATIC
:
1187 *exstyle
|= WS_EX_STATICEDGE
;
1190 case wxBORDER_RAISED
:
1191 *exstyle
|= WS_EX_DLGMODALFRAME
;
1194 case wxBORDER_SUNKEN
:
1195 *exstyle
|= WS_EX_CLIENTEDGE
;
1196 style
&= ~WS_BORDER
;
1199 case wxBORDER_DOUBLE
:
1200 *exstyle
|= WS_EX_DLGMODALFRAME
;
1204 // wxUniv doesn't use Windows dialog navigation functions at all
1205 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1206 // to make the dialog navigation work with the nested panels we must
1207 // use this style (top level windows such as dialogs don't need it)
1208 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1210 *exstyle
|= WS_EX_CONTROLPARENT
;
1212 #endif // __WXUNIVERSAL__
1218 // Setup background and foreground colours correctly
1219 void wxWindowMSW::SetupColours()
1222 SetBackgroundColour(GetParent()->GetBackgroundColour());
1225 bool wxWindowMSW::IsMouseInWindow() const
1227 // get the mouse position
1229 ::GetCursorPos(&pt
);
1231 // find the window which currently has the cursor and go up the window
1232 // chain until we find this window - or exhaust it
1233 HWND hwnd
= ::WindowFromPoint(pt
);
1234 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1235 hwnd
= ::GetParent(hwnd
);
1237 return hwnd
!= NULL
;
1240 void wxWindowMSW::OnInternalIdle()
1242 // Check if we need to send a LEAVE event
1243 if ( m_mouseInWindow
)
1245 // note that we should generate the leave event whether the window has
1246 // or doesn't have mouse capture
1247 if ( !IsMouseInWindow() )
1249 // Generate a LEAVE event
1250 m_mouseInWindow
= false;
1252 // Unfortunately the mouse button and keyboard state may have
1253 // changed by the time the OnInternalIdle function is called, so 'state'
1254 // may be meaningless.
1256 if ( wxIsShiftDown() )
1258 if ( wxIsCtrlDown() )
1259 state
|= MK_CONTROL
;
1260 if ( GetKeyState( VK_LBUTTON
) )
1261 state
|= MK_LBUTTON
;
1262 if ( GetKeyState( VK_MBUTTON
) )
1263 state
|= MK_MBUTTON
;
1264 if ( GetKeyState( VK_RBUTTON
) )
1265 state
|= MK_RBUTTON
;
1268 if ( !::GetCursorPos(&pt
) )
1270 wxLogLastError(_T("GetCursorPos"));
1273 // we need to have client coordinates here for symmetry with
1274 // wxEVT_ENTER_WINDOW
1275 RECT rect
= wxGetWindowRect(GetHwnd());
1279 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1280 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1282 (void)GetEventHandler()->ProcessEvent(event2
);
1286 if (wxUpdateUIEvent::CanUpdate(this))
1287 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1290 // Set this window to be the child of 'parent'.
1291 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1293 if ( !wxWindowBase::Reparent(parent
) )
1296 HWND hWndChild
= GetHwnd();
1297 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1299 ::SetParent(hWndChild
, hWndParent
);
1302 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1304 EnsureParentHasControlParentStyle(GetParent());
1306 #endif // !__WXWINCE__
1311 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1313 #ifndef __WXMICROWIN__
1314 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1318 void wxWindowMSW::Freeze()
1320 if ( !m_frozenness
++ )
1322 SendSetRedraw(GetHwnd(), false);
1326 void wxWindowMSW::Thaw()
1328 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1330 if ( !--m_frozenness
)
1332 SendSetRedraw(GetHwnd(), true);
1334 // we need to refresh everything or otherwise he invalidated area is not
1340 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1342 HWND hWnd
= GetHwnd();
1348 mswRect
.left
= rect
->x
;
1349 mswRect
.top
= rect
->y
;
1350 mswRect
.right
= rect
->x
+ rect
->width
;
1351 mswRect
.bottom
= rect
->y
+ rect
->height
;
1353 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1356 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1360 void wxWindowMSW::Update()
1362 if ( !::UpdateWindow(GetHwnd()) )
1364 wxLogLastError(_T("UpdateWindow"));
1367 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1368 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1369 // handler needs to be really drawn right now
1374 // ---------------------------------------------------------------------------
1376 // ---------------------------------------------------------------------------
1379 #if wxUSE_DRAG_AND_DROP
1380 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1382 if ( m_dropTarget
!= 0 ) {
1383 m_dropTarget
->Revoke(m_hWnd
);
1384 delete m_dropTarget
;
1387 m_dropTarget
= pDropTarget
;
1388 if ( m_dropTarget
!= 0 )
1389 m_dropTarget
->Register(m_hWnd
);
1391 #endif // wxUSE_DRAG_AND_DROP
1393 // old style file-manager drag&drop support: we retain the old-style
1394 // DragAcceptFiles in parallel with SetDropTarget.
1395 void wxWindowMSW::DragAcceptFiles(bool accept
)
1397 #if !defined(__WXWINCE__)
1398 HWND hWnd
= GetHwnd();
1400 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1402 wxUnusedVar(accept
);
1406 // ----------------------------------------------------------------------------
1408 // ----------------------------------------------------------------------------
1412 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1414 wxWindowBase::DoSetToolTip(tooltip
);
1417 m_tooltip
->SetWindow((wxWindow
*)this);
1420 #endif // wxUSE_TOOLTIPS
1422 // ---------------------------------------------------------------------------
1423 // moving and resizing
1424 // ---------------------------------------------------------------------------
1427 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1429 RECT rect
= wxGetWindowRect(GetHwnd());
1432 *x
= rect
.right
- rect
.left
;
1434 *y
= rect
.bottom
- rect
.top
;
1437 // Get size *available for subwindows* i.e. excluding menu bar etc.
1438 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1440 RECT rect
= wxGetClientRect(GetHwnd());
1448 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1450 RECT rect
= wxGetWindowRect(GetHwnd());
1453 point
.x
= rect
.left
;
1456 // we do the adjustments with respect to the parent only for the "real"
1457 // children, not for the dialogs/frames
1458 if ( !IsTopLevel() )
1460 HWND hParentWnd
= 0;
1461 wxWindow
*parent
= GetParent();
1463 hParentWnd
= GetWinHwnd(parent
);
1465 // Since we now have the absolute screen coords, if there's a parent we
1466 // must subtract its top left corner
1469 ::ScreenToClient(hParentWnd
, &point
);
1474 // We may be faking the client origin. So a window that's really at (0,
1475 // 30) may appear (to wxWin apps) to be at (0, 0).
1476 wxPoint
pt(parent
->GetClientAreaOrigin());
1488 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1496 ::ScreenToClient(GetHwnd(), &pt
);
1504 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1512 ::ClientToScreen(GetHwnd(), &pt
);
1520 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1522 // TODO: is this consistent with other platforms?
1523 // Still, negative width or height shouldn't be allowed
1528 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, IsShown() /*Repaint?*/) )
1530 wxLogLastError(wxT("MoveWindow"));
1534 // set the size of the window: if the dimensions are positive, just use them,
1535 // but if any of them is equal to -1, it means that we must find the value for
1536 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1537 // which case -1 is a valid value for x and y)
1539 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1540 // the width/height to best suit our contents, otherwise we reuse the current
1542 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1544 // get the current size and position...
1545 int currentX
, currentY
;
1546 GetPosition(¤tX
, ¤tY
);
1547 int currentW
,currentH
;
1548 GetSize(¤tW
, ¤tH
);
1550 // ... and don't do anything (avoiding flicker) if it's already ok
1551 if ( x
== currentX
&& y
== currentY
&&
1552 width
== currentW
&& height
== currentH
)
1557 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1559 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1562 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1564 wxSize size
= wxDefaultSize
;
1565 if ( width
== wxDefaultCoord
)
1567 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1569 size
= DoGetBestSize();
1574 // just take the current one
1579 if ( height
== wxDefaultCoord
)
1581 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1583 if ( size
.x
== wxDefaultCoord
)
1585 size
= DoGetBestSize();
1587 //else: already called DoGetBestSize() above
1593 // just take the current one
1598 DoMoveWindow(x
, y
, width
, height
);
1601 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1603 // setting the client size is less obvious than it it could have been
1604 // because in the result of changing the total size the window scrollbar
1605 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1606 // will not be correct as the difference between the total and client size
1607 // changes - so we keep changing it until we get it right
1609 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1610 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1611 // may become 3 if the window had 0 size originally and so we didn't
1612 // calculate the scrollbar correction correctly during the first iteration)
1613 // but just to be on the safe side we check for it instead of making it an
1614 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1615 for ( int i
= 0; i
< 4; i
++ )
1618 ::GetClientRect(GetHwnd(), &rectClient
);
1620 // if the size is already ok, stop here (rectClient.left = top = 0)
1621 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1622 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1627 int widthClient
= width
,
1628 heightClient
= height
;
1630 // Find the difference between the entire window (title bar and all)
1631 // and the client area; add this to the new client size to move the
1634 ::GetWindowRect(GetHwnd(), &rectWin
);
1636 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1637 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1640 point
.x
= rectWin
.left
;
1641 point
.y
= rectWin
.top
;
1643 // MoveWindow positions the child windows relative to the parent, so
1644 // adjust if necessary
1645 if ( !IsTopLevel() )
1647 wxWindow
*parent
= GetParent();
1650 ::ScreenToClient(GetHwndOf(parent
), &point
);
1654 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1658 // For implementation purposes - sometimes decorations make the client area
1660 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1662 return wxPoint(0, 0);
1665 // ---------------------------------------------------------------------------
1667 // ---------------------------------------------------------------------------
1669 int wxWindowMSW::GetCharHeight() const
1671 return wxGetTextMetrics(this).tmHeight
;
1674 int wxWindowMSW::GetCharWidth() const
1676 // +1 is needed because Windows apparently adds it when calculating the
1677 // dialog units size in pixels
1678 #if wxDIALOG_UNIT_COMPATIBILITY
1679 return wxGetTextMetrics(this).tmAveCharWidth
;
1681 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1685 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1687 int *descent
, int *externalLeading
,
1688 const wxFont
*theFont
) const
1690 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1691 _T("invalid font in GetTextExtent()") );
1695 fontToUse
= *theFont
;
1697 fontToUse
= GetFont();
1699 WindowHDC
hdc(GetHwnd());
1700 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1704 GetTextExtentPoint(hdc
, string
, string
.length(), &sizeRect
);
1705 GetTextMetrics(hdc
, &tm
);
1712 *descent
= tm
.tmDescent
;
1713 if ( externalLeading
)
1714 *externalLeading
= tm
.tmExternalLeading
;
1717 // ---------------------------------------------------------------------------
1719 // ---------------------------------------------------------------------------
1721 #if wxUSE_MENUS_NATIVE
1723 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1724 // immediately, without waiting for the next event loop iteration
1726 // NB: this function should probably be made public later as it can almost
1727 // surely replace wxYield() elsewhere as well
1728 static void wxYieldForCommandsOnly()
1730 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1731 // want to process it here)
1733 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1735 if ( msg
.message
== WM_QUIT
)
1737 // if we retrieved a WM_QUIT, insert back into the message queue.
1738 ::PostQuitMessage(0);
1742 // luckily (as we don't have access to wxEventLoopImpl method from here
1743 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1745 ::TranslateMessage(&msg
);
1746 ::DispatchMessage(&msg
);
1750 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1752 menu
->SetInvokingWindow(this);
1755 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1757 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1758 x
= mouse
.x
; y
= mouse
.y
;
1761 HWND hWnd
= GetHwnd();
1762 HMENU hMenu
= GetHmenuOf(menu
);
1766 ::ClientToScreen(hWnd
, &point
);
1767 wxCurrentPopupMenu
= menu
;
1768 #if defined(__WXWINCE__)
1771 UINT flags
= TPM_RIGHTBUTTON
;
1773 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1775 // we need to do it righ now as otherwise the events are never going to be
1776 // sent to wxCurrentPopupMenu from HandleCommand()
1778 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1779 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1780 // destroyed as soon as we return (it can be a local variable in the caller
1781 // for example) and so we do need to process the event immediately
1782 wxYieldForCommandsOnly();
1784 wxCurrentPopupMenu
= NULL
;
1786 menu
->SetInvokingWindow(NULL
);
1791 #endif // wxUSE_MENUS_NATIVE
1793 // ===========================================================================
1794 // pre/post message processing
1795 // ===========================================================================
1797 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1800 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1802 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1805 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1807 // wxUniversal implements tab traversal itself
1808 #ifndef __WXUNIVERSAL__
1809 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1811 // intercept dialog navigation keys
1812 MSG
*msg
= (MSG
*)pMsg
;
1814 // here we try to do all the job which ::IsDialogMessage() usually does
1817 if ( msg
->message
== WM_KEYDOWN
)
1819 bool bCtrlDown
= wxIsCtrlDown();
1820 bool bShiftDown
= wxIsShiftDown();
1822 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1823 // don't process it if it's the case (except for Ctrl-Tab/Enter
1824 // combinations which are always processed)
1828 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1830 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1831 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1832 // it, of course, implies them
1833 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1835 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1839 bool bForward
= true,
1840 bWindowChange
= false;
1842 // should we process this message specially?
1843 bool bProcess
= true;
1844 switch ( msg
->wParam
)
1847 if ( lDlgCode
& DLGC_WANTTAB
) {
1851 // Ctrl-Tab cycles thru notebook pages
1852 bWindowChange
= bCtrlDown
;
1853 bForward
= !bShiftDown
;
1859 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1867 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1874 wxButton
*btn
= wxDynamicCast(FindWindow(wxID_CANCEL
),
1876 if ( btn
&& btn
->IsEnabled() )
1878 // if we do have a cancel button, do press it
1879 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1881 // we consumed the message
1884 #endif // wxUSE_BUTTON
1892 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1894 // control wants to process Enter itself, don't
1895 // call IsDialogMessage() which would interpret
1899 else if ( lDlgCode
& DLGC_BUTTON
)
1901 // let IsDialogMessage() handle this for all
1902 // buttons except the owner-drawn ones which it
1903 // just seems to ignore
1904 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1905 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1907 // emulate the button click
1908 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1910 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1915 // FIXME: this should be handled by
1916 // wxNavigationKeyEvent handler and not here!!
1920 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1922 if ( btn
&& btn
->IsEnabled() )
1924 // if we do have a default button, do press it
1925 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1929 else // no default button
1930 #endif // wxUSE_BUTTON
1932 // this is a quick and dirty test for a text
1934 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1936 // don't process Enter, the control might
1937 // need it for itself and don't let
1938 // ::IsDialogMessage() have it as it can
1939 // eat the Enter events sometimes
1942 else if (!IsTopLevel())
1944 // if not a top level window, let parent
1948 //else: treat Enter as TAB: pass to the next
1949 // control as this is the best thing to do
1950 // if the text doesn't handle Enter itself
1962 wxNavigationKeyEvent event
;
1963 event
.SetDirection(bForward
);
1964 event
.SetWindowChange(bWindowChange
);
1965 event
.SetEventObject(this);
1967 if ( GetEventHandler()->ProcessEvent(event
) )
1974 // let ::IsDialogMessage() do almost everything and handle just the
1975 // things it doesn't here: Ctrl-TAB for switching notebook pages
1976 if ( msg
->message
== WM_KEYDOWN
)
1978 // don't process system keys here
1979 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1981 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1983 // find the first notebook parent and change its page
1984 wxWindow
*win
= this;
1985 wxNotebook
*nbook
= NULL
;
1986 while ( win
&& !nbook
)
1988 nbook
= wxDynamicCast(win
, wxNotebook
);
1989 win
= win
->GetParent();
1994 bool forward
= !wxIsShiftDown();
1996 nbook
->AdvanceSelection(forward
);
2003 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2004 // message even when there is no cancel button and when the message is
2005 // needed by the control itself: in particular, it prevents the tree in
2006 // place edit control from being closed with Escape in a dialog
2007 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2009 // ::IsDialogMessage() is broken and may sometimes hang the
2010 // application by going into an infinite loop, so we try to detect
2011 // [some of] the situatations when this may happen and not call it
2014 // assume we can call it by default
2015 bool canSafelyCallIsDlgMsg
= true;
2017 HWND hwndFocus
= ::GetFocus();
2019 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2020 // an infinite loop, because it will recursively check the child
2021 // windows but not the window itself and so if none of the children
2022 // accepts focus it loops forever (as it only stops when it gets
2023 // back to the window it started from)
2025 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2026 // style has the focus, it can happen. One such possibility is if
2027 // all windows are either toplevel, wxDialog, wxPanel or static
2028 // controls and no window can actually accept keyboard input.
2029 #if !defined(__WXWINCE__)
2030 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2032 // passimistic by default
2033 canSafelyCallIsDlgMsg
= false;
2034 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2036 node
= node
->GetNext() )
2038 wxWindow
* const win
= node
->GetData();
2039 if ( win
->AcceptsFocus() &&
2040 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2041 WS_EX_CONTROLPARENT
) )
2043 // it shouldn't hang...
2044 canSafelyCallIsDlgMsg
= true;
2050 #endif // !__WXWINCE__
2052 if ( canSafelyCallIsDlgMsg
)
2054 // ::IsDialogMessage() can enter in an infinite loop when the
2055 // currently focused window is disabled or hidden and its
2056 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2060 if ( !::IsWindowEnabled(hwndFocus
) ||
2061 !::IsWindowVisible(hwndFocus
) )
2063 // it would enter an infinite loop if we do this!
2064 canSafelyCallIsDlgMsg
= false;
2069 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2071 // it's a top level window, don't go further -- e.g. even
2072 // if the parent of a dialog is disabled, this doesn't
2073 // break navigation inside the dialog
2077 hwndFocus
= ::GetParent(hwndFocus
);
2081 // let IsDialogMessage() have the message if it's safe to call it
2082 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2084 // IsDialogMessage() did something...
2089 #endif // __WXUNIVERSAL__
2094 // relay mouse move events to the tooltip control
2095 MSG
*msg
= (MSG
*)pMsg
;
2096 if ( msg
->message
== WM_MOUSEMOVE
)
2097 m_tooltip
->RelayEvent(pMsg
);
2099 #endif // wxUSE_TOOLTIPS
2104 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2106 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2107 return m_acceleratorTable
.Translate(this, pMsg
);
2111 #endif // wxUSE_ACCEL
2114 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2116 // preprocess all messages by default
2120 // ---------------------------------------------------------------------------
2121 // message params unpackers
2122 // ---------------------------------------------------------------------------
2124 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2125 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2127 *id
= LOWORD(wParam
);
2128 *hwnd
= (WXHWND
)lParam
;
2129 *cmd
= HIWORD(wParam
);
2132 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2133 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2135 *state
= LOWORD(wParam
);
2136 *minimized
= HIWORD(wParam
);
2137 *hwnd
= (WXHWND
)lParam
;
2140 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2141 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2143 *code
= LOWORD(wParam
);
2144 *pos
= HIWORD(wParam
);
2145 *hwnd
= (WXHWND
)lParam
;
2148 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2149 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2151 #ifndef __WXMICROWIN__
2152 *nCtlColor
= CTLCOLOR_BTN
;
2153 *hwnd
= (WXHWND
)lParam
;
2154 *hdc
= (WXHDC
)wParam
;
2158 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2159 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2161 *item
= (WXWORD
)wParam
;
2162 *flags
= HIWORD(wParam
);
2163 *hmenu
= (WXHMENU
)lParam
;
2166 // ---------------------------------------------------------------------------
2167 // Main wxWidgets window proc and the window proc for wxWindow
2168 // ---------------------------------------------------------------------------
2170 // Hook for new window just as it's being created, when the window isn't yet
2171 // associated with the handle
2172 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2174 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2175 // window being created and insures that it's always unset back later
2176 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2178 gs_winBeingCreated
= winBeingCreated
;
2181 wxWindowCreationHook::~wxWindowCreationHook()
2183 gs_winBeingCreated
= NULL
;
2187 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2189 // trace all messages - useful for the debugging
2191 wxLogTrace(wxTraceMessages
,
2192 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2193 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2194 #endif // __WXDEBUG__
2196 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2198 // when we get the first message for the HWND we just created, we associate
2199 // it with wxWindow stored in gs_winBeingCreated
2200 if ( !wnd
&& gs_winBeingCreated
)
2202 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2203 wnd
= gs_winBeingCreated
;
2204 gs_winBeingCreated
= NULL
;
2205 wnd
->SetHWND((WXHWND
)hWnd
);
2211 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2213 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2218 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2220 // did we process the message?
2221 bool processed
= false;
2232 // for most messages we should return 0 when we do process the message
2240 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2243 // return 0 to allow window creation
2244 rc
.result
= mayCreate
? 0 : -1;
2250 // never set processed to true and *always* pass WM_DESTROY to
2251 // DefWindowProc() as Windows may do some internal cleanup when
2252 // processing it and failing to pass the message along may cause
2253 // memory and resource leaks!
2254 (void)HandleDestroy();
2258 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2261 #if !defined(__WXWINCE__)
2264 LPRECT pRect
= (LPRECT
)lParam
;
2266 rc
.SetLeft(pRect
->left
);
2267 rc
.SetTop(pRect
->top
);
2268 rc
.SetRight(pRect
->right
);
2269 rc
.SetBottom(pRect
->bottom
);
2270 processed
= HandleMoving(rc
);
2272 pRect
->left
= rc
.GetLeft();
2273 pRect
->top
= rc
.GetTop();
2274 pRect
->right
= rc
.GetRight();
2275 pRect
->bottom
= rc
.GetBottom();
2282 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2285 #if !defined(__WXWINCE__)
2288 LPRECT pRect
= (LPRECT
)lParam
;
2290 rc
.SetLeft(pRect
->left
);
2291 rc
.SetTop(pRect
->top
);
2292 rc
.SetRight(pRect
->right
);
2293 rc
.SetBottom(pRect
->bottom
);
2294 processed
= HandleSizing(rc
);
2296 pRect
->left
= rc
.GetLeft();
2297 pRect
->top
= rc
.GetTop();
2298 pRect
->right
= rc
.GetRight();
2299 pRect
->bottom
= rc
.GetBottom();
2305 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2306 case WM_ACTIVATEAPP
:
2307 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2313 WXWORD state
, minimized
;
2315 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2317 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2322 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2326 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2333 // cast to wxWindow is needed for wxUniv
2334 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2335 processed
= HandlePaint();
2339 processed
= HandlePaint();
2348 // Don't call the wx handlers in this case
2349 if ( wxIsKindOf(this, wxListCtrl
) )
2353 if ( lParam
& PRF_ERASEBKGND
)
2354 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2356 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2357 processed
= HandlePaint();
2363 #ifdef __WXUNIVERSAL__
2364 // Universal uses its own wxFrame/wxDialog, so we don't receive
2365 // close events unless we have this.
2370 // don't let the DefWindowProc() destroy our window - we'll do it
2371 // ourselves in ~wxWindow
2378 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2382 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2383 GET_Y_LPARAM(lParam
),
2387 // Seems to be broken currently
2388 #if 0 // ndef __WXWINCE__
2391 wxASSERT_MSG( !m_mouseInWindow
, wxT("the mouse should be in a window to generate this event!") );
2393 // only process this message if the mouse is not in the window,
2394 // This can also check for children in composite windows.
2395 // however, this may mean the the wxEVT_LEAVE_WINDOW is never sent
2396 // if the mouse does not enter the window from it's child before
2397 // leaving the scope of the window. ( perhaps this can be picked
2398 // up in the OnIdle code as before, for this special case )
2399 if ( /*IsComposite() && */ !IsMouseInWindow() )
2401 m_mouseInWindow
= false;
2403 // Unfortunately no mouse state is passed with a WM_MOUSE_LEAVE
2405 if ( wxIsShiftDown() )
2407 if ( wxIsCtrlDown() )
2408 state
|= MK_CONTROL
;
2409 if ( GetKeyState( VK_LBUTTON
) )
2410 state
|= MK_LBUTTON
;
2411 if ( GetKeyState( VK_MBUTTON
) )
2412 state
|= MK_MBUTTON
;
2413 if ( GetKeyState( VK_RBUTTON
) )
2414 state
|= MK_RBUTTON
;
2417 if ( !::GetCursorPos(&pt
) )
2419 wxLogLastError(_T("GetCursorPos"));
2422 // we need to have client coordinates here for symmetry with
2423 // wxEVT_ENTER_WINDOW
2424 RECT rect
= wxGetWindowRect(GetHwnd());
2428 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
2429 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
2431 (void)GetEventHandler()->ProcessEvent(event2
);
2433 // always pass processed back as false, this allows the window
2434 // manager to process the message too. This is needed to ensure
2435 // windows XP themes work properly as the mouse moves over widgets
2443 #if wxUSE_MOUSEWHEEL
2445 processed
= HandleMouseWheel(wParam
, lParam
);
2449 case WM_LBUTTONDOWN
:
2451 case WM_LBUTTONDBLCLK
:
2452 case WM_RBUTTONDOWN
:
2454 case WM_RBUTTONDBLCLK
:
2455 case WM_MBUTTONDOWN
:
2457 case WM_MBUTTONDBLCLK
:
2459 #ifdef __WXMICROWIN__
2460 // MicroWindows seems to ignore the fact that a window is
2461 // disabled. So catch mouse events and throw them away if
2463 wxWindowMSW
* win
= this;
2466 if (!win
->IsEnabled())
2472 win
= win
->GetParent();
2473 if ( !win
|| win
->IsTopLevel() )
2480 #endif // __WXMICROWIN__
2481 int x
= GET_X_LPARAM(lParam
),
2482 y
= GET_Y_LPARAM(lParam
);
2484 // redirect the event to a static control if necessary by
2485 // finding one under mouse
2487 if ( GetCapture() == this )
2489 // but don't do it if the mouse is captured by this window
2490 // because then it should really get this event itself
2495 win
= FindWindowForMouseEvent(this, &x
, &y
);
2497 // this should never happen
2498 wxCHECK_MSG( win
, 0,
2499 _T("FindWindowForMouseEvent() returned NULL") );
2502 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2504 // if the app didn't eat the event, handle it in the default
2505 // way, that is by giving this window the focus
2508 // for the standard classes their WndProc sets the focus to
2509 // them anyhow and doing it from here results in some weird
2510 // problems, so don't do it for them (unnecessary anyhow)
2511 if ( !win
->IsOfStandardClass() )
2513 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2525 case MM_JOY1BUTTONDOWN
:
2526 case MM_JOY2BUTTONDOWN
:
2527 case MM_JOY1BUTTONUP
:
2528 case MM_JOY2BUTTONUP
:
2529 processed
= HandleJoystickEvent(message
,
2530 GET_X_LPARAM(lParam
),
2531 GET_Y_LPARAM(lParam
),
2534 #endif // __WXMICROWIN__
2540 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2542 processed
= HandleCommand(id
, cmd
, hwnd
);
2547 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2550 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2551 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2552 // apparently doesn't always behave properly and needs some help
2553 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2554 case WM_NOTIFYFORMAT
:
2555 if ( lParam
== NF_QUERY
)
2558 rc
.result
= NFR_UNICODE
;
2561 #endif // wxUSE_UNICODE_MSLU
2563 // for these messages we must return true if process the message
2566 case WM_MEASUREITEM
:
2568 int idCtrl
= (UINT
)wParam
;
2569 if ( message
== WM_DRAWITEM
)
2571 processed
= MSWOnDrawItem(idCtrl
,
2572 (WXDRAWITEMSTRUCT
*)lParam
);
2576 processed
= MSWOnMeasureItem(idCtrl
,
2577 (WXMEASUREITEMSTRUCT
*)lParam
);
2584 #endif // defined(WM_DRAWITEM)
2587 if ( !IsOfStandardClass() )
2589 // we always want to get the char events
2590 rc
.result
= DLGC_WANTCHARS
;
2592 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2594 // in fact, we want everything
2595 rc
.result
|= DLGC_WANTARROWS
|
2602 //else: get the dlg code from the DefWindowProc()
2607 // If this has been processed by an event handler, return 0 now
2608 // (we've handled it).
2609 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2610 if ( m_lastKeydownProcessed
)
2619 // we consider these message "not interesting" to OnChar, so
2620 // just don't do anything more with them
2630 // avoid duplicate messages to OnChar for these ASCII keys:
2631 // they will be translated by TranslateMessage() and received
2653 // but set processed to false, not true to still pass them
2654 // to the control's default window proc - otherwise
2655 // built-in keyboard handling won't work
2660 // special case of VK_APPS: treat it the same as right mouse
2661 // click because both usually pop up a context menu
2663 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2668 // do generate a CHAR event
2669 processed
= HandleChar((WORD
)wParam
, lParam
);
2672 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2679 // special case of VK_APPS: treat it the same as right mouse button
2680 if ( wParam
== VK_APPS
)
2682 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2687 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2692 case WM_CHAR
: // Always an ASCII character
2693 if ( m_lastKeydownProcessed
)
2695 // The key was handled in the EVT_KEY_DOWN and handling
2696 // a key in an EVT_KEY_DOWN handler is meant, by
2697 // design, to prevent EVT_CHARs from happening
2698 m_lastKeydownProcessed
= false;
2703 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2709 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2711 #endif // wxUSE_HOTKEY
2718 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2720 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2726 // CTLCOLOR messages are sent by children to query the parent for their
2727 // colors#ifndef __WXMICROWIN__
2728 #ifndef __WXMICROWIN__
2729 case WM_CTLCOLORMSGBOX
:
2730 case WM_CTLCOLOREDIT
:
2731 case WM_CTLCOLORLISTBOX
:
2732 case WM_CTLCOLORBTN
:
2733 case WM_CTLCOLORDLG
:
2734 case WM_CTLCOLORSCROLLBAR
:
2735 case WM_CTLCOLORSTATIC
:
2740 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2742 processed
= HandleCtlColor(&rc
.hBrush
,
2751 #endif // !__WXMICROWIN__
2753 case WM_SYSCOLORCHANGE
:
2754 // the return value for this message is ignored
2755 processed
= HandleSysColorChange();
2758 #if !defined(__WXWINCE__)
2759 case WM_DISPLAYCHANGE
:
2760 processed
= HandleDisplayChange();
2764 case WM_PALETTECHANGED
:
2765 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2768 case WM_CAPTURECHANGED
:
2769 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2772 case WM_QUERYNEWPALETTE
:
2773 processed
= HandleQueryNewPalette();
2777 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2780 // we processed the message, i.e. erased the background
2785 #if !defined(__WXWINCE__)
2787 processed
= HandleDropFiles(wParam
);
2792 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2796 // we never set focus from here
2801 #if !defined(__WXWINCE__)
2802 case WM_QUERYENDSESSION
:
2803 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2807 processed
= HandleEndSession(wParam
!= 0, lParam
);
2810 case WM_GETMINMAXINFO
:
2811 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2816 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2817 LOWORD(lParam
), // hit test
2818 HIWORD(lParam
)); // mouse msg
2822 // returning TRUE stops the DefWindowProc() from further
2823 // processing this message - exactly what we need because we've
2824 // just set the cursor.
2829 #if wxUSE_ACCESSIBILITY
2832 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2833 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2835 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2837 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2843 #if defined(WM_HELP)
2846 // HELPINFO doesn't seem to be supported on WinCE.
2848 HELPINFO
* info
= (HELPINFO
*) lParam
;
2849 // Don't yet process menu help events, just windows
2850 if (info
->iContextType
== HELPINFO_WINDOW
)
2853 wxWindowMSW
* subjectOfHelp
= this;
2854 bool eventProcessed
= false;
2855 while (subjectOfHelp
&& !eventProcessed
)
2857 wxHelpEvent
helpEvent(wxEVT_HELP
,
2858 subjectOfHelp
->GetId(),
2862 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2866 helpEvent
.SetEventObject(this);
2868 GetEventHandler()->ProcessEvent(helpEvent
);
2870 // Go up the window hierarchy until the event is
2872 subjectOfHelp
= subjectOfHelp
->GetParent();
2875 processed
= eventProcessed
;
2878 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2880 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2881 helpEvent
.SetEventObject(this);
2882 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2885 //else: processed is already false
2891 #if !defined(__WXWINCE__)
2892 case WM_CONTEXTMENU
:
2894 // we don't convert from screen to client coordinates as
2895 // the event may be handled by a parent window
2896 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2898 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2900 // we could have got an event from our child, reflect it back
2901 // to it if this is the case
2902 wxWindowMSW
*win
= NULL
;
2903 if ( (WXHWND
)wParam
!= m_hWnd
)
2905 win
= FindItemByHWND((WXHWND
)wParam
);
2911 evtCtx
.SetEventObject(win
);
2912 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
2918 // we're only interested in our own menus, not MF_SYSMENU
2919 if ( HIWORD(wParam
) == MF_POPUP
)
2921 // handle menu chars for ownerdrawn menu items
2922 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2923 if ( i
!= wxNOT_FOUND
)
2925 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2935 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2936 wxGetMessageName(message
));
2937 #endif // __WXDEBUG__
2938 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2944 // ----------------------------------------------------------------------------
2945 // wxWindow <-> HWND map
2946 // ----------------------------------------------------------------------------
2948 wxWinHashTable
*wxWinHandleHash
= NULL
;
2950 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2952 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
2955 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2957 // adding NULL hWnd is (first) surely a result of an error and
2958 // (secondly) breaks menu command processing
2959 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2960 wxT("attempt to add a NULL hWnd to window list ignored") );
2962 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2964 if ( oldWin
&& (oldWin
!= win
) )
2966 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2967 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2970 #endif // __WXDEBUG__
2973 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2977 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2979 wxWinHandleHash
->Delete((long)win
->GetHWND());
2982 // ----------------------------------------------------------------------------
2983 // various MSW speciic class dependent functions
2984 // ----------------------------------------------------------------------------
2986 // Default destroyer - override if you destroy it in some other way
2987 // (e.g. with MDI child windows)
2988 void wxWindowMSW::MSWDestroyWindow()
2992 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2995 int& w
, int& h
) const
2997 // yes, those are just some arbitrary hardcoded numbers
2998 static const int DEFAULT_Y
= 200;
3000 bool nonDefault
= false;
3002 if ( pos
.x
== wxDefaultCoord
)
3004 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3005 // can just as well set it to CW_USEDEFAULT as well
3011 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3012 // neither because it is not handled as a special value by Windows then
3013 // and so we have to choose some default value for it
3015 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3021 NB: there used to be some code here which set the initial size of the
3022 window to the client size of the parent if no explicit size was
3023 specified. This was wrong because wxWidgets programs often assume
3024 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3025 it. To see why, you should understand that Windows sends WM_SIZE from
3026 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3027 from some base class ctor and so this WM_SIZE is not processed in the
3028 real class' OnSize() (because it's not fully constructed yet and the
3029 event goes to some base class OnSize() instead). So the WM_SIZE we
3030 rely on is the one sent when the parent frame resizes its children
3031 but here is the problem: if the child already has just the right
3032 size, nothing will happen as both wxWidgets and Windows check for
3033 this and ignore any attempts to change the window size to the size it
3034 already has - so no WM_SIZE would be sent.
3038 // we don't use CW_USEDEFAULT here for several reasons:
3040 // 1. it results in huge frames on modern screens (1000*800 is not
3041 // uncommon on my 1280*1024 screen) which is way too big for a half
3042 // empty frame of most of wxWidgets samples for example)
3044 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3045 // the default is for whatever reason 8*8 which breaks client <->
3046 // window size calculations (it would be nice if it didn't, but it
3047 // does and the simplest way to fix it seemed to change the broken
3048 // default size anyhow)
3050 // 3. there is just no advantage in doing it: with x and y it is
3051 // possible that [future versions of] Windows position the new top
3052 // level window in some smart way which we can't do, but we can
3053 // guess a reasonably good size for a new window just as well
3056 // However, on PocketPC devices, we must use the default
3057 // size if possible.
3059 if (size
.x
== wxDefaultCoord
)
3063 if (size
.y
== wxDefaultCoord
)
3068 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3072 w
= WidthDefault(size
.x
);
3073 h
= HeightDefault(size
.y
);
3076 AdjustForParentClientOrigin(x
, y
);
3081 WXHWND
wxWindowMSW::MSWGetParent() const
3083 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3086 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3087 const wxChar
*title
,
3091 WXDWORD extendedStyle
)
3093 // choose the position/size for the new window
3095 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3097 // controlId is menu handle for the top level windows, so set it to 0
3098 // unless we're creating a child window
3099 int controlId
= style
& WS_CHILD
? GetId() : 0;
3101 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3102 // which is the same but without CS_[HV]REDRAW class styles so using it
3103 // ensures that the window is not fully repainted on each resize
3104 wxString
className(wclass
);
3105 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3107 className
+= wxT("NR");
3110 // do create the window
3111 wxWindowCreationHook
hook(this);
3113 // VZ: anyone care to explain why this is done for CE?
3115 if (extendedStyle
== 0)
3117 m_hWnd
= (WXHWND
)::CreateWindow
3120 title
? title
: wxEmptyString
,
3123 (HWND
)MSWGetParent(),
3126 NULL
// no extra data
3130 #endif // __WXWINCE__
3132 m_hWnd
= (WXHWND
)::CreateWindowEx
3136 title
? title
: wxEmptyString
,
3139 (HWND
)MSWGetParent(),
3142 NULL
// no extra data
3148 wxLogSysError(_("Can't create window of class %s"), wclass
);
3153 SubclassWin(m_hWnd
);
3158 // ===========================================================================
3159 // MSW message handlers
3160 // ===========================================================================
3162 // ---------------------------------------------------------------------------
3164 // ---------------------------------------------------------------------------
3168 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3170 #ifndef __WXMICROWIN__
3171 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3172 HWND hWnd
= hdr
->hwndFrom
;
3173 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3175 // if the control is one of our windows, let it handle the message itself
3178 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3181 // VZ: why did we do it? normally this is unnecessary and, besides, it
3182 // breaks the message processing for the toolbars because the tooltip
3183 // notifications were being forwarded to the toolbar child controls
3184 // (if it had any) before being passed to the toolbar itself, so in my
3185 // example the tooltip for the combobox was always shown instead of the
3186 // correct button tooltips
3188 // try all our children
3189 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3192 wxWindow
*child
= node
->GetData();
3193 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3198 node
= node
->GetNext();
3202 // by default, handle it ourselves
3203 return MSWOnNotify(idCtrl
, lParam
, result
);
3204 #else // __WXMICROWIN__
3211 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3213 const wxString
& ttip
)
3215 // I don't know why it happens, but the versions of comctl32.dll starting
3216 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3217 // this message is supposed to be sent to Unicode programs only) -- hence
3218 // we need to handle it as well, otherwise no tooltips will be shown in
3221 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3224 // not a tooltip message or no tooltip to show anyhow
3229 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3231 // We don't want to use the szText buffer because it has a limit of 80
3232 // bytes and this is not enough, especially for Unicode build where it
3233 // limits the tooltip string length to only 40 characters
3235 // The best would be, of course, to not impose any length limitations at
3236 // all but then the buffer would have to be dynamic and someone would have
3237 // to free it and we don't have the tooltip owner object here any more, so
3238 // for now use our own static buffer with a higher fixed max length.
3240 // Note that using a static buffer should not be a problem as only a single
3241 // tooltip can be shown at the same time anyhow.
3243 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3245 // We need to convert tooltip from multi byte to Unicode on the fly.
3246 static wchar_t buf
[513];
3248 // Truncate tooltip length if needed as otherwise we might not have
3249 // enough space for it in the buffer and MultiByteToWideChar() would
3251 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3253 // Convert to WideChar without adding the NULL character. The NULL
3254 // character is added afterwards (this is more efficient).
3255 int len
= ::MultiByteToWideChar
3267 wxLogLastError(_T("MultiByteToWideChar()"));
3271 ttText
->lpszText
= (LPSTR
) buf
;
3273 else // TTN_NEEDTEXTA
3274 #endif // !wxUSE_UNICODE
3276 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3277 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3278 // to copy the string we have into the buffer
3279 static wxChar buf
[513];
3280 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3281 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3282 ttText
->lpszText
= buf
;
3288 #endif // wxUSE_TOOLTIPS
3290 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3292 WXLPARAM
* WXUNUSED(result
))
3297 NMHDR
* hdr
= (NMHDR
*)lParam
;
3298 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3305 wxUnusedVar(lParam
);
3306 #endif // wxUSE_TOOLTIPS
3313 // ---------------------------------------------------------------------------
3314 // end session messages
3315 // ---------------------------------------------------------------------------
3317 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3320 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3321 event
.SetEventObject(wxTheApp
);
3322 event
.SetCanVeto(true);
3323 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3325 bool rc
= wxTheApp
->ProcessEvent(event
);
3329 // we may end only if the app didn't veto session closing (double
3331 *mayEnd
= !event
.GetVeto();
3340 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3343 // do nothing if the session isn't ending
3348 if ( (this != wxTheApp
->GetTopWindow()) )
3351 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3352 event
.SetEventObject(wxTheApp
);
3353 event
.SetCanVeto(false);
3354 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3356 return wxTheApp
->ProcessEvent(event
);
3362 // ---------------------------------------------------------------------------
3363 // window creation/destruction
3364 // ---------------------------------------------------------------------------
3366 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3368 // VZ: why is this commented out for WinCE? If it doesn't support
3369 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3370 // not with multiple #ifdef's!
3372 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3373 EnsureParentHasControlParentStyle(GetParent());
3376 #endif // !__WXWINCE__
3378 // TODO: should generate this event from WM_NCCREATE
3379 wxWindowCreateEvent
event((wxWindow
*)this);
3380 (void)GetEventHandler()->ProcessEvent(event
);
3387 bool wxWindowMSW::HandleDestroy()
3391 // delete our drop target if we've got one
3392 #if wxUSE_DRAG_AND_DROP
3393 if ( m_dropTarget
!= NULL
)
3395 m_dropTarget
->Revoke(m_hWnd
);
3397 delete m_dropTarget
;
3398 m_dropTarget
= NULL
;
3400 #endif // wxUSE_DRAG_AND_DROP
3402 // WM_DESTROY handled
3406 // ---------------------------------------------------------------------------
3408 // ---------------------------------------------------------------------------
3410 bool wxWindowMSW::HandleActivate(int state
,
3411 bool WXUNUSED(minimized
),
3412 WXHWND
WXUNUSED(activate
))
3414 wxActivateEvent
event(wxEVT_ACTIVATE
,
3415 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3417 event
.SetEventObject(this);
3419 return GetEventHandler()->ProcessEvent(event
);
3422 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3424 // Strangly enough, some controls get set focus events when they are being
3425 // deleted, even if they already had focus before.
3426 if ( m_isBeingDeleted
)
3431 // notify the parent keeping track of focus for the kbd navigation
3432 // purposes that we got it
3433 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3434 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3440 m_caret
->OnSetFocus();
3442 #endif // wxUSE_CARET
3445 // If it's a wxTextCtrl don't send the event as it will be done
3446 // after the control gets to process it from EN_FOCUS handler
3447 if ( wxDynamicCastThis(wxTextCtrl
) )
3451 #endif // wxUSE_TEXTCTRL
3453 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3454 event
.SetEventObject(this);
3456 // wxFindWinFromHandle() may return NULL, it is ok
3457 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3459 return GetEventHandler()->ProcessEvent(event
);
3462 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3468 m_caret
->OnKillFocus();
3470 #endif // wxUSE_CARET
3473 // If it's a wxTextCtrl don't send the event as it will be done
3474 // after the control gets to process it.
3475 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3482 // Don't send the event when in the process of being deleted. This can
3483 // only cause problems if the event handler tries to access the object.
3484 if ( m_isBeingDeleted
)
3489 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3490 event
.SetEventObject(this);
3492 // wxFindWinFromHandle() may return NULL, it is ok
3493 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3495 return GetEventHandler()->ProcessEvent(event
);
3498 // ---------------------------------------------------------------------------
3500 // ---------------------------------------------------------------------------
3502 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3504 wxShowEvent
event(GetId(), show
);
3505 event
.m_eventObject
= this;
3507 return GetEventHandler()->ProcessEvent(event
);
3510 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3512 wxInitDialogEvent
event(GetId());
3513 event
.m_eventObject
= this;
3515 return GetEventHandler()->ProcessEvent(event
);
3518 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3520 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3521 wxUnusedVar(wParam
);
3523 #else // __WXMICROWIN__
3524 HDROP hFilesInfo
= (HDROP
) wParam
;
3526 // Get the total number of files dropped
3527 UINT gwFilesDropped
= ::DragQueryFile
3535 wxString
*files
= new wxString
[gwFilesDropped
];
3536 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3538 // first get the needed buffer length (+1 for terminating NUL)
3539 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3541 // and now get the file name
3542 ::DragQueryFile(hFilesInfo
, wIndex
,
3543 wxStringBuffer(files
[wIndex
], len
), len
);
3545 DragFinish (hFilesInfo
);
3547 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3548 event
.m_eventObject
= this;
3551 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3552 event
.m_pos
.x
= dropPoint
.x
;
3553 event
.m_pos
.y
= dropPoint
.y
;
3555 return GetEventHandler()->ProcessEvent(event
);
3560 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3562 int WXUNUSED(mouseMsg
))
3564 #ifndef __WXMICROWIN__
3565 // the logic is as follows:
3566 // -1. don't set cursor for non client area, including but not limited to
3567 // the title bar, scrollbars, &c
3568 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3569 // 1. if we have the cursor set it unless wxIsBusy()
3570 // 2. if we're a top level window, set some cursor anyhow
3571 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3573 if ( nHitTest
!= HTCLIENT
)
3578 HCURSOR hcursor
= 0;
3580 // first ask the user code - it may wish to set the cursor in some very
3581 // specific way (for example, depending on the current position)
3583 if ( !::GetCursorPos(&pt
) )
3585 wxLogLastError(wxT("GetCursorPos"));
3590 ScreenToClient(&x
, &y
);
3591 wxSetCursorEvent
event(x
, y
);
3593 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3594 if ( processedEvtSetCursor
&& event
.HasCursor() )
3596 hcursor
= GetHcursorOf(event
.GetCursor());
3601 bool isBusy
= wxIsBusy();
3603 // the test for processedEvtSetCursor is here to prevent using m_cursor
3604 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3605 // it - this is a way to say that our cursor shouldn't be used for this
3607 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3609 hcursor
= GetHcursorOf(m_cursor
);
3616 hcursor
= wxGetCurrentBusyCursor();
3618 else if ( !hcursor
)
3620 const wxCursor
*cursor
= wxGetGlobalCursor();
3621 if ( cursor
&& cursor
->Ok() )
3623 hcursor
= GetHcursorOf(*cursor
);
3631 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3633 ::SetCursor(hcursor
);
3635 // cursor set, stop here
3638 #endif // __WXMICROWIN__
3640 // pass up the window chain
3644 // ---------------------------------------------------------------------------
3645 // owner drawn stuff
3646 // ---------------------------------------------------------------------------
3648 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3649 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3650 #define WXUNUSED_UNLESS_ODRAWN(param) param
3652 #define WXUNUSED_UNLESS_ODRAWN(param)
3656 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3657 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3659 #if wxUSE_OWNER_DRAWN
3661 #if wxUSE_MENUS_NATIVE
3662 // is it a menu item?
3663 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3664 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3666 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3668 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3669 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3671 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3672 // the DC from being released
3673 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3674 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3675 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3676 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3678 return pMenuItem
->OnDrawItem
3682 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3683 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3686 #endif // wxUSE_MENUS_NATIVE
3688 #endif // USE_OWNER_DRAWN
3690 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3692 #if wxUSE_OWNER_DRAWN
3693 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3694 #else // !wxUSE_OWNER_DRAWN
3695 // we may still have owner-drawn buttons internally because we have to make
3696 // them owner-drawn to support colour change
3699 wxDynamicCast(FindItem(id
), wxButton
)
3704 #endif // USE_OWNER_DRAWN
3708 return item
->MSWOnDraw(itemStruct
);
3711 #endif // wxUSE_CONTROLS
3717 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3719 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3720 // is it a menu item?
3721 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3722 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3724 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3726 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3727 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3730 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3732 pMeasureStruct
->itemWidth
= w
;
3733 pMeasureStruct
->itemHeight
= h
;
3738 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3741 return item
->MSWOnMeasure(itemStruct
);
3745 wxUnusedVar(itemStruct
);
3746 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3751 // ---------------------------------------------------------------------------
3752 // colours and palettes
3753 // ---------------------------------------------------------------------------
3755 bool wxWindowMSW::HandleSysColorChange()
3757 wxSysColourChangedEvent event
;
3758 event
.SetEventObject(this);
3760 (void)GetEventHandler()->ProcessEvent(event
);
3762 // always let the system carry on the default processing to allow the
3763 // native controls to react to the colours update
3767 bool wxWindowMSW::HandleDisplayChange()
3769 wxDisplayChangedEvent event
;
3770 event
.SetEventObject(this);
3772 return GetEventHandler()->ProcessEvent(event
);
3775 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3783 #ifndef __WXMICROWIN__
3784 WXHBRUSH hBrush
= 0;
3789 if ( nCtlColor
== CTLCOLOR_DLG
)
3792 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3797 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, true);
3799 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3801 #endif // wxUSE_CONTROLS
3807 #else // __WXMICROWIN__
3812 // Define for each class of dialog and control
3813 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3814 WXHWND
WXUNUSED(hWnd
),
3815 WXUINT
WXUNUSED(nCtlColor
),
3816 WXUINT
WXUNUSED(message
),
3817 WXWPARAM
WXUNUSED(wParam
),
3818 WXLPARAM
WXUNUSED(lParam
))
3823 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3826 // same as below except we don't respond to our own messages
3827 if ( hWndPalChange
!= GetHWND() )
3829 // check to see if we our our parents have a custom palette
3830 wxWindowMSW
*win
= this;
3831 while ( win
&& !win
->HasCustomPalette() )
3833 win
= win
->GetParent();
3836 if ( win
&& win
->HasCustomPalette() )
3838 // realize the palette to see whether redrawing is needed
3839 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3840 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3841 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3843 int result
= ::RealizePalette(hdc
);
3845 // restore the palette (before releasing the DC)
3846 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3847 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3848 ::RealizePalette(hdc
);
3849 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3851 // now check for the need to redraw
3853 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3857 #endif // wxUSE_PALETTE
3859 wxPaletteChangedEvent
event(GetId());
3860 event
.SetEventObject(this);
3861 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3863 return GetEventHandler()->ProcessEvent(event
);
3866 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3868 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3869 event
.SetEventObject(this);
3871 return GetEventHandler()->ProcessEvent(event
);
3874 bool wxWindowMSW::HandleQueryNewPalette()
3878 // check to see if we our our parents have a custom palette
3879 wxWindowMSW
*win
= this;
3880 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3881 if (win
->HasCustomPalette()) {
3882 /* realize the palette to see whether redrawing is needed */
3883 HDC hdc
= ::GetDC((HWND
) GetHWND());
3884 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3885 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3887 int result
= ::RealizePalette(hdc
);
3888 /* restore the palette (before releasing the DC) */
3889 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3890 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3891 ::RealizePalette(hdc
);
3892 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3893 /* now check for the need to redraw */
3895 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3897 #endif // wxUSE_PALETTE
3899 wxQueryNewPaletteEvent
event(GetId());
3900 event
.SetEventObject(this);
3902 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3905 // Responds to colour changes: passes event on to children.
3906 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3908 // the top level window also reset the standard colour map as it might have
3909 // changed (there is no need to do it for the non top level windows as we
3910 // only have to do it once)
3914 gs_hasStdCmap
= false;
3916 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3919 // Only propagate to non-top-level windows because Windows already
3920 // sends this event to all top-level ones
3921 wxWindow
*win
= node
->GetData();
3922 if ( !win
->IsTopLevel() )
3924 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3925 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3926 // the standard controls
3927 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3930 node
= node
->GetNext();
3934 extern wxCOLORMAP
*wxGetStdColourMap()
3936 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3937 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3939 if ( !gs_hasStdCmap
)
3941 static bool s_coloursInit
= false;
3943 if ( !s_coloursInit
)
3945 // When a bitmap is loaded, the RGB values can change (apparently
3946 // because Windows adjusts them to care for the old programs always
3947 // using 0xc0c0c0 while the transparent colour for the new Windows
3948 // versions is different). But we do this adjustment ourselves so
3949 // we want to avoid Windows' "help" and for this we need to have a
3950 // reference bitmap which can tell us what the RGB values change
3952 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3953 if ( stdColourBitmap
.Ok() )
3955 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3956 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3957 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3960 memDC
.SelectObject(stdColourBitmap
);
3963 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3965 memDC
.GetPixel(i
, 0, &colour
);
3966 s_stdColours
[i
] = wxColourToRGB(colour
);
3969 else // wxBITMAP_STD_COLOURS couldn't be loaded
3971 s_stdColours
[0] = RGB(000,000,000); // black
3972 s_stdColours
[1] = RGB(128,128,128); // dark grey
3973 s_stdColours
[2] = RGB(192,192,192); // light grey
3974 s_stdColours
[3] = RGB(255,255,255); // white
3975 //s_stdColours[4] = RGB(000,000,255); // blue
3976 //s_stdColours[5] = RGB(255,000,255); // magenta
3979 s_coloursInit
= true;
3982 gs_hasStdCmap
= true;
3984 // create the colour map
3985 #define INIT_CMAP_ENTRY(col) \
3986 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3987 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3989 INIT_CMAP_ENTRY(BTNTEXT
);
3990 INIT_CMAP_ENTRY(BTNSHADOW
);
3991 INIT_CMAP_ENTRY(BTNFACE
);
3992 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3994 #undef INIT_CMAP_ENTRY
4000 // ---------------------------------------------------------------------------
4002 // ---------------------------------------------------------------------------
4004 bool wxWindowMSW::HandlePaint()
4006 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
4009 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4011 wxLogLastError(wxT("CreateRectRgn"));
4012 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4013 wxLogLastError(wxT("GetUpdateRgn"));
4015 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4017 wxPaintEvent
event(m_windowId
);
4018 event
.SetEventObject(this);
4020 bool processed
= GetEventHandler()->ProcessEvent(event
);
4022 // note that we must generate NC event after the normal one as otherwise
4023 // BeginPaint() will happily overwrite our decorations with the background
4025 wxNcPaintEvent
eventNc(m_windowId
);
4026 eventNc
.SetEventObject(this);
4027 GetEventHandler()->ProcessEvent(eventNc
);
4032 // Can be called from an application's OnPaint handler
4033 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4035 #ifdef __WXUNIVERSAL__
4038 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
4041 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4046 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4048 // Prevents flicker when dragging
4049 if ( ::IsIconic(GetHwnd()) )
4055 dc
.SetWindow((wxWindow
*)this);
4058 wxEraseEvent
event(m_windowId
, &dc
);
4059 event
.SetEventObject(this);
4060 bool rc
= GetEventHandler()->ProcessEvent(event
);
4064 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4065 dc
.SelectOldObjects(hdc
);
4070 // ---------------------------------------------------------------------------
4071 // moving and resizing
4072 // ---------------------------------------------------------------------------
4074 bool wxWindowMSW::HandleMinimize()
4076 wxIconizeEvent
event(m_windowId
);
4077 event
.SetEventObject(this);
4079 return GetEventHandler()->ProcessEvent(event
);
4082 bool wxWindowMSW::HandleMaximize()
4084 wxMaximizeEvent
event(m_windowId
);
4085 event
.SetEventObject(this);
4087 return GetEventHandler()->ProcessEvent(event
);
4090 bool wxWindowMSW::HandleMove(int x
, int y
)
4093 wxMoveEvent
event(point
, m_windowId
);
4094 event
.SetEventObject(this);
4096 return GetEventHandler()->ProcessEvent(event
);
4099 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4101 wxMoveEvent
event(rect
, m_windowId
);
4102 event
.SetEventObject(this);
4104 bool rc
= GetEventHandler()->ProcessEvent(event
);
4106 rect
= event
.GetRect();
4110 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4112 bool processed
= false;
4117 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4118 // fall through nevertheless
4122 // we're not interested in these messages at all
4125 case SIZE_MINIMIZED
:
4126 processed
= HandleMinimize();
4129 case SIZE_MAXIMIZED
:
4130 /* processed = */ HandleMaximize();
4131 // fall through to send a normal size event as well
4134 // don't use w and h parameters as they specify the client size
4135 // while according to the docs EVT_SIZE handler is supposed to
4136 // receive the total size
4137 wxSizeEvent
event(GetSize(), m_windowId
);
4138 event
.SetEventObject(this);
4140 processed
= GetEventHandler()->ProcessEvent(event
);
4146 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4148 wxSizeEvent
event(rect
, m_windowId
);
4149 event
.SetEventObject(this);
4151 bool rc
= GetEventHandler()->ProcessEvent(event
);
4153 rect
= event
.GetRect();
4157 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
4160 wxUnusedVar(mmInfo
);
4163 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4167 int minWidth
= GetMinWidth(),
4168 minHeight
= GetMinHeight(),
4169 maxWidth
= GetMaxWidth(),
4170 maxHeight
= GetMaxHeight();
4172 if ( minWidth
!= wxDefaultCoord
)
4174 info
->ptMinTrackSize
.x
= minWidth
;
4178 if ( minHeight
!= wxDefaultCoord
)
4180 info
->ptMinTrackSize
.y
= minHeight
;
4184 if ( maxWidth
!= wxDefaultCoord
)
4186 info
->ptMaxTrackSize
.x
= maxWidth
;
4190 if ( maxHeight
!= wxDefaultCoord
)
4192 info
->ptMaxTrackSize
.y
= maxHeight
;
4200 // ---------------------------------------------------------------------------
4202 // ---------------------------------------------------------------------------
4204 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4206 #if wxUSE_MENUS_NATIVE
4207 if ( !cmd
&& wxCurrentPopupMenu
)
4209 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4210 wxCurrentPopupMenu
= NULL
;
4212 return popupMenu
->MSWCommand(cmd
, id
);
4214 #endif // wxUSE_MENUS_NATIVE
4216 wxWindow
*win
= NULL
;
4218 // first try to find it from HWND - this works even with the broken
4219 // programs using the same ids for different controls
4222 win
= wxFindWinFromHandle(control
);
4228 // must cast to a signed type before comparing with other ids!
4229 win
= FindItem((signed short)id
);
4234 return win
->MSWCommand(cmd
, id
);
4237 // the messages sent from the in-place edit control used by the treectrl
4238 // for label editing have id == 0, but they should _not_ be treated as menu
4239 // messages (they are EN_XXX ones, in fact) so don't translate anything
4240 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4243 // If no child window, it may be an accelerator, e.g. for a popup menu
4246 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4247 event
.SetEventObject(this);
4251 return GetEventHandler()->ProcessEvent(event
);
4253 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4256 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4257 // notifications to its parent which we want to reflect back to
4259 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4260 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4263 #endif // wxUSE_SPINCTRL
4268 // ---------------------------------------------------------------------------
4270 // ---------------------------------------------------------------------------
4272 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4276 // our client coords are not quite the same as Windows ones
4277 wxPoint pt
= GetClientAreaOrigin();
4278 event
.m_x
= x
- pt
.x
;
4279 event
.m_y
= y
- pt
.y
;
4281 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4282 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4283 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4284 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4285 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4286 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4287 // Returns different negative values on WinME and WinNT,
4288 // so simply test for negative value.
4289 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4292 event
.SetTimestamp(::GetMessageTime());
4295 event
.m_eventObject
= this;
4296 event
.SetId(GetId());
4298 #if wxUSE_MOUSEEVENT_HACK
4301 m_lastMouseEvent
= event
.GetEventType();
4302 #endif // wxUSE_MOUSEEVENT_HACK
4305 // Windows doesn't send the mouse events to the static controls (which are
4306 // transparent in the sense that their WM_NCHITTEST handler returns
4307 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4308 // and so we manually check if we don't have a child window under mouse and if
4309 // we do, send the event to it instead of the window Windows had sent WM_XXX
4312 // Notice that this is not done for the mouse move events because this could
4313 // (would?) be too slow, but only for clicks which means that the static texts
4314 // still don't get move, enter nor leave events.
4315 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4317 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4319 // first try to find a non transparent child: this allows us to send events
4320 // to a static text which is inside a static box, for example
4321 POINT pt
= { *x
, *y
};
4322 HWND hwnd
= GetHwndOf(win
),
4326 hwndUnderMouse
= ::ChildWindowFromPoint
4332 hwndUnderMouse
= ::ChildWindowFromPointEx
4342 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4344 // now try any child window at all
4345 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4348 // check that we have a child window which is susceptible to receive mouse
4349 // events: for this it must be shown and enabled
4350 if ( hwndUnderMouse
&&
4351 hwndUnderMouse
!= hwnd
&&
4352 ::IsWindowVisible(hwndUnderMouse
) &&
4353 ::IsWindowEnabled(hwndUnderMouse
) )
4355 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4356 if ( winUnderMouse
)
4358 // translate the mouse coords to the other window coords
4359 win
->ClientToScreen(x
, y
);
4360 winUnderMouse
->ScreenToClient(x
, y
);
4362 win
= winUnderMouse
;
4369 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4371 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4372 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4373 // from the message id and take the value in the table to get wxWin event
4375 static const wxEventType eventsMouse
[] =
4389 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4390 InitMouseEvent(event
, x
, y
, flags
);
4392 return GetEventHandler()->ProcessEvent(event
);
4395 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4397 if ( !m_mouseInWindow
)
4399 // it would be wrong to assume that just because we get a mouse move
4400 // event that the mouse is inside the window: although this is usually
4401 // true, it is not if we had captured the mouse, so we need to check
4402 // the mouse coordinates here
4403 if ( !HasCapture() || IsMouseInWindow() )
4405 // Generate an ENTER event
4406 m_mouseInWindow
= true;
4407 #if _WIN32_WINNT >= 0x0400
4409 TRACKMOUSEEVENT trackinfo
;
4411 trackinfo
.cbSize
= sizeof(trackinfo
);
4412 trackinfo
.dwFlags
= TME_LEAVE
;
4413 trackinfo
.hwndTrack
= GetHwnd();
4414 //Use the commctrl.h _TrackMouseEvent, which will call the
4415 // appropriate TrackMouseEvent or emulate it ( win95 )
4416 // else we need _WIN32_WINNT >= 0x0400
4417 _TrackMouseEvent(&trackinfo
);
4420 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4421 InitMouseEvent(event
, x
, y
, flags
);
4423 (void)GetEventHandler()->ProcessEvent(event
);
4427 #if wxUSE_MOUSEEVENT_HACK
4428 // Window gets a click down message followed by a mouse move message even
4429 // if position isn't changed! We want to discard the trailing move event
4430 // if x and y are the same.
4431 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4432 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4433 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4434 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4436 m_lastMouseEvent
= wxEVT_MOTION
;
4440 #endif // wxUSE_MOUSEEVENT_HACK
4442 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4446 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4448 #if wxUSE_MOUSEWHEEL
4449 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4450 InitMouseEvent(event
,
4451 GET_X_LPARAM(lParam
),
4452 GET_Y_LPARAM(lParam
),
4454 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4455 event
.m_wheelDelta
= WHEEL_DELTA
;
4457 static int s_linesPerRotation
= -1;
4458 if ( s_linesPerRotation
== -1 )
4460 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4461 &s_linesPerRotation
, 0))
4463 // this is not supposed to happen
4464 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4466 // the default is 3, so use it if SystemParametersInfo() failed
4467 s_linesPerRotation
= 3;
4471 event
.m_linesPerAction
= s_linesPerRotation
;
4472 return GetEventHandler()->ProcessEvent(event
);
4483 // ---------------------------------------------------------------------------
4484 // keyboard handling
4485 // ---------------------------------------------------------------------------
4487 // create the key event of the given type for the given key - used by
4488 // HandleChar and HandleKeyDown/Up
4489 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4492 WXWPARAM wParam
) const
4494 wxKeyEvent
event(evType
);
4495 event
.SetId(GetId());
4496 event
.m_shiftDown
= wxIsShiftDown();
4497 event
.m_controlDown
= wxIsCtrlDown();
4498 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4500 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4501 event
.m_keyCode
= id
;
4503 event
.m_uniChar
= (wxChar
) wParam
;
4505 event
.m_rawCode
= (wxUint32
) wParam
;
4506 event
.m_rawFlags
= (wxUint32
) lParam
;
4508 event
.SetTimestamp(::GetMessageTime());
4511 // translate the position to client coords
4515 GetWindowRect(GetHwnd(),&rect
);
4525 // isASCII is true only when we're called from WM_CHAR handler and not from
4527 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4532 // If 1 -> 26, translate to either special keycode or just set
4533 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4534 // ControlDown() == true.
4536 if ( (id
> 0) && (id
< 27) )
4558 else // we're called from WM_KEYDOWN
4560 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4563 // it's ASCII and will be processed here only when called from
4564 // WM_CHAR (i.e. when isASCII = true), don't process it now
4569 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4571 // the alphanumeric keys produced by pressing AltGr+something on European
4572 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4573 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4574 // alphanumeric, so pretend that there are no modifiers at all (the
4575 // KEY_DOWN event would still have the correct modifiers if they're really
4577 if ( event
.m_controlDown
&& event
.m_altDown
&&
4578 (id
>= 32 && id
< 256) )
4580 event
.m_controlDown
=
4581 event
.m_altDown
= false;
4584 return GetEventHandler()->ProcessEvent(event
);
4587 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4589 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4593 // normal ASCII char
4597 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4599 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4600 if ( GetEventHandler()->ProcessEvent(event
) )
4609 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4611 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4615 // normal ASCII char
4619 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4621 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4622 if ( GetEventHandler()->ProcessEvent(event
) )
4629 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4631 // FIXME: implement GetMenuItemCount for WinCE, possibly
4632 // in terms of GetMenuItemInfo
4634 const HMENU hmenu
= (HMENU
)lParam
;
4638 mii
.cbSize
= sizeof(MENUITEMINFO
);
4639 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4641 // find if we have this letter in any owner drawn item
4642 const int count
= ::GetMenuItemCount(hmenu
);
4643 for ( int i
= 0; i
< count
; i
++ )
4645 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4647 if ( mii
.fType
== MFT_OWNERDRAW
)
4649 // dwItemData member of the MENUITEMINFO is a
4650 // pointer to the associated wxMenuItem -- see the
4651 // menu creation code
4652 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4654 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4657 if ( *p
== _T('&') )
4659 // this is not the accel char, find the real one
4660 p
= wxStrchr(p
+ 1, _T('&'));
4662 else // got the accel char
4664 // FIXME-UNICODE: this comparison doesn't risk to work
4665 // for non ASCII accelerator characters I'm afraid, but
4667 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
4673 // this one doesn't match
4680 else // failed to get the menu text?
4682 // it's not fatal, so don't show error, but still log
4684 wxLogLastError(_T("GetMenuItemInfo"));
4688 wxUnusedVar(chAccel
);
4689 wxUnusedVar(lParam
);
4694 // ---------------------------------------------------------------------------
4696 // ---------------------------------------------------------------------------
4698 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4702 if ( flags
& JOY_BUTTON1CHG
)
4703 change
= wxJOY_BUTTON1
;
4704 if ( flags
& JOY_BUTTON2CHG
)
4705 change
= wxJOY_BUTTON2
;
4706 if ( flags
& JOY_BUTTON3CHG
)
4707 change
= wxJOY_BUTTON3
;
4708 if ( flags
& JOY_BUTTON4CHG
)
4709 change
= wxJOY_BUTTON4
;
4712 if ( flags
& JOY_BUTTON1
)
4713 buttons
|= wxJOY_BUTTON1
;
4714 if ( flags
& JOY_BUTTON2
)
4715 buttons
|= wxJOY_BUTTON2
;
4716 if ( flags
& JOY_BUTTON3
)
4717 buttons
|= wxJOY_BUTTON3
;
4718 if ( flags
& JOY_BUTTON4
)
4719 buttons
|= wxJOY_BUTTON4
;
4721 // the event ids aren't consecutive so we can't use table based lookup
4723 wxEventType eventType
;
4728 eventType
= wxEVT_JOY_MOVE
;
4733 eventType
= wxEVT_JOY_MOVE
;
4738 eventType
= wxEVT_JOY_ZMOVE
;
4743 eventType
= wxEVT_JOY_ZMOVE
;
4746 case MM_JOY1BUTTONDOWN
:
4748 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4751 case MM_JOY2BUTTONDOWN
:
4753 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4756 case MM_JOY1BUTTONUP
:
4758 eventType
= wxEVT_JOY_BUTTON_UP
;
4761 case MM_JOY2BUTTONUP
:
4763 eventType
= wxEVT_JOY_BUTTON_UP
;
4767 wxFAIL_MSG(wxT("no such joystick event"));
4772 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4773 event
.SetPosition(wxPoint(x
, y
));
4774 event
.SetEventObject(this);
4776 return GetEventHandler()->ProcessEvent(event
);
4786 // ---------------------------------------------------------------------------
4788 // ---------------------------------------------------------------------------
4790 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4791 WXWORD pos
, WXHWND control
)
4793 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
4795 wxWindow
*child
= wxFindWinFromHandle(control
);
4797 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4800 wxScrollWinEvent event
;
4801 event
.SetPosition(pos
);
4802 event
.SetOrientation(orientation
);
4803 event
.m_eventObject
= this;
4808 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4812 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4816 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4820 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4824 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4828 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4831 case SB_THUMBPOSITION
:
4833 // under Win32, the scrollbar range and position are 32 bit integers,
4834 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4835 // explicitly query the scrollbar for the correct position (this must
4836 // be done only for these two SB_ events as they are the only one
4837 // carrying the scrollbar position)
4839 WinStruct
<SCROLLINFO
> scrollInfo
;
4840 scrollInfo
.fMask
= SIF_TRACKPOS
;
4842 if ( !::GetScrollInfo(GetHwnd(),
4843 orientation
== wxHORIZONTAL
? SB_HORZ
4847 // Not neccessarily an error, if there are no scrollbars yet.
4848 // wxLogLastError(_T("GetScrollInfo"));
4851 event
.SetPosition(scrollInfo
.nTrackPos
);
4854 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4855 ? wxEVT_SCROLLWIN_THUMBRELEASE
4856 : wxEVT_SCROLLWIN_THUMBTRACK
;
4863 return GetEventHandler()->ProcessEvent(event
);
4866 // ===========================================================================
4868 // ===========================================================================
4870 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
4873 HDC dc
= ::GetDC((HWND
) wnd
);
4876 // the_font.UseResource();
4877 // the_font.RealizeResource();
4878 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
4880 was
= (HFONT
) SelectObject(dc
,fnt
);
4882 GetTextMetrics(dc
, &tm
);
4885 SelectObject(dc
,was
);
4887 ReleaseDC((HWND
)wnd
, dc
);
4890 *x
= tm
.tmAveCharWidth
;
4892 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4894 // the_font.ReleaseResource();
4897 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4898 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4899 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
4904 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4905 case VK_BACK
: id
= WXK_BACK
; break;
4906 case VK_TAB
: id
= WXK_TAB
; break;
4907 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4908 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4909 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4910 case VK_MENU
: id
= WXK_MENU
; break;
4911 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4912 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4913 case VK_SPACE
: id
= WXK_SPACE
; break;
4914 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4915 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4916 case VK_NEXT
: id
= WXK_NEXT
; break;
4917 case VK_END
: id
= WXK_END
; break;
4918 case VK_HOME
: id
= WXK_HOME
; break;
4919 case VK_LEFT
: id
= WXK_LEFT
; break;
4920 case VK_UP
: id
= WXK_UP
; break;
4921 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4922 case VK_DOWN
: id
= WXK_DOWN
; break;
4923 case VK_SELECT
: id
= WXK_SELECT
; break;
4924 case VK_PRINT
: id
= WXK_PRINT
; break;
4925 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4926 case VK_INSERT
: id
= WXK_INSERT
; break;
4927 case VK_DELETE
: id
= WXK_DELETE
; break;
4928 case VK_HELP
: id
= WXK_HELP
; break;
4929 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4930 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4931 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4932 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4933 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4934 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4935 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4936 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4937 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4938 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4939 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4940 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4941 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4942 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4943 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4944 case VK_F1
: id
= WXK_F1
; break;
4945 case VK_F2
: id
= WXK_F2
; break;
4946 case VK_F3
: id
= WXK_F3
; break;
4947 case VK_F4
: id
= WXK_F4
; break;
4948 case VK_F5
: id
= WXK_F5
; break;
4949 case VK_F6
: id
= WXK_F6
; break;
4950 case VK_F7
: id
= WXK_F7
; break;
4951 case VK_F8
: id
= WXK_F8
; break;
4952 case VK_F9
: id
= WXK_F9
; break;
4953 case VK_F10
: id
= WXK_F10
; break;
4954 case VK_F11
: id
= WXK_F11
; break;
4955 case VK_F12
: id
= WXK_F12
; break;
4956 case VK_F13
: id
= WXK_F13
; break;
4957 case VK_F14
: id
= WXK_F14
; break;
4958 case VK_F15
: id
= WXK_F15
; break;
4959 case VK_F16
: id
= WXK_F16
; break;
4960 case VK_F17
: id
= WXK_F17
; break;
4961 case VK_F18
: id
= WXK_F18
; break;
4962 case VK_F19
: id
= WXK_F19
; break;
4963 case VK_F20
: id
= WXK_F20
; break;
4964 case VK_F21
: id
= WXK_F21
; break;
4965 case VK_F22
: id
= WXK_F22
; break;
4966 case VK_F23
: id
= WXK_F23
; break;
4967 case VK_F24
: id
= WXK_F24
; break;
4968 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4969 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4971 case VK_OEM_1
: id
= ';'; break;
4972 case VK_OEM_PLUS
: id
= '+'; break;
4973 case VK_OEM_COMMA
: id
= ','; break;
4974 case VK_OEM_MINUS
: id
= '-'; break;
4975 case VK_OEM_PERIOD
: id
= '.'; break;
4976 case VK_OEM_2
: id
= '/'; break;
4977 case VK_OEM_3
: id
= '~'; break;
4978 case VK_OEM_4
: id
= '['; break;
4979 case VK_OEM_5
: id
= '\\'; break;
4980 case VK_OEM_6
: id
= ']'; break;
4981 case VK_OEM_7
: id
= '\''; break;
4984 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4985 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4986 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4987 #endif // VK_APPS defined
4990 // the same key is sent for both the "return" key on the main
4991 // keyboard and the numeric keypad but we want to distinguish
4992 // between them: we do this using the "extended" bit (24) of lParam
4993 id
= lParam
& (1 << 24) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5003 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5009 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5010 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5011 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5012 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5013 case WXK_ALT
: keySym
= VK_MENU
; break;
5014 case WXK_MENU
: keySym
= VK_MENU
; break;
5015 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5016 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5017 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5018 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5019 case WXK_END
: keySym
= VK_END
; break;
5020 case WXK_HOME
: keySym
= VK_HOME
; break;
5021 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5022 case WXK_UP
: keySym
= VK_UP
; break;
5023 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5024 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5025 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5026 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5027 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5028 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5029 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5030 case WXK_HELP
: keySym
= VK_HELP
; break;
5031 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5032 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5033 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5034 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5035 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5036 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5037 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5038 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5039 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5040 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5041 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5042 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5043 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5044 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5045 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5046 case WXK_F1
: keySym
= VK_F1
; break;
5047 case WXK_F2
: keySym
= VK_F2
; break;
5048 case WXK_F3
: keySym
= VK_F3
; break;
5049 case WXK_F4
: keySym
= VK_F4
; break;
5050 case WXK_F5
: keySym
= VK_F5
; break;
5051 case WXK_F6
: keySym
= VK_F6
; break;
5052 case WXK_F7
: keySym
= VK_F7
; break;
5053 case WXK_F8
: keySym
= VK_F8
; break;
5054 case WXK_F9
: keySym
= VK_F9
; break;
5055 case WXK_F10
: keySym
= VK_F10
; break;
5056 case WXK_F11
: keySym
= VK_F11
; break;
5057 case WXK_F12
: keySym
= VK_F12
; break;
5058 case WXK_F13
: keySym
= VK_F13
; break;
5059 case WXK_F14
: keySym
= VK_F14
; break;
5060 case WXK_F15
: keySym
= VK_F15
; break;
5061 case WXK_F16
: keySym
= VK_F16
; break;
5062 case WXK_F17
: keySym
= VK_F17
; break;
5063 case WXK_F18
: keySym
= VK_F18
; break;
5064 case WXK_F19
: keySym
= VK_F19
; break;
5065 case WXK_F20
: keySym
= VK_F20
; break;
5066 case WXK_F21
: keySym
= VK_F21
; break;
5067 case WXK_F22
: keySym
= VK_F22
; break;
5068 case WXK_F23
: keySym
= VK_F23
; break;
5069 case WXK_F24
: keySym
= VK_F24
; break;
5070 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5071 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5082 bool wxGetKeyState(wxKeyCode key
)
5086 //High order with GetAsyncKeyState only available on WIN32
5088 //If the requested key is a LED key, return
5089 //true if the led is pressed
5090 if (key
== WXK_NUMLOCK
||
5091 key
== WXK_CAPITAL
||
5095 //low order bit means LED is highlighted,
5096 //high order means key is down
5097 //Here, for compat with other ports we want both
5098 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5105 //low order bit means key pressed since last call
5106 //high order means key is down
5107 //We want only the high order bit - the key may not be down if only low order
5108 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5113 wxWindow
*wxGetActiveWindow()
5115 HWND hWnd
= GetActiveWindow();
5118 return wxFindWinFromHandle((WXHWND
) hWnd
);
5123 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5125 HWND hwnd
= (HWND
)hWnd
;
5127 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5128 // by code in msw/radiobox.cpp), for all the others we just search up the
5130 wxWindow
*win
= (wxWindow
*)NULL
;
5133 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5137 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5138 // wxWindow class which overrides WM_GETDLGCODE processing to
5139 // do it as well, win would be already non NULL
5140 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5142 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5144 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5145 #endif // wxUSE_RADIOBOX
5147 // spin control text buddy window should be mapped to spin ctrl
5148 // itself so try it too
5149 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5152 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5154 #endif // wxUSE_SPINCTRL
5158 while ( hwnd
&& !win
)
5160 // this is a really ugly hack needed to avoid mistakenly returning the
5161 // parent frame wxWindow for the find/replace modeless dialog HWND -
5162 // this, in turn, is needed to call IsDialogMessage() from
5163 // wxApp::ProcessMessage() as for this we must return NULL from here
5165 // FIXME: this is clearly not the best way to do it but I think we'll
5166 // need to change HWND <-> wxWindow code more heavily than I can
5167 // do it now to fix it
5168 #ifndef __WXMICROWIN__
5169 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5171 // it's a dialog box, don't go upwards
5176 hwnd
= ::GetParent(hwnd
);
5177 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5183 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5185 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5186 // in active frames and dialogs, regardless of where the focus is.
5187 static HHOOK wxTheKeyboardHook
= 0;
5188 static FARPROC wxTheKeyboardHookProc
= 0;
5189 int APIENTRY _EXPORT
5190 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5192 void wxSetKeyboardHook(bool doIt
)
5196 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5197 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5199 GetCurrentThreadId()
5200 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5205 UnhookWindowsHookEx(wxTheKeyboardHook
);
5209 int APIENTRY _EXPORT
5210 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5212 DWORD hiWord
= HIWORD(lParam
);
5213 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5215 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5218 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5219 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5220 event
.m_altDown
= true;
5222 event
.m_eventObject
= NULL
;
5223 event
.m_keyCode
= id
;
5224 event
.m_shiftDown
= wxIsShiftDown();
5225 event
.m_controlDown
= wxIsCtrlDown();
5227 event
.SetTimestamp(::GetMessageTime());
5229 wxWindow
*win
= wxGetActiveWindow();
5230 wxEvtHandler
*handler
;
5233 handler
= win
->GetEventHandler();
5234 event
.SetId(win
->GetId());
5239 event
.SetId(wxID_ANY
);
5242 if ( handler
&& handler
->ProcessEvent(event
) )
5250 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5253 #endif // !__WXMICROWIN__
5256 const char *wxGetMessageName(int message
)
5260 case 0x0000: return "WM_NULL";
5261 case 0x0001: return "WM_CREATE";
5262 case 0x0002: return "WM_DESTROY";
5263 case 0x0003: return "WM_MOVE";
5264 case 0x0005: return "WM_SIZE";
5265 case 0x0006: return "WM_ACTIVATE";
5266 case 0x0007: return "WM_SETFOCUS";
5267 case 0x0008: return "WM_KILLFOCUS";
5268 case 0x000A: return "WM_ENABLE";
5269 case 0x000B: return "WM_SETREDRAW";
5270 case 0x000C: return "WM_SETTEXT";
5271 case 0x000D: return "WM_GETTEXT";
5272 case 0x000E: return "WM_GETTEXTLENGTH";
5273 case 0x000F: return "WM_PAINT";
5274 case 0x0010: return "WM_CLOSE";
5275 case 0x0011: return "WM_QUERYENDSESSION";
5276 case 0x0012: return "WM_QUIT";
5277 case 0x0013: return "WM_QUERYOPEN";
5278 case 0x0014: return "WM_ERASEBKGND";
5279 case 0x0015: return "WM_SYSCOLORCHANGE";
5280 case 0x0016: return "WM_ENDSESSION";
5281 case 0x0017: return "WM_SYSTEMERROR";
5282 case 0x0018: return "WM_SHOWWINDOW";
5283 case 0x0019: return "WM_CTLCOLOR";
5284 case 0x001A: return "WM_WININICHANGE";
5285 case 0x001B: return "WM_DEVMODECHANGE";
5286 case 0x001C: return "WM_ACTIVATEAPP";
5287 case 0x001D: return "WM_FONTCHANGE";
5288 case 0x001E: return "WM_TIMECHANGE";
5289 case 0x001F: return "WM_CANCELMODE";
5290 case 0x0020: return "WM_SETCURSOR";
5291 case 0x0021: return "WM_MOUSEACTIVATE";
5292 case 0x0022: return "WM_CHILDACTIVATE";
5293 case 0x0023: return "WM_QUEUESYNC";
5294 case 0x0024: return "WM_GETMINMAXINFO";
5295 case 0x0026: return "WM_PAINTICON";
5296 case 0x0027: return "WM_ICONERASEBKGND";
5297 case 0x0028: return "WM_NEXTDLGCTL";
5298 case 0x002A: return "WM_SPOOLERSTATUS";
5299 case 0x002B: return "WM_DRAWITEM";
5300 case 0x002C: return "WM_MEASUREITEM";
5301 case 0x002D: return "WM_DELETEITEM";
5302 case 0x002E: return "WM_VKEYTOITEM";
5303 case 0x002F: return "WM_CHARTOITEM";
5304 case 0x0030: return "WM_SETFONT";
5305 case 0x0031: return "WM_GETFONT";
5306 case 0x0037: return "WM_QUERYDRAGICON";
5307 case 0x0039: return "WM_COMPAREITEM";
5308 case 0x0041: return "WM_COMPACTING";
5309 case 0x0044: return "WM_COMMNOTIFY";
5310 case 0x0046: return "WM_WINDOWPOSCHANGING";
5311 case 0x0047: return "WM_WINDOWPOSCHANGED";
5312 case 0x0048: return "WM_POWER";
5314 case 0x004A: return "WM_COPYDATA";
5315 case 0x004B: return "WM_CANCELJOURNAL";
5316 case 0x004E: return "WM_NOTIFY";
5317 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5318 case 0x0051: return "WM_INPUTLANGCHANGE";
5319 case 0x0052: return "WM_TCARD";
5320 case 0x0053: return "WM_HELP";
5321 case 0x0054: return "WM_USERCHANGED";
5322 case 0x0055: return "WM_NOTIFYFORMAT";
5323 case 0x007B: return "WM_CONTEXTMENU";
5324 case 0x007C: return "WM_STYLECHANGING";
5325 case 0x007D: return "WM_STYLECHANGED";
5326 case 0x007E: return "WM_DISPLAYCHANGE";
5327 case 0x007F: return "WM_GETICON";
5328 case 0x0080: return "WM_SETICON";
5330 case 0x0081: return "WM_NCCREATE";
5331 case 0x0082: return "WM_NCDESTROY";
5332 case 0x0083: return "WM_NCCALCSIZE";
5333 case 0x0084: return "WM_NCHITTEST";
5334 case 0x0085: return "WM_NCPAINT";
5335 case 0x0086: return "WM_NCACTIVATE";
5336 case 0x0087: return "WM_GETDLGCODE";
5337 case 0x00A0: return "WM_NCMOUSEMOVE";
5338 case 0x00A1: return "WM_NCLBUTTONDOWN";
5339 case 0x00A2: return "WM_NCLBUTTONUP";
5340 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5341 case 0x00A4: return "WM_NCRBUTTONDOWN";
5342 case 0x00A5: return "WM_NCRBUTTONUP";
5343 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5344 case 0x00A7: return "WM_NCMBUTTONDOWN";
5345 case 0x00A8: return "WM_NCMBUTTONUP";
5346 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5347 case 0x0100: return "WM_KEYDOWN";
5348 case 0x0101: return "WM_KEYUP";
5349 case 0x0102: return "WM_CHAR";
5350 case 0x0103: return "WM_DEADCHAR";
5351 case 0x0104: return "WM_SYSKEYDOWN";
5352 case 0x0105: return "WM_SYSKEYUP";
5353 case 0x0106: return "WM_SYSCHAR";
5354 case 0x0107: return "WM_SYSDEADCHAR";
5355 case 0x0108: return "WM_KEYLAST";
5357 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5358 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5359 case 0x010F: return "WM_IME_COMPOSITION";
5361 case 0x0110: return "WM_INITDIALOG";
5362 case 0x0111: return "WM_COMMAND";
5363 case 0x0112: return "WM_SYSCOMMAND";
5364 case 0x0113: return "WM_TIMER";
5365 case 0x0114: return "WM_HSCROLL";
5366 case 0x0115: return "WM_VSCROLL";
5367 case 0x0116: return "WM_INITMENU";
5368 case 0x0117: return "WM_INITMENUPOPUP";
5369 case 0x011F: return "WM_MENUSELECT";
5370 case 0x0120: return "WM_MENUCHAR";
5371 case 0x0121: return "WM_ENTERIDLE";
5372 case 0x0200: return "WM_MOUSEMOVE";
5373 case 0x0201: return "WM_LBUTTONDOWN";
5374 case 0x0202: return "WM_LBUTTONUP";
5375 case 0x0203: return "WM_LBUTTONDBLCLK";
5376 case 0x0204: return "WM_RBUTTONDOWN";
5377 case 0x0205: return "WM_RBUTTONUP";
5378 case 0x0206: return "WM_RBUTTONDBLCLK";
5379 case 0x0207: return "WM_MBUTTONDOWN";
5380 case 0x0208: return "WM_MBUTTONUP";
5381 case 0x0209: return "WM_MBUTTONDBLCLK";
5382 case 0x020A: return "WM_MOUSEWHEEL";
5383 case 0x0210: return "WM_PARENTNOTIFY";
5384 case 0x0211: return "WM_ENTERMENULOOP";
5385 case 0x0212: return "WM_EXITMENULOOP";
5387 case 0x0213: return "WM_NEXTMENU";
5388 case 0x0214: return "WM_SIZING";
5389 case 0x0215: return "WM_CAPTURECHANGED";
5390 case 0x0216: return "WM_MOVING";
5391 case 0x0218: return "WM_POWERBROADCAST";
5392 case 0x0219: return "WM_DEVICECHANGE";
5394 case 0x0220: return "WM_MDICREATE";
5395 case 0x0221: return "WM_MDIDESTROY";
5396 case 0x0222: return "WM_MDIACTIVATE";
5397 case 0x0223: return "WM_MDIRESTORE";
5398 case 0x0224: return "WM_MDINEXT";
5399 case 0x0225: return "WM_MDIMAXIMIZE";
5400 case 0x0226: return "WM_MDITILE";
5401 case 0x0227: return "WM_MDICASCADE";
5402 case 0x0228: return "WM_MDIICONARRANGE";
5403 case 0x0229: return "WM_MDIGETACTIVE";
5404 case 0x0230: return "WM_MDISETMENU";
5405 case 0x0233: return "WM_DROPFILES";
5407 case 0x0281: return "WM_IME_SETCONTEXT";
5408 case 0x0282: return "WM_IME_NOTIFY";
5409 case 0x0283: return "WM_IME_CONTROL";
5410 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5411 case 0x0285: return "WM_IME_SELECT";
5412 case 0x0286: return "WM_IME_CHAR";
5413 case 0x0290: return "WM_IME_KEYDOWN";
5414 case 0x0291: return "WM_IME_KEYUP";
5416 case 0x0300: return "WM_CUT";
5417 case 0x0301: return "WM_COPY";
5418 case 0x0302: return "WM_PASTE";
5419 case 0x0303: return "WM_CLEAR";
5420 case 0x0304: return "WM_UNDO";
5421 case 0x0305: return "WM_RENDERFORMAT";
5422 case 0x0306: return "WM_RENDERALLFORMATS";
5423 case 0x0307: return "WM_DESTROYCLIPBOARD";
5424 case 0x0308: return "WM_DRAWCLIPBOARD";
5425 case 0x0309: return "WM_PAINTCLIPBOARD";
5426 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5427 case 0x030B: return "WM_SIZECLIPBOARD";
5428 case 0x030C: return "WM_ASKCBFORMATNAME";
5429 case 0x030D: return "WM_CHANGECBCHAIN";
5430 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5431 case 0x030F: return "WM_QUERYNEWPALETTE";
5432 case 0x0310: return "WM_PALETTEISCHANGING";
5433 case 0x0311: return "WM_PALETTECHANGED";
5435 case 0x0312: return "WM_HOTKEY";
5438 // common controls messages - although they're not strictly speaking
5439 // standard, it's nice to decode them nevertheless
5442 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5443 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5444 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5445 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5446 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5447 case 0x1000 + 5: return "LVM_GETITEMA";
5448 case 0x1000 + 75: return "LVM_GETITEMW";
5449 case 0x1000 + 6: return "LVM_SETITEMA";
5450 case 0x1000 + 76: return "LVM_SETITEMW";
5451 case 0x1000 + 7: return "LVM_INSERTITEMA";
5452 case 0x1000 + 77: return "LVM_INSERTITEMW";
5453 case 0x1000 + 8: return "LVM_DELETEITEM";
5454 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5455 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5456 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5457 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5458 case 0x1000 + 13: return "LVM_FINDITEMA";
5459 case 0x1000 + 83: return "LVM_FINDITEMW";
5460 case 0x1000 + 14: return "LVM_GETITEMRECT";
5461 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5462 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5463 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5464 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5465 case 0x1000 + 18: return "LVM_HITTEST";
5466 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5467 case 0x1000 + 20: return "LVM_SCROLL";
5468 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5469 case 0x1000 + 22: return "LVM_ARRANGE";
5470 case 0x1000 + 23: return "LVM_EDITLABELA";
5471 case 0x1000 + 118: return "LVM_EDITLABELW";
5472 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5473 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5474 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5475 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5476 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5477 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5478 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5479 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5480 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5481 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5482 case 0x1000 + 31: return "LVM_GETHEADER";
5483 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5484 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5485 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5486 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5487 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5488 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5489 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5490 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5491 case 0x1000 + 41: return "LVM_GETORIGIN";
5492 case 0x1000 + 42: return "LVM_UPDATE";
5493 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5494 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5495 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5496 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5497 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5498 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5499 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5500 case 0x1000 + 48: return "LVM_SORTITEMS";
5501 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5502 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5503 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5504 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5505 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5506 case 0x1000 + 53: return "LVM_SETICONSPACING";
5507 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5508 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5509 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5510 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5511 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5512 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5513 case 0x1000 + 60: return "LVM_SETHOTITEM";
5514 case 0x1000 + 61: return "LVM_GETHOTITEM";
5515 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5516 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5517 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5518 case 0x1000 + 65: return "LVM_SETWORKAREA";
5521 case 0x1100 + 0: return "TVM_INSERTITEMA";
5522 case 0x1100 + 50: return "TVM_INSERTITEMW";
5523 case 0x1100 + 1: return "TVM_DELETEITEM";
5524 case 0x1100 + 2: return "TVM_EXPAND";
5525 case 0x1100 + 4: return "TVM_GETITEMRECT";
5526 case 0x1100 + 5: return "TVM_GETCOUNT";
5527 case 0x1100 + 6: return "TVM_GETINDENT";
5528 case 0x1100 + 7: return "TVM_SETINDENT";
5529 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5530 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5531 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5532 case 0x1100 + 11: return "TVM_SELECTITEM";
5533 case 0x1100 + 12: return "TVM_GETITEMA";
5534 case 0x1100 + 62: return "TVM_GETITEMW";
5535 case 0x1100 + 13: return "TVM_SETITEMA";
5536 case 0x1100 + 63: return "TVM_SETITEMW";
5537 case 0x1100 + 14: return "TVM_EDITLABELA";
5538 case 0x1100 + 65: return "TVM_EDITLABELW";
5539 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5540 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5541 case 0x1100 + 17: return "TVM_HITTEST";
5542 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5543 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5544 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5545 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5546 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5547 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5548 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5549 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5550 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5553 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5554 case 0x1200 + 1: return "HDM_INSERTITEMA";
5555 case 0x1200 + 10: return "HDM_INSERTITEMW";
5556 case 0x1200 + 2: return "HDM_DELETEITEM";
5557 case 0x1200 + 3: return "HDM_GETITEMA";
5558 case 0x1200 + 11: return "HDM_GETITEMW";
5559 case 0x1200 + 4: return "HDM_SETITEMA";
5560 case 0x1200 + 12: return "HDM_SETITEMW";
5561 case 0x1200 + 5: return "HDM_LAYOUT";
5562 case 0x1200 + 6: return "HDM_HITTEST";
5563 case 0x1200 + 7: return "HDM_GETITEMRECT";
5564 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5565 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5566 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5567 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5568 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5569 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5570 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5573 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5574 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5575 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5576 case 0x1300 + 5: return "TCM_GETITEMA";
5577 case 0x1300 + 60: return "TCM_GETITEMW";
5578 case 0x1300 + 6: return "TCM_SETITEMA";
5579 case 0x1300 + 61: return "TCM_SETITEMW";
5580 case 0x1300 + 7: return "TCM_INSERTITEMA";
5581 case 0x1300 + 62: return "TCM_INSERTITEMW";
5582 case 0x1300 + 8: return "TCM_DELETEITEM";
5583 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5584 case 0x1300 + 10: return "TCM_GETITEMRECT";
5585 case 0x1300 + 11: return "TCM_GETCURSEL";
5586 case 0x1300 + 12: return "TCM_SETCURSEL";
5587 case 0x1300 + 13: return "TCM_HITTEST";
5588 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5589 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5590 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5591 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5592 case 0x1300 + 43: return "TCM_SETPADDING";
5593 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5594 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5595 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5596 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5597 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5598 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5599 case 0x1300 + 50: return "TCM_DESELECTALL";
5602 case WM_USER
+1: return "TB_ENABLEBUTTON";
5603 case WM_USER
+2: return "TB_CHECKBUTTON";
5604 case WM_USER
+3: return "TB_PRESSBUTTON";
5605 case WM_USER
+4: return "TB_HIDEBUTTON";
5606 case WM_USER
+5: return "TB_INDETERMINATE";
5607 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5608 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5609 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5610 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5611 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5612 case WM_USER
+17: return "TB_SETSTATE";
5613 case WM_USER
+18: return "TB_GETSTATE";
5614 case WM_USER
+19: return "TB_ADDBITMAP";
5615 case WM_USER
+20: return "TB_ADDBUTTONS";
5616 case WM_USER
+21: return "TB_INSERTBUTTON";
5617 case WM_USER
+22: return "TB_DELETEBUTTON";
5618 case WM_USER
+23: return "TB_GETBUTTON";
5619 case WM_USER
+24: return "TB_BUTTONCOUNT";
5620 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5621 case WM_USER
+26: return "TB_SAVERESTOREA";
5622 case WM_USER
+76: return "TB_SAVERESTOREW";
5623 case WM_USER
+27: return "TB_CUSTOMIZE";
5624 case WM_USER
+28: return "TB_ADDSTRINGA";
5625 case WM_USER
+77: return "TB_ADDSTRINGW";
5626 case WM_USER
+29: return "TB_GETITEMRECT";
5627 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5628 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5629 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5630 case WM_USER
+33: return "TB_AUTOSIZE";
5631 case WM_USER
+35: return "TB_GETTOOLTIPS";
5632 case WM_USER
+36: return "TB_SETTOOLTIPS";
5633 case WM_USER
+37: return "TB_SETPARENT";
5634 case WM_USER
+39: return "TB_SETROWS";
5635 case WM_USER
+40: return "TB_GETROWS";
5636 case WM_USER
+42: return "TB_SETCMDID";
5637 case WM_USER
+43: return "TB_CHANGEBITMAP";
5638 case WM_USER
+44: return "TB_GETBITMAP";
5639 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5640 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5641 case WM_USER
+46: return "TB_REPLACEBITMAP";
5642 case WM_USER
+47: return "TB_SETINDENT";
5643 case WM_USER
+48: return "TB_SETIMAGELIST";
5644 case WM_USER
+49: return "TB_GETIMAGELIST";
5645 case WM_USER
+50: return "TB_LOADIMAGES";
5646 case WM_USER
+51: return "TB_GETRECT";
5647 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5648 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5649 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5650 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5651 case WM_USER
+56: return "TB_SETSTYLE";
5652 case WM_USER
+57: return "TB_GETSTYLE";
5653 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5654 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5655 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5656 case WM_USER
+61: return "TB_GETTEXTROWS";
5657 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5660 static char s_szBuf
[128];
5661 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5665 #endif //__WXDEBUG__
5667 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5671 HWND hwnd
= GetHwndOf(win
);
5672 HDC hdc
= ::GetDC(hwnd
);
5674 #if !wxDIALOG_UNIT_COMPATIBILITY
5675 // and select the current font into it
5676 HFONT hfont
= GetHfontOf(win
->GetFont());
5679 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5683 // finally retrieve the text metrics from it
5684 GetTextMetrics(hdc
, &tm
);
5686 #if !wxDIALOG_UNIT_COMPATIBILITY
5690 (void)::SelectObject(hdc
, hfont
);
5694 ::ReleaseDC(hwnd
, hdc
);
5699 // Find the wxWindow at the current mouse position, returning the mouse
5701 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5703 pt
= wxGetMousePosition();
5704 return wxFindWindowAtPoint(pt
);
5707 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5712 HWND hWndHit
= ::WindowFromPoint(pt2
);
5714 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5715 HWND hWnd
= hWndHit
;
5717 // Try to find a window with a wxWindow associated with it
5718 while (!win
&& (hWnd
!= 0))
5720 hWnd
= ::GetParent(hWnd
);
5721 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5726 // Get the current mouse position.
5727 wxPoint
wxGetMousePosition()
5730 GetCursorPos( & pt
);
5732 return wxPoint(pt
.x
, pt
.y
);
5737 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5739 UINT win_modifiers
=0;
5740 if ( modifiers
& wxMOD_ALT
)
5741 win_modifiers
|= MOD_ALT
;
5742 if ( modifiers
& wxMOD_SHIFT
)
5743 win_modifiers
|= MOD_SHIFT
;
5744 if ( modifiers
& wxMOD_CONTROL
)
5745 win_modifiers
|= MOD_CONTROL
;
5746 if ( modifiers
& wxMOD_WIN
)
5747 win_modifiers
|= MOD_WIN
;
5749 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5751 wxLogLastError(_T("RegisterHotKey"));
5759 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
5761 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5763 wxLogLastError(_T("UnregisterHotKey"));
5773 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5775 int hotkeyId
= wParam
;
5776 int virtualKey
= HIWORD(lParam
);
5777 int win_modifiers
= LOWORD(lParam
);
5779 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5780 event
.SetId(hotkeyId
);
5781 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5782 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5783 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5784 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5786 return GetEventHandler()->ProcessEvent(event
);
5789 #endif // wxUSE_ACCEL
5791 #endif // wxUSE_HOTKEY
5793 // Not tested under WinCE
5796 // this class installs a message hook which really wakes up our idle processing
5797 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
5798 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
5799 // being dragged or even inside ::MessageBox()) and so don't control message
5800 // dispatching otherwise
5801 class wxIdleWakeUpModule
: public wxModule
5804 virtual bool OnInit()
5806 ms_hMsgHookProc
= ::SetWindowsHookEx
5809 &wxIdleWakeUpModule::MsgHookProc
,
5811 GetCurrentThreadId()
5814 if ( !ms_hMsgHookProc
)
5816 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
5824 virtual void OnExit()
5826 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
5829 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
5831 MSG
*msg
= (MSG
*)lParam
;
5832 if ( msg
->message
== WM_NULL
)
5834 wxTheApp
->ProcessPendingEvents();
5837 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
5841 static HHOOK ms_hMsgHookProc
;
5843 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
5846 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
5848 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
5850 #endif // __WXWINCE__
5855 static void wxAdjustZOrder(wxWindow
* parent
)
5857 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
5859 // Set the z-order correctly
5860 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
5863 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
5866 wxWindow
*childWin
= current
->GetData();
5867 wxAdjustZOrder(childWin
);
5868 current
= current
->GetNext();
5873 // We need to adjust the z-order of static boxes in WinCE, to
5874 // make 'contained' controls visible
5875 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
5878 wxAdjustZOrder(this);