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
)
336 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
338 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
342 // ===========================================================================
344 // ===========================================================================
346 // ---------------------------------------------------------------------------
347 // wxWindow utility functions
348 // ---------------------------------------------------------------------------
350 // Find an item given the MS Windows id
351 wxWindow
*wxWindowMSW::FindItem(long id
) const
354 wxControl
*item
= wxDynamicCastThis(wxControl
);
357 // is it we or one of our "internal" children?
358 if ( item
->GetId() == id
359 #ifndef __WXUNIVERSAL__
360 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
361 #endif // __WXUNIVERSAL__
367 #endif // wxUSE_CONTROLS
369 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
372 wxWindow
*childWin
= current
->GetData();
374 wxWindow
*wnd
= childWin
->FindItem(id
);
378 current
= current
->GetNext();
384 // Find an item given the MS Windows handle
385 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
387 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
390 wxWindow
*parent
= current
->GetData();
392 // Do a recursive search.
393 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
399 || parent
->IsKindOf(CLASSINFO(wxControl
))
400 #endif // wxUSE_CONTROLS
403 wxWindow
*item
= current
->GetData();
404 if ( item
->GetHWND() == hWnd
)
408 if ( item
->ContainsHWND(hWnd
) )
413 current
= current
->GetNext();
418 // Default command handler
419 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
424 // ----------------------------------------------------------------------------
425 // constructors and such
426 // ----------------------------------------------------------------------------
428 void wxWindowMSW::Init()
431 m_isBeingDeleted
= false;
433 m_mouseInWindow
= false;
434 m_lastKeydownProcessed
= false;
436 m_childrenDisabled
= NULL
;
447 #if wxUSE_MOUSEEVENT_HACK
450 m_lastMouseEvent
= -1;
451 #endif // wxUSE_MOUSEEVENT_HACK
455 wxWindowMSW::~wxWindowMSW()
457 m_isBeingDeleted
= true;
459 #ifndef __WXUNIVERSAL__
460 // VS: make sure there's no wxFrame with last focus set to us:
461 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
463 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
466 if ( frame
->GetLastFocus() == this )
468 frame
->SetLastFocus(NULL
);
473 #endif // __WXUNIVERSAL__
475 // VS: destroy children first and _then_ detach *this from its parent.
476 // If we'd do it the other way around, children wouldn't be able
477 // find their parent frame (see above).
482 // VZ: test temp removed to understand what really happens here
483 //if (::IsWindow(GetHwnd()))
485 if ( !::DestroyWindow(GetHwnd()) )
486 wxLogLastError(wxT("DestroyWindow"));
489 // remove hWnd <-> wxWindow association
490 wxRemoveHandleAssociation(this);
493 delete m_childrenDisabled
;
496 // real construction (Init() must have been called before!)
497 bool wxWindowMSW::Create(wxWindow
*parent
,
502 const wxString
& name
)
504 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
506 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
509 parent
->AddChild(this);
512 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
514 #ifdef __WXUNIVERSAL__
515 // no borders, we draw them ourselves
516 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
520 msflags
&= ~WS_BORDER
;
521 #endif // wxUniversal
525 msflags
|= WS_VISIBLE
;
528 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
536 // ---------------------------------------------------------------------------
538 // ---------------------------------------------------------------------------
540 void wxWindowMSW::SetFocus()
542 HWND hWnd
= GetHwnd();
543 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
545 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
549 if ( !::SetFocus(hWnd
) )
551 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
552 // was there really an error?
553 DWORD dwRes
= ::GetLastError();
556 HWND hwndFocus
= ::GetFocus();
557 if ( hwndFocus
!= hWnd
)
559 wxLogApiError(_T("SetFocus"), dwRes
);
566 void wxWindowMSW::SetFocusFromKbd()
568 // when the focus is given to the control with DLGC_HASSETSEL style from
569 // keyboard its contents should be entirely selected: this is what
570 // ::IsDialogMessage() does and so we should do it as well to provide the
571 // same LNF as the native programs
572 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
574 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
577 // do this after (maybe) setting the selection as like this when
578 // wxEVT_SET_FOCUS handler is called, the selection would have been already
579 // set correctly -- this may be important
580 wxWindowBase::SetFocusFromKbd();
583 // Get the window with the focus
584 wxWindow
*wxWindowBase::DoFindFocus()
586 HWND hWnd
= ::GetFocus();
589 return wxGetWindowFromHWND((WXHWND
)hWnd
);
595 bool wxWindowMSW::Enable(bool enable
)
597 if ( !wxWindowBase::Enable(enable
) )
600 HWND hWnd
= GetHwnd();
602 ::EnableWindow(hWnd
, (BOOL
)enable
);
604 // the logic below doesn't apply to the top level windows -- otherwise
605 // showing a modal dialog would result in total greying out (and ungreying
606 // out later) of everything which would be really ugly
610 // when the parent is disabled, all of its children should be disabled as
611 // well but when it is enabled back, only those of the children which
612 // hadn't been already disabled in the beginning should be enabled again,
613 // so we have to keep the list of those children
614 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
616 node
= node
->GetNext() )
618 wxWindow
*child
= node
->GetData();
619 if ( child
->IsTopLevel() )
621 // the logic below doesn't apply to top level children
627 // enable the child back unless it had been disabled before us
628 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
631 else // we're being disabled
633 if ( child
->IsEnabled() )
635 // disable it as children shouldn't stay enabled while the
639 else // child already disabled, remember it
641 // have we created the list of disabled children already?
642 if ( !m_childrenDisabled
)
643 m_childrenDisabled
= new wxWindowList
;
645 m_childrenDisabled
->Append(child
);
650 if ( enable
&& m_childrenDisabled
)
652 // we don't need this list any more, don't keep unused memory
653 delete m_childrenDisabled
;
654 m_childrenDisabled
= NULL
;
660 bool wxWindowMSW::Show(bool show
)
662 if ( !wxWindowBase::Show(show
) )
665 HWND hWnd
= GetHwnd();
666 int cshow
= show
? SW_SHOW
: SW_HIDE
;
667 ::ShowWindow(hWnd
, cshow
);
669 if ( show
&& IsTopLevel() )
671 wxBringWindowToTop(hWnd
);
677 // Raise the window to the top of the Z order
678 void wxWindowMSW::Raise()
680 wxBringWindowToTop(GetHwnd());
683 // Lower the window to the bottom of the Z order
684 void wxWindowMSW::Lower()
686 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
687 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
690 void wxWindowMSW::SetTitle( const wxString
& title
)
692 SetWindowText(GetHwnd(), title
.c_str());
695 wxString
wxWindowMSW::GetTitle() const
697 return wxGetWindowText(GetHWND());
700 void wxWindowMSW::DoCaptureMouse()
702 HWND hWnd
= GetHwnd();
709 void wxWindowMSW::DoReleaseMouse()
711 if ( !::ReleaseCapture() )
713 wxLogLastError(_T("ReleaseCapture"));
717 /* static */ wxWindow
*wxWindowBase::GetCapture()
719 HWND hwnd
= ::GetCapture();
720 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
723 bool wxWindowMSW::SetFont(const wxFont
& font
)
725 if ( !wxWindowBase::SetFont(font
) )
731 HWND hWnd
= GetHwnd();
734 WXHANDLE hFont
= m_font
.GetResourceHandle();
736 wxASSERT_MSG( hFont
, wxT("should have valid font") );
738 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
743 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
745 if ( !wxWindowBase::SetCursor(cursor
) )
753 HWND hWnd
= GetHwnd();
755 // Change the cursor NOW if we're within the correct window
757 ::GetCursorPos(&point
);
759 RECT rect
= wxGetWindowRect(hWnd
);
761 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
762 ::SetCursor(GetHcursorOf(m_cursor
));
768 void wxWindowMSW::WarpPointer (int x
, int y
)
770 ClientToScreen(&x
, &y
);
772 if ( !::SetCursorPos(x
, y
) )
774 wxLogLastError(_T("SetCursorPos"));
778 // ---------------------------------------------------------------------------
780 // ---------------------------------------------------------------------------
782 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
783 static inline int wxDirToWinStyle(int orient
)
785 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
788 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
790 #ifdef __WXMICROWIN__
791 return ::GetScrollPosWX(hWnd
, wOrient
);
793 WinStruct
<SCROLLINFO
> scrollInfo
;
794 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
795 scrollInfo
.fMask
= SIF_POS
;
796 if ( !::GetScrollInfo(hWnd
,
800 // Not neccessarily an error, if there are no scrollbars yet.
801 // wxLogLastError(_T("GetScrollInfo"));
803 return scrollInfo
.nPos
;
804 // return ::GetScrollPos(hWnd, wOrient);
808 int wxWindowMSW::GetScrollPos(int orient
) const
810 HWND hWnd
= GetHwnd();
811 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
813 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
816 // This now returns the whole range, not just the number
817 // of positions that we can scroll.
818 int wxWindowMSW::GetScrollRange(int orient
) const
821 HWND hWnd
= GetHwnd();
825 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
828 WinStruct
<SCROLLINFO
> scrollInfo
;
829 scrollInfo
.fMask
= SIF_RANGE
;
830 if ( !::GetScrollInfo(hWnd
,
831 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
834 // Most of the time this is not really an error, since the return
835 // value can also be zero when there is no scrollbar yet.
836 // wxLogLastError(_T("GetScrollInfo"));
838 maxPos
= scrollInfo
.nMax
;
840 // undo "range - 1" done in SetScrollbar()
844 int wxWindowMSW::GetScrollThumb(int orient
) const
846 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
849 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
851 HWND hWnd
= GetHwnd();
852 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
854 WinStruct
<SCROLLINFO
> info
;
858 info
.fMask
= SIF_POS
;
859 if ( HasFlag(wxALWAYS_SHOW_SB
) )
861 // disable scrollbar instead of removing it then
862 info
.fMask
|= SIF_DISABLENOSCROLL
;
865 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
869 // New function that will replace some of the above.
870 void wxWindowMSW::SetScrollbar(int orient
,
876 WinStruct
<SCROLLINFO
> info
;
877 info
.nPage
= pageSize
;
878 info
.nMin
= 0; // range is nMax - nMin + 1
879 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
881 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
882 if ( HasFlag(wxALWAYS_SHOW_SB
) )
884 // disable scrollbar instead of removing it then
885 info
.fMask
|= SIF_DISABLENOSCROLL
;
888 HWND hWnd
= GetHwnd();
891 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
895 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
898 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
904 rect
.left
= prect
->x
;
906 rect
.right
= prect
->x
+ prect
->width
;
907 rect
.bottom
= prect
->y
+ prect
->height
;
917 // FIXME: is this the exact equivalent of the line below?
918 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
920 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
924 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
926 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
929 for ( int n
= 0; n
< count
; n
++ )
931 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
933 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
936 // don't bother to continue, we're already at top/bottom
943 return pos
!= posStart
;
946 bool wxWindowMSW::ScrollLines(int lines
)
948 bool down
= lines
> 0;
950 return ScrollVertically(GetHwnd(),
951 down
? SB_LINEDOWN
: SB_LINEUP
,
952 down
? lines
: -lines
);
955 bool wxWindowMSW::ScrollPages(int pages
)
957 bool down
= pages
> 0;
959 return ScrollVertically(GetHwnd(),
960 down
? SB_PAGEDOWN
: SB_PAGEUP
,
961 down
? pages
: -pages
);
964 // ---------------------------------------------------------------------------
966 // ---------------------------------------------------------------------------
968 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
970 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
972 HWND hwnd
= (HWND
)hWnd
;
973 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
975 wxAssociateWinWithHandle(hwnd
, this);
977 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
979 // we don't need to subclass the window of our own class (in the Windows
980 // sense of the word)
981 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
983 wxSetWindowProc(hwnd
, wxWndProc
);
987 // don't bother restoring it neither: this also makes it easy to
988 // implement IsOfStandardClass() method which returns true for the
989 // standard controls and false for the wxWidgets own windows as it can
990 // simply check m_oldWndProc
995 void wxWindowMSW::UnsubclassWin()
997 wxRemoveHandleAssociation(this);
999 // Restore old Window proc
1000 HWND hwnd
= GetHwnd();
1005 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1009 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1011 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1014 m_oldWndProc
= NULL
;
1019 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1023 if ( !::DestroyWindow(GetHwnd()) )
1024 wxLogLastError(wxT("DestroyWindow"));
1027 WXHWND wxhwnd
= (WXHWND
)handle
;
1030 SubclassWin(wxhwnd
);
1033 void wxWindowMSW::DissociateHandle()
1035 // this also calls SetHWND(0) for us
1040 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1042 // Unicows note: the code below works, but only because WNDCLASS contains
1043 // original window handler rather that the unicows fake one. This may not
1044 // be on purpose, though; if it stops working with future versions of
1045 // unicows.dll, we can override unicows hooks by setting
1046 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1047 // versions that keep track of fake<->real wnd proc mapping.
1049 // On WinCE (at least), the wndproc comparison doesn't work,
1050 // so have to use something like this.
1052 extern wxChar
*wxCanvasClassName
;
1053 extern wxChar
*wxCanvasClassNameNR
;
1054 extern const wxChar
*wxMDIFrameClassName
;
1055 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1056 extern const wxChar
*wxMDIChildFrameClassName
;
1057 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1058 wxString
str(wxGetWindowClass(hWnd
));
1059 if (str
== wxCanvasClassName
||
1060 str
== wxCanvasClassNameNR
||
1061 str
== wxMDIFrameClassName
||
1062 str
== wxMDIFrameClassNameNoRedraw
||
1063 str
== wxMDIChildFrameClassName
||
1064 str
== wxMDIChildFrameClassNameNoRedraw
||
1065 str
== _T("wxTLWHiddenParent"))
1066 return true; // Effectively means don't subclass
1071 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1073 wxLogLastError(_T("GetClassInfo"));
1078 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1082 // ----------------------------------------------------------------------------
1084 // ----------------------------------------------------------------------------
1086 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1088 long flagsOld
= GetWindowStyleFlag();
1089 if ( flags
== flagsOld
)
1092 // update the internal variable
1093 wxWindowBase::SetWindowStyleFlag(flags
);
1095 // now update the Windows style as well if needed - and if the window had
1096 // been already created
1100 WXDWORD exstyle
, exstyleOld
;
1101 long style
= MSWGetStyle(flags
, &exstyle
),
1102 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1104 if ( style
!= styleOld
)
1106 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1107 // this function so instead of simply setting the style to the new
1108 // value we clear the bits which were set in styleOld but are set in
1109 // the new one and set the ones which were not set before
1110 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1111 styleReal
&= ~styleOld
;
1114 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1117 // and the extended style
1118 if ( exstyle
!= exstyleOld
)
1120 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1121 exstyleReal
&= ~exstyleOld
;
1122 exstyleReal
|= exstyle
;
1124 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1126 // we must call SetWindowPos() to flash the cached extended style and
1127 // also to make the change to wxSTAY_ON_TOP style take effect: just
1128 // setting the style simply doesn't work
1129 if ( !::SetWindowPos(GetHwnd(),
1130 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1133 SWP_NOMOVE
| SWP_NOSIZE
) )
1135 wxLogLastError(_T("SetWindowPos"));
1140 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1142 // translate common wxWidgets styles to Windows ones
1144 // most of windows are child ones, those which are not (such as
1145 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1146 WXDWORD style
= WS_CHILD
;
1148 if ( flags
& wxCLIP_CHILDREN
)
1149 style
|= WS_CLIPCHILDREN
;
1151 if ( flags
& wxCLIP_SIBLINGS
)
1152 style
|= WS_CLIPSIBLINGS
;
1154 if ( flags
& wxVSCROLL
)
1155 style
|= WS_VSCROLL
;
1157 if ( flags
& wxHSCROLL
)
1158 style
|= WS_HSCROLL
;
1160 const wxBorder border
= GetBorder(flags
);
1162 // WS_BORDER is only required for wxBORDER_SIMPLE
1163 if ( border
== wxBORDER_SIMPLE
)
1166 // now deal with ext style if the caller wants it
1172 if ( flags
& wxTRANSPARENT_WINDOW
)
1173 *exstyle
|= WS_EX_TRANSPARENT
;
1179 case wxBORDER_DEFAULT
:
1180 wxFAIL_MSG( _T("unknown border style") );
1184 case wxBORDER_SIMPLE
:
1187 case wxBORDER_STATIC
:
1188 *exstyle
|= WS_EX_STATICEDGE
;
1191 case wxBORDER_RAISED
:
1192 *exstyle
|= WS_EX_DLGMODALFRAME
;
1195 case wxBORDER_SUNKEN
:
1196 *exstyle
|= WS_EX_CLIENTEDGE
;
1197 style
&= ~WS_BORDER
;
1200 case wxBORDER_DOUBLE
:
1201 *exstyle
|= WS_EX_DLGMODALFRAME
;
1205 // wxUniv doesn't use Windows dialog navigation functions at all
1206 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1207 // to make the dialog navigation work with the nested panels we must
1208 // use this style (top level windows such as dialogs don't need it)
1209 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1211 *exstyle
|= WS_EX_CONTROLPARENT
;
1213 #endif // __WXUNIVERSAL__
1219 // Setup background and foreground colours correctly
1220 void wxWindowMSW::SetupColours()
1223 SetBackgroundColour(GetParent()->GetBackgroundColour());
1226 bool wxWindowMSW::IsMouseInWindow() const
1228 // get the mouse position
1230 ::GetCursorPos(&pt
);
1232 // find the window which currently has the cursor and go up the window
1233 // chain until we find this window - or exhaust it
1234 HWND hwnd
= ::WindowFromPoint(pt
);
1235 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1236 hwnd
= ::GetParent(hwnd
);
1238 return hwnd
!= NULL
;
1241 void wxWindowMSW::OnInternalIdle()
1243 // Check if we need to send a LEAVE event
1244 if ( m_mouseInWindow
)
1246 // note that we should generate the leave event whether the window has
1247 // or doesn't have mouse capture
1248 if ( !IsMouseInWindow() )
1250 // Generate a LEAVE event
1251 m_mouseInWindow
= false;
1253 // Unfortunately the mouse button and keyboard state may have
1254 // changed by the time the OnInternalIdle function is called, so 'state'
1255 // may be meaningless.
1257 if ( wxIsShiftDown() )
1259 if ( wxIsCtrlDown() )
1260 state
|= MK_CONTROL
;
1261 if ( GetKeyState( VK_LBUTTON
) )
1262 state
|= MK_LBUTTON
;
1263 if ( GetKeyState( VK_MBUTTON
) )
1264 state
|= MK_MBUTTON
;
1265 if ( GetKeyState( VK_RBUTTON
) )
1266 state
|= MK_RBUTTON
;
1269 if ( !::GetCursorPos(&pt
) )
1271 wxLogLastError(_T("GetCursorPos"));
1274 // we need to have client coordinates here for symmetry with
1275 // wxEVT_ENTER_WINDOW
1276 RECT rect
= wxGetWindowRect(GetHwnd());
1280 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1281 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1283 (void)GetEventHandler()->ProcessEvent(event2
);
1287 if (wxUpdateUIEvent::CanUpdate(this))
1288 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1291 // Set this window to be the child of 'parent'.
1292 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1294 if ( !wxWindowBase::Reparent(parent
) )
1297 HWND hWndChild
= GetHwnd();
1298 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1300 ::SetParent(hWndChild
, hWndParent
);
1303 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1305 EnsureParentHasControlParentStyle(GetParent());
1307 #endif // !__WXWINCE__
1312 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1314 #ifndef __WXMICROWIN__
1315 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1319 void wxWindowMSW::Freeze()
1321 if ( !m_frozenness
++ )
1323 SendSetRedraw(GetHwnd(), false);
1327 void wxWindowMSW::Thaw()
1329 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1331 if ( !--m_frozenness
)
1333 SendSetRedraw(GetHwnd(), true);
1335 // we need to refresh everything or otherwise he invalidated area is not
1341 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1343 HWND hWnd
= GetHwnd();
1349 mswRect
.left
= rect
->x
;
1350 mswRect
.top
= rect
->y
;
1351 mswRect
.right
= rect
->x
+ rect
->width
;
1352 mswRect
.bottom
= rect
->y
+ rect
->height
;
1354 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1357 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1361 void wxWindowMSW::Update()
1363 if ( !::UpdateWindow(GetHwnd()) )
1365 wxLogLastError(_T("UpdateWindow"));
1368 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1369 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1370 // handler needs to be really drawn right now
1375 // ---------------------------------------------------------------------------
1377 // ---------------------------------------------------------------------------
1380 #if wxUSE_DRAG_AND_DROP
1381 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1383 if ( m_dropTarget
!= 0 ) {
1384 m_dropTarget
->Revoke(m_hWnd
);
1385 delete m_dropTarget
;
1388 m_dropTarget
= pDropTarget
;
1389 if ( m_dropTarget
!= 0 )
1390 m_dropTarget
->Register(m_hWnd
);
1392 #endif // wxUSE_DRAG_AND_DROP
1394 // old style file-manager drag&drop support: we retain the old-style
1395 // DragAcceptFiles in parallel with SetDropTarget.
1396 void wxWindowMSW::DragAcceptFiles(bool accept
)
1398 #if !defined(__WXWINCE__)
1399 HWND hWnd
= GetHwnd();
1401 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1403 wxUnusedVar(accept
);
1407 // ----------------------------------------------------------------------------
1409 // ----------------------------------------------------------------------------
1413 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1415 wxWindowBase::DoSetToolTip(tooltip
);
1418 m_tooltip
->SetWindow((wxWindow
*)this);
1421 #endif // wxUSE_TOOLTIPS
1423 // ---------------------------------------------------------------------------
1424 // moving and resizing
1425 // ---------------------------------------------------------------------------
1428 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1430 RECT rect
= wxGetWindowRect(GetHwnd());
1433 *x
= rect
.right
- rect
.left
;
1435 *y
= rect
.bottom
- rect
.top
;
1438 // Get size *available for subwindows* i.e. excluding menu bar etc.
1439 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1441 RECT rect
= wxGetClientRect(GetHwnd());
1449 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1451 RECT rect
= wxGetWindowRect(GetHwnd());
1454 point
.x
= rect
.left
;
1457 // we do the adjustments with respect to the parent only for the "real"
1458 // children, not for the dialogs/frames
1459 if ( !IsTopLevel() )
1461 HWND hParentWnd
= 0;
1462 wxWindow
*parent
= GetParent();
1464 hParentWnd
= GetWinHwnd(parent
);
1466 // Since we now have the absolute screen coords, if there's a parent we
1467 // must subtract its top left corner
1470 ::ScreenToClient(hParentWnd
, &point
);
1475 // We may be faking the client origin. So a window that's really at (0,
1476 // 30) may appear (to wxWin apps) to be at (0, 0).
1477 wxPoint
pt(parent
->GetClientAreaOrigin());
1489 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1497 ::ScreenToClient(GetHwnd(), &pt
);
1505 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1513 ::ClientToScreen(GetHwnd(), &pt
);
1521 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1523 // TODO: is this consistent with other platforms?
1524 // Still, negative width or height shouldn't be allowed
1529 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, IsShown() /*Repaint?*/) )
1531 wxLogLastError(wxT("MoveWindow"));
1535 // set the size of the window: if the dimensions are positive, just use them,
1536 // but if any of them is equal to -1, it means that we must find the value for
1537 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1538 // which case -1 is a valid value for x and y)
1540 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1541 // the width/height to best suit our contents, otherwise we reuse the current
1543 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1545 // get the current size and position...
1546 int currentX
, currentY
;
1547 GetPosition(¤tX
, ¤tY
);
1548 int currentW
,currentH
;
1549 GetSize(¤tW
, ¤tH
);
1551 // ... and don't do anything (avoiding flicker) if it's already ok
1552 if ( x
== currentX
&& y
== currentY
&&
1553 width
== currentW
&& height
== currentH
)
1558 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1560 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1563 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1565 wxSize size
= wxDefaultSize
;
1566 if ( width
== wxDefaultCoord
)
1568 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1570 size
= DoGetBestSize();
1575 // just take the current one
1580 if ( height
== wxDefaultCoord
)
1582 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1584 if ( size
.x
== wxDefaultCoord
)
1586 size
= DoGetBestSize();
1588 //else: already called DoGetBestSize() above
1594 // just take the current one
1599 DoMoveWindow(x
, y
, width
, height
);
1602 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1604 // setting the client size is less obvious than it it could have been
1605 // because in the result of changing the total size the window scrollbar
1606 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1607 // will not be correct as the difference between the total and client size
1608 // changes - so we keep changing it until we get it right
1610 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1611 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1612 // may become 3 if the window had 0 size originally and so we didn't
1613 // calculate the scrollbar correction correctly during the first iteration)
1614 // but just to be on the safe side we check for it instead of making it an
1615 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1616 for ( int i
= 0; i
< 4; i
++ )
1619 ::GetClientRect(GetHwnd(), &rectClient
);
1621 // if the size is already ok, stop here (rectClient.left = top = 0)
1622 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1623 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1628 int widthClient
= width
,
1629 heightClient
= height
;
1631 // Find the difference between the entire window (title bar and all)
1632 // and the client area; add this to the new client size to move the
1635 ::GetWindowRect(GetHwnd(), &rectWin
);
1637 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1638 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1641 point
.x
= rectWin
.left
;
1642 point
.y
= rectWin
.top
;
1644 // MoveWindow positions the child windows relative to the parent, so
1645 // adjust if necessary
1646 if ( !IsTopLevel() )
1648 wxWindow
*parent
= GetParent();
1651 ::ScreenToClient(GetHwndOf(parent
), &point
);
1655 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1659 // For implementation purposes - sometimes decorations make the client area
1661 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1663 return wxPoint(0, 0);
1666 // ---------------------------------------------------------------------------
1668 // ---------------------------------------------------------------------------
1670 int wxWindowMSW::GetCharHeight() const
1672 return wxGetTextMetrics(this).tmHeight
;
1675 int wxWindowMSW::GetCharWidth() const
1677 // +1 is needed because Windows apparently adds it when calculating the
1678 // dialog units size in pixels
1679 #if wxDIALOG_UNIT_COMPATIBILITY
1680 return wxGetTextMetrics(this).tmAveCharWidth
;
1682 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1686 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1688 int *descent
, int *externalLeading
,
1689 const wxFont
*theFont
) const
1691 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1692 _T("invalid font in GetTextExtent()") );
1696 fontToUse
= *theFont
;
1698 fontToUse
= GetFont();
1700 WindowHDC
hdc(GetHwnd());
1701 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1705 GetTextExtentPoint(hdc
, string
, string
.length(), &sizeRect
);
1706 GetTextMetrics(hdc
, &tm
);
1713 *descent
= tm
.tmDescent
;
1714 if ( externalLeading
)
1715 *externalLeading
= tm
.tmExternalLeading
;
1718 // ---------------------------------------------------------------------------
1720 // ---------------------------------------------------------------------------
1722 #if wxUSE_MENUS_NATIVE
1724 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1725 // immediately, without waiting for the next event loop iteration
1727 // NB: this function should probably be made public later as it can almost
1728 // surely replace wxYield() elsewhere as well
1729 static void wxYieldForCommandsOnly()
1731 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1732 // want to process it here)
1734 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1736 if ( msg
.message
== WM_QUIT
)
1738 // if we retrieved a WM_QUIT, insert back into the message queue.
1739 ::PostQuitMessage(0);
1743 // luckily (as we don't have access to wxEventLoopImpl method from here
1744 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1746 ::TranslateMessage(&msg
);
1747 ::DispatchMessage(&msg
);
1751 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1753 menu
->SetInvokingWindow(this);
1756 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1758 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1759 x
= mouse
.x
; y
= mouse
.y
;
1762 HWND hWnd
= GetHwnd();
1763 HMENU hMenu
= GetHmenuOf(menu
);
1767 ::ClientToScreen(hWnd
, &point
);
1768 wxCurrentPopupMenu
= menu
;
1769 #if defined(__WXWINCE__)
1772 UINT flags
= TPM_RIGHTBUTTON
;
1774 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1776 // we need to do it righ now as otherwise the events are never going to be
1777 // sent to wxCurrentPopupMenu from HandleCommand()
1779 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1780 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1781 // destroyed as soon as we return (it can be a local variable in the caller
1782 // for example) and so we do need to process the event immediately
1783 wxYieldForCommandsOnly();
1785 wxCurrentPopupMenu
= NULL
;
1787 menu
->SetInvokingWindow(NULL
);
1792 #endif // wxUSE_MENUS_NATIVE
1794 // ===========================================================================
1795 // pre/post message processing
1796 // ===========================================================================
1798 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1801 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1803 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1806 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1808 // wxUniversal implements tab traversal itself
1809 #ifndef __WXUNIVERSAL__
1810 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1812 // intercept dialog navigation keys
1813 MSG
*msg
= (MSG
*)pMsg
;
1815 // 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 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
1975 // message even when there is no cancel button and when the message is
1976 // needed by the control itself: in particular, it prevents the tree in
1977 // place edit control from being closed with Escape in a dialog
1978 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
1980 // ::IsDialogMessage() is broken and may sometimes hang the
1981 // application by going into an infinite loop, so we try to detect
1982 // [some of] the situatations when this may happen and not call it
1985 // assume we can call it by default
1986 bool canSafelyCallIsDlgMsg
= true;
1988 HWND hwndFocus
= ::GetFocus();
1990 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
1991 // an infinite loop, because it will recursively check the child
1992 // windows but not the window itself and so if none of the children
1993 // accepts focus it loops forever (as it only stops when it gets
1994 // back to the window it started from)
1996 // while it is very unusual that a window with WS_EX_CONTROLPARENT
1997 // style has the focus, it can happen. One such possibility is if
1998 // all windows are either toplevel, wxDialog, wxPanel or static
1999 // controls and no window can actually accept keyboard input.
2000 #if !defined(__WXWINCE__)
2001 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2003 // passimistic by default
2004 canSafelyCallIsDlgMsg
= false;
2005 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2007 node
= node
->GetNext() )
2009 wxWindow
* const win
= node
->GetData();
2010 if ( win
->AcceptsFocus() &&
2011 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2012 WS_EX_CONTROLPARENT
) )
2014 // it shouldn't hang...
2015 canSafelyCallIsDlgMsg
= true;
2021 #endif // !__WXWINCE__
2023 if ( canSafelyCallIsDlgMsg
)
2025 // ::IsDialogMessage() can enter in an infinite loop when the
2026 // currently focused window is disabled or hidden and its
2027 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2031 if ( !::IsWindowEnabled(hwndFocus
) ||
2032 !::IsWindowVisible(hwndFocus
) )
2034 // it would enter an infinite loop if we do this!
2035 canSafelyCallIsDlgMsg
= false;
2040 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2042 // it's a top level window, don't go further -- e.g. even
2043 // if the parent of a dialog is disabled, this doesn't
2044 // break navigation inside the dialog
2048 hwndFocus
= ::GetParent(hwndFocus
);
2052 // let IsDialogMessage() have the message if it's safe to call it
2053 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2055 // IsDialogMessage() did something...
2060 #endif // __WXUNIVERSAL__
2065 // relay mouse move events to the tooltip control
2066 MSG
*msg
= (MSG
*)pMsg
;
2067 if ( msg
->message
== WM_MOUSEMOVE
)
2068 m_tooltip
->RelayEvent(pMsg
);
2070 #endif // wxUSE_TOOLTIPS
2075 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2077 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2078 return m_acceleratorTable
.Translate(this, pMsg
);
2082 #endif // wxUSE_ACCEL
2085 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2087 // preprocess all messages by default
2091 // ---------------------------------------------------------------------------
2092 // message params unpackers
2093 // ---------------------------------------------------------------------------
2095 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2096 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2098 *id
= LOWORD(wParam
);
2099 *hwnd
= (WXHWND
)lParam
;
2100 *cmd
= HIWORD(wParam
);
2103 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2104 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2106 *state
= LOWORD(wParam
);
2107 *minimized
= HIWORD(wParam
);
2108 *hwnd
= (WXHWND
)lParam
;
2111 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2112 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2114 *code
= LOWORD(wParam
);
2115 *pos
= HIWORD(wParam
);
2116 *hwnd
= (WXHWND
)lParam
;
2119 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2120 WXHDC
*hdc
, WXHWND
*hwnd
)
2122 *hwnd
= (WXHWND
)lParam
;
2123 *hdc
= (WXHDC
)wParam
;
2126 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2127 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2129 *item
= (WXWORD
)wParam
;
2130 *flags
= HIWORD(wParam
);
2131 *hmenu
= (WXHMENU
)lParam
;
2134 // ---------------------------------------------------------------------------
2135 // Main wxWidgets window proc and the window proc for wxWindow
2136 // ---------------------------------------------------------------------------
2138 // Hook for new window just as it's being created, when the window isn't yet
2139 // associated with the handle
2140 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2142 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2143 // window being created and insures that it's always unset back later
2144 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2146 gs_winBeingCreated
= winBeingCreated
;
2149 wxWindowCreationHook::~wxWindowCreationHook()
2151 gs_winBeingCreated
= NULL
;
2155 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2157 // trace all messages - useful for the debugging
2159 wxLogTrace(wxTraceMessages
,
2160 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2161 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2162 #endif // __WXDEBUG__
2164 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2166 // when we get the first message for the HWND we just created, we associate
2167 // it with wxWindow stored in gs_winBeingCreated
2168 if ( !wnd
&& gs_winBeingCreated
)
2170 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2171 wnd
= gs_winBeingCreated
;
2172 gs_winBeingCreated
= NULL
;
2173 wnd
->SetHWND((WXHWND
)hWnd
);
2179 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2181 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2186 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2188 // did we process the message?
2189 bool processed
= false;
2200 // for most messages we should return 0 when we do process the message
2208 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2211 // return 0 to allow window creation
2212 rc
.result
= mayCreate
? 0 : -1;
2218 // never set processed to true and *always* pass WM_DESTROY to
2219 // DefWindowProc() as Windows may do some internal cleanup when
2220 // processing it and failing to pass the message along may cause
2221 // memory and resource leaks!
2222 (void)HandleDestroy();
2226 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2229 #if !defined(__WXWINCE__)
2232 LPRECT pRect
= (LPRECT
)lParam
;
2234 rc
.SetLeft(pRect
->left
);
2235 rc
.SetTop(pRect
->top
);
2236 rc
.SetRight(pRect
->right
);
2237 rc
.SetBottom(pRect
->bottom
);
2238 processed
= HandleMoving(rc
);
2240 pRect
->left
= rc
.GetLeft();
2241 pRect
->top
= rc
.GetTop();
2242 pRect
->right
= rc
.GetRight();
2243 pRect
->bottom
= rc
.GetBottom();
2250 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2253 #if !defined(__WXWINCE__)
2256 LPRECT pRect
= (LPRECT
)lParam
;
2258 rc
.SetLeft(pRect
->left
);
2259 rc
.SetTop(pRect
->top
);
2260 rc
.SetRight(pRect
->right
);
2261 rc
.SetBottom(pRect
->bottom
);
2262 processed
= HandleSizing(rc
);
2264 pRect
->left
= rc
.GetLeft();
2265 pRect
->top
= rc
.GetTop();
2266 pRect
->right
= rc
.GetRight();
2267 pRect
->bottom
= rc
.GetBottom();
2273 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2274 case WM_ACTIVATEAPP
:
2275 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2281 WXWORD state
, minimized
;
2283 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2285 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2290 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2294 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2301 // cast to wxWindow is needed for wxUniv
2302 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2303 processed
= HandlePaint();
2307 processed
= HandlePaint();
2316 // Don't call the wx handlers in this case
2317 if ( wxIsKindOf(this, wxListCtrl
) )
2321 if ( lParam
& PRF_ERASEBKGND
)
2322 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2324 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2325 processed
= HandlePaint();
2331 #ifdef __WXUNIVERSAL__
2332 // Universal uses its own wxFrame/wxDialog, so we don't receive
2333 // close events unless we have this.
2338 // don't let the DefWindowProc() destroy our window - we'll do it
2339 // ourselves in ~wxWindow
2346 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2350 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2351 GET_Y_LPARAM(lParam
),
2355 // Seems to be broken currently
2356 #if 0 // ndef __WXWINCE__
2359 wxASSERT_MSG( !m_mouseInWindow
, wxT("the mouse should be in a window to generate this event!") );
2361 // only process this message if the mouse is not in the window,
2362 // This can also check for children in composite windows.
2363 // however, this may mean the the wxEVT_LEAVE_WINDOW is never sent
2364 // if the mouse does not enter the window from it's child before
2365 // leaving the scope of the window. ( perhaps this can be picked
2366 // up in the OnIdle code as before, for this special case )
2367 if ( /*IsComposite() && */ !IsMouseInWindow() )
2369 m_mouseInWindow
= false;
2371 // Unfortunately no mouse state is passed with a WM_MOUSE_LEAVE
2373 if ( wxIsShiftDown() )
2375 if ( wxIsCtrlDown() )
2376 state
|= MK_CONTROL
;
2377 if ( GetKeyState( VK_LBUTTON
) )
2378 state
|= MK_LBUTTON
;
2379 if ( GetKeyState( VK_MBUTTON
) )
2380 state
|= MK_MBUTTON
;
2381 if ( GetKeyState( VK_RBUTTON
) )
2382 state
|= MK_RBUTTON
;
2385 if ( !::GetCursorPos(&pt
) )
2387 wxLogLastError(_T("GetCursorPos"));
2390 // we need to have client coordinates here for symmetry with
2391 // wxEVT_ENTER_WINDOW
2392 RECT rect
= wxGetWindowRect(GetHwnd());
2396 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
2397 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
2399 (void)GetEventHandler()->ProcessEvent(event2
);
2401 // always pass processed back as false, this allows the window
2402 // manager to process the message too. This is needed to ensure
2403 // windows XP themes work properly as the mouse moves over widgets
2411 #if wxUSE_MOUSEWHEEL
2413 processed
= HandleMouseWheel(wParam
, lParam
);
2417 case WM_LBUTTONDOWN
:
2419 case WM_LBUTTONDBLCLK
:
2420 case WM_RBUTTONDOWN
:
2422 case WM_RBUTTONDBLCLK
:
2423 case WM_MBUTTONDOWN
:
2425 case WM_MBUTTONDBLCLK
:
2427 #ifdef __WXMICROWIN__
2428 // MicroWindows seems to ignore the fact that a window is
2429 // disabled. So catch mouse events and throw them away if
2431 wxWindowMSW
* win
= this;
2434 if (!win
->IsEnabled())
2440 win
= win
->GetParent();
2441 if ( !win
|| win
->IsTopLevel() )
2448 #endif // __WXMICROWIN__
2449 int x
= GET_X_LPARAM(lParam
),
2450 y
= GET_Y_LPARAM(lParam
);
2452 // redirect the event to a static control if necessary by
2453 // finding one under mouse
2455 if ( GetCapture() == this )
2457 // but don't do it if the mouse is captured by this window
2458 // because then it should really get this event itself
2463 win
= FindWindowForMouseEvent(this, &x
, &y
);
2465 // this should never happen
2466 wxCHECK_MSG( win
, 0,
2467 _T("FindWindowForMouseEvent() returned NULL") );
2470 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2472 // if the app didn't eat the event, handle it in the default
2473 // way, that is by giving this window the focus
2476 // for the standard classes their WndProc sets the focus to
2477 // them anyhow and doing it from here results in some weird
2478 // problems, so don't do it for them (unnecessary anyhow)
2479 if ( !win
->IsOfStandardClass() )
2481 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2493 case MM_JOY1BUTTONDOWN
:
2494 case MM_JOY2BUTTONDOWN
:
2495 case MM_JOY1BUTTONUP
:
2496 case MM_JOY2BUTTONUP
:
2497 processed
= HandleJoystickEvent(message
,
2498 GET_X_LPARAM(lParam
),
2499 GET_Y_LPARAM(lParam
),
2502 #endif // __WXMICROWIN__
2508 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2510 processed
= HandleCommand(id
, cmd
, hwnd
);
2515 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2518 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2519 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2520 // apparently doesn't always behave properly and needs some help
2521 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2522 case WM_NOTIFYFORMAT
:
2523 if ( lParam
== NF_QUERY
)
2526 rc
.result
= NFR_UNICODE
;
2529 #endif // wxUSE_UNICODE_MSLU
2531 // for these messages we must return true if process the message
2534 case WM_MEASUREITEM
:
2536 int idCtrl
= (UINT
)wParam
;
2537 if ( message
== WM_DRAWITEM
)
2539 processed
= MSWOnDrawItem(idCtrl
,
2540 (WXDRAWITEMSTRUCT
*)lParam
);
2544 processed
= MSWOnMeasureItem(idCtrl
,
2545 (WXMEASUREITEMSTRUCT
*)lParam
);
2552 #endif // defined(WM_DRAWITEM)
2555 if ( !IsOfStandardClass() )
2557 // we always want to get the char events
2558 rc
.result
= DLGC_WANTCHARS
;
2560 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2562 // in fact, we want everything
2563 rc
.result
|= DLGC_WANTARROWS
|
2570 //else: get the dlg code from the DefWindowProc()
2575 // If this has been processed by an event handler, return 0 now
2576 // (we've handled it).
2577 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2578 if ( m_lastKeydownProcessed
)
2587 // we consider these message "not interesting" to OnChar, so
2588 // just don't do anything more with them
2598 // avoid duplicate messages to OnChar for these ASCII keys:
2599 // they will be translated by TranslateMessage() and received
2621 // but set processed to false, not true to still pass them
2622 // to the control's default window proc - otherwise
2623 // built-in keyboard handling won't work
2628 // special case of VK_APPS: treat it the same as right mouse
2629 // click because both usually pop up a context menu
2631 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2636 // do generate a CHAR event
2637 processed
= HandleChar((WORD
)wParam
, lParam
);
2640 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2647 // special case of VK_APPS: treat it the same as right mouse button
2648 if ( wParam
== VK_APPS
)
2650 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2655 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2660 case WM_CHAR
: // Always an ASCII character
2661 if ( m_lastKeydownProcessed
)
2663 // The key was handled in the EVT_KEY_DOWN and handling
2664 // a key in an EVT_KEY_DOWN handler is meant, by
2665 // design, to prevent EVT_CHARs from happening
2666 m_lastKeydownProcessed
= false;
2671 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2677 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2679 #endif // wxUSE_HOTKEY
2686 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2688 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2694 // CTLCOLOR messages are sent by children to query the parent for their
2696 #ifndef __WXMICROWIN__
2697 case WM_CTLCOLORMSGBOX
:
2698 case WM_CTLCOLOREDIT
:
2699 case WM_CTLCOLORLISTBOX
:
2700 case WM_CTLCOLORBTN
:
2701 case WM_CTLCOLORDLG
:
2702 case WM_CTLCOLORSCROLLBAR
:
2703 case WM_CTLCOLORSTATIC
:
2707 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2709 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2712 #endif // !__WXMICROWIN__
2714 case WM_SYSCOLORCHANGE
:
2715 // the return value for this message is ignored
2716 processed
= HandleSysColorChange();
2719 #if !defined(__WXWINCE__)
2720 case WM_DISPLAYCHANGE
:
2721 processed
= HandleDisplayChange();
2725 case WM_PALETTECHANGED
:
2726 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2729 case WM_CAPTURECHANGED
:
2730 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2733 case WM_QUERYNEWPALETTE
:
2734 processed
= HandleQueryNewPalette();
2738 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2741 // we processed the message, i.e. erased the background
2746 #if !defined(__WXWINCE__)
2748 processed
= HandleDropFiles(wParam
);
2753 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2757 // we never set focus from here
2762 #if !defined(__WXWINCE__)
2763 case WM_QUERYENDSESSION
:
2764 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2768 processed
= HandleEndSession(wParam
!= 0, lParam
);
2771 case WM_GETMINMAXINFO
:
2772 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2777 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2778 LOWORD(lParam
), // hit test
2779 HIWORD(lParam
)); // mouse msg
2783 // returning TRUE stops the DefWindowProc() from further
2784 // processing this message - exactly what we need because we've
2785 // just set the cursor.
2790 #if wxUSE_ACCESSIBILITY
2793 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2794 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2796 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2798 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2804 #if defined(WM_HELP)
2807 // HELPINFO doesn't seem to be supported on WinCE.
2809 HELPINFO
* info
= (HELPINFO
*) lParam
;
2810 // Don't yet process menu help events, just windows
2811 if (info
->iContextType
== HELPINFO_WINDOW
)
2814 wxWindowMSW
* subjectOfHelp
= this;
2815 bool eventProcessed
= false;
2816 while (subjectOfHelp
&& !eventProcessed
)
2818 wxHelpEvent
helpEvent(wxEVT_HELP
,
2819 subjectOfHelp
->GetId(),
2823 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2827 helpEvent
.SetEventObject(this);
2829 GetEventHandler()->ProcessEvent(helpEvent
);
2831 // Go up the window hierarchy until the event is
2833 subjectOfHelp
= subjectOfHelp
->GetParent();
2836 processed
= eventProcessed
;
2839 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2841 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2842 helpEvent
.SetEventObject(this);
2843 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2846 //else: processed is already false
2852 #if !defined(__WXWINCE__)
2853 case WM_CONTEXTMENU
:
2855 // we don't convert from screen to client coordinates as
2856 // the event may be handled by a parent window
2857 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2859 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2861 // we could have got an event from our child, reflect it back
2862 // to it if this is the case
2863 wxWindowMSW
*win
= NULL
;
2864 if ( (WXHWND
)wParam
!= m_hWnd
)
2866 win
= FindItemByHWND((WXHWND
)wParam
);
2872 evtCtx
.SetEventObject(win
);
2873 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
2879 // we're only interested in our own menus, not MF_SYSMENU
2880 if ( HIWORD(wParam
) == MF_POPUP
)
2882 // handle menu chars for ownerdrawn menu items
2883 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2884 if ( i
!= wxNOT_FOUND
)
2886 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2896 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2897 wxGetMessageName(message
));
2898 #endif // __WXDEBUG__
2899 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2905 // ----------------------------------------------------------------------------
2906 // wxWindow <-> HWND map
2907 // ----------------------------------------------------------------------------
2909 wxWinHashTable
*wxWinHandleHash
= NULL
;
2911 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2913 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
2916 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2918 // adding NULL hWnd is (first) surely a result of an error and
2919 // (secondly) breaks menu command processing
2920 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2921 wxT("attempt to add a NULL hWnd to window list ignored") );
2923 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2925 if ( oldWin
&& (oldWin
!= win
) )
2927 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2928 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2931 #endif // __WXDEBUG__
2934 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2938 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2940 wxWinHandleHash
->Delete((long)win
->GetHWND());
2943 // ----------------------------------------------------------------------------
2944 // various MSW speciic class dependent functions
2945 // ----------------------------------------------------------------------------
2947 // Default destroyer - override if you destroy it in some other way
2948 // (e.g. with MDI child windows)
2949 void wxWindowMSW::MSWDestroyWindow()
2953 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2956 int& w
, int& h
) const
2958 // yes, those are just some arbitrary hardcoded numbers
2959 static const int DEFAULT_Y
= 200;
2961 bool nonDefault
= false;
2963 if ( pos
.x
== wxDefaultCoord
)
2965 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
2966 // can just as well set it to CW_USEDEFAULT as well
2972 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2973 // neither because it is not handled as a special value by Windows then
2974 // and so we have to choose some default value for it
2976 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
2982 NB: there used to be some code here which set the initial size of the
2983 window to the client size of the parent if no explicit size was
2984 specified. This was wrong because wxWidgets programs often assume
2985 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2986 it. To see why, you should understand that Windows sends WM_SIZE from
2987 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2988 from some base class ctor and so this WM_SIZE is not processed in the
2989 real class' OnSize() (because it's not fully constructed yet and the
2990 event goes to some base class OnSize() instead). So the WM_SIZE we
2991 rely on is the one sent when the parent frame resizes its children
2992 but here is the problem: if the child already has just the right
2993 size, nothing will happen as both wxWidgets and Windows check for
2994 this and ignore any attempts to change the window size to the size it
2995 already has - so no WM_SIZE would be sent.
2999 // we don't use CW_USEDEFAULT here for several reasons:
3001 // 1. it results in huge frames on modern screens (1000*800 is not
3002 // uncommon on my 1280*1024 screen) which is way too big for a half
3003 // empty frame of most of wxWidgets samples for example)
3005 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3006 // the default is for whatever reason 8*8 which breaks client <->
3007 // window size calculations (it would be nice if it didn't, but it
3008 // does and the simplest way to fix it seemed to change the broken
3009 // default size anyhow)
3011 // 3. there is just no advantage in doing it: with x and y it is
3012 // possible that [future versions of] Windows position the new top
3013 // level window in some smart way which we can't do, but we can
3014 // guess a reasonably good size for a new window just as well
3017 // However, on PocketPC devices, we must use the default
3018 // size if possible.
3020 if (size
.x
== wxDefaultCoord
)
3024 if (size
.y
== wxDefaultCoord
)
3029 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3033 w
= WidthDefault(size
.x
);
3034 h
= HeightDefault(size
.y
);
3037 AdjustForParentClientOrigin(x
, y
);
3042 WXHWND
wxWindowMSW::MSWGetParent() const
3044 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3047 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3048 const wxChar
*title
,
3052 WXDWORD extendedStyle
)
3054 // choose the position/size for the new window
3056 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3058 // controlId is menu handle for the top level windows, so set it to 0
3059 // unless we're creating a child window
3060 int controlId
= style
& WS_CHILD
? GetId() : 0;
3062 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3063 // which is the same but without CS_[HV]REDRAW class styles so using it
3064 // ensures that the window is not fully repainted on each resize
3065 wxString
className(wclass
);
3066 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3068 className
+= wxT("NR");
3071 // do create the window
3072 wxWindowCreationHook
hook(this);
3074 // VZ: anyone care to explain why this is done for CE?
3076 if (extendedStyle
== 0)
3078 m_hWnd
= (WXHWND
)::CreateWindow
3081 title
? title
: wxEmptyString
,
3084 (HWND
)MSWGetParent(),
3087 NULL
// no extra data
3091 #endif // __WXWINCE__
3093 m_hWnd
= (WXHWND
)::CreateWindowEx
3097 title
? title
: wxEmptyString
,
3100 (HWND
)MSWGetParent(),
3103 NULL
// no extra data
3109 wxLogSysError(_("Can't create window of class %s"), wclass
);
3114 SubclassWin(m_hWnd
);
3119 // ===========================================================================
3120 // MSW message handlers
3121 // ===========================================================================
3123 // ---------------------------------------------------------------------------
3125 // ---------------------------------------------------------------------------
3129 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3131 #ifndef __WXMICROWIN__
3132 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3133 HWND hWnd
= hdr
->hwndFrom
;
3134 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3136 // if the control is one of our windows, let it handle the message itself
3139 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3142 // VZ: why did we do it? normally this is unnecessary and, besides, it
3143 // breaks the message processing for the toolbars because the tooltip
3144 // notifications were being forwarded to the toolbar child controls
3145 // (if it had any) before being passed to the toolbar itself, so in my
3146 // example the tooltip for the combobox was always shown instead of the
3147 // correct button tooltips
3149 // try all our children
3150 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3153 wxWindow
*child
= node
->GetData();
3154 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3159 node
= node
->GetNext();
3163 // by default, handle it ourselves
3164 return MSWOnNotify(idCtrl
, lParam
, result
);
3165 #else // __WXMICROWIN__
3172 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3174 const wxString
& ttip
)
3176 // I don't know why it happens, but the versions of comctl32.dll starting
3177 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3178 // this message is supposed to be sent to Unicode programs only) -- hence
3179 // we need to handle it as well, otherwise no tooltips will be shown in
3182 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3185 // not a tooltip message or no tooltip to show anyhow
3190 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3192 // We don't want to use the szText buffer because it has a limit of 80
3193 // bytes and this is not enough, especially for Unicode build where it
3194 // limits the tooltip string length to only 40 characters
3196 // The best would be, of course, to not impose any length limitations at
3197 // all but then the buffer would have to be dynamic and someone would have
3198 // to free it and we don't have the tooltip owner object here any more, so
3199 // for now use our own static buffer with a higher fixed max length.
3201 // Note that using a static buffer should not be a problem as only a single
3202 // tooltip can be shown at the same time anyhow.
3204 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3206 // We need to convert tooltip from multi byte to Unicode on the fly.
3207 static wchar_t buf
[513];
3209 // Truncate tooltip length if needed as otherwise we might not have
3210 // enough space for it in the buffer and MultiByteToWideChar() would
3212 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3214 // Convert to WideChar without adding the NULL character. The NULL
3215 // character is added afterwards (this is more efficient).
3216 int len
= ::MultiByteToWideChar
3228 wxLogLastError(_T("MultiByteToWideChar()"));
3232 ttText
->lpszText
= (LPSTR
) buf
;
3234 else // TTN_NEEDTEXTA
3235 #endif // !wxUSE_UNICODE
3237 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3238 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3239 // to copy the string we have into the buffer
3240 static wxChar buf
[513];
3241 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3242 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3243 ttText
->lpszText
= buf
;
3249 #endif // wxUSE_TOOLTIPS
3251 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3253 WXLPARAM
* WXUNUSED(result
))
3258 NMHDR
* hdr
= (NMHDR
*)lParam
;
3259 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3266 wxUnusedVar(lParam
);
3267 #endif // wxUSE_TOOLTIPS
3274 // ---------------------------------------------------------------------------
3275 // end session messages
3276 // ---------------------------------------------------------------------------
3278 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3281 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3282 event
.SetEventObject(wxTheApp
);
3283 event
.SetCanVeto(true);
3284 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3286 bool rc
= wxTheApp
->ProcessEvent(event
);
3290 // we may end only if the app didn't veto session closing (double
3292 *mayEnd
= !event
.GetVeto();
3301 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3304 // do nothing if the session isn't ending
3309 if ( (this != wxTheApp
->GetTopWindow()) )
3312 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3313 event
.SetEventObject(wxTheApp
);
3314 event
.SetCanVeto(false);
3315 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3317 return wxTheApp
->ProcessEvent(event
);
3323 // ---------------------------------------------------------------------------
3324 // window creation/destruction
3325 // ---------------------------------------------------------------------------
3327 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3329 // VZ: why is this commented out for WinCE? If it doesn't support
3330 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3331 // not with multiple #ifdef's!
3333 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3334 EnsureParentHasControlParentStyle(GetParent());
3337 #endif // !__WXWINCE__
3339 // TODO: should generate this event from WM_NCCREATE
3340 wxWindowCreateEvent
event((wxWindow
*)this);
3341 (void)GetEventHandler()->ProcessEvent(event
);
3348 bool wxWindowMSW::HandleDestroy()
3352 // delete our drop target if we've got one
3353 #if wxUSE_DRAG_AND_DROP
3354 if ( m_dropTarget
!= NULL
)
3356 m_dropTarget
->Revoke(m_hWnd
);
3358 delete m_dropTarget
;
3359 m_dropTarget
= NULL
;
3361 #endif // wxUSE_DRAG_AND_DROP
3363 // WM_DESTROY handled
3367 // ---------------------------------------------------------------------------
3369 // ---------------------------------------------------------------------------
3371 bool wxWindowMSW::HandleActivate(int state
,
3372 bool WXUNUSED(minimized
),
3373 WXHWND
WXUNUSED(activate
))
3375 wxActivateEvent
event(wxEVT_ACTIVATE
,
3376 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3378 event
.SetEventObject(this);
3380 return GetEventHandler()->ProcessEvent(event
);
3383 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3385 // Strangly enough, some controls get set focus events when they are being
3386 // deleted, even if they already had focus before.
3387 if ( m_isBeingDeleted
)
3392 // notify the parent keeping track of focus for the kbd navigation
3393 // purposes that we got it
3394 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3395 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3401 m_caret
->OnSetFocus();
3403 #endif // wxUSE_CARET
3406 // If it's a wxTextCtrl don't send the event as it will be done
3407 // after the control gets to process it from EN_FOCUS handler
3408 if ( wxDynamicCastThis(wxTextCtrl
) )
3412 #endif // wxUSE_TEXTCTRL
3414 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3415 event
.SetEventObject(this);
3417 // wxFindWinFromHandle() may return NULL, it is ok
3418 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3420 return GetEventHandler()->ProcessEvent(event
);
3423 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3429 m_caret
->OnKillFocus();
3431 #endif // wxUSE_CARET
3434 // If it's a wxTextCtrl don't send the event as it will be done
3435 // after the control gets to process it.
3436 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3443 // Don't send the event when in the process of being deleted. This can
3444 // only cause problems if the event handler tries to access the object.
3445 if ( m_isBeingDeleted
)
3450 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3451 event
.SetEventObject(this);
3453 // wxFindWinFromHandle() may return NULL, it is ok
3454 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3456 return GetEventHandler()->ProcessEvent(event
);
3459 // ---------------------------------------------------------------------------
3461 // ---------------------------------------------------------------------------
3463 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3465 wxShowEvent
event(GetId(), show
);
3466 event
.m_eventObject
= this;
3468 return GetEventHandler()->ProcessEvent(event
);
3471 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3473 wxInitDialogEvent
event(GetId());
3474 event
.m_eventObject
= this;
3476 return GetEventHandler()->ProcessEvent(event
);
3479 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3481 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3482 wxUnusedVar(wParam
);
3484 #else // __WXMICROWIN__
3485 HDROP hFilesInfo
= (HDROP
) wParam
;
3487 // Get the total number of files dropped
3488 UINT gwFilesDropped
= ::DragQueryFile
3496 wxString
*files
= new wxString
[gwFilesDropped
];
3497 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3499 // first get the needed buffer length (+1 for terminating NUL)
3500 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3502 // and now get the file name
3503 ::DragQueryFile(hFilesInfo
, wIndex
,
3504 wxStringBuffer(files
[wIndex
], len
), len
);
3506 DragFinish (hFilesInfo
);
3508 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3509 event
.m_eventObject
= this;
3512 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3513 event
.m_pos
.x
= dropPoint
.x
;
3514 event
.m_pos
.y
= dropPoint
.y
;
3516 return GetEventHandler()->ProcessEvent(event
);
3521 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3523 int WXUNUSED(mouseMsg
))
3525 #ifndef __WXMICROWIN__
3526 // the logic is as follows:
3527 // -1. don't set cursor for non client area, including but not limited to
3528 // the title bar, scrollbars, &c
3529 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3530 // 1. if we have the cursor set it unless wxIsBusy()
3531 // 2. if we're a top level window, set some cursor anyhow
3532 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3534 if ( nHitTest
!= HTCLIENT
)
3539 HCURSOR hcursor
= 0;
3541 // first ask the user code - it may wish to set the cursor in some very
3542 // specific way (for example, depending on the current position)
3544 if ( !::GetCursorPos(&pt
) )
3546 wxLogLastError(wxT("GetCursorPos"));
3551 ScreenToClient(&x
, &y
);
3552 wxSetCursorEvent
event(x
, y
);
3554 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3555 if ( processedEvtSetCursor
&& event
.HasCursor() )
3557 hcursor
= GetHcursorOf(event
.GetCursor());
3562 bool isBusy
= wxIsBusy();
3564 // the test for processedEvtSetCursor is here to prevent using m_cursor
3565 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3566 // it - this is a way to say that our cursor shouldn't be used for this
3568 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3570 hcursor
= GetHcursorOf(m_cursor
);
3577 hcursor
= wxGetCurrentBusyCursor();
3579 else if ( !hcursor
)
3581 const wxCursor
*cursor
= wxGetGlobalCursor();
3582 if ( cursor
&& cursor
->Ok() )
3584 hcursor
= GetHcursorOf(*cursor
);
3592 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3594 ::SetCursor(hcursor
);
3596 // cursor set, stop here
3599 #endif // __WXMICROWIN__
3601 // pass up the window chain
3605 // ---------------------------------------------------------------------------
3606 // owner drawn stuff
3607 // ---------------------------------------------------------------------------
3609 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3610 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3611 #define WXUNUSED_UNLESS_ODRAWN(param) param
3613 #define WXUNUSED_UNLESS_ODRAWN(param)
3617 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3618 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3620 #if wxUSE_OWNER_DRAWN
3622 #if wxUSE_MENUS_NATIVE
3623 // is it a menu item?
3624 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3625 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3627 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3629 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3630 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3632 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3633 // the DC from being released
3634 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3635 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3636 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3637 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3639 return pMenuItem
->OnDrawItem
3643 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3644 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3647 #endif // wxUSE_MENUS_NATIVE
3649 #endif // USE_OWNER_DRAWN
3651 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3653 #if wxUSE_OWNER_DRAWN
3654 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3655 #else // !wxUSE_OWNER_DRAWN
3656 // we may still have owner-drawn buttons internally because we have to make
3657 // them owner-drawn to support colour change
3660 wxDynamicCast(FindItem(id
), wxButton
)
3665 #endif // USE_OWNER_DRAWN
3669 return item
->MSWOnDraw(itemStruct
);
3672 #endif // wxUSE_CONTROLS
3678 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3680 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3681 // is it a menu item?
3682 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3683 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3685 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3687 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3688 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3691 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3693 pMeasureStruct
->itemWidth
= w
;
3694 pMeasureStruct
->itemHeight
= h
;
3699 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3702 return item
->MSWOnMeasure(itemStruct
);
3706 wxUnusedVar(itemStruct
);
3707 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3712 // ---------------------------------------------------------------------------
3713 // colours and palettes
3714 // ---------------------------------------------------------------------------
3716 bool wxWindowMSW::HandleSysColorChange()
3718 wxSysColourChangedEvent event
;
3719 event
.SetEventObject(this);
3721 (void)GetEventHandler()->ProcessEvent(event
);
3723 // always let the system carry on the default processing to allow the
3724 // native controls to react to the colours update
3728 bool wxWindowMSW::HandleDisplayChange()
3730 wxDisplayChangedEvent event
;
3731 event
.SetEventObject(this);
3733 return GetEventHandler()->ProcessEvent(event
);
3736 #ifndef __WXMICROWIN__
3738 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC pDC
, WXHWND pWnd
)
3741 wxWindow
*item
= FindItemByHWND(pWnd
, true);
3743 *brush
= item
->MSWControlColor(pDC
);
3745 #endif // wxUSE_CONTROLS
3748 return *brush
!= NULL
;
3751 #endif // __WXMICROWIN__
3753 WXHBRUSH
wxWindowMSW::MSWControlColor(WXHDC
WXUNUSED(hDC
))
3758 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3761 // same as below except we don't respond to our own messages
3762 if ( hWndPalChange
!= GetHWND() )
3764 // check to see if we our our parents have a custom palette
3765 wxWindowMSW
*win
= this;
3766 while ( win
&& !win
->HasCustomPalette() )
3768 win
= win
->GetParent();
3771 if ( win
&& win
->HasCustomPalette() )
3773 // realize the palette to see whether redrawing is needed
3774 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3775 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3776 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3778 int result
= ::RealizePalette(hdc
);
3780 // restore the palette (before releasing the DC)
3781 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3782 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3783 ::RealizePalette(hdc
);
3784 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3786 // now check for the need to redraw
3788 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3792 #endif // wxUSE_PALETTE
3794 wxPaletteChangedEvent
event(GetId());
3795 event
.SetEventObject(this);
3796 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3798 return GetEventHandler()->ProcessEvent(event
);
3801 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3803 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3804 event
.SetEventObject(this);
3806 return GetEventHandler()->ProcessEvent(event
);
3809 bool wxWindowMSW::HandleQueryNewPalette()
3813 // check to see if we our our parents have a custom palette
3814 wxWindowMSW
*win
= this;
3815 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3816 if (win
->HasCustomPalette()) {
3817 /* realize the palette to see whether redrawing is needed */
3818 HDC hdc
= ::GetDC((HWND
) GetHWND());
3819 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3820 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3822 int result
= ::RealizePalette(hdc
);
3823 /* restore the palette (before releasing the DC) */
3824 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3825 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3826 ::RealizePalette(hdc
);
3827 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3828 /* now check for the need to redraw */
3830 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3832 #endif // wxUSE_PALETTE
3834 wxQueryNewPaletteEvent
event(GetId());
3835 event
.SetEventObject(this);
3837 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3840 // Responds to colour changes: passes event on to children.
3841 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3843 // the top level window also reset the standard colour map as it might have
3844 // changed (there is no need to do it for the non top level windows as we
3845 // only have to do it once)
3849 gs_hasStdCmap
= false;
3851 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3854 // Only propagate to non-top-level windows because Windows already
3855 // sends this event to all top-level ones
3856 wxWindow
*win
= node
->GetData();
3857 if ( !win
->IsTopLevel() )
3859 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3860 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3861 // the standard controls
3862 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3865 node
= node
->GetNext();
3869 extern wxCOLORMAP
*wxGetStdColourMap()
3871 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3872 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3874 if ( !gs_hasStdCmap
)
3876 static bool s_coloursInit
= false;
3878 if ( !s_coloursInit
)
3880 // When a bitmap is loaded, the RGB values can change (apparently
3881 // because Windows adjusts them to care for the old programs always
3882 // using 0xc0c0c0 while the transparent colour for the new Windows
3883 // versions is different). But we do this adjustment ourselves so
3884 // we want to avoid Windows' "help" and for this we need to have a
3885 // reference bitmap which can tell us what the RGB values change
3887 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3888 if ( stdColourBitmap
.Ok() )
3890 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3891 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3892 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3895 memDC
.SelectObject(stdColourBitmap
);
3898 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3900 memDC
.GetPixel(i
, 0, &colour
);
3901 s_stdColours
[i
] = wxColourToRGB(colour
);
3904 else // wxBITMAP_STD_COLOURS couldn't be loaded
3906 s_stdColours
[0] = RGB(000,000,000); // black
3907 s_stdColours
[1] = RGB(128,128,128); // dark grey
3908 s_stdColours
[2] = RGB(192,192,192); // light grey
3909 s_stdColours
[3] = RGB(255,255,255); // white
3910 //s_stdColours[4] = RGB(000,000,255); // blue
3911 //s_stdColours[5] = RGB(255,000,255); // magenta
3914 s_coloursInit
= true;
3917 gs_hasStdCmap
= true;
3919 // create the colour map
3920 #define INIT_CMAP_ENTRY(col) \
3921 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3922 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3924 INIT_CMAP_ENTRY(BTNTEXT
);
3925 INIT_CMAP_ENTRY(BTNSHADOW
);
3926 INIT_CMAP_ENTRY(BTNFACE
);
3927 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3929 #undef INIT_CMAP_ENTRY
3935 // ---------------------------------------------------------------------------
3937 // ---------------------------------------------------------------------------
3939 bool wxWindowMSW::HandlePaint()
3941 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3944 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3946 wxLogLastError(wxT("CreateRectRgn"));
3947 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3948 wxLogLastError(wxT("GetUpdateRgn"));
3950 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3952 wxPaintEvent
event(m_windowId
);
3953 event
.SetEventObject(this);
3955 bool processed
= GetEventHandler()->ProcessEvent(event
);
3957 // note that we must generate NC event after the normal one as otherwise
3958 // BeginPaint() will happily overwrite our decorations with the background
3960 wxNcPaintEvent
eventNc(m_windowId
);
3961 eventNc
.SetEventObject(this);
3962 GetEventHandler()->ProcessEvent(eventNc
);
3967 // Can be called from an application's OnPaint handler
3968 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3970 #ifdef __WXUNIVERSAL__
3973 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3976 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3981 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3983 // Prevents flicker when dragging
3984 if ( ::IsIconic(GetHwnd()) )
3990 dc
.SetWindow((wxWindow
*)this);
3993 wxEraseEvent
event(m_windowId
, &dc
);
3994 event
.SetEventObject(this);
3995 bool rc
= GetEventHandler()->ProcessEvent(event
);
3999 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4000 dc
.SelectOldObjects(hdc
);
4005 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4007 switch ( GetBackgroundStyle() )
4010 wxFAIL_MSG( _T("unexpected background style") );
4013 case wxBG_STYLE_CUSTOM
:
4014 // don't skip the event here, custom background means that the app
4015 // is drawing it itself in its OnPaint()
4018 case wxBG_STYLE_SYSTEM
:
4019 #if wxUSE_NOTEBOOK && wxUSE_UXTHEME && !defined(__WXUNIVERSAL__)
4020 // automatically apply the tab control theme background to any
4021 // child panels to have the same look as the native property sheet
4023 if ( !IsOfStandardClass() )
4025 for ( wxWindow
*win
= this; win
; win
= win
->GetParent() )
4027 wxNotebook
*nbook
= wxDynamicCast(win
, wxNotebook
);
4030 nbook
->DoEraseBackground(event
);
4035 #endif // wxUSE_NOTEBOOK
4039 case wxBG_STYLE_COLOUR
:
4040 // we have a fixed solid background colour, do use it
4042 ::GetClientRect(GetHwnd(), &rect
);
4044 HBRUSH hBrush
= ::CreateSolidBrush(
4045 wxColourToPalRGB(GetBackgroundColour()));
4047 wxLogLastError(wxT("CreateSolidBrush"));
4049 HDC hdc
= GetHdcOf((*event
.GetDC()));
4051 ::FillRect(hdc
, &rect
, hBrush
);
4052 ::DeleteObject(hBrush
);
4056 // ---------------------------------------------------------------------------
4057 // moving and resizing
4058 // ---------------------------------------------------------------------------
4060 bool wxWindowMSW::HandleMinimize()
4062 wxIconizeEvent
event(m_windowId
);
4063 event
.SetEventObject(this);
4065 return GetEventHandler()->ProcessEvent(event
);
4068 bool wxWindowMSW::HandleMaximize()
4070 wxMaximizeEvent
event(m_windowId
);
4071 event
.SetEventObject(this);
4073 return GetEventHandler()->ProcessEvent(event
);
4076 bool wxWindowMSW::HandleMove(int x
, int y
)
4079 wxMoveEvent
event(point
, m_windowId
);
4080 event
.SetEventObject(this);
4082 return GetEventHandler()->ProcessEvent(event
);
4085 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4087 wxMoveEvent
event(rect
, m_windowId
);
4088 event
.SetEventObject(this);
4090 bool rc
= GetEventHandler()->ProcessEvent(event
);
4092 rect
= event
.GetRect();
4096 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4098 bool processed
= false;
4103 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4104 // fall through nevertheless
4108 // we're not interested in these messages at all
4111 case SIZE_MINIMIZED
:
4112 processed
= HandleMinimize();
4115 case SIZE_MAXIMIZED
:
4116 /* processed = */ HandleMaximize();
4117 // fall through to send a normal size event as well
4120 // don't use w and h parameters as they specify the client size
4121 // while according to the docs EVT_SIZE handler is supposed to
4122 // receive the total size
4123 wxSizeEvent
event(GetSize(), m_windowId
);
4124 event
.SetEventObject(this);
4126 processed
= GetEventHandler()->ProcessEvent(event
);
4132 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4134 wxSizeEvent
event(rect
, m_windowId
);
4135 event
.SetEventObject(this);
4137 bool rc
= GetEventHandler()->ProcessEvent(event
);
4139 rect
= event
.GetRect();
4143 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
4146 wxUnusedVar(mmInfo
);
4149 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4153 int minWidth
= GetMinWidth(),
4154 minHeight
= GetMinHeight(),
4155 maxWidth
= GetMaxWidth(),
4156 maxHeight
= GetMaxHeight();
4158 if ( minWidth
!= wxDefaultCoord
)
4160 info
->ptMinTrackSize
.x
= minWidth
;
4164 if ( minHeight
!= wxDefaultCoord
)
4166 info
->ptMinTrackSize
.y
= minHeight
;
4170 if ( maxWidth
!= wxDefaultCoord
)
4172 info
->ptMaxTrackSize
.x
= maxWidth
;
4176 if ( maxHeight
!= wxDefaultCoord
)
4178 info
->ptMaxTrackSize
.y
= maxHeight
;
4186 // ---------------------------------------------------------------------------
4188 // ---------------------------------------------------------------------------
4190 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4192 #if wxUSE_MENUS_NATIVE
4193 if ( !cmd
&& wxCurrentPopupMenu
)
4195 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4196 wxCurrentPopupMenu
= NULL
;
4198 return popupMenu
->MSWCommand(cmd
, id
);
4200 #endif // wxUSE_MENUS_NATIVE
4202 wxWindow
*win
= NULL
;
4204 // first try to find it from HWND - this works even with the broken
4205 // programs using the same ids for different controls
4208 win
= wxFindWinFromHandle(control
);
4214 // must cast to a signed type before comparing with other ids!
4215 win
= FindItem((signed short)id
);
4220 return win
->MSWCommand(cmd
, id
);
4223 // the messages sent from the in-place edit control used by the treectrl
4224 // for label editing have id == 0, but they should _not_ be treated as menu
4225 // messages (they are EN_XXX ones, in fact) so don't translate anything
4226 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4229 // If no child window, it may be an accelerator, e.g. for a popup menu
4232 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4233 event
.SetEventObject(this);
4237 return GetEventHandler()->ProcessEvent(event
);
4239 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4242 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4243 // notifications to its parent which we want to reflect back to
4245 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4246 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4249 #endif // wxUSE_SPINCTRL
4254 // ---------------------------------------------------------------------------
4256 // ---------------------------------------------------------------------------
4258 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4262 // our client coords are not quite the same as Windows ones
4263 wxPoint pt
= GetClientAreaOrigin();
4264 event
.m_x
= x
- pt
.x
;
4265 event
.m_y
= y
- pt
.y
;
4267 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4268 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4269 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4270 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4271 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4272 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4273 // Returns different negative values on WinME and WinNT,
4274 // so simply test for negative value.
4275 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4278 event
.SetTimestamp(::GetMessageTime());
4281 event
.m_eventObject
= this;
4282 event
.SetId(GetId());
4284 #if wxUSE_MOUSEEVENT_HACK
4287 m_lastMouseEvent
= event
.GetEventType();
4288 #endif // wxUSE_MOUSEEVENT_HACK
4291 // Windows doesn't send the mouse events to the static controls (which are
4292 // transparent in the sense that their WM_NCHITTEST handler returns
4293 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4294 // and so we manually check if we don't have a child window under mouse and if
4295 // we do, send the event to it instead of the window Windows had sent WM_XXX
4298 // Notice that this is not done for the mouse move events because this could
4299 // (would?) be too slow, but only for clicks which means that the static texts
4300 // still don't get move, enter nor leave events.
4301 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4303 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4305 // first try to find a non transparent child: this allows us to send events
4306 // to a static text which is inside a static box, for example
4307 POINT pt
= { *x
, *y
};
4308 HWND hwnd
= GetHwndOf(win
),
4312 hwndUnderMouse
= ::ChildWindowFromPoint
4318 hwndUnderMouse
= ::ChildWindowFromPointEx
4328 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4330 // now try any child window at all
4331 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4334 // check that we have a child window which is susceptible to receive mouse
4335 // events: for this it must be shown and enabled
4336 if ( hwndUnderMouse
&&
4337 hwndUnderMouse
!= hwnd
&&
4338 ::IsWindowVisible(hwndUnderMouse
) &&
4339 ::IsWindowEnabled(hwndUnderMouse
) )
4341 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4342 if ( winUnderMouse
)
4344 // translate the mouse coords to the other window coords
4345 win
->ClientToScreen(x
, y
);
4346 winUnderMouse
->ScreenToClient(x
, y
);
4348 win
= winUnderMouse
;
4355 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4357 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4358 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4359 // from the message id and take the value in the table to get wxWin event
4361 static const wxEventType eventsMouse
[] =
4375 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4376 InitMouseEvent(event
, x
, y
, flags
);
4378 return GetEventHandler()->ProcessEvent(event
);
4381 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4383 if ( !m_mouseInWindow
)
4385 // it would be wrong to assume that just because we get a mouse move
4386 // event that the mouse is inside the window: although this is usually
4387 // true, it is not if we had captured the mouse, so we need to check
4388 // the mouse coordinates here
4389 if ( !HasCapture() || IsMouseInWindow() )
4391 // Generate an ENTER event
4392 m_mouseInWindow
= true;
4393 #if _WIN32_WINNT >= 0x0400
4395 TRACKMOUSEEVENT trackinfo
;
4397 trackinfo
.cbSize
= sizeof(trackinfo
);
4398 trackinfo
.dwFlags
= TME_LEAVE
;
4399 trackinfo
.hwndTrack
= GetHwnd();
4400 //Use the commctrl.h _TrackMouseEvent, which will call the
4401 // appropriate TrackMouseEvent or emulate it ( win95 )
4402 // else we need _WIN32_WINNT >= 0x0400
4403 _TrackMouseEvent(&trackinfo
);
4406 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4407 InitMouseEvent(event
, x
, y
, flags
);
4409 (void)GetEventHandler()->ProcessEvent(event
);
4413 #if wxUSE_MOUSEEVENT_HACK
4414 // Window gets a click down message followed by a mouse move message even
4415 // if position isn't changed! We want to discard the trailing move event
4416 // if x and y are the same.
4417 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4418 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4419 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4420 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4422 m_lastMouseEvent
= wxEVT_MOTION
;
4426 #endif // wxUSE_MOUSEEVENT_HACK
4428 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4432 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4434 #if wxUSE_MOUSEWHEEL
4435 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4436 InitMouseEvent(event
,
4437 GET_X_LPARAM(lParam
),
4438 GET_Y_LPARAM(lParam
),
4440 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4441 event
.m_wheelDelta
= WHEEL_DELTA
;
4443 static int s_linesPerRotation
= -1;
4444 if ( s_linesPerRotation
== -1 )
4446 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4447 &s_linesPerRotation
, 0))
4449 // this is not supposed to happen
4450 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4452 // the default is 3, so use it if SystemParametersInfo() failed
4453 s_linesPerRotation
= 3;
4457 event
.m_linesPerAction
= s_linesPerRotation
;
4458 return GetEventHandler()->ProcessEvent(event
);
4469 // ---------------------------------------------------------------------------
4470 // keyboard handling
4471 // ---------------------------------------------------------------------------
4473 // create the key event of the given type for the given key - used by
4474 // HandleChar and HandleKeyDown/Up
4475 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4478 WXWPARAM wParam
) const
4480 wxKeyEvent
event(evType
);
4481 event
.SetId(GetId());
4482 event
.m_shiftDown
= wxIsShiftDown();
4483 event
.m_controlDown
= wxIsCtrlDown();
4484 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4486 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4487 event
.m_keyCode
= id
;
4489 event
.m_uniChar
= (wxChar
) wParam
;
4491 event
.m_rawCode
= (wxUint32
) wParam
;
4492 event
.m_rawFlags
= (wxUint32
) lParam
;
4494 event
.SetTimestamp(::GetMessageTime());
4497 // translate the position to client coords
4501 GetWindowRect(GetHwnd(),&rect
);
4511 // isASCII is true only when we're called from WM_CHAR handler and not from
4513 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4518 // If 1 -> 26, translate to either special keycode or just set
4519 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4520 // ControlDown() == true.
4522 if ( (id
> 0) && (id
< 27) )
4544 else // we're called from WM_KEYDOWN
4546 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4549 // it's ASCII and will be processed here only when called from
4550 // WM_CHAR (i.e. when isASCII = true), don't process it now
4555 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4557 // the alphanumeric keys produced by pressing AltGr+something on European
4558 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4559 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4560 // alphanumeric, so pretend that there are no modifiers at all (the
4561 // KEY_DOWN event would still have the correct modifiers if they're really
4563 if ( event
.m_controlDown
&& event
.m_altDown
&&
4564 (id
>= 32 && id
< 256) )
4566 event
.m_controlDown
=
4567 event
.m_altDown
= false;
4570 return GetEventHandler()->ProcessEvent(event
);
4573 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4575 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4579 // normal ASCII char
4583 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4585 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4586 if ( GetEventHandler()->ProcessEvent(event
) )
4595 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4597 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4601 // normal ASCII char
4605 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4607 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4608 if ( GetEventHandler()->ProcessEvent(event
) )
4615 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4617 // FIXME: implement GetMenuItemCount for WinCE, possibly
4618 // in terms of GetMenuItemInfo
4620 const HMENU hmenu
= (HMENU
)lParam
;
4624 mii
.cbSize
= sizeof(MENUITEMINFO
);
4625 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4627 // find if we have this letter in any owner drawn item
4628 const int count
= ::GetMenuItemCount(hmenu
);
4629 for ( int i
= 0; i
< count
; i
++ )
4631 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4633 if ( mii
.fType
== MFT_OWNERDRAW
)
4635 // dwItemData member of the MENUITEMINFO is a
4636 // pointer to the associated wxMenuItem -- see the
4637 // menu creation code
4638 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4640 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4643 if ( *p
== _T('&') )
4645 // this is not the accel char, find the real one
4646 p
= wxStrchr(p
+ 1, _T('&'));
4648 else // got the accel char
4650 // FIXME-UNICODE: this comparison doesn't risk to work
4651 // for non ASCII accelerator characters I'm afraid, but
4653 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
4659 // this one doesn't match
4666 else // failed to get the menu text?
4668 // it's not fatal, so don't show error, but still log
4670 wxLogLastError(_T("GetMenuItemInfo"));
4674 wxUnusedVar(chAccel
);
4675 wxUnusedVar(lParam
);
4680 // ---------------------------------------------------------------------------
4682 // ---------------------------------------------------------------------------
4684 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4688 if ( flags
& JOY_BUTTON1CHG
)
4689 change
= wxJOY_BUTTON1
;
4690 if ( flags
& JOY_BUTTON2CHG
)
4691 change
= wxJOY_BUTTON2
;
4692 if ( flags
& JOY_BUTTON3CHG
)
4693 change
= wxJOY_BUTTON3
;
4694 if ( flags
& JOY_BUTTON4CHG
)
4695 change
= wxJOY_BUTTON4
;
4698 if ( flags
& JOY_BUTTON1
)
4699 buttons
|= wxJOY_BUTTON1
;
4700 if ( flags
& JOY_BUTTON2
)
4701 buttons
|= wxJOY_BUTTON2
;
4702 if ( flags
& JOY_BUTTON3
)
4703 buttons
|= wxJOY_BUTTON3
;
4704 if ( flags
& JOY_BUTTON4
)
4705 buttons
|= wxJOY_BUTTON4
;
4707 // the event ids aren't consecutive so we can't use table based lookup
4709 wxEventType eventType
;
4714 eventType
= wxEVT_JOY_MOVE
;
4719 eventType
= wxEVT_JOY_MOVE
;
4724 eventType
= wxEVT_JOY_ZMOVE
;
4729 eventType
= wxEVT_JOY_ZMOVE
;
4732 case MM_JOY1BUTTONDOWN
:
4734 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4737 case MM_JOY2BUTTONDOWN
:
4739 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4742 case MM_JOY1BUTTONUP
:
4744 eventType
= wxEVT_JOY_BUTTON_UP
;
4747 case MM_JOY2BUTTONUP
:
4749 eventType
= wxEVT_JOY_BUTTON_UP
;
4753 wxFAIL_MSG(wxT("no such joystick event"));
4758 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4759 event
.SetPosition(wxPoint(x
, y
));
4760 event
.SetEventObject(this);
4762 return GetEventHandler()->ProcessEvent(event
);
4772 // ---------------------------------------------------------------------------
4774 // ---------------------------------------------------------------------------
4776 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4777 WXWORD pos
, WXHWND control
)
4779 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
4781 wxWindow
*child
= wxFindWinFromHandle(control
);
4783 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4786 wxScrollWinEvent event
;
4787 event
.SetPosition(pos
);
4788 event
.SetOrientation(orientation
);
4789 event
.m_eventObject
= this;
4794 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4798 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4802 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4806 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4810 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4814 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4817 case SB_THUMBPOSITION
:
4819 // under Win32, the scrollbar range and position are 32 bit integers,
4820 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4821 // explicitly query the scrollbar for the correct position (this must
4822 // be done only for these two SB_ events as they are the only one
4823 // carrying the scrollbar position)
4825 WinStruct
<SCROLLINFO
> scrollInfo
;
4826 scrollInfo
.fMask
= SIF_TRACKPOS
;
4828 if ( !::GetScrollInfo(GetHwnd(),
4829 orientation
== wxHORIZONTAL
? SB_HORZ
4833 // Not neccessarily an error, if there are no scrollbars yet.
4834 // wxLogLastError(_T("GetScrollInfo"));
4837 event
.SetPosition(scrollInfo
.nTrackPos
);
4840 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4841 ? wxEVT_SCROLLWIN_THUMBRELEASE
4842 : wxEVT_SCROLLWIN_THUMBTRACK
;
4849 return GetEventHandler()->ProcessEvent(event
);
4852 // ===========================================================================
4854 // ===========================================================================
4856 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
4859 HDC dc
= ::GetDC((HWND
) wnd
);
4862 // the_font.UseResource();
4863 // the_font.RealizeResource();
4864 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
4866 was
= (HFONT
) SelectObject(dc
,fnt
);
4868 GetTextMetrics(dc
, &tm
);
4871 SelectObject(dc
,was
);
4873 ReleaseDC((HWND
)wnd
, dc
);
4876 *x
= tm
.tmAveCharWidth
;
4878 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4880 // the_font.ReleaseResource();
4883 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4884 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4885 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
4890 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4891 case VK_BACK
: id
= WXK_BACK
; break;
4892 case VK_TAB
: id
= WXK_TAB
; break;
4893 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4894 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4895 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4896 case VK_MENU
: id
= WXK_MENU
; break;
4897 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4898 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4899 case VK_SPACE
: id
= WXK_SPACE
; break;
4900 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4901 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4902 case VK_NEXT
: id
= WXK_NEXT
; break;
4903 case VK_END
: id
= WXK_END
; break;
4904 case VK_HOME
: id
= WXK_HOME
; break;
4905 case VK_LEFT
: id
= WXK_LEFT
; break;
4906 case VK_UP
: id
= WXK_UP
; break;
4907 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4908 case VK_DOWN
: id
= WXK_DOWN
; break;
4909 case VK_SELECT
: id
= WXK_SELECT
; break;
4910 case VK_PRINT
: id
= WXK_PRINT
; break;
4911 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4912 case VK_INSERT
: id
= WXK_INSERT
; break;
4913 case VK_DELETE
: id
= WXK_DELETE
; break;
4914 case VK_HELP
: id
= WXK_HELP
; break;
4915 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4916 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4917 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4918 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4919 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4920 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4921 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4922 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4923 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4924 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4925 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4926 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4927 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4928 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4929 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4930 case VK_F1
: id
= WXK_F1
; break;
4931 case VK_F2
: id
= WXK_F2
; break;
4932 case VK_F3
: id
= WXK_F3
; break;
4933 case VK_F4
: id
= WXK_F4
; break;
4934 case VK_F5
: id
= WXK_F5
; break;
4935 case VK_F6
: id
= WXK_F6
; break;
4936 case VK_F7
: id
= WXK_F7
; break;
4937 case VK_F8
: id
= WXK_F8
; break;
4938 case VK_F9
: id
= WXK_F9
; break;
4939 case VK_F10
: id
= WXK_F10
; break;
4940 case VK_F11
: id
= WXK_F11
; break;
4941 case VK_F12
: id
= WXK_F12
; break;
4942 case VK_F13
: id
= WXK_F13
; break;
4943 case VK_F14
: id
= WXK_F14
; break;
4944 case VK_F15
: id
= WXK_F15
; break;
4945 case VK_F16
: id
= WXK_F16
; break;
4946 case VK_F17
: id
= WXK_F17
; break;
4947 case VK_F18
: id
= WXK_F18
; break;
4948 case VK_F19
: id
= WXK_F19
; break;
4949 case VK_F20
: id
= WXK_F20
; break;
4950 case VK_F21
: id
= WXK_F21
; break;
4951 case VK_F22
: id
= WXK_F22
; break;
4952 case VK_F23
: id
= WXK_F23
; break;
4953 case VK_F24
: id
= WXK_F24
; break;
4954 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4955 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4957 case VK_OEM_1
: id
= ';'; break;
4958 case VK_OEM_PLUS
: id
= '+'; break;
4959 case VK_OEM_COMMA
: id
= ','; break;
4960 case VK_OEM_MINUS
: id
= '-'; break;
4961 case VK_OEM_PERIOD
: id
= '.'; break;
4962 case VK_OEM_2
: id
= '/'; break;
4963 case VK_OEM_3
: id
= '~'; break;
4964 case VK_OEM_4
: id
= '['; break;
4965 case VK_OEM_5
: id
= '\\'; break;
4966 case VK_OEM_6
: id
= ']'; break;
4967 case VK_OEM_7
: id
= '\''; break;
4970 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4971 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4972 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4973 #endif // VK_APPS defined
4976 // the same key is sent for both the "return" key on the main
4977 // keyboard and the numeric keypad but we want to distinguish
4978 // between them: we do this using the "extended" bit (24) of lParam
4979 id
= lParam
& (1 << 24) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
4989 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4995 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4996 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4997 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4998 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4999 case WXK_ALT
: keySym
= VK_MENU
; break;
5000 case WXK_MENU
: keySym
= VK_MENU
; break;
5001 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5002 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5003 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5004 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5005 case WXK_END
: keySym
= VK_END
; break;
5006 case WXK_HOME
: keySym
= VK_HOME
; break;
5007 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5008 case WXK_UP
: keySym
= VK_UP
; break;
5009 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5010 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5011 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5012 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5013 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5014 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5015 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5016 case WXK_HELP
: keySym
= VK_HELP
; break;
5017 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5018 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5019 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5020 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5021 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5022 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5023 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5024 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5025 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5026 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5027 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5028 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5029 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5030 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5031 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5032 case WXK_F1
: keySym
= VK_F1
; break;
5033 case WXK_F2
: keySym
= VK_F2
; break;
5034 case WXK_F3
: keySym
= VK_F3
; break;
5035 case WXK_F4
: keySym
= VK_F4
; break;
5036 case WXK_F5
: keySym
= VK_F5
; break;
5037 case WXK_F6
: keySym
= VK_F6
; break;
5038 case WXK_F7
: keySym
= VK_F7
; break;
5039 case WXK_F8
: keySym
= VK_F8
; break;
5040 case WXK_F9
: keySym
= VK_F9
; break;
5041 case WXK_F10
: keySym
= VK_F10
; break;
5042 case WXK_F11
: keySym
= VK_F11
; break;
5043 case WXK_F12
: keySym
= VK_F12
; break;
5044 case WXK_F13
: keySym
= VK_F13
; break;
5045 case WXK_F14
: keySym
= VK_F14
; break;
5046 case WXK_F15
: keySym
= VK_F15
; break;
5047 case WXK_F16
: keySym
= VK_F16
; break;
5048 case WXK_F17
: keySym
= VK_F17
; break;
5049 case WXK_F18
: keySym
= VK_F18
; break;
5050 case WXK_F19
: keySym
= VK_F19
; break;
5051 case WXK_F20
: keySym
= VK_F20
; break;
5052 case WXK_F21
: keySym
= VK_F21
; break;
5053 case WXK_F22
: keySym
= VK_F22
; break;
5054 case WXK_F23
: keySym
= VK_F23
; break;
5055 case WXK_F24
: keySym
= VK_F24
; break;
5056 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5057 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5068 bool wxGetKeyState(wxKeyCode key
)
5072 //High order with GetAsyncKeyState only available on WIN32
5074 //If the requested key is a LED key, return
5075 //true if the led is pressed
5076 if (key
== WXK_NUMLOCK
||
5077 key
== WXK_CAPITAL
||
5081 //low order bit means LED is highlighted,
5082 //high order means key is down
5083 //Here, for compat with other ports we want both
5084 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5091 //low order bit means key pressed since last call
5092 //high order means key is down
5093 //We want only the high order bit - the key may not be down if only low order
5094 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5099 wxWindow
*wxGetActiveWindow()
5101 HWND hWnd
= GetActiveWindow();
5104 return wxFindWinFromHandle((WXHWND
) hWnd
);
5109 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5111 HWND hwnd
= (HWND
)hWnd
;
5113 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5114 // by code in msw/radiobox.cpp), for all the others we just search up the
5116 wxWindow
*win
= (wxWindow
*)NULL
;
5119 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5123 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5124 // wxWindow class which overrides WM_GETDLGCODE processing to
5125 // do it as well, win would be already non NULL
5126 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5128 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5130 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5131 #endif // wxUSE_RADIOBOX
5133 // spin control text buddy window should be mapped to spin ctrl
5134 // itself so try it too
5135 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5138 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5140 #endif // wxUSE_SPINCTRL
5144 while ( hwnd
&& !win
)
5146 // this is a really ugly hack needed to avoid mistakenly returning the
5147 // parent frame wxWindow for the find/replace modeless dialog HWND -
5148 // this, in turn, is needed to call IsDialogMessage() from
5149 // wxApp::ProcessMessage() as for this we must return NULL from here
5151 // FIXME: this is clearly not the best way to do it but I think we'll
5152 // need to change HWND <-> wxWindow code more heavily than I can
5153 // do it now to fix it
5154 #ifndef __WXMICROWIN__
5155 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5157 // it's a dialog box, don't go upwards
5162 hwnd
= ::GetParent(hwnd
);
5163 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5169 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5171 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5172 // in active frames and dialogs, regardless of where the focus is.
5173 static HHOOK wxTheKeyboardHook
= 0;
5174 static FARPROC wxTheKeyboardHookProc
= 0;
5175 int APIENTRY _EXPORT
5176 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5178 void wxSetKeyboardHook(bool doIt
)
5182 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5183 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5185 GetCurrentThreadId()
5186 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5191 UnhookWindowsHookEx(wxTheKeyboardHook
);
5195 int APIENTRY _EXPORT
5196 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5198 DWORD hiWord
= HIWORD(lParam
);
5199 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5201 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5204 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5205 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5206 event
.m_altDown
= true;
5208 event
.m_eventObject
= NULL
;
5209 event
.m_keyCode
= id
;
5210 event
.m_shiftDown
= wxIsShiftDown();
5211 event
.m_controlDown
= wxIsCtrlDown();
5213 event
.SetTimestamp(::GetMessageTime());
5215 wxWindow
*win
= wxGetActiveWindow();
5216 wxEvtHandler
*handler
;
5219 handler
= win
->GetEventHandler();
5220 event
.SetId(win
->GetId());
5225 event
.SetId(wxID_ANY
);
5228 if ( handler
&& handler
->ProcessEvent(event
) )
5236 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5239 #endif // !__WXMICROWIN__
5242 const char *wxGetMessageName(int message
)
5246 case 0x0000: return "WM_NULL";
5247 case 0x0001: return "WM_CREATE";
5248 case 0x0002: return "WM_DESTROY";
5249 case 0x0003: return "WM_MOVE";
5250 case 0x0005: return "WM_SIZE";
5251 case 0x0006: return "WM_ACTIVATE";
5252 case 0x0007: return "WM_SETFOCUS";
5253 case 0x0008: return "WM_KILLFOCUS";
5254 case 0x000A: return "WM_ENABLE";
5255 case 0x000B: return "WM_SETREDRAW";
5256 case 0x000C: return "WM_SETTEXT";
5257 case 0x000D: return "WM_GETTEXT";
5258 case 0x000E: return "WM_GETTEXTLENGTH";
5259 case 0x000F: return "WM_PAINT";
5260 case 0x0010: return "WM_CLOSE";
5261 case 0x0011: return "WM_QUERYENDSESSION";
5262 case 0x0012: return "WM_QUIT";
5263 case 0x0013: return "WM_QUERYOPEN";
5264 case 0x0014: return "WM_ERASEBKGND";
5265 case 0x0015: return "WM_SYSCOLORCHANGE";
5266 case 0x0016: return "WM_ENDSESSION";
5267 case 0x0017: return "WM_SYSTEMERROR";
5268 case 0x0018: return "WM_SHOWWINDOW";
5269 case 0x0019: return "WM_CTLCOLOR";
5270 case 0x001A: return "WM_WININICHANGE";
5271 case 0x001B: return "WM_DEVMODECHANGE";
5272 case 0x001C: return "WM_ACTIVATEAPP";
5273 case 0x001D: return "WM_FONTCHANGE";
5274 case 0x001E: return "WM_TIMECHANGE";
5275 case 0x001F: return "WM_CANCELMODE";
5276 case 0x0020: return "WM_SETCURSOR";
5277 case 0x0021: return "WM_MOUSEACTIVATE";
5278 case 0x0022: return "WM_CHILDACTIVATE";
5279 case 0x0023: return "WM_QUEUESYNC";
5280 case 0x0024: return "WM_GETMINMAXINFO";
5281 case 0x0026: return "WM_PAINTICON";
5282 case 0x0027: return "WM_ICONERASEBKGND";
5283 case 0x0028: return "WM_NEXTDLGCTL";
5284 case 0x002A: return "WM_SPOOLERSTATUS";
5285 case 0x002B: return "WM_DRAWITEM";
5286 case 0x002C: return "WM_MEASUREITEM";
5287 case 0x002D: return "WM_DELETEITEM";
5288 case 0x002E: return "WM_VKEYTOITEM";
5289 case 0x002F: return "WM_CHARTOITEM";
5290 case 0x0030: return "WM_SETFONT";
5291 case 0x0031: return "WM_GETFONT";
5292 case 0x0037: return "WM_QUERYDRAGICON";
5293 case 0x0039: return "WM_COMPAREITEM";
5294 case 0x0041: return "WM_COMPACTING";
5295 case 0x0044: return "WM_COMMNOTIFY";
5296 case 0x0046: return "WM_WINDOWPOSCHANGING";
5297 case 0x0047: return "WM_WINDOWPOSCHANGED";
5298 case 0x0048: return "WM_POWER";
5300 case 0x004A: return "WM_COPYDATA";
5301 case 0x004B: return "WM_CANCELJOURNAL";
5302 case 0x004E: return "WM_NOTIFY";
5303 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5304 case 0x0051: return "WM_INPUTLANGCHANGE";
5305 case 0x0052: return "WM_TCARD";
5306 case 0x0053: return "WM_HELP";
5307 case 0x0054: return "WM_USERCHANGED";
5308 case 0x0055: return "WM_NOTIFYFORMAT";
5309 case 0x007B: return "WM_CONTEXTMENU";
5310 case 0x007C: return "WM_STYLECHANGING";
5311 case 0x007D: return "WM_STYLECHANGED";
5312 case 0x007E: return "WM_DISPLAYCHANGE";
5313 case 0x007F: return "WM_GETICON";
5314 case 0x0080: return "WM_SETICON";
5316 case 0x0081: return "WM_NCCREATE";
5317 case 0x0082: return "WM_NCDESTROY";
5318 case 0x0083: return "WM_NCCALCSIZE";
5319 case 0x0084: return "WM_NCHITTEST";
5320 case 0x0085: return "WM_NCPAINT";
5321 case 0x0086: return "WM_NCACTIVATE";
5322 case 0x0087: return "WM_GETDLGCODE";
5323 case 0x00A0: return "WM_NCMOUSEMOVE";
5324 case 0x00A1: return "WM_NCLBUTTONDOWN";
5325 case 0x00A2: return "WM_NCLBUTTONUP";
5326 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5327 case 0x00A4: return "WM_NCRBUTTONDOWN";
5328 case 0x00A5: return "WM_NCRBUTTONUP";
5329 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5330 case 0x00A7: return "WM_NCMBUTTONDOWN";
5331 case 0x00A8: return "WM_NCMBUTTONUP";
5332 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5333 case 0x0100: return "WM_KEYDOWN";
5334 case 0x0101: return "WM_KEYUP";
5335 case 0x0102: return "WM_CHAR";
5336 case 0x0103: return "WM_DEADCHAR";
5337 case 0x0104: return "WM_SYSKEYDOWN";
5338 case 0x0105: return "WM_SYSKEYUP";
5339 case 0x0106: return "WM_SYSCHAR";
5340 case 0x0107: return "WM_SYSDEADCHAR";
5341 case 0x0108: return "WM_KEYLAST";
5343 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5344 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5345 case 0x010F: return "WM_IME_COMPOSITION";
5347 case 0x0110: return "WM_INITDIALOG";
5348 case 0x0111: return "WM_COMMAND";
5349 case 0x0112: return "WM_SYSCOMMAND";
5350 case 0x0113: return "WM_TIMER";
5351 case 0x0114: return "WM_HSCROLL";
5352 case 0x0115: return "WM_VSCROLL";
5353 case 0x0116: return "WM_INITMENU";
5354 case 0x0117: return "WM_INITMENUPOPUP";
5355 case 0x011F: return "WM_MENUSELECT";
5356 case 0x0120: return "WM_MENUCHAR";
5357 case 0x0121: return "WM_ENTERIDLE";
5358 case 0x0200: return "WM_MOUSEMOVE";
5359 case 0x0201: return "WM_LBUTTONDOWN";
5360 case 0x0202: return "WM_LBUTTONUP";
5361 case 0x0203: return "WM_LBUTTONDBLCLK";
5362 case 0x0204: return "WM_RBUTTONDOWN";
5363 case 0x0205: return "WM_RBUTTONUP";
5364 case 0x0206: return "WM_RBUTTONDBLCLK";
5365 case 0x0207: return "WM_MBUTTONDOWN";
5366 case 0x0208: return "WM_MBUTTONUP";
5367 case 0x0209: return "WM_MBUTTONDBLCLK";
5368 case 0x020A: return "WM_MOUSEWHEEL";
5369 case 0x0210: return "WM_PARENTNOTIFY";
5370 case 0x0211: return "WM_ENTERMENULOOP";
5371 case 0x0212: return "WM_EXITMENULOOP";
5373 case 0x0213: return "WM_NEXTMENU";
5374 case 0x0214: return "WM_SIZING";
5375 case 0x0215: return "WM_CAPTURECHANGED";
5376 case 0x0216: return "WM_MOVING";
5377 case 0x0218: return "WM_POWERBROADCAST";
5378 case 0x0219: return "WM_DEVICECHANGE";
5380 case 0x0220: return "WM_MDICREATE";
5381 case 0x0221: return "WM_MDIDESTROY";
5382 case 0x0222: return "WM_MDIACTIVATE";
5383 case 0x0223: return "WM_MDIRESTORE";
5384 case 0x0224: return "WM_MDINEXT";
5385 case 0x0225: return "WM_MDIMAXIMIZE";
5386 case 0x0226: return "WM_MDITILE";
5387 case 0x0227: return "WM_MDICASCADE";
5388 case 0x0228: return "WM_MDIICONARRANGE";
5389 case 0x0229: return "WM_MDIGETACTIVE";
5390 case 0x0230: return "WM_MDISETMENU";
5391 case 0x0233: return "WM_DROPFILES";
5393 case 0x0281: return "WM_IME_SETCONTEXT";
5394 case 0x0282: return "WM_IME_NOTIFY";
5395 case 0x0283: return "WM_IME_CONTROL";
5396 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5397 case 0x0285: return "WM_IME_SELECT";
5398 case 0x0286: return "WM_IME_CHAR";
5399 case 0x0290: return "WM_IME_KEYDOWN";
5400 case 0x0291: return "WM_IME_KEYUP";
5402 case 0x0300: return "WM_CUT";
5403 case 0x0301: return "WM_COPY";
5404 case 0x0302: return "WM_PASTE";
5405 case 0x0303: return "WM_CLEAR";
5406 case 0x0304: return "WM_UNDO";
5407 case 0x0305: return "WM_RENDERFORMAT";
5408 case 0x0306: return "WM_RENDERALLFORMATS";
5409 case 0x0307: return "WM_DESTROYCLIPBOARD";
5410 case 0x0308: return "WM_DRAWCLIPBOARD";
5411 case 0x0309: return "WM_PAINTCLIPBOARD";
5412 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5413 case 0x030B: return "WM_SIZECLIPBOARD";
5414 case 0x030C: return "WM_ASKCBFORMATNAME";
5415 case 0x030D: return "WM_CHANGECBCHAIN";
5416 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5417 case 0x030F: return "WM_QUERYNEWPALETTE";
5418 case 0x0310: return "WM_PALETTEISCHANGING";
5419 case 0x0311: return "WM_PALETTECHANGED";
5421 case 0x0312: return "WM_HOTKEY";
5424 // common controls messages - although they're not strictly speaking
5425 // standard, it's nice to decode them nevertheless
5428 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5429 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5430 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5431 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5432 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5433 case 0x1000 + 5: return "LVM_GETITEMA";
5434 case 0x1000 + 75: return "LVM_GETITEMW";
5435 case 0x1000 + 6: return "LVM_SETITEMA";
5436 case 0x1000 + 76: return "LVM_SETITEMW";
5437 case 0x1000 + 7: return "LVM_INSERTITEMA";
5438 case 0x1000 + 77: return "LVM_INSERTITEMW";
5439 case 0x1000 + 8: return "LVM_DELETEITEM";
5440 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5441 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5442 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5443 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5444 case 0x1000 + 13: return "LVM_FINDITEMA";
5445 case 0x1000 + 83: return "LVM_FINDITEMW";
5446 case 0x1000 + 14: return "LVM_GETITEMRECT";
5447 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5448 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5449 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5450 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5451 case 0x1000 + 18: return "LVM_HITTEST";
5452 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5453 case 0x1000 + 20: return "LVM_SCROLL";
5454 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5455 case 0x1000 + 22: return "LVM_ARRANGE";
5456 case 0x1000 + 23: return "LVM_EDITLABELA";
5457 case 0x1000 + 118: return "LVM_EDITLABELW";
5458 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5459 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5460 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5461 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5462 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5463 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5464 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5465 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5466 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5467 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5468 case 0x1000 + 31: return "LVM_GETHEADER";
5469 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5470 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5471 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5472 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5473 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5474 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5475 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5476 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5477 case 0x1000 + 41: return "LVM_GETORIGIN";
5478 case 0x1000 + 42: return "LVM_UPDATE";
5479 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5480 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5481 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5482 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5483 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5484 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5485 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5486 case 0x1000 + 48: return "LVM_SORTITEMS";
5487 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5488 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5489 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5490 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5491 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5492 case 0x1000 + 53: return "LVM_SETICONSPACING";
5493 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5494 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5495 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5496 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5497 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5498 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5499 case 0x1000 + 60: return "LVM_SETHOTITEM";
5500 case 0x1000 + 61: return "LVM_GETHOTITEM";
5501 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5502 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5503 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5504 case 0x1000 + 65: return "LVM_SETWORKAREA";
5507 case 0x1100 + 0: return "TVM_INSERTITEMA";
5508 case 0x1100 + 50: return "TVM_INSERTITEMW";
5509 case 0x1100 + 1: return "TVM_DELETEITEM";
5510 case 0x1100 + 2: return "TVM_EXPAND";
5511 case 0x1100 + 4: return "TVM_GETITEMRECT";
5512 case 0x1100 + 5: return "TVM_GETCOUNT";
5513 case 0x1100 + 6: return "TVM_GETINDENT";
5514 case 0x1100 + 7: return "TVM_SETINDENT";
5515 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5516 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5517 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5518 case 0x1100 + 11: return "TVM_SELECTITEM";
5519 case 0x1100 + 12: return "TVM_GETITEMA";
5520 case 0x1100 + 62: return "TVM_GETITEMW";
5521 case 0x1100 + 13: return "TVM_SETITEMA";
5522 case 0x1100 + 63: return "TVM_SETITEMW";
5523 case 0x1100 + 14: return "TVM_EDITLABELA";
5524 case 0x1100 + 65: return "TVM_EDITLABELW";
5525 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5526 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5527 case 0x1100 + 17: return "TVM_HITTEST";
5528 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5529 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5530 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5531 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5532 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5533 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5534 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5535 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5536 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5539 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5540 case 0x1200 + 1: return "HDM_INSERTITEMA";
5541 case 0x1200 + 10: return "HDM_INSERTITEMW";
5542 case 0x1200 + 2: return "HDM_DELETEITEM";
5543 case 0x1200 + 3: return "HDM_GETITEMA";
5544 case 0x1200 + 11: return "HDM_GETITEMW";
5545 case 0x1200 + 4: return "HDM_SETITEMA";
5546 case 0x1200 + 12: return "HDM_SETITEMW";
5547 case 0x1200 + 5: return "HDM_LAYOUT";
5548 case 0x1200 + 6: return "HDM_HITTEST";
5549 case 0x1200 + 7: return "HDM_GETITEMRECT";
5550 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5551 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5552 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5553 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5554 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5555 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5556 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5559 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5560 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5561 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5562 case 0x1300 + 5: return "TCM_GETITEMA";
5563 case 0x1300 + 60: return "TCM_GETITEMW";
5564 case 0x1300 + 6: return "TCM_SETITEMA";
5565 case 0x1300 + 61: return "TCM_SETITEMW";
5566 case 0x1300 + 7: return "TCM_INSERTITEMA";
5567 case 0x1300 + 62: return "TCM_INSERTITEMW";
5568 case 0x1300 + 8: return "TCM_DELETEITEM";
5569 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5570 case 0x1300 + 10: return "TCM_GETITEMRECT";
5571 case 0x1300 + 11: return "TCM_GETCURSEL";
5572 case 0x1300 + 12: return "TCM_SETCURSEL";
5573 case 0x1300 + 13: return "TCM_HITTEST";
5574 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5575 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5576 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5577 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5578 case 0x1300 + 43: return "TCM_SETPADDING";
5579 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5580 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5581 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5582 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5583 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5584 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5585 case 0x1300 + 50: return "TCM_DESELECTALL";
5588 case WM_USER
+1: return "TB_ENABLEBUTTON";
5589 case WM_USER
+2: return "TB_CHECKBUTTON";
5590 case WM_USER
+3: return "TB_PRESSBUTTON";
5591 case WM_USER
+4: return "TB_HIDEBUTTON";
5592 case WM_USER
+5: return "TB_INDETERMINATE";
5593 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5594 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5595 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5596 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5597 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5598 case WM_USER
+17: return "TB_SETSTATE";
5599 case WM_USER
+18: return "TB_GETSTATE";
5600 case WM_USER
+19: return "TB_ADDBITMAP";
5601 case WM_USER
+20: return "TB_ADDBUTTONS";
5602 case WM_USER
+21: return "TB_INSERTBUTTON";
5603 case WM_USER
+22: return "TB_DELETEBUTTON";
5604 case WM_USER
+23: return "TB_GETBUTTON";
5605 case WM_USER
+24: return "TB_BUTTONCOUNT";
5606 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5607 case WM_USER
+26: return "TB_SAVERESTOREA";
5608 case WM_USER
+76: return "TB_SAVERESTOREW";
5609 case WM_USER
+27: return "TB_CUSTOMIZE";
5610 case WM_USER
+28: return "TB_ADDSTRINGA";
5611 case WM_USER
+77: return "TB_ADDSTRINGW";
5612 case WM_USER
+29: return "TB_GETITEMRECT";
5613 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5614 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5615 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5616 case WM_USER
+33: return "TB_AUTOSIZE";
5617 case WM_USER
+35: return "TB_GETTOOLTIPS";
5618 case WM_USER
+36: return "TB_SETTOOLTIPS";
5619 case WM_USER
+37: return "TB_SETPARENT";
5620 case WM_USER
+39: return "TB_SETROWS";
5621 case WM_USER
+40: return "TB_GETROWS";
5622 case WM_USER
+42: return "TB_SETCMDID";
5623 case WM_USER
+43: return "TB_CHANGEBITMAP";
5624 case WM_USER
+44: return "TB_GETBITMAP";
5625 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5626 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5627 case WM_USER
+46: return "TB_REPLACEBITMAP";
5628 case WM_USER
+47: return "TB_SETINDENT";
5629 case WM_USER
+48: return "TB_SETIMAGELIST";
5630 case WM_USER
+49: return "TB_GETIMAGELIST";
5631 case WM_USER
+50: return "TB_LOADIMAGES";
5632 case WM_USER
+51: return "TB_GETRECT";
5633 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5634 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5635 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5636 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5637 case WM_USER
+56: return "TB_SETSTYLE";
5638 case WM_USER
+57: return "TB_GETSTYLE";
5639 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5640 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5641 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5642 case WM_USER
+61: return "TB_GETTEXTROWS";
5643 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5646 static char s_szBuf
[128];
5647 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5651 #endif //__WXDEBUG__
5653 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5657 HWND hwnd
= GetHwndOf(win
);
5658 HDC hdc
= ::GetDC(hwnd
);
5660 #if !wxDIALOG_UNIT_COMPATIBILITY
5661 // and select the current font into it
5662 HFONT hfont
= GetHfontOf(win
->GetFont());
5665 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5669 // finally retrieve the text metrics from it
5670 GetTextMetrics(hdc
, &tm
);
5672 #if !wxDIALOG_UNIT_COMPATIBILITY
5676 (void)::SelectObject(hdc
, hfont
);
5680 ::ReleaseDC(hwnd
, hdc
);
5685 // Find the wxWindow at the current mouse position, returning the mouse
5687 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5689 pt
= wxGetMousePosition();
5690 return wxFindWindowAtPoint(pt
);
5693 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5698 HWND hWndHit
= ::WindowFromPoint(pt2
);
5700 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5701 HWND hWnd
= hWndHit
;
5703 // Try to find a window with a wxWindow associated with it
5704 while (!win
&& (hWnd
!= 0))
5706 hWnd
= ::GetParent(hWnd
);
5707 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5712 // Get the current mouse position.
5713 wxPoint
wxGetMousePosition()
5716 GetCursorPos( & pt
);
5718 return wxPoint(pt
.x
, pt
.y
);
5723 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5725 UINT win_modifiers
=0;
5726 if ( modifiers
& wxMOD_ALT
)
5727 win_modifiers
|= MOD_ALT
;
5728 if ( modifiers
& wxMOD_SHIFT
)
5729 win_modifiers
|= MOD_SHIFT
;
5730 if ( modifiers
& wxMOD_CONTROL
)
5731 win_modifiers
|= MOD_CONTROL
;
5732 if ( modifiers
& wxMOD_WIN
)
5733 win_modifiers
|= MOD_WIN
;
5735 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5737 wxLogLastError(_T("RegisterHotKey"));
5745 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
5747 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5749 wxLogLastError(_T("UnregisterHotKey"));
5759 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5761 int hotkeyId
= wParam
;
5762 int virtualKey
= HIWORD(lParam
);
5763 int win_modifiers
= LOWORD(lParam
);
5765 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5766 event
.SetId(hotkeyId
);
5767 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5768 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5769 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5770 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5772 return GetEventHandler()->ProcessEvent(event
);
5775 #endif // wxUSE_ACCEL
5777 #endif // wxUSE_HOTKEY
5779 // Not tested under WinCE
5782 // this class installs a message hook which really wakes up our idle processing
5783 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
5784 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
5785 // being dragged or even inside ::MessageBox()) and so don't control message
5786 // dispatching otherwise
5787 class wxIdleWakeUpModule
: public wxModule
5790 virtual bool OnInit()
5792 ms_hMsgHookProc
= ::SetWindowsHookEx
5795 &wxIdleWakeUpModule::MsgHookProc
,
5797 GetCurrentThreadId()
5800 if ( !ms_hMsgHookProc
)
5802 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
5810 virtual void OnExit()
5812 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
5815 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
5817 MSG
*msg
= (MSG
*)lParam
;
5818 if ( msg
->message
== WM_NULL
)
5820 wxTheApp
->ProcessPendingEvents();
5823 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
5827 static HHOOK ms_hMsgHookProc
;
5829 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
5832 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
5834 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
5836 #endif // __WXWINCE__
5841 static void wxAdjustZOrder(wxWindow
* parent
)
5843 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
5845 // Set the z-order correctly
5846 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
5849 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
5852 wxWindow
*childWin
= current
->GetData();
5853 wxAdjustZOrder(childWin
);
5854 current
= current
->GetNext();
5859 // We need to adjust the z-order of static boxes in WinCE, to
5860 // make 'contained' controls visible
5861 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
5864 wxAdjustZOrder(this);