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 #if wxUSE_DRAG_AND_DROP
60 #if wxUSE_ACCESSIBILITY
61 #include "wx/access.h"
65 #define WM_GETOBJECT 0x003D
68 #define OBJID_CLIENT 0xFFFFFFFC
72 #include "wx/menuitem.h"
75 #include "wx/msw/private.h"
78 #include "wx/tooltip.h"
86 #include "wx/spinctrl.h"
87 #endif // wxUSE_SPINCTRL
92 #include "wx/textctrl.h"
93 #include "wx/notebook.h"
94 #include "wx/listctrl.h"
98 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
100 #include <mmsystem.h>
104 #include <windowsx.h>
107 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
109 #include <commctrl.h>
111 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
112 #include "wx/msw/gnuwin32/extra.h"
115 #if defined(__GNUG__)
116 #include "wx/msw/missing.h"
119 #if defined(__WXWINCE__)
120 #include "wx/msw/wince/missing.h"
123 // ----------------------------------------------------------------------------
124 // standard constants not available with all compilers/headers
125 // ----------------------------------------------------------------------------
127 // This didn't appear in mingw until 2.95.2
129 #define SIF_TRACKPOS 16
133 #ifndef WM_MOUSEWHEEL
134 #define WM_MOUSEWHEEL 0x020A
137 #define WHEEL_DELTA 120
139 #ifndef SPI_GETWHEELSCROLLLINES
140 #define SPI_GETWHEELSCROLLLINES 104
142 #endif // wxUSE_MOUSEWHEEL
145 #define VK_OEM_1 0xBA
146 #define VK_OEM_2 0xBF
147 #define VK_OEM_3 0xC0
148 #define VK_OEM_4 0xDB
149 #define VK_OEM_5 0xDC
150 #define VK_OEM_6 0xDD
151 #define VK_OEM_7 0xDE
155 #define VK_OEM_PLUS 0xBB
156 #define VK_OEM_COMMA 0xBC
157 #define VK_OEM_MINUS 0xBD
158 #define VK_OEM_PERIOD 0xBE
161 // ---------------------------------------------------------------------------
163 // ---------------------------------------------------------------------------
165 // the last Windows message we got (FIXME-MT)
166 extern MSG s_currentMsg
;
168 #if wxUSE_MENUS_NATIVE
169 wxMenu
*wxCurrentPopupMenu
= NULL
;
170 #endif // wxUSE_MENUS_NATIVE
172 extern const wxChar
*wxCanvasClassName
;
174 // true if we had already created the std colour map, used by
175 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
176 static bool gs_hasStdCmap
= FALSE
;
178 // ---------------------------------------------------------------------------
180 // ---------------------------------------------------------------------------
182 // the window proc for all our windows
183 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
184 WPARAM wParam
, LPARAM lParam
);
188 const char *wxGetMessageName(int message
);
191 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
192 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
193 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
195 // this magical function is used to translate VK_APPS key presses to right
197 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
198 int *x
, int *y
, WPARAM
*flags
);
200 // get the text metrics for the current font
201 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
203 // find the window for the mouse event at the specified position
204 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
206 // wrapper around BringWindowToTop() API
207 static inline void wxBringWindowToTop(HWND hwnd
)
209 #ifdef __WXMICROWIN__
210 // It seems that MicroWindows brings the _parent_ of the window to the top,
211 // which can be the wrong one.
213 // activate (set focus to) specified window
217 // raise top level parent to top of z order
218 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
220 wxLogLastError(_T("SetWindowPos"));
224 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
225 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
228 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
229 parent as well as otherwise several Win32 functions using
230 GetNextDlgTabItem() to iterate over all controls such as
231 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
232 all of them iterate over all the controls starting from the currently
233 focused one and stop iterating when they get back to the focus but
234 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
235 get back to the initial (focused) window: as we do have this style,
236 GetNextDlgTabItem() will leave this window and continue in its parent,
237 but if the parent doesn't have it, it wouldn't recurse inside it later
238 on and so wouldn't have a chance of getting back to this window neither.
241 while ( parent
&& !parent
->IsTopLevel() )
243 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
244 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
246 // force the parent to have this style
247 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
248 exStyle
| WS_EX_CONTROLPARENT
);
251 parent
= parent
->GetParent();
253 #endif // !__WXWINCE__
256 // ---------------------------------------------------------------------------
258 // ---------------------------------------------------------------------------
260 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
262 #ifdef __WXUNIVERSAL__
263 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
265 #if wxUSE_EXTENDED_RTTI
267 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
268 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
269 // windows with negative ids never can be recreated anyway
271 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
273 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
274 if ( win
&& win
->GetId() < 0 )
279 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
281 // make wxWindowList known before the property is used
283 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
285 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
287 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
290 WX_DEFINE_FLAGS( wxWindowStyle
)
292 wxBEGIN_FLAGS( wxWindowStyle
)
293 // new style border flags, we put them first to
294 // use them for streaming out
296 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
297 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
298 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
299 wxFLAGS_MEMBER(wxBORDER_RAISED
)
300 wxFLAGS_MEMBER(wxBORDER_STATIC
)
301 wxFLAGS_MEMBER(wxBORDER_NONE
)
303 // old style border flags
304 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
305 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
306 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
307 wxFLAGS_MEMBER(wxRAISED_BORDER
)
308 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
309 wxFLAGS_MEMBER(wxNO_BORDER
)
311 // standard window styles
312 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
313 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
314 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
315 wxFLAGS_MEMBER(wxWANTS_CHARS
)
316 wxFLAGS_MEMBER(wxNO_FULL_REPAINT_ON_RESIZE
)
317 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
318 wxFLAGS_MEMBER(wxVSCROLL
)
319 wxFLAGS_MEMBER(wxHSCROLL
)
321 wxEND_FLAGS( wxWindowStyle
)
323 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
324 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
325 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
326 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
327 // Always constructor Properties first
329 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
330 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
331 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxPoint(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
332 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxSize(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
333 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
335 // Then all relations of the object graph
337 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
339 // and finally all other properties
341 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
342 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
343 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
344 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
345 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
347 // possible property candidates (not in xrc) or not valid in all subclasses
348 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxT("") )
349 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
350 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxT("") )
351 // MaxHeight, Width , MinHeight , Width
352 // TODO switch label to control and title to toplevels
354 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
355 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
356 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
357 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
362 wxEND_PROPERTIES_TABLE()
364 wxBEGIN_HANDLERS_TABLE(wxWindow
)
365 wxEND_HANDLERS_TABLE()
367 wxCONSTRUCTOR_DUMMY(wxWindow
)
370 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
372 #endif // __WXUNIVERSAL__/__WXMSW__
374 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
375 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
376 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
377 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
380 // ===========================================================================
382 // ===========================================================================
384 // ---------------------------------------------------------------------------
385 // wxWindow utility functions
386 // ---------------------------------------------------------------------------
388 // Find an item given the MS Windows id
389 wxWindow
*wxWindowMSW::FindItem(long id
) const
392 wxControl
*item
= wxDynamicCastThis(wxControl
);
395 // is it we or one of our "internal" children?
396 if ( item
->GetId() == id
397 #ifndef __WXUNIVERSAL__
398 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
399 #endif // __WXUNIVERSAL__
405 #endif // wxUSE_CONTROLS
407 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
410 wxWindow
*childWin
= current
->GetData();
412 wxWindow
*wnd
= childWin
->FindItem(id
);
416 current
= current
->GetNext();
422 // Find an item given the MS Windows handle
423 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
425 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
428 wxWindow
*parent
= current
->GetData();
430 // Do a recursive search.
431 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
437 || parent
->IsKindOf(CLASSINFO(wxControl
))
438 #endif // wxUSE_CONTROLS
441 wxWindow
*item
= current
->GetData();
442 if ( item
->GetHWND() == hWnd
)
446 if ( item
->ContainsHWND(hWnd
) )
451 current
= current
->GetNext();
456 // Default command handler
457 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
462 // ----------------------------------------------------------------------------
463 // constructors and such
464 // ----------------------------------------------------------------------------
466 void wxWindowMSW::Init()
472 m_isBeingDeleted
= FALSE
;
474 m_mouseInWindow
= FALSE
;
475 m_lastKeydownProcessed
= FALSE
;
477 m_childrenDisabled
= NULL
;
487 // as all windows are created with WS_VISIBLE style...
490 #if wxUSE_MOUSEEVENT_HACK
493 m_lastMouseEvent
= -1;
494 #endif // wxUSE_MOUSEEVENT_HACK
498 wxWindowMSW::~wxWindowMSW()
500 m_isBeingDeleted
= TRUE
;
502 #ifndef __WXUNIVERSAL__
503 // VS: make sure there's no wxFrame with last focus set to us:
504 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
506 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
509 if ( frame
->GetLastFocus() == this )
511 frame
->SetLastFocus(NULL
);
516 #endif // __WXUNIVERSAL__
518 // VS: destroy children first and _then_ detach *this from its parent.
519 // If we'd do it the other way around, children wouldn't be able
520 // find their parent frame (see above).
524 m_parent
->RemoveChild(this);
528 // VZ: test temp removed to understand what really happens here
529 //if (::IsWindow(GetHwnd()))
531 if ( !::DestroyWindow(GetHwnd()) )
532 wxLogLastError(wxT("DestroyWindow"));
535 // remove hWnd <-> wxWindow association
536 wxRemoveHandleAssociation(this);
539 delete m_childrenDisabled
;
542 // real construction (Init() must have been called before!)
543 bool wxWindowMSW::Create(wxWindow
*parent
,
548 const wxString
& name
)
550 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
552 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
555 parent
->AddChild(this);
558 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
560 #ifdef __WXUNIVERSAL__
561 // no borders, we draw them ourselves
562 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
566 msflags
&= ~WS_BORDER
;
567 #endif // wxUniversal
569 // all windows are created visible by default except popup ones (which are
570 // like the wxTopLevelWindows in this aspect)
571 if ( style
& wxPOPUP_WINDOW
)
573 msflags
&= ~WS_VISIBLE
;
578 msflags
|= WS_VISIBLE
;
581 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
584 // ---------------------------------------------------------------------------
586 // ---------------------------------------------------------------------------
588 void wxWindowMSW::SetFocus()
590 HWND hWnd
= GetHwnd();
591 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
593 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
597 if ( !::SetFocus(hWnd
) )
599 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
600 // was there really an error?
601 DWORD dwRes
= ::GetLastError();
604 HWND hwndFocus
= ::GetFocus();
605 if ( hwndFocus
!= hWnd
)
607 wxLogApiError(_T("SetFocus"), dwRes
);
614 void wxWindowMSW::SetFocusFromKbd()
616 // when the focus is given to the control with DLGC_HASSETSEL style from
617 // keyboard its contents should be entirely selected: this is what
618 // ::IsDialogMessage() does and so we should do it as well to provide the
619 // same LNF as the native programs
620 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
622 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
625 // do this after (maybe) setting the selection as like this when
626 // wxEVT_SET_FOCUS handler is called, the selection would have been already
627 // set correctly -- this may be important
628 wxWindowBase::SetFocusFromKbd();
631 // Get the window with the focus
632 wxWindow
*wxWindowBase::FindFocus()
634 HWND hWnd
= ::GetFocus();
637 return wxGetWindowFromHWND((WXHWND
)hWnd
);
643 bool wxWindowMSW::Enable(bool enable
)
645 if ( !wxWindowBase::Enable(enable
) )
648 HWND hWnd
= GetHwnd();
650 ::EnableWindow(hWnd
, (BOOL
)enable
);
652 // the logic below doesn't apply to the top level windows -- otherwise
653 // showing a modal dialog would result in total greying out (and ungreying
654 // out later) of everything which would be really ugly
658 // when the parent is disabled, all of its children should be disabled as
659 // well but when it is enabled back, only those of the children which
660 // hadn't been already disabled in the beginning should be enabled again,
661 // so we have to keep the list of those children
662 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
664 node
= node
->GetNext() )
666 wxWindow
*child
= node
->GetData();
667 if ( child
->IsTopLevel() )
669 // the logic below doesn't apply to top level children
675 // enable the child back unless it had been disabled before us
676 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
679 else // we're being disabled
681 if ( child
->IsEnabled() )
683 // disable it as children shouldn't stay enabled while the
687 else // child already disabled, remember it
689 // have we created the list of disabled children already?
690 if ( !m_childrenDisabled
)
691 m_childrenDisabled
= new wxWindowList
;
693 m_childrenDisabled
->Append(child
);
698 if ( enable
&& m_childrenDisabled
)
700 // we don't need this list any more, don't keep unused memory
701 delete m_childrenDisabled
;
702 m_childrenDisabled
= NULL
;
708 bool wxWindowMSW::Show(bool show
)
710 if ( !wxWindowBase::Show(show
) )
713 HWND hWnd
= GetHwnd();
714 int cshow
= show
? SW_SHOW
: SW_HIDE
;
715 ::ShowWindow(hWnd
, cshow
);
717 if ( show
&& IsTopLevel() )
719 wxBringWindowToTop(hWnd
);
725 // Raise the window to the top of the Z order
726 void wxWindowMSW::Raise()
728 wxBringWindowToTop(GetHwnd());
731 // Lower the window to the bottom of the Z order
732 void wxWindowMSW::Lower()
734 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
735 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
738 void wxWindowMSW::SetTitle( const wxString
& title
)
740 SetWindowText(GetHwnd(), title
.c_str());
743 wxString
wxWindowMSW::GetTitle() const
745 return wxGetWindowText(GetHWND());
748 void wxWindowMSW::DoCaptureMouse()
750 HWND hWnd
= GetHwnd();
757 void wxWindowMSW::DoReleaseMouse()
759 if ( !::ReleaseCapture() )
761 wxLogLastError(_T("ReleaseCapture"));
765 /* static */ wxWindow
*wxWindowBase::GetCapture()
767 HWND hwnd
= ::GetCapture();
768 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
771 bool wxWindowMSW::SetFont(const wxFont
& font
)
773 if ( !wxWindowBase::SetFont(font
) )
779 HWND hWnd
= GetHwnd();
782 WXHANDLE hFont
= m_font
.GetResourceHandle();
784 wxASSERT_MSG( hFont
, wxT("should have valid font") );
786 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
791 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
793 if ( !wxWindowBase::SetCursor(cursor
) )
801 HWND hWnd
= GetHwnd();
803 // Change the cursor NOW if we're within the correct window
805 ::GetCursorPos(&point
);
807 RECT rect
= wxGetWindowRect(hWnd
);
809 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
810 ::SetCursor(GetHcursorOf(m_cursor
));
816 void wxWindowMSW::WarpPointer (int x
, int y
)
818 ClientToScreen(&x
, &y
);
820 if ( !::SetCursorPos(x
, y
) )
822 wxLogLastError(_T("SetCursorPos"));
826 // ---------------------------------------------------------------------------
828 // ---------------------------------------------------------------------------
830 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
831 static inline int wxDirToWinStyle(int orient
)
833 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
836 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
838 #ifdef __WXMICROWIN__
839 return ::GetScrollPosWX(hWnd
, wOrient
);
841 WinStruct
<SCROLLINFO
> scrollInfo
;
842 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
843 scrollInfo
.fMask
= SIF_POS
;
844 if ( !::GetScrollInfo(hWnd
,
848 // Not neccessarily an error, if there are no scrollbars yet.
849 // wxLogLastError(_T("GetScrollInfo"));
851 return scrollInfo
.nPos
;
852 // return ::GetScrollPos(hWnd, wOrient);
856 int wxWindowMSW::GetScrollPos(int orient
) const
858 HWND hWnd
= GetHwnd();
859 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
861 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
864 // This now returns the whole range, not just the number
865 // of positions that we can scroll.
866 int wxWindowMSW::GetScrollRange(int orient
) const
869 HWND hWnd
= GetHwnd();
873 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
876 WinStruct
<SCROLLINFO
> scrollInfo
;
877 scrollInfo
.fMask
= SIF_RANGE
;
878 if ( !::GetScrollInfo(hWnd
,
879 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
882 // Most of the time this is not really an error, since the return
883 // value can also be zero when there is no scrollbar yet.
884 // wxLogLastError(_T("GetScrollInfo"));
886 maxPos
= scrollInfo
.nMax
;
888 // undo "range - 1" done in SetScrollbar()
892 int wxWindowMSW::GetScrollThumb(int orient
) const
894 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
897 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
899 HWND hWnd
= GetHwnd();
900 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
902 WinStruct
<SCROLLINFO
> info
;
906 info
.fMask
= SIF_POS
;
907 if ( HasFlag(wxALWAYS_SHOW_SB
) )
909 // disable scrollbar instead of removing it then
910 info
.fMask
|= SIF_DISABLENOSCROLL
;
913 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
917 // New function that will replace some of the above.
918 void wxWindowMSW::SetScrollbar(int orient
,
924 WinStruct
<SCROLLINFO
> info
;
925 info
.nPage
= pageSize
;
926 info
.nMin
= 0; // range is nMax - nMin + 1
927 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
929 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
930 if ( HasFlag(wxALWAYS_SHOW_SB
) )
932 // disable scrollbar instead of removing it then
933 info
.fMask
|= SIF_DISABLENOSCROLL
;
936 HWND hWnd
= GetHwnd();
939 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
943 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
946 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
952 rect
.left
= prect
->x
;
954 rect
.right
= prect
->x
+ prect
->width
;
955 rect
.bottom
= prect
->y
+ prect
->height
;
964 // FIXME: is this the exact equivalent of the line below?
965 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_ERASE
|SW_INVALIDATE
);
967 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
971 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
973 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
976 for ( int n
= 0; n
< count
; n
++ )
978 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
980 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
983 // don't bother to continue, we're already at top/bottom
990 return pos
!= posStart
;
993 bool wxWindowMSW::ScrollLines(int lines
)
995 bool down
= lines
> 0;
997 return ScrollVertically(GetHwnd(),
998 down
? SB_LINEDOWN
: SB_LINEUP
,
999 down
? lines
: -lines
);
1002 bool wxWindowMSW::ScrollPages(int pages
)
1004 bool down
= pages
> 0;
1006 return ScrollVertically(GetHwnd(),
1007 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1008 down
? pages
: -pages
);
1011 // ---------------------------------------------------------------------------
1013 // ---------------------------------------------------------------------------
1015 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1017 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1019 HWND hwnd
= (HWND
)hWnd
;
1020 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1022 wxAssociateWinWithHandle(hwnd
, this);
1024 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
1026 // we don't need to subclass the window of our own class (in the Windows
1027 // sense of the word)
1028 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1030 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
1034 // don't bother restoring it neither: this also makes it easy to
1035 // implement IsOfStandardClass() method which returns TRUE for the
1036 // standard controls and FALSE for the wxWindows own windows as it can
1037 // simply check m_oldWndProc
1038 m_oldWndProc
= NULL
;
1042 void wxWindowMSW::UnsubclassWin()
1044 wxRemoveHandleAssociation(this);
1046 // Restore old Window proc
1047 HWND hwnd
= GetHwnd();
1052 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1056 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1058 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
1061 m_oldWndProc
= NULL
;
1066 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1068 // Unicows note: the code below works, but only because WNDCLASS contains
1069 // original window handler rather that the unicows fake one. This may not
1070 // be on purpose, though; if it stops working with future versions of
1071 // unicows.dll, we can override unicows hooks by setting
1072 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1073 // versions that keep track of fake<->real wnd proc mapping.
1075 // On WinCE (at least), the wndproc comparison doesn't work,
1076 // so have to use something like this.
1078 extern const wxChar
*wxCanvasClassName
;
1079 extern const wxChar
*wxCanvasClassNameNR
;
1080 extern const wxChar
*wxMDIFrameClassName
;
1081 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1082 extern const wxChar
*wxMDIChildFrameClassName
;
1083 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1084 wxString
str(wxGetWindowClass(hWnd
));
1085 if (str
== wxCanvasClassName
||
1086 str
== wxCanvasClassNameNR
||
1087 str
== wxMDIFrameClassName
||
1088 str
== wxMDIFrameClassNameNoRedraw
||
1089 str
== wxMDIChildFrameClassName
||
1090 str
== wxMDIChildFrameClassNameNoRedraw
||
1091 str
== _T("wxTLWHiddenParent"))
1092 return TRUE
; // Effectively means don't subclass
1097 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1099 wxLogLastError(_T("GetClassInfo"));
1104 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1108 // ----------------------------------------------------------------------------
1110 // ----------------------------------------------------------------------------
1112 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1114 long flagsOld
= GetWindowStyleFlag();
1115 if ( flags
== flagsOld
)
1118 // update the internal variable
1119 wxWindowBase::SetWindowStyleFlag(flags
);
1121 // now update the Windows style as well if needed - and if the window had
1122 // been already created
1126 WXDWORD exstyle
, exstyleOld
;
1127 long style
= MSWGetStyle(flags
, &exstyle
),
1128 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1130 if ( style
!= styleOld
)
1132 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1133 // this function so instead of simply setting the style to the new
1134 // value we clear the bits which were set in styleOld but are set in
1135 // the new one and set the ones which were not set before
1136 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1137 styleReal
&= ~styleOld
;
1140 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1143 // and the extended style
1144 if ( exstyle
!= exstyleOld
)
1146 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1147 exstyleReal
&= ~exstyleOld
;
1148 exstyleReal
|= exstyle
;
1150 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1152 // we must call SetWindowPos() to flash the cached extended style and
1153 // also to make the change to wxSTAY_ON_TOP style take effect: just
1154 // setting the style simply doesn't work
1155 if ( !::SetWindowPos(GetHwnd(),
1156 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1159 SWP_NOMOVE
| SWP_NOSIZE
) )
1161 wxLogLastError(_T("SetWindowPos"));
1166 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1168 // translate the style
1169 WXDWORD style
= WS_CHILD
| WS_VISIBLE
;
1171 if ( flags
& wxCLIP_CHILDREN
)
1172 style
|= WS_CLIPCHILDREN
;
1174 if ( flags
& wxCLIP_SIBLINGS
)
1175 style
|= WS_CLIPSIBLINGS
;
1177 if ( flags
& wxVSCROLL
)
1178 style
|= WS_VSCROLL
;
1180 if ( flags
& wxHSCROLL
)
1181 style
|= WS_HSCROLL
;
1183 const wxBorder border
= GetBorder(flags
);
1185 // WS_BORDER is only required for wxBORDER_SIMPLE
1186 if ( border
== wxBORDER_SIMPLE
)
1189 // now deal with ext style if the caller wants it
1195 if ( flags
& wxTRANSPARENT_WINDOW
)
1196 *exstyle
|= WS_EX_TRANSPARENT
;
1202 case wxBORDER_DEFAULT
:
1203 wxFAIL_MSG( _T("unknown border style") );
1207 case wxBORDER_SIMPLE
:
1210 case wxBORDER_STATIC
:
1211 *exstyle
|= WS_EX_STATICEDGE
;
1214 case wxBORDER_RAISED
:
1215 *exstyle
|= WS_EX_DLGMODALFRAME
;
1218 case wxBORDER_SUNKEN
:
1219 *exstyle
|= WS_EX_CLIENTEDGE
;
1220 style
&= ~WS_BORDER
;
1223 case wxBORDER_DOUBLE
:
1224 *exstyle
|= WS_EX_DLGMODALFRAME
;
1228 // wxUniv doesn't use Windows dialog navigation functions at all
1229 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1230 // to make the dialog navigation work with the nested panels we must
1231 // use this style (top level windows such as dialogs don't need it)
1232 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1234 *exstyle
|= WS_EX_CONTROLPARENT
;
1236 #endif // __WXUNIVERSAL__
1242 // Setup background and foreground colours correctly
1243 void wxWindowMSW::SetupColours()
1246 SetBackgroundColour(GetParent()->GetBackgroundColour());
1249 bool wxWindowMSW::IsMouseInWindow() const
1251 // get the mouse position
1253 ::GetCursorPos(&pt
);
1255 // find the window which currently has the cursor and go up the window
1256 // chain until we find this window - or exhaust it
1257 HWND hwnd
= ::WindowFromPoint(pt
);
1258 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1259 hwnd
= ::GetParent(hwnd
);
1261 return hwnd
!= NULL
;
1264 void wxWindowMSW::OnInternalIdle()
1266 // Check if we need to send a LEAVE event
1267 if ( m_mouseInWindow
)
1269 // note that we should generate the leave event whether the window has
1270 // or doesn't have mouse capture
1271 if ( !IsMouseInWindow() )
1273 // Generate a LEAVE event
1274 m_mouseInWindow
= FALSE
;
1276 // Unfortunately the mouse button and keyboard state may have
1277 // changed by the time the OnInternalIdle function is called, so 'state'
1278 // may be meaningless.
1280 if ( wxIsShiftDown() )
1282 if ( wxIsCtrlDown() )
1283 state
|= MK_CONTROL
;
1284 if ( GetKeyState( VK_LBUTTON
) )
1285 state
|= MK_LBUTTON
;
1286 if ( GetKeyState( VK_MBUTTON
) )
1287 state
|= MK_MBUTTON
;
1288 if ( GetKeyState( VK_RBUTTON
) )
1289 state
|= MK_RBUTTON
;
1292 if ( !::GetCursorPos(&pt
) )
1294 wxLogLastError(_T("GetCursorPos"));
1297 // we need to have client coordinates here for symmetry with
1298 // wxEVT_ENTER_WINDOW
1299 RECT rect
= wxGetWindowRect(GetHwnd());
1303 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1304 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1306 (void)GetEventHandler()->ProcessEvent(event2
);
1310 if (wxUpdateUIEvent::CanUpdate(this))
1311 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1314 // Set this window to be the child of 'parent'.
1315 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1317 if ( !wxWindowBase::Reparent(parent
) )
1320 HWND hWndChild
= GetHwnd();
1321 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1323 ::SetParent(hWndChild
, hWndParent
);
1326 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1328 EnsureParentHasControlParentStyle(GetParent());
1330 #endif // !__WXWINCE__
1335 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1337 #ifndef __WXMICROWIN__
1338 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1342 void wxWindowMSW::Freeze()
1344 SendSetRedraw(GetHwnd(), FALSE
);
1347 void wxWindowMSW::Thaw()
1349 SendSetRedraw(GetHwnd(), TRUE
);
1351 // we need to refresh everything or otherwise he invalidated area is not
1356 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1358 HWND hWnd
= GetHwnd();
1364 mswRect
.left
= rect
->x
;
1365 mswRect
.top
= rect
->y
;
1366 mswRect
.right
= rect
->x
+ rect
->width
;
1367 mswRect
.bottom
= rect
->y
+ rect
->height
;
1369 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1372 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1376 void wxWindowMSW::Update()
1378 if ( !::UpdateWindow(GetHwnd()) )
1380 wxLogLastError(_T("UpdateWindow"));
1383 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1384 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1385 // handler needs to be really drawn right now
1390 // ---------------------------------------------------------------------------
1392 // ---------------------------------------------------------------------------
1395 #if wxUSE_DRAG_AND_DROP
1396 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1398 if ( m_dropTarget
!= 0 ) {
1399 m_dropTarget
->Revoke(m_hWnd
);
1400 delete m_dropTarget
;
1403 m_dropTarget
= pDropTarget
;
1404 if ( m_dropTarget
!= 0 )
1405 m_dropTarget
->Register(m_hWnd
);
1407 #endif // wxUSE_DRAG_AND_DROP
1409 // old style file-manager drag&drop support: we retain the old-style
1410 // DragAcceptFiles in parallel with SetDropTarget.
1411 void wxWindowMSW::DragAcceptFiles(bool accept
)
1413 #if !defined(__WXWINCE__)
1414 HWND hWnd
= GetHwnd();
1416 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1420 // ----------------------------------------------------------------------------
1422 // ----------------------------------------------------------------------------
1426 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1428 wxWindowBase::DoSetToolTip(tooltip
);
1431 m_tooltip
->SetWindow((wxWindow
*)this);
1434 #endif // wxUSE_TOOLTIPS
1436 // ---------------------------------------------------------------------------
1437 // moving and resizing
1438 // ---------------------------------------------------------------------------
1441 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1443 RECT rect
= wxGetWindowRect(GetHwnd());
1446 *x
= rect
.right
- rect
.left
;
1448 *y
= rect
.bottom
- rect
.top
;
1451 // Get size *available for subwindows* i.e. excluding menu bar etc.
1452 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1454 RECT rect
= wxGetClientRect(GetHwnd());
1462 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1464 RECT rect
= wxGetWindowRect(GetHwnd());
1467 point
.x
= rect
.left
;
1470 // we do the adjustments with respect to the parent only for the "real"
1471 // children, not for the dialogs/frames
1472 if ( !IsTopLevel() )
1474 HWND hParentWnd
= 0;
1475 wxWindow
*parent
= GetParent();
1477 hParentWnd
= GetWinHwnd(parent
);
1479 // Since we now have the absolute screen coords, if there's a parent we
1480 // must subtract its top left corner
1483 ::ScreenToClient(hParentWnd
, &point
);
1488 // We may be faking the client origin. So a window that's really at (0,
1489 // 30) may appear (to wxWin apps) to be at (0, 0).
1490 wxPoint
pt(parent
->GetClientAreaOrigin());
1502 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1510 ::ScreenToClient(GetHwnd(), &pt
);
1518 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1526 ::ClientToScreen(GetHwnd(), &pt
);
1534 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1536 // TODO: is this consistent with other platforms?
1537 // Still, negative width or height shouldn't be allowed
1542 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1544 wxLogLastError(wxT("MoveWindow"));
1548 // set the size of the window: if the dimensions are positive, just use them,
1549 // but if any of them is equal to -1, it means that we must find the value for
1550 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1551 // which case -1 is a valid value for x and y)
1553 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1554 // the width/height to best suit our contents, otherwise we reuse the current
1556 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1558 // get the current size and position...
1559 int currentX
, currentY
;
1560 GetPosition(¤tX
, ¤tY
);
1561 int currentW
,currentH
;
1562 GetSize(¤tW
, ¤tH
);
1564 // ... and don't do anything (avoiding flicker) if it's already ok
1565 if ( x
== currentX
&& y
== currentY
&&
1566 width
== currentW
&& height
== currentH
)
1571 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1573 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1576 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1578 wxSize
size(-1, -1);
1581 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1583 size
= DoGetBestSize();
1588 // just take the current one
1595 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1599 size
= DoGetBestSize();
1601 //else: already called DoGetBestSize() above
1607 // just take the current one
1612 DoMoveWindow(x
, y
, width
, height
);
1615 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1617 // setting the client size is less obvious than it it could have been
1618 // because in the result of changing the total size the window scrollbar
1619 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1620 // will not be correct as the difference between the total and client size
1621 // changes - so we keep changing it until we get it right
1623 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1624 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1625 // may become 3 if the window had 0 size originally and so we didn't
1626 // calculate the scrollbar correction correctly during the first iteration)
1627 // but just to be on the safe side we check for it instead of making it an
1628 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1629 for ( int i
= 0; i
< 4; i
++ )
1632 ::GetClientRect(GetHwnd(), &rectClient
);
1634 // if the size is already ok, stop here (rectClient.left = top = 0)
1635 if ( (rectClient
.right
== width
|| width
== -1) &&
1636 (rectClient
.bottom
== height
|| height
== -1) )
1641 int widthClient
= width
,
1642 heightClient
= height
;
1644 // Find the difference between the entire window (title bar and all)
1645 // and the client area; add this to the new client size to move the
1648 ::GetWindowRect(GetHwnd(), &rectWin
);
1650 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1651 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1654 point
.x
= rectWin
.left
;
1655 point
.y
= rectWin
.top
;
1657 // MoveWindow positions the child windows relative to the parent, so
1658 // adjust if necessary
1659 if ( !IsTopLevel() )
1661 wxWindow
*parent
= GetParent();
1664 ::ScreenToClient(GetHwndOf(parent
), &point
);
1668 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1672 // For implementation purposes - sometimes decorations make the client area
1674 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1676 return wxPoint(0, 0);
1679 // ---------------------------------------------------------------------------
1681 // ---------------------------------------------------------------------------
1683 int wxWindowMSW::GetCharHeight() const
1685 return wxGetTextMetrics(this).tmHeight
;
1688 int wxWindowMSW::GetCharWidth() const
1690 // +1 is needed because Windows apparently adds it when calculating the
1691 // dialog units size in pixels
1692 #if wxDIALOG_UNIT_COMPATIBILITY
1693 return wxGetTextMetrics(this).tmAveCharWidth
;
1695 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1699 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1701 int *descent
, int *externalLeading
,
1702 const wxFont
*theFont
) const
1704 const wxFont
*fontToUse
= theFont
;
1706 fontToUse
= &m_font
;
1708 HWND hWnd
= GetHwnd();
1709 HDC dc
= ::GetDC(hWnd
);
1713 if ( fontToUse
&& fontToUse
->Ok() )
1715 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1717 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1722 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1723 GetTextMetrics(dc
, &tm
);
1725 if ( fontToUse
&& fnt
&& hfontOld
)
1726 SelectObject(dc
, hfontOld
);
1728 ReleaseDC(hWnd
, dc
);
1735 *descent
= tm
.tmDescent
;
1736 if ( externalLeading
)
1737 *externalLeading
= tm
.tmExternalLeading
;
1740 // ---------------------------------------------------------------------------
1742 // ---------------------------------------------------------------------------
1744 #if wxUSE_MENUS_NATIVE
1746 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1747 // immediately, without waiting for the next event loop iteration
1749 // NB: this function should probably be made public later as it can almost
1750 // surely replace wxYield() elsewhere as well
1751 static void wxYieldForCommandsOnly()
1753 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1754 // want to process it here)
1756 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1757 && msg
.message
!= WM_QUIT
)
1759 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1762 // If we retrieved a WM_QUIT, insert back into the message queue.
1763 if (msg
.message
== WM_QUIT
)
1764 ::PostQuitMessage(0);
1767 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1769 menu
->SetInvokingWindow(this);
1772 HWND hWnd
= GetHwnd();
1773 HMENU hMenu
= GetHmenuOf(menu
);
1777 ::ClientToScreen(hWnd
, &point
);
1778 wxCurrentPopupMenu
= menu
;
1780 #if !defined(__WXWINCE__)
1781 flags
= TPM_RIGHTBUTTON
;
1783 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1785 // we need to do it righ now as otherwise the events are never going to be
1786 // sent to wxCurrentPopupMenu from HandleCommand()
1788 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1789 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1790 // destroyed as soon as we return (it can be a local variable in the caller
1791 // for example) and so we do need to process the event immediately
1792 wxYieldForCommandsOnly();
1794 wxCurrentPopupMenu
= NULL
;
1796 menu
->SetInvokingWindow(NULL
);
1801 #endif // wxUSE_MENUS_NATIVE
1803 // ===========================================================================
1804 // pre/post message processing
1805 // ===========================================================================
1807 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1810 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1812 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1815 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1817 // wxUniversal implements tab traversal itself
1818 #ifndef __WXUNIVERSAL__
1819 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1821 // intercept dialog navigation keys
1822 MSG
*msg
= (MSG
*)pMsg
;
1824 // here we try to do all the job which ::IsDialogMessage() usually does
1827 if ( msg
->message
== WM_KEYDOWN
)
1829 bool bCtrlDown
= wxIsCtrlDown();
1830 bool bShiftDown
= wxIsShiftDown();
1832 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1833 // don't process it if it's the case (except for Ctrl-Tab/Enter
1834 // combinations which are always processed)
1838 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1840 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1841 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1842 // it, of course, implies them
1843 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1845 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1849 bool bForward
= TRUE
,
1850 bWindowChange
= FALSE
;
1852 // should we process this message specially?
1853 bool bProcess
= TRUE
;
1854 switch ( msg
->wParam
)
1857 // assume that nobody wants Shift-TAB for himself - if we
1858 // don't do it there is no easy way for a control to grab
1859 // TABs but still let Shift-TAB work as navugation key
1860 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1864 // Ctrl-Tab cycles thru notebook pages
1865 bWindowChange
= bCtrlDown
;
1866 bForward
= !bShiftDown
;
1872 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1880 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1886 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1888 // control wants to process Enter itself, don't
1889 // call IsDialogMessage() which would interpret
1893 else if ( lDlgCode
& DLGC_BUTTON
)
1895 // let IsDialogMessage() handle this for all
1896 // buttons except the owner-drawn ones which it
1897 // just seems to ignore
1898 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1899 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1901 // emulate the button click
1902 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1904 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1909 // FIXME: this should be handled by
1910 // wxNavigationKeyEvent handler and not here!!
1914 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1916 if ( btn
&& btn
->IsEnabled() )
1918 // if we do have a default button, do press it
1919 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1923 else // no default button
1925 #endif // wxUSE_BUTTON
1926 // this is a quick and dirty test for a text
1928 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1930 // don't process Enter, the control might
1931 // need it for itself and don't let
1932 // ::IsDialogMessage() have it as it can
1933 // eat the Enter events sometimes
1936 else if (!IsTopLevel())
1938 // if not a top level window, let parent
1942 //else: treat Enter as TAB: pass to the next
1943 // control as this is the best thing to do
1944 // if the text doesn't handle Enter itself
1956 wxNavigationKeyEvent event
;
1957 event
.SetDirection(bForward
);
1958 event
.SetWindowChange(bWindowChange
);
1959 event
.SetEventObject(this);
1961 if ( GetEventHandler()->ProcessEvent(event
) )
1968 // let ::IsDialogMessage() do almost everything and handle just the
1969 // things it doesn't here: Ctrl-TAB for switching notebook pages
1970 if ( msg
->message
== WM_KEYDOWN
)
1972 // don't process system keys here
1973 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1975 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1977 // find the first notebook parent and change its page
1978 wxWindow
*win
= this;
1979 wxNotebook
*nbook
= NULL
;
1980 while ( win
&& !nbook
)
1982 nbook
= wxDynamicCast(win
, wxNotebook
);
1983 win
= win
->GetParent();
1988 bool forward
= !wxIsShiftDown();
1990 nbook
->AdvanceSelection(forward
);
1997 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1998 // shouldn't let IsDialogMessage() get it as it _always_ eats the
1999 // message even when there is no cancel button and when the message is
2000 // needed by the control itself: in particular, it prevents the tree in
2001 // place edit control from being closed with Escape in a dialog
2002 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2004 // ::IsDialogMessage() is broken and may sometimes hang the
2005 // application by going into an infinite loop, so we try to detect
2006 // [some of] the situatations when this may happen and not call it
2009 // assume we can call it by default
2010 bool canSafelyCallIsDlgMsg
= TRUE
;
2012 HWND hwndFocus
= ::GetFocus();
2014 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2015 // an infinite loop, because it will recursively check the child
2016 // windows but not the window itself and so if none of the children
2017 // accepts focus it loops forever (as it only stops when it gets
2018 // back to the window it started from)
2020 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2021 // style has the focus, it can happen. One such possibility is if
2022 // all windows are either toplevel, wxDialog, wxPanel or static
2023 // controls and no window can actually accept keyboard input.
2024 #if !defined(__WXWINCE__)
2025 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2027 // passimistic by default
2028 canSafelyCallIsDlgMsg
= FALSE
;
2029 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2031 node
= node
->GetNext() )
2033 wxWindow
* const win
= node
->GetData();
2034 if ( win
->AcceptsFocus() &&
2035 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2036 WS_EX_CONTROLPARENT
) )
2038 // it shouldn't hang...
2039 canSafelyCallIsDlgMsg
= TRUE
;
2045 #endif // !__WXWINCE__
2047 if ( canSafelyCallIsDlgMsg
)
2049 // ::IsDialogMessage() can enter in an infinite loop when the
2050 // currently focused window is disabled or hidden and its
2051 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2055 if ( !::IsWindowEnabled(hwndFocus
) ||
2056 !::IsWindowVisible(hwndFocus
) )
2058 // it would enter an infinite loop if we do this!
2059 canSafelyCallIsDlgMsg
= FALSE
;
2064 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2066 // it's a top level window, don't go further -- e.g. even
2067 // if the parent of a dialog is disabled, this doesn't
2068 // break navigation inside the dialog
2072 hwndFocus
= ::GetParent(hwndFocus
);
2076 // let IsDialogMessage() have the message if it's safe to call it
2077 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2079 // IsDialogMessage() did something...
2084 #endif // __WXUNIVERSAL__
2089 // relay mouse move events to the tooltip control
2090 MSG
*msg
= (MSG
*)pMsg
;
2091 if ( msg
->message
== WM_MOUSEMOVE
)
2092 m_tooltip
->RelayEvent(pMsg
);
2094 #endif // wxUSE_TOOLTIPS
2099 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2101 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2102 return m_acceleratorTable
.Translate(this, pMsg
);
2106 #endif // wxUSE_ACCEL
2109 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2111 // preprocess all messages by default
2115 // ---------------------------------------------------------------------------
2116 // message params unpackers
2117 // ---------------------------------------------------------------------------
2119 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2120 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2122 *id
= LOWORD(wParam
);
2123 *hwnd
= (WXHWND
)lParam
;
2124 *cmd
= HIWORD(wParam
);
2127 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2128 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2130 *state
= LOWORD(wParam
);
2131 *minimized
= HIWORD(wParam
);
2132 *hwnd
= (WXHWND
)lParam
;
2135 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2136 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2138 *code
= LOWORD(wParam
);
2139 *pos
= HIWORD(wParam
);
2140 *hwnd
= (WXHWND
)lParam
;
2143 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2144 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2146 #ifndef __WXMICROWIN__
2147 *nCtlColor
= CTLCOLOR_BTN
;
2148 *hwnd
= (WXHWND
)lParam
;
2149 *hdc
= (WXHDC
)wParam
;
2153 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2154 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2156 *item
= (WXWORD
)wParam
;
2157 *flags
= HIWORD(wParam
);
2158 *hmenu
= (WXHMENU
)lParam
;
2161 // ---------------------------------------------------------------------------
2162 // Main wxWindows window proc and the window proc for wxWindow
2163 // ---------------------------------------------------------------------------
2165 // Hook for new window just as it's being created, when the window isn't yet
2166 // associated with the handle
2167 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2169 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2170 // window being created and insures that it's always unset back later
2171 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2173 gs_winBeingCreated
= winBeingCreated
;
2176 wxWindowCreationHook::~wxWindowCreationHook()
2178 gs_winBeingCreated
= NULL
;
2182 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2184 // trace all messages - useful for the debugging
2186 wxLogTrace(wxTraceMessages
,
2187 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2188 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2189 #endif // __WXDEBUG__
2191 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2193 // when we get the first message for the HWND we just created, we associate
2194 // it with wxWindow stored in gs_winBeingCreated
2195 if ( !wnd
&& gs_winBeingCreated
)
2197 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2198 wnd
= gs_winBeingCreated
;
2199 gs_winBeingCreated
= NULL
;
2200 wnd
->SetHWND((WXHWND
)hWnd
);
2206 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2208 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2213 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2215 // did we process the message?
2216 bool processed
= FALSE
;
2227 // for most messages we should return 0 when we do process the message
2235 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2238 // return 0 to allow window creation
2239 rc
.result
= mayCreate
? 0 : -1;
2245 // never set processed to TRUE and *always* pass WM_DESTROY to
2246 // DefWindowProc() as Windows may do some internal cleanup when
2247 // processing it and failing to pass the message along may cause
2248 // memory and resource leaks!
2249 (void)HandleDestroy();
2253 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2256 #if !defined(__WXWINCE__)
2259 LPRECT pRect
= (LPRECT
)lParam
;
2261 rc
.SetLeft(pRect
->left
);
2262 rc
.SetTop(pRect
->top
);
2263 rc
.SetRight(pRect
->right
);
2264 rc
.SetBottom(pRect
->bottom
);
2265 processed
= HandleMoving(rc
);
2267 pRect
->left
= rc
.GetLeft();
2268 pRect
->top
= rc
.GetTop();
2269 pRect
->right
= rc
.GetRight();
2270 pRect
->bottom
= rc
.GetBottom();
2281 // we're not interested in these messages at all
2284 case SIZE_MINIMIZED
:
2285 // we shouldn't send sizev events for these messages as the
2286 // client size may be negative which breaks existing code
2288 // OTOH we might send another (wxMinimizedEvent?) one or
2289 // add an additional parameter to wxSizeEvent if this is
2290 // useful to anybody
2294 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2295 // fall through nevertheless
2297 case SIZE_MAXIMIZED
:
2299 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2304 #if !defined(__WXWINCE__)
2307 LPRECT pRect
= (LPRECT
)lParam
;
2309 rc
.SetLeft(pRect
->left
);
2310 rc
.SetTop(pRect
->top
);
2311 rc
.SetRight(pRect
->right
);
2312 rc
.SetBottom(pRect
->bottom
);
2313 processed
= HandleSizing(rc
);
2315 pRect
->left
= rc
.GetLeft();
2316 pRect
->top
= rc
.GetTop();
2317 pRect
->right
= rc
.GetRight();
2318 pRect
->bottom
= rc
.GetBottom();
2324 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2325 case WM_ACTIVATEAPP
:
2326 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2332 WXWORD state
, minimized
;
2334 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2336 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2341 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2345 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2352 // cast to wxWindow is needed for wxUniv
2353 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2354 processed
= HandlePaint();
2358 processed
= HandlePaint();
2366 // Don't call the wx handlers in this case
2367 if ( wxIsKindOf(this, wxListCtrl
) )
2370 if ( lParam
& PRF_ERASEBKGND
)
2371 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2373 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2374 processed
= HandlePaint();
2380 #ifdef __WXUNIVERSAL__
2381 // Universal uses its own wxFrame/wxDialog, so we don't receive
2382 // close events unless we have this.
2387 // don't let the DefWindowProc() destroy our window - we'll do it
2388 // ourselves in ~wxWindow
2395 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2399 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2400 GET_Y_LPARAM(lParam
),
2404 #if wxUSE_MOUSEWHEEL
2406 processed
= HandleMouseWheel(wParam
, lParam
);
2410 case WM_LBUTTONDOWN
:
2412 case WM_LBUTTONDBLCLK
:
2413 case WM_RBUTTONDOWN
:
2415 case WM_RBUTTONDBLCLK
:
2416 case WM_MBUTTONDOWN
:
2418 case WM_MBUTTONDBLCLK
:
2420 #ifdef __WXMICROWIN__
2421 // MicroWindows seems to ignore the fact that a window is
2422 // disabled. So catch mouse events and throw them away if
2424 wxWindowMSW
* win
= this;
2427 if (!win
->IsEnabled())
2433 win
= win
->GetParent();
2434 if ( !win
|| win
->IsTopLevel() )
2441 #endif // __WXMICROWIN__
2442 int x
= GET_X_LPARAM(lParam
),
2443 y
= GET_Y_LPARAM(lParam
);
2445 // redirect the event to a static control if necessary by
2446 // finding one under mouse
2448 if ( GetCapture() == this )
2450 // but don't do it if the mouse is captured by this window
2451 // because then it should really get this event itself
2456 win
= FindWindowForMouseEvent(this, &x
, &y
);
2458 // this should never happen
2459 wxCHECK_MSG( win
, 0,
2460 _T("FindWindowForMouseEvent() returned NULL") );
2462 // for the standard classes their WndProc sets the focus to
2463 // them anyhow and doing it from here results in some weird
2464 // problems, but for our windows we want them to acquire
2465 // focus when clicked
2466 if ( !win
->IsOfStandardClass() )
2468 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2473 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2482 case MM_JOY1BUTTONDOWN
:
2483 case MM_JOY2BUTTONDOWN
:
2484 case MM_JOY1BUTTONUP
:
2485 case MM_JOY2BUTTONUP
:
2486 processed
= HandleJoystickEvent(message
,
2487 GET_X_LPARAM(lParam
),
2488 GET_Y_LPARAM(lParam
),
2491 #endif // __WXMICROWIN__
2494 processed
= HandleSysCommand(wParam
, lParam
);
2501 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2503 processed
= HandleCommand(id
, cmd
, hwnd
);
2508 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2511 // for these messages we must return TRUE if process the message
2514 case WM_MEASUREITEM
:
2516 int idCtrl
= (UINT
)wParam
;
2517 if ( message
== WM_DRAWITEM
)
2519 processed
= MSWOnDrawItem(idCtrl
,
2520 (WXDRAWITEMSTRUCT
*)lParam
);
2524 processed
= MSWOnMeasureItem(idCtrl
,
2525 (WXMEASUREITEMSTRUCT
*)lParam
);
2532 #endif // defined(WM_DRAWITEM)
2535 if ( !IsOfStandardClass() )
2537 // we always want to get the char events
2538 rc
.result
= DLGC_WANTCHARS
;
2540 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2542 // in fact, we want everything
2543 rc
.result
|= DLGC_WANTARROWS
|
2550 //else: get the dlg code from the DefWindowProc()
2555 // If this has been processed by an event handler, return 0 now
2556 // (we've handled it).
2557 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2558 if ( m_lastKeydownProcessed
)
2567 // we consider these message "not interesting" to OnChar, so
2568 // just don't do anything more with them
2578 // avoid duplicate messages to OnChar for these ASCII keys:
2579 // they will be translated by TranslateMessage() and received
2601 // but set processed to FALSE, not TRUE to still pass them
2602 // to the control's default window proc - otherwise
2603 // built-in keyboard handling won't work
2608 // special case of VK_APPS: treat it the same as right mouse
2609 // click because both usually pop up a context menu
2615 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2616 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2622 // do generate a CHAR event
2623 processed
= HandleChar((WORD
)wParam
, lParam
);
2626 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2633 // special case of VK_APPS: treat it the same as right mouse button
2634 if ( wParam
== VK_APPS
)
2639 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2640 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2645 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2650 case WM_CHAR
: // Always an ASCII character
2651 if ( m_lastKeydownProcessed
)
2653 // The key was handled in the EVT_KEY_DOWN and handling
2654 // a key in an EVT_KEY_DOWN handler is meant, by
2655 // design, to prevent EVT_CHARs from happening
2656 m_lastKeydownProcessed
= FALSE
;
2661 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2667 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2669 #endif // wxUSE_HOTKEY
2676 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2678 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2684 // CTLCOLOR messages are sent by children to query the parent for their
2685 // colors#ifndef __WXMICROWIN__
2686 #ifndef __WXMICROWIN__
2687 case WM_CTLCOLORMSGBOX
:
2688 case WM_CTLCOLOREDIT
:
2689 case WM_CTLCOLORLISTBOX
:
2690 case WM_CTLCOLORBTN
:
2691 case WM_CTLCOLORDLG
:
2692 case WM_CTLCOLORSCROLLBAR
:
2693 case WM_CTLCOLORSTATIC
:
2698 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2700 processed
= HandleCtlColor(&rc
.hBrush
,
2709 #endif // !__WXMICROWIN__
2711 case WM_SYSCOLORCHANGE
:
2712 // the return value for this message is ignored
2713 processed
= HandleSysColorChange();
2716 #if !defined(__WXWINCE__)
2717 case WM_DISPLAYCHANGE
:
2718 processed
= HandleDisplayChange();
2722 case WM_PALETTECHANGED
:
2723 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2726 case WM_CAPTURECHANGED
:
2727 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2730 case WM_QUERYNEWPALETTE
:
2731 processed
= HandleQueryNewPalette();
2735 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2738 // we processed the message, i.e. erased the background
2743 #if !defined(__WXWINCE__)
2745 processed
= HandleDropFiles(wParam
);
2750 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2754 // we never set focus from here
2759 #if !defined(__WXWINCE__)
2760 case WM_QUERYENDSESSION
:
2761 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2765 processed
= HandleEndSession(wParam
!= 0, lParam
);
2768 case WM_GETMINMAXINFO
:
2769 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2774 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2775 LOWORD(lParam
), // hit test
2776 HIWORD(lParam
)); // mouse msg
2780 // returning TRUE stops the DefWindowProc() from further
2781 // processing this message - exactly what we need because we've
2782 // just set the cursor.
2787 #if wxUSE_ACCESSIBILITY
2790 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2791 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2793 if (dwObjId
== OBJID_CLIENT
&& GetOrCreateAccessible())
2795 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2801 #if defined(WM_HELP)
2804 // HELPINFO doesn't seem to be supported on WinCE.
2806 HELPINFO
* info
= (HELPINFO
*) lParam
;
2807 // Don't yet process menu help events, just windows
2808 if (info
->iContextType
== HELPINFO_WINDOW
)
2811 wxWindowMSW
* subjectOfHelp
= this;
2812 bool eventProcessed
= FALSE
;
2813 while (subjectOfHelp
&& !eventProcessed
)
2815 wxHelpEvent
helpEvent(wxEVT_HELP
,
2816 subjectOfHelp
->GetId(),
2820 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2824 helpEvent
.SetEventObject(this);
2826 GetEventHandler()->ProcessEvent(helpEvent
);
2828 // Go up the window hierarchy until the event is
2830 subjectOfHelp
= subjectOfHelp
->GetParent();
2833 processed
= eventProcessed
;
2836 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2838 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2839 helpEvent
.SetEventObject(this);
2840 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2843 //else: processed is already FALSE
2849 #if !defined(__WXWINCE__)
2850 case WM_CONTEXTMENU
:
2852 // we don't convert from screen to client coordinates as
2853 // the event may be handled by a parent window
2854 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2856 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2857 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2863 // we're only interested in our own menus, not MF_SYSMENU
2864 if ( HIWORD(wParam
) == MF_POPUP
)
2866 // handle menu chars for ownerdrawn menu items
2867 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2868 if ( i
!= wxNOT_FOUND
)
2870 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2880 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2881 wxGetMessageName(message
));
2882 #endif // __WXDEBUG__
2883 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2889 // ----------------------------------------------------------------------------
2890 // wxWindow <-> HWND map
2891 // ----------------------------------------------------------------------------
2893 wxWinHashTable
*wxWinHandleHash
= NULL
;
2895 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2897 return wxWinHandleHash
->Get((long)hWnd
);
2900 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2902 // adding NULL hWnd is (first) surely a result of an error and
2903 // (secondly) breaks menu command processing
2904 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2905 wxT("attempt to add a NULL hWnd to window list ignored") );
2907 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2909 if ( oldWin
&& (oldWin
!= win
) )
2911 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2912 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2915 #endif // __WXDEBUG__
2918 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2922 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2924 wxWinHandleHash
->Delete((long)win
->GetHWND());
2927 // ----------------------------------------------------------------------------
2928 // various MSW speciic class dependent functions
2929 // ----------------------------------------------------------------------------
2931 // Default destroyer - override if you destroy it in some other way
2932 // (e.g. with MDI child windows)
2933 void wxWindowMSW::MSWDestroyWindow()
2937 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2940 int& w
, int& h
) const
2942 static const int DEFAULT_Y
= 200;
2943 static const int DEFAULT_H
= 250;
2945 bool nonDefault
= FALSE
;
2949 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2950 // just as well set it to CW_USEDEFAULT as well
2956 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2957 // neither because it is not handled as a special value by Windows then
2958 // and so we have to choose some default value for it
2960 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2966 NB: there used to be some code here which set the initial size of the
2967 window to the client size of the parent if no explicit size was
2968 specified. This was wrong because wxWindows programs often assume
2969 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2970 it. To see why, you should understand that Windows sends WM_SIZE from
2971 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2972 from some base class ctor and so this WM_SIZE is not processed in the
2973 real class' OnSize() (because it's not fully constructed yet and the
2974 event goes to some base class OnSize() instead). So the WM_SIZE we
2975 rely on is the one sent when the parent frame resizes its children
2976 but here is the problem: if the child already has just the right
2977 size, nothing will happen as both wxWindows and Windows check for
2978 this and ignore any attempts to change the window size to the size it
2979 already has - so no WM_SIZE would be sent.
2983 // as above, h is not used at all in this case anyhow
2989 // and, again as above, we can't set the height to CW_USEDEFAULT here
2991 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2999 WXHWND
wxWindowMSW::MSWGetParent() const
3001 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3004 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3005 const wxChar
*title
,
3009 WXDWORD extendedStyle
)
3011 // choose the position/size for the new window
3013 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3015 // controlId is menu handle for the top level windows, so set it to 0
3016 // unless we're creating a child window
3017 int controlId
= style
& WS_CHILD
? GetId() : 0;
3019 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3020 // which is the same but without CS_[HV]REDRAW class styles so using it
3021 // ensures that the window is not fully repainted on each resize
3022 wxString
className(wclass
);
3023 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
3025 className
+= wxT("NR");
3028 // do create the window
3029 wxWindowCreationHook
hook(this);
3032 if (extendedStyle
== 0)
3034 m_hWnd
= (WXHWND
)::CreateWindow
3037 title
? title
: wxEmptyString
,
3040 (HWND
)MSWGetParent(),
3043 NULL
// no extra data
3049 m_hWnd
= (WXHWND
)::CreateWindowEx
3053 title
? title
: wxEmptyString
,
3056 (HWND
)MSWGetParent(),
3059 NULL
// no extra data
3065 wxLogSysError(_("Can't create window of class %s"), wclass
);
3070 SubclassWin(m_hWnd
);
3072 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
3077 // ===========================================================================
3078 // MSW message handlers
3079 // ===========================================================================
3081 // ---------------------------------------------------------------------------
3083 // ---------------------------------------------------------------------------
3087 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3089 #ifndef __WXMICROWIN__
3090 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3091 HWND hWnd
= hdr
->hwndFrom
;
3092 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3094 // if the control is one of our windows, let it handle the message itself
3097 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3100 // VZ: why did we do it? normally this is unnecessary and, besides, it
3101 // breaks the message processing for the toolbars because the tooltip
3102 // notifications were being forwarded to the toolbar child controls
3103 // (if it had any) before being passed to the toolbar itself, so in my
3104 // example the tooltip for the combobox was always shown instead of the
3105 // correct button tooltips
3107 // try all our children
3108 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3111 wxWindow
*child
= node
->GetData();
3112 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3117 node
= node
->GetNext();
3121 // by default, handle it ourselves
3122 return MSWOnNotify(idCtrl
, lParam
, result
);
3123 #else // __WXMICROWIN__
3130 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3132 const wxString
& ttip
)
3134 // I don't know why it happens, but the versions of comctl32.dll starting
3135 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3136 // this message is supposed to be sent to Unicode programs only) -- hence
3137 // we need to handle it as well, otherwise no tooltips will be shown in
3140 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
3142 // not a tooltip message or no tooltip to show anyhow
3147 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3150 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
3152 // we pass just the pointer as we store the string internally anyhow
3153 ttText
->lpszText
= (char *)ttip
.c_str();
3155 else // TTN_NEEDTEXTW
3159 // in Unicode mode this is just what we need
3160 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3163 MultiByteToWideChar(CP_ACP, 0, ttip, ttip.length()+1,
3164 (wchar_t *)ttText->szText,
3165 sizeof(ttText->szText) / sizeof(wchar_t));
3167 // Fix by dimitrishortcut: see patch 771772
3169 // FIXME: szText has a max of 80 bytes, so limit the tooltip string
3170 // length accordingly. Ideally lpszText should be used, but who
3171 // would be responsible for freeing the buffer?
3173 // Maximum length of a tip is 39 characters. 39 is 80/2 minus 1 byte
3174 // needed for NULL character.
3175 size_t tipLength
= wxMin(ttip
.Len(), 39);
3177 // Convert to WideChar without adding the NULL character. The NULL
3178 // character is added afterwards (Could have used ttip.Left(tipLength)
3179 // and a cchMultiByte parameter of tipLength+1, but this is more
3181 ::MultiByteToWideChar(CP_ACP
, 0, ttip
, tipLength
,
3182 (wchar_t *)ttText
->szText
,
3183 sizeof(ttText
->szText
) / sizeof(wchar_t));
3185 // Add the NULL character.
3186 ttText
->szText
[tipLength
*2+0] = '\0';
3187 ttText
->szText
[tipLength
*2+1] = '\0';
3189 #endif // Unicode/!Unicode
3195 #endif // wxUSE_TOOLTIPS
3197 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3199 WXLPARAM
* WXUNUSED(result
))
3204 NMHDR
* hdr
= (NMHDR
*)lParam
;
3205 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3211 #endif // wxUSE_TOOLTIPS
3218 // ---------------------------------------------------------------------------
3219 // end session messages
3220 // ---------------------------------------------------------------------------
3222 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3225 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3226 event
.SetEventObject(wxTheApp
);
3227 event
.SetCanVeto(TRUE
);
3228 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3230 bool rc
= wxTheApp
->ProcessEvent(event
);
3234 // we may end only if the app didn't veto session closing (double
3236 *mayEnd
= !event
.GetVeto();
3245 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3248 // do nothing if the session isn't ending
3253 if ( (this != wxTheApp
->GetTopWindow()) )
3256 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3257 event
.SetEventObject(wxTheApp
);
3258 event
.SetCanVeto(FALSE
);
3259 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3261 return wxTheApp
->ProcessEvent(event
);
3267 // ---------------------------------------------------------------------------
3268 // window creation/destruction
3269 // ---------------------------------------------------------------------------
3271 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3273 // VZ: why is this commented out for WinCE? If it doesn't support
3274 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3275 // not with multiple #ifdef's!
3277 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3278 EnsureParentHasControlParentStyle(GetParent());
3279 #endif // !__WXWINCE__
3281 // TODO: should generate this event from WM_NCCREATE
3282 wxWindowCreateEvent
event((wxWindow
*)this);
3283 (void)GetEventHandler()->ProcessEvent(event
);
3290 bool wxWindowMSW::HandleDestroy()
3294 // delete our drop target if we've got one
3295 #if wxUSE_DRAG_AND_DROP
3296 if ( m_dropTarget
!= NULL
)
3298 m_dropTarget
->Revoke(m_hWnd
);
3300 delete m_dropTarget
;
3301 m_dropTarget
= NULL
;
3303 #endif // wxUSE_DRAG_AND_DROP
3305 // WM_DESTROY handled
3309 // ---------------------------------------------------------------------------
3311 // ---------------------------------------------------------------------------
3313 bool wxWindowMSW::HandleActivate(int state
,
3314 bool WXUNUSED(minimized
),
3315 WXHWND
WXUNUSED(activate
))
3317 wxActivateEvent
event(wxEVT_ACTIVATE
,
3318 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3320 event
.SetEventObject(this);
3322 return GetEventHandler()->ProcessEvent(event
);
3325 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3327 // notify the parent keeping track of focus for the kbd navigation
3328 // purposes that we got it
3329 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3330 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3336 m_caret
->OnSetFocus();
3338 #endif // wxUSE_CARET
3341 // If it's a wxTextCtrl don't send the event as it will be done
3342 // after the control gets to process it from EN_FOCUS handler
3343 if ( wxDynamicCastThis(wxTextCtrl
) )
3347 #endif // wxUSE_TEXTCTRL
3349 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3350 event
.SetEventObject(this);
3352 // wxFindWinFromHandle() may return NULL, it is ok
3353 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3355 return GetEventHandler()->ProcessEvent(event
);
3358 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3364 m_caret
->OnKillFocus();
3366 #endif // wxUSE_CARET
3369 // If it's a wxTextCtrl don't send the event as it will be done
3370 // after the control gets to process it.
3371 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3378 // Don't send the event when in the process of being deleted. This can
3379 // only cause problems if the event handler tries to access the object.
3380 if ( m_isBeingDeleted
)
3385 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3386 event
.SetEventObject(this);
3388 // wxFindWinFromHandle() may return NULL, it is ok
3389 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3391 return GetEventHandler()->ProcessEvent(event
);
3394 // ---------------------------------------------------------------------------
3396 // ---------------------------------------------------------------------------
3398 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3400 wxShowEvent
event(GetId(), show
);
3401 event
.m_eventObject
= this;
3403 return GetEventHandler()->ProcessEvent(event
);
3406 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3408 wxInitDialogEvent
event(GetId());
3409 event
.m_eventObject
= this;
3411 return GetEventHandler()->ProcessEvent(event
);
3414 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3416 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3418 #else // __WXMICROWIN__
3419 HDROP hFilesInfo
= (HDROP
) wParam
;
3421 // Get the total number of files dropped
3422 UINT gwFilesDropped
= ::DragQueryFile
3430 wxString
*files
= new wxString
[gwFilesDropped
];
3431 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3433 // first get the needed buffer length (+1 for terminating NUL)
3434 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3436 // and now get the file name
3437 ::DragQueryFile(hFilesInfo
, wIndex
,
3438 wxStringBuffer(files
[wIndex
], len
), len
);
3440 DragFinish (hFilesInfo
);
3442 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3443 event
.m_eventObject
= this;
3446 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3447 event
.m_pos
.x
= dropPoint
.x
;
3448 event
.m_pos
.y
= dropPoint
.y
;
3450 return GetEventHandler()->ProcessEvent(event
);
3455 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3457 int WXUNUSED(mouseMsg
))
3459 #ifndef __WXMICROWIN__
3460 // the logic is as follows:
3461 // -1. don't set cursor for non client area, including but not limited to
3462 // the title bar, scrollbars, &c
3463 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3464 // 1. if we have the cursor set it unless wxIsBusy()
3465 // 2. if we're a top level window, set some cursor anyhow
3466 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3468 if ( nHitTest
!= HTCLIENT
)
3473 HCURSOR hcursor
= 0;
3475 // first ask the user code - it may wish to set the cursor in some very
3476 // specific way (for example, depending on the current position)
3478 if ( !::GetCursorPos(&pt
) )
3480 wxLogLastError(wxT("GetCursorPos"));
3485 ScreenToClient(&x
, &y
);
3486 wxSetCursorEvent
event(x
, y
);
3488 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3489 if ( processedEvtSetCursor
&& event
.HasCursor() )
3491 hcursor
= GetHcursorOf(event
.GetCursor());
3496 bool isBusy
= wxIsBusy();
3498 // the test for processedEvtSetCursor is here to prevent using m_cursor
3499 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3500 // it - this is a way to say that our cursor shouldn't be used for this
3502 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3504 hcursor
= GetHcursorOf(m_cursor
);
3511 hcursor
= wxGetCurrentBusyCursor();
3513 else if ( !hcursor
)
3515 const wxCursor
*cursor
= wxGetGlobalCursor();
3516 if ( cursor
&& cursor
->Ok() )
3518 hcursor
= GetHcursorOf(*cursor
);
3526 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3528 ::SetCursor(hcursor
);
3530 // cursor set, stop here
3533 #endif // __WXMICROWIN__
3535 // pass up the window chain
3539 // ---------------------------------------------------------------------------
3540 // owner drawn stuff
3541 // ---------------------------------------------------------------------------
3543 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3544 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3545 #define WXUNUSED_UNLESS_ODRAWN(param) param
3547 #define WXUNUSED_UNLESS_ODRAWN(param)
3551 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3552 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3554 #if wxUSE_OWNER_DRAWN
3556 #if wxUSE_MENUS_NATIVE
3557 // is it a menu item?
3558 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3559 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3561 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3563 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3565 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3566 // the DC from being released
3567 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3568 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3569 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3570 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3572 return pMenuItem
->OnDrawItem
3576 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3577 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3580 #endif // wxUSE_MENUS_NATIVE
3582 #endif // USE_OWNER_DRAWN
3584 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3586 #if wxUSE_OWNER_DRAWN
3587 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3588 #else // !wxUSE_OWNER_DRAWN
3589 // we may still have owner-drawn buttons internally because we have to make
3590 // them owner-drawn to support colour change
3591 wxControl
*item
= wxDynamicCast(FindItem(id
), wxButton
);
3592 #endif // USE_OWNER_DRAWN
3596 return item
->MSWOnDraw(itemStruct
);
3599 #endif // wxUSE_CONTROLS
3605 wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3606 WXMEASUREITEMSTRUCT
*
3607 WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3609 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3610 // is it a menu item?
3611 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3612 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3614 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3616 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3618 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3619 &pMeasureStruct
->itemHeight
);
3622 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3625 return item
->MSWOnMeasure(itemStruct
);
3627 #endif // wxUSE_OWNER_DRAWN
3632 // ---------------------------------------------------------------------------
3633 // colours and palettes
3634 // ---------------------------------------------------------------------------
3636 bool wxWindowMSW::HandleSysColorChange()
3638 wxSysColourChangedEvent event
;
3639 event
.SetEventObject(this);
3641 (void)GetEventHandler()->ProcessEvent(event
);
3643 // always let the system carry on the default processing to allow the
3644 // native controls to react to the colours update
3648 bool wxWindowMSW::HandleDisplayChange()
3650 wxDisplayChangedEvent event
;
3651 event
.SetEventObject(this);
3653 return GetEventHandler()->ProcessEvent(event
);
3656 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3664 #ifndef __WXMICROWIN__
3665 WXHBRUSH hBrush
= 0;
3670 if ( nCtlColor
== CTLCOLOR_DLG
)
3673 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3678 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3680 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3682 #endif // wxUSE_CONTROLS
3688 #else // __WXMICROWIN__
3693 // Define for each class of dialog and control
3694 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3695 WXHWND
WXUNUSED(hWnd
),
3696 WXUINT
WXUNUSED(nCtlColor
),
3697 WXUINT
WXUNUSED(message
),
3698 WXWPARAM
WXUNUSED(wParam
),
3699 WXLPARAM
WXUNUSED(lParam
))
3704 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3707 // same as below except we don't respond to our own messages
3708 if ( hWndPalChange
!= GetHWND() )
3710 // check to see if we our our parents have a custom palette
3711 wxWindowMSW
*win
= this;
3712 while ( win
&& !win
->HasCustomPalette() )
3714 win
= win
->GetParent();
3717 if ( win
&& win
->HasCustomPalette() )
3719 // realize the palette to see whether redrawing is needed
3720 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3721 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3722 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3724 int result
= ::RealizePalette(hdc
);
3726 // restore the palette (before releasing the DC)
3727 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3728 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3729 ::RealizePalette(hdc
);
3730 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3732 // now check for the need to redraw
3734 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3738 #endif // wxUSE_PALETTE
3740 wxPaletteChangedEvent
event(GetId());
3741 event
.SetEventObject(this);
3742 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3744 return GetEventHandler()->ProcessEvent(event
);
3747 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3749 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3750 event
.SetEventObject(this);
3752 return GetEventHandler()->ProcessEvent(event
);
3755 bool wxWindowMSW::HandleQueryNewPalette()
3759 // check to see if we our our parents have a custom palette
3760 wxWindowMSW
*win
= this;
3761 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3762 if (win
->HasCustomPalette()) {
3763 /* realize the palette to see whether redrawing is needed */
3764 HDC hdc
= GetDC((HWND
) GetHWND());
3765 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3766 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3768 int result
= ::RealizePalette(hdc
);
3769 /* restore the palette (before releasing the DC) */
3770 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3771 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3772 ::RealizePalette(hdc
);
3773 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3774 /* now check for the need to redraw */
3776 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3778 #endif // wxUSE_PALETTE
3780 wxQueryNewPaletteEvent
event(GetId());
3781 event
.SetEventObject(this);
3783 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3786 // Responds to colour changes: passes event on to children.
3787 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3789 // the top level window also reset the standard colour map as it might have
3790 // changed (there is no need to do it for the non top level windows as we
3791 // only have to do it once)
3795 gs_hasStdCmap
= FALSE
;
3797 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3800 // Only propagate to non-top-level windows because Windows already
3801 // sends this event to all top-level ones
3802 wxWindow
*win
= node
->GetData();
3803 if ( !win
->IsTopLevel() )
3805 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3806 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3807 // the standard controls
3808 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3811 node
= node
->GetNext();
3814 // update the colours we use if they were not set explicitly by the user:
3815 // this must be done or OnCtlColor() would continue to use the old colours
3818 m_foregroundColour
= wxSystemSettings::
3819 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3824 m_backgroundColour
= wxSystemSettings::
3825 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3829 extern wxCOLORMAP
*wxGetStdColourMap()
3831 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3832 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3834 if ( !gs_hasStdCmap
)
3836 static bool s_coloursInit
= FALSE
;
3838 if ( !s_coloursInit
)
3840 // When a bitmap is loaded, the RGB values can change (apparently
3841 // because Windows adjusts them to care for the old programs always
3842 // using 0xc0c0c0 while the transparent colour for the new Windows
3843 // versions is different). But we do this adjustment ourselves so
3844 // we want to avoid Windows' "help" and for this we need to have a
3845 // reference bitmap which can tell us what the RGB values change
3847 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3848 if ( stdColourBitmap
.Ok() )
3850 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3851 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3852 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3855 memDC
.SelectObject(stdColourBitmap
);
3858 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3860 memDC
.GetPixel(i
, 0, &colour
);
3861 s_stdColours
[i
] = wxColourToRGB(colour
);
3864 else // wxBITMAP_STD_COLOURS couldn't be loaded
3866 s_stdColours
[0] = RGB(000,000,000); // black
3867 s_stdColours
[1] = RGB(128,128,128); // dark grey
3868 s_stdColours
[2] = RGB(192,192,192); // light grey
3869 s_stdColours
[3] = RGB(255,255,255); // white
3870 //s_stdColours[4] = RGB(000,000,255); // blue
3871 //s_stdColours[5] = RGB(255,000,255); // magenta
3874 s_coloursInit
= TRUE
;
3877 gs_hasStdCmap
= TRUE
;
3879 // create the colour map
3880 #define INIT_CMAP_ENTRY(col) \
3881 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3882 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3884 INIT_CMAP_ENTRY(BTNTEXT
);
3885 INIT_CMAP_ENTRY(BTNSHADOW
);
3886 INIT_CMAP_ENTRY(BTNFACE
);
3887 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3889 #undef INIT_CMAP_ENTRY
3895 // ---------------------------------------------------------------------------
3897 // ---------------------------------------------------------------------------
3899 bool wxWindowMSW::HandlePaint()
3901 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3904 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3906 wxLogLastError(wxT("CreateRectRgn"));
3907 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3908 wxLogLastError(wxT("GetUpdateRgn"));
3910 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3912 wxPaintEvent
event(m_windowId
);
3913 event
.SetEventObject(this);
3915 bool processed
= GetEventHandler()->ProcessEvent(event
);
3917 // note that we must generate NC event after the normal one as otherwise
3918 // BeginPaint() will happily overwrite our decorations with the background
3920 wxNcPaintEvent
eventNc(m_windowId
);
3921 eventNc
.SetEventObject(this);
3922 GetEventHandler()->ProcessEvent(eventNc
);
3927 // Can be called from an application's OnPaint handler
3928 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3930 #ifdef __WXUNIVERSAL__
3933 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3936 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3941 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3943 // Prevents flicker when dragging
3944 if ( ::IsIconic(GetHwnd()) )
3948 if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3953 if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3955 if (wxUxThemeEngine::Get())
3957 WXHTHEME hTheme
= wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L
"TAB");
3961 ::GetClientRect((HWND
) GetHWND(), (RECT
*) & rect
);
3962 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme
, hdc
, 10 /* TABP_BODY */, 0, &rect
, &rect
);
3963 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme
);
3973 dc
.SetWindow((wxWindow
*)this);
3976 wxEraseEvent
event(m_windowId
, &dc
);
3977 event
.SetEventObject(this);
3978 bool rc
= GetEventHandler()->ProcessEvent(event
);
3982 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3983 dc
.SelectOldObjects(hdc
);
3988 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3991 ::GetClientRect(GetHwnd(), &rect
);
3993 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3994 m_backgroundColour
.Green(),
3995 m_backgroundColour
.Blue());
3996 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3998 wxLogLastError(wxT("CreateSolidBrush"));
4000 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
4003 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
4006 ::FillRect(hdc
, &rect
, hBrush
);
4007 ::DeleteObject(hBrush
);
4010 ::SetMapMode(hdc
, mode
);
4014 // ---------------------------------------------------------------------------
4015 // moving and resizing
4016 // ---------------------------------------------------------------------------
4018 bool wxWindowMSW::HandleMinimize()
4020 wxIconizeEvent
event(m_windowId
);
4021 event
.SetEventObject(this);
4023 return GetEventHandler()->ProcessEvent(event
);
4026 bool wxWindowMSW::HandleMaximize()
4028 wxMaximizeEvent
event(m_windowId
);
4029 event
.SetEventObject(this);
4031 return GetEventHandler()->ProcessEvent(event
);
4034 bool wxWindowMSW::HandleMove(int x
, int y
)
4036 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
4037 event
.SetEventObject(this);
4039 return GetEventHandler()->ProcessEvent(event
);
4042 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4044 wxMoveEvent
event(rect
, m_windowId
);
4045 event
.SetEventObject(this);
4047 bool rc
= GetEventHandler()->ProcessEvent(event
);
4049 rect
= event
.GetRect();
4053 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
4054 WXUINT
WXUNUSED(flag
))
4056 // don't use w and h parameters as they specify the client size while
4057 // according to the docs EVT_SIZE handler is supposed to receive the total
4059 wxSizeEvent
event(GetSize(), m_windowId
);
4060 event
.SetEventObject(this);
4062 return GetEventHandler()->ProcessEvent(event
);
4065 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4067 wxSizeEvent
event(rect
, m_windowId
);
4068 event
.SetEventObject(this);
4070 bool rc
= GetEventHandler()->ProcessEvent(event
);
4072 rect
= event
.GetRect();
4076 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
4081 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4085 int minWidth
= GetMinWidth(),
4086 minHeight
= GetMinHeight(),
4087 maxWidth
= GetMaxWidth(),
4088 maxHeight
= GetMaxHeight();
4090 if ( minWidth
!= -1 )
4092 info
->ptMinTrackSize
.x
= minWidth
;
4096 if ( minHeight
!= -1 )
4098 info
->ptMinTrackSize
.y
= minHeight
;
4102 if ( maxWidth
!= -1 )
4104 info
->ptMaxTrackSize
.x
= maxWidth
;
4108 if ( maxHeight
!= -1 )
4110 info
->ptMaxTrackSize
.y
= maxHeight
;
4118 // ---------------------------------------------------------------------------
4120 // ---------------------------------------------------------------------------
4122 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4124 #if wxUSE_MENUS_NATIVE
4125 if ( !cmd
&& wxCurrentPopupMenu
)
4127 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4128 wxCurrentPopupMenu
= NULL
;
4130 return popupMenu
->MSWCommand(cmd
, id
);
4132 #endif // wxUSE_MENUS_NATIVE
4134 wxWindow
*win
= NULL
;
4136 // first try to find it from HWND - this works even with the broken
4137 // programs using the same ids for different controls
4140 win
= wxFindWinFromHandle(control
);
4146 // must cast to a signed type before comparing with other ids!
4147 win
= FindItem((signed short)id
);
4152 return win
->MSWCommand(cmd
, id
);
4155 // the messages sent from the in-place edit control used by the treectrl
4156 // for label editing have id == 0, but they should _not_ be treated as menu
4157 // messages (they are EN_XXX ones, in fact) so don't translate anything
4158 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4161 // If no child window, it may be an accelerator, e.g. for a popup menu
4164 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4165 event
.SetEventObject(this);
4169 return GetEventHandler()->ProcessEvent(event
);
4171 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4174 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4175 // notifications to its parent which we want to reflect back to
4177 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4178 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4181 #endif // wxUSE_SPINCTRL
4186 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4189 // 4 bits are reserved
4190 switch ( wParam
& 0xFFFFFFF0 )
4193 return HandleMaximize();
4196 return HandleMinimize();
4203 // ---------------------------------------------------------------------------
4205 // ---------------------------------------------------------------------------
4207 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4211 // our client coords are not quite the same as Windows ones
4212 wxPoint pt
= GetClientAreaOrigin();
4213 event
.m_x
= x
- pt
.x
;
4214 event
.m_y
= y
- pt
.y
;
4216 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4217 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4218 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4219 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4220 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4221 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4222 // Returns different negative values on WinME and WinNT,
4223 // so simply test for negative value.
4224 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4226 event
.SetTimestamp(s_currentMsg
.time
);
4227 event
.m_eventObject
= this;
4228 event
.SetId(GetId());
4230 #if wxUSE_MOUSEEVENT_HACK
4233 m_lastMouseEvent
= event
.GetEventType();
4234 #endif // wxUSE_MOUSEEVENT_HACK
4237 // Windows doesn't send the mouse events to the static controls (which are
4238 // transparent in the sense that their WM_NCHITTEST handler returns
4239 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4240 // and so we manually check if we don't have a child window under mouse and if
4241 // we do, send the event to it instead of the window Windows had sent WM_XXX
4244 // Notice that this is not done for the mouse move events because this could
4245 // (would?) be too slow, but only for clicks which means that the static texts
4246 // still don't get move, enter nor leave events.
4247 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4249 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4251 // first try to find a non transparent child: this allows us to send events
4252 // to a static text which is inside a static box, for example
4253 POINT pt
= { *x
, *y
};
4254 HWND hwnd
= GetHwndOf(win
),
4258 hwndUnderMouse
= ::ChildWindowFromPoint
4264 hwndUnderMouse
= ::ChildWindowFromPointEx
4274 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4276 // now try any child window at all
4277 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4280 // check that we have a child window which is susceptible to receive mouse
4281 // events: for this it must be shown and enabled
4282 if ( hwndUnderMouse
&&
4283 hwndUnderMouse
!= hwnd
&&
4284 ::IsWindowVisible(hwndUnderMouse
) &&
4285 ::IsWindowEnabled(hwndUnderMouse
) )
4287 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4288 if ( winUnderMouse
)
4290 // translate the mouse coords to the other window coords
4291 win
->ClientToScreen(x
, y
);
4292 winUnderMouse
->ScreenToClient(x
, y
);
4294 win
= winUnderMouse
;
4301 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4303 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4304 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4305 // from the message id and take the value in the table to get wxWin event
4307 static const wxEventType eventsMouse
[] =
4321 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4322 InitMouseEvent(event
, x
, y
, flags
);
4324 return GetEventHandler()->ProcessEvent(event
);
4327 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4329 if ( !m_mouseInWindow
)
4331 // it would be wrong to assume that just because we get a mouse move
4332 // event that the mouse is inside the window: although this is usually
4333 // true, it is not if we had captured the mouse, so we need to check
4334 // the mouse coordinates here
4335 if ( !HasCapture() || IsMouseInWindow() )
4337 // Generate an ENTER event
4338 m_mouseInWindow
= TRUE
;
4340 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4341 InitMouseEvent(event
, x
, y
, flags
);
4343 (void)GetEventHandler()->ProcessEvent(event
);
4347 #if wxUSE_MOUSEEVENT_HACK
4348 // Window gets a click down message followed by a mouse move message even
4349 // if position isn't changed! We want to discard the trailing move event
4350 // if x and y are the same.
4351 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4352 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4353 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4354 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4356 m_lastMouseEvent
= wxEVT_MOTION
;
4360 #endif // wxUSE_MOUSEEVENT_HACK
4362 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4366 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4368 #if wxUSE_MOUSEWHEEL
4369 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4370 InitMouseEvent(event
,
4371 GET_X_LPARAM(lParam
),
4372 GET_Y_LPARAM(lParam
),
4374 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4375 event
.m_wheelDelta
= WHEEL_DELTA
;
4377 static int s_linesPerRotation
= -1;
4378 if ( s_linesPerRotation
== -1 )
4380 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4381 &s_linesPerRotation
, 0))
4383 // this is not supposed to happen
4384 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4386 // the default is 3, so use it if SystemParametersInfo() failed
4387 s_linesPerRotation
= 3;
4391 event
.m_linesPerAction
= s_linesPerRotation
;
4392 return GetEventHandler()->ProcessEvent(event
);
4403 // ---------------------------------------------------------------------------
4404 // keyboard handling
4405 // ---------------------------------------------------------------------------
4407 // create the key event of the given type for the given key - used by
4408 // HandleChar and HandleKeyDown/Up
4409 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4412 WXWPARAM wParam
) const
4414 wxKeyEvent
event(evType
);
4415 event
.SetId(GetId());
4416 event
.m_shiftDown
= wxIsShiftDown();
4417 event
.m_controlDown
= wxIsCtrlDown();
4418 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4420 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4421 event
.m_keyCode
= id
;
4422 event
.m_rawCode
= (wxUint32
) wParam
;
4423 event
.m_rawFlags
= (wxUint32
) lParam
;
4424 event
.SetTimestamp(s_currentMsg
.time
);
4426 // translate the position to client coords
4430 GetWindowRect(GetHwnd(),&rect
);
4440 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4442 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4447 // If 1 -> 26, translate to either special keycode or just set
4448 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4449 // ControlDown() == TRUE.
4451 if ( (id
> 0) && (id
< 27) )
4473 else // we're called from WM_KEYDOWN
4475 id
= wxCharCodeMSWToWX(wParam
);
4478 // it's ASCII and will be processed here only when called from
4479 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4484 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4486 // the alphanumeric keys produced by pressing AltGr+something on European
4487 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4488 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4489 // alphanumeric, so pretend that there are no modifiers at all (the
4490 // KEY_DOWN event would still have the correct modifiers if they're really
4492 if ( event
.m_controlDown
&& event
.m_altDown
&&
4493 (id
>= 32 && id
< 256) )
4495 event
.m_controlDown
=
4496 event
.m_altDown
= FALSE
;
4499 return GetEventHandler()->ProcessEvent(event
);
4502 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4504 int id
= wxCharCodeMSWToWX(wParam
);
4508 // normal ASCII char
4512 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4514 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4515 if ( GetEventHandler()->ProcessEvent(event
) )
4524 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4526 int id
= wxCharCodeMSWToWX(wParam
);
4530 // normal ASCII char
4534 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4536 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4537 if ( GetEventHandler()->ProcessEvent(event
) )
4544 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4546 // FIXME: implement GetMenuItemCount for WinCE, possibly
4547 // in terms of GetMenuItemInfo
4549 const HMENU hmenu
= (HMENU
)lParam
;
4553 mii
.cbSize
= sizeof(MENUITEMINFO
);
4554 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4556 // find if we have this letter in any owner drawn item
4557 const int count
= ::GetMenuItemCount(hmenu
);
4558 for ( int i
= 0; i
< count
; i
++ )
4560 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4562 if ( mii
.fType
== MFT_OWNERDRAW
)
4564 // dwItemData member of the MENUITEMINFO is a
4565 // pointer to the associated wxMenuItem -- see the
4566 // menu creation code
4567 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4569 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4572 if ( *p
== _T('&') )
4574 // this is not the accel char, find the real one
4575 p
= wxStrchr(p
+ 1, _T('&'));
4577 else // got the accel char
4579 // FIXME-UNICODE: this comparison doesn't risk to work
4580 // for non ASCII accelerator characters I'm afraid, but
4582 if ( wxToupper(*p
) == chAccel
)
4588 // this one doesn't match
4595 else // failed to get the menu text?
4597 // it's not fatal, so don't show error, but still log
4599 wxLogLastError(_T("GetMenuItemInfo"));
4606 // ---------------------------------------------------------------------------
4608 // ---------------------------------------------------------------------------
4610 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4614 if ( flags
& JOY_BUTTON1CHG
)
4615 change
= wxJOY_BUTTON1
;
4616 if ( flags
& JOY_BUTTON2CHG
)
4617 change
= wxJOY_BUTTON2
;
4618 if ( flags
& JOY_BUTTON3CHG
)
4619 change
= wxJOY_BUTTON3
;
4620 if ( flags
& JOY_BUTTON4CHG
)
4621 change
= wxJOY_BUTTON4
;
4624 if ( flags
& JOY_BUTTON1
)
4625 buttons
|= wxJOY_BUTTON1
;
4626 if ( flags
& JOY_BUTTON2
)
4627 buttons
|= wxJOY_BUTTON2
;
4628 if ( flags
& JOY_BUTTON3
)
4629 buttons
|= wxJOY_BUTTON3
;
4630 if ( flags
& JOY_BUTTON4
)
4631 buttons
|= wxJOY_BUTTON4
;
4633 // the event ids aren't consecutive so we can't use table based lookup
4635 wxEventType eventType
;
4640 eventType
= wxEVT_JOY_MOVE
;
4645 eventType
= wxEVT_JOY_MOVE
;
4650 eventType
= wxEVT_JOY_ZMOVE
;
4655 eventType
= wxEVT_JOY_ZMOVE
;
4658 case MM_JOY1BUTTONDOWN
:
4660 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4663 case MM_JOY2BUTTONDOWN
:
4665 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4668 case MM_JOY1BUTTONUP
:
4670 eventType
= wxEVT_JOY_BUTTON_UP
;
4673 case MM_JOY2BUTTONUP
:
4675 eventType
= wxEVT_JOY_BUTTON_UP
;
4679 wxFAIL_MSG(wxT("no such joystick event"));
4684 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4685 event
.SetPosition(wxPoint(x
, y
));
4686 event
.SetEventObject(this);
4688 return GetEventHandler()->ProcessEvent(event
);
4694 // ---------------------------------------------------------------------------
4696 // ---------------------------------------------------------------------------
4698 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4699 WXWORD pos
, WXHWND control
)
4703 wxWindow
*child
= wxFindWinFromHandle(control
);
4705 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4708 wxScrollWinEvent event
;
4709 event
.SetPosition(pos
);
4710 event
.SetOrientation(orientation
);
4711 event
.m_eventObject
= this;
4716 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4720 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4724 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4728 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4732 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4736 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4739 case SB_THUMBPOSITION
:
4741 // under Win32, the scrollbar range and position are 32 bit integers,
4742 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4743 // explicitly query the scrollbar for the correct position (this must
4744 // be done only for these two SB_ events as they are the only one
4745 // carrying the scrollbar position)
4747 WinStruct
<SCROLLINFO
> scrollInfo
;
4748 scrollInfo
.fMask
= SIF_TRACKPOS
;
4750 if ( !::GetScrollInfo(GetHwnd(),
4751 orientation
== wxHORIZONTAL
? SB_HORZ
4755 // Not neccessarily an error, if there are no scrollbars yet.
4756 // wxLogLastError(_T("GetScrollInfo"));
4759 event
.SetPosition(scrollInfo
.nTrackPos
);
4762 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4763 ? wxEVT_SCROLLWIN_THUMBRELEASE
4764 : wxEVT_SCROLLWIN_THUMBTRACK
;
4771 return GetEventHandler()->ProcessEvent(event
);
4774 // ===========================================================================
4776 // ===========================================================================
4778 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4781 HDC dc
= ::GetDC((HWND
) wnd
);
4786 // the_font->UseResource();
4787 // the_font->RealizeResource();
4788 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4790 was
= (HFONT
) SelectObject(dc
,fnt
);
4792 GetTextMetrics(dc
, &tm
);
4793 if ( the_font
&& fnt
&& was
)
4795 SelectObject(dc
,was
);
4797 ReleaseDC((HWND
)wnd
, dc
);
4800 *x
= tm
.tmAveCharWidth
;
4802 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4805 // the_font->ReleaseResource();
4808 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4809 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4810 int wxCharCodeMSWToWX(int keySym
)
4815 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4816 case VK_BACK
: id
= WXK_BACK
; break;
4817 case VK_TAB
: id
= WXK_TAB
; break;
4818 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4819 case VK_RETURN
: id
= WXK_RETURN
; break;
4820 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4821 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4822 case VK_MENU
: id
= WXK_MENU
; break;
4823 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4824 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4825 case VK_SPACE
: id
= WXK_SPACE
; break;
4826 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4827 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4828 case VK_NEXT
: id
= WXK_NEXT
; break;
4829 case VK_END
: id
= WXK_END
; break;
4830 case VK_HOME
: id
= WXK_HOME
; break;
4831 case VK_LEFT
: id
= WXK_LEFT
; break;
4832 case VK_UP
: id
= WXK_UP
; break;
4833 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4834 case VK_DOWN
: id
= WXK_DOWN
; break;
4835 case VK_SELECT
: id
= WXK_SELECT
; break;
4836 case VK_PRINT
: id
= WXK_PRINT
; break;
4837 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4838 case VK_INSERT
: id
= WXK_INSERT
; break;
4839 case VK_DELETE
: id
= WXK_DELETE
; break;
4840 case VK_HELP
: id
= WXK_HELP
; break;
4841 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4842 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4843 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4844 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4845 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4846 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4847 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4848 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4849 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4850 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4851 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4852 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4853 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4854 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4855 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4856 case VK_F1
: id
= WXK_F1
; break;
4857 case VK_F2
: id
= WXK_F2
; break;
4858 case VK_F3
: id
= WXK_F3
; break;
4859 case VK_F4
: id
= WXK_F4
; break;
4860 case VK_F5
: id
= WXK_F5
; break;
4861 case VK_F6
: id
= WXK_F6
; break;
4862 case VK_F7
: id
= WXK_F7
; break;
4863 case VK_F8
: id
= WXK_F8
; break;
4864 case VK_F9
: id
= WXK_F9
; break;
4865 case VK_F10
: id
= WXK_F10
; break;
4866 case VK_F11
: id
= WXK_F11
; break;
4867 case VK_F12
: id
= WXK_F12
; break;
4868 case VK_F13
: id
= WXK_F13
; break;
4869 case VK_F14
: id
= WXK_F14
; break;
4870 case VK_F15
: id
= WXK_F15
; break;
4871 case VK_F16
: id
= WXK_F16
; break;
4872 case VK_F17
: id
= WXK_F17
; break;
4873 case VK_F18
: id
= WXK_F18
; break;
4874 case VK_F19
: id
= WXK_F19
; break;
4875 case VK_F20
: id
= WXK_F20
; break;
4876 case VK_F21
: id
= WXK_F21
; break;
4877 case VK_F22
: id
= WXK_F22
; break;
4878 case VK_F23
: id
= WXK_F23
; break;
4879 case VK_F24
: id
= WXK_F24
; break;
4880 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4881 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4883 case VK_OEM_1
: id
= ';'; break;
4884 case VK_OEM_PLUS
: id
= '+'; break;
4885 case VK_OEM_COMMA
: id
= ','; break;
4886 case VK_OEM_MINUS
: id
= '-'; break;
4887 case VK_OEM_PERIOD
: id
= '.'; break;
4888 case VK_OEM_2
: id
= '/'; break;
4889 case VK_OEM_3
: id
= '~'; break;
4890 case VK_OEM_4
: id
= '['; break;
4891 case VK_OEM_5
: id
= '\\'; break;
4892 case VK_OEM_6
: id
= ']'; break;
4893 case VK_OEM_7
: id
= '\''; break;
4896 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4897 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4898 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4899 #endif // VK_APPS defined
4908 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4914 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4915 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4916 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4917 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4918 case WXK_MENU
: keySym
= VK_MENU
; break;
4919 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4920 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4921 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4922 case WXK_END
: keySym
= VK_END
; break;
4923 case WXK_HOME
: keySym
= VK_HOME
; break;
4924 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4925 case WXK_UP
: keySym
= VK_UP
; break;
4926 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4927 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4928 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4929 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4930 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4931 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4932 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4933 case WXK_HELP
: keySym
= VK_HELP
; break;
4934 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4935 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4936 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4937 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4938 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4939 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4940 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4941 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4942 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4943 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4944 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4945 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4946 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4947 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4948 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4949 case WXK_F1
: keySym
= VK_F1
; break;
4950 case WXK_F2
: keySym
= VK_F2
; break;
4951 case WXK_F3
: keySym
= VK_F3
; break;
4952 case WXK_F4
: keySym
= VK_F4
; break;
4953 case WXK_F5
: keySym
= VK_F5
; break;
4954 case WXK_F6
: keySym
= VK_F6
; break;
4955 case WXK_F7
: keySym
= VK_F7
; break;
4956 case WXK_F8
: keySym
= VK_F8
; break;
4957 case WXK_F9
: keySym
= VK_F9
; break;
4958 case WXK_F10
: keySym
= VK_F10
; break;
4959 case WXK_F11
: keySym
= VK_F11
; break;
4960 case WXK_F12
: keySym
= VK_F12
; break;
4961 case WXK_F13
: keySym
= VK_F13
; break;
4962 case WXK_F14
: keySym
= VK_F14
; break;
4963 case WXK_F15
: keySym
= VK_F15
; break;
4964 case WXK_F16
: keySym
= VK_F16
; break;
4965 case WXK_F17
: keySym
= VK_F17
; break;
4966 case WXK_F18
: keySym
= VK_F18
; break;
4967 case WXK_F19
: keySym
= VK_F19
; break;
4968 case WXK_F20
: keySym
= VK_F20
; break;
4969 case WXK_F21
: keySym
= VK_F21
; break;
4970 case WXK_F22
: keySym
= VK_F22
; break;
4971 case WXK_F23
: keySym
= VK_F23
; break;
4972 case WXK_F24
: keySym
= VK_F24
; break;
4973 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4974 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4985 wxWindow
*wxGetActiveWindow()
4987 HWND hWnd
= GetActiveWindow();
4990 return wxFindWinFromHandle((WXHWND
) hWnd
);
4995 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4997 HWND hwnd
= (HWND
)hWnd
;
4999 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5000 // by code in msw/radiobox.cpp), for all the others we just search up the
5002 wxWindow
*win
= (wxWindow
*)NULL
;
5005 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5009 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5010 // wxWindow class which overrides WM_GETDLGCODE processing to
5011 // do it as well, win would be already non NULL
5012 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5014 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
5016 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5017 #endif // wxUSE_RADIOBOX
5019 // spin control text buddy window should be mapped to spin ctrl
5020 // itself so try it too
5021 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5024 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5026 #endif // wxUSE_SPINCTRL
5030 while ( hwnd
&& !win
)
5032 // this is a really ugly hack needed to avoid mistakenly returning the
5033 // parent frame wxWindow for the find/replace modeless dialog HWND -
5034 // this, in turn, is needed to call IsDialogMessage() from
5035 // wxApp::ProcessMessage() as for this we must return NULL from here
5037 // FIXME: this is clearly not the best way to do it but I think we'll
5038 // need to change HWND <-> wxWindow code more heavily than I can
5039 // do it now to fix it
5040 #ifndef __WXMICROWIN__
5041 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5043 // it's a dialog box, don't go upwards
5048 hwnd
= ::GetParent(hwnd
);
5049 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5055 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5057 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5058 // in active frames and dialogs, regardless of where the focus is.
5059 static HHOOK wxTheKeyboardHook
= 0;
5060 static FARPROC wxTheKeyboardHookProc
= 0;
5061 int APIENTRY _EXPORT
5062 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5064 void wxSetKeyboardHook(bool doIt
)
5068 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5069 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5071 GetCurrentThreadId()
5072 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5077 UnhookWindowsHookEx(wxTheKeyboardHook
);
5081 int APIENTRY _EXPORT
5082 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5084 DWORD hiWord
= HIWORD(lParam
);
5085 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5087 int id
= wxCharCodeMSWToWX(wParam
);
5090 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5091 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5092 event
.m_altDown
= TRUE
;
5094 event
.m_eventObject
= NULL
;
5095 event
.m_keyCode
= id
;
5096 event
.m_shiftDown
= wxIsShiftDown();
5097 event
.m_controlDown
= wxIsCtrlDown();
5098 event
.SetTimestamp(s_currentMsg
.time
);
5100 wxWindow
*win
= wxGetActiveWindow();
5101 wxEvtHandler
*handler
;
5104 handler
= win
->GetEventHandler();
5105 event
.SetId(win
->GetId());
5113 if ( handler
&& handler
->ProcessEvent(event
) )
5121 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5124 #endif // !__WXMICROWIN__
5127 const char *wxGetMessageName(int message
)
5131 case 0x0000: return "WM_NULL";
5132 case 0x0001: return "WM_CREATE";
5133 case 0x0002: return "WM_DESTROY";
5134 case 0x0003: return "WM_MOVE";
5135 case 0x0005: return "WM_SIZE";
5136 case 0x0006: return "WM_ACTIVATE";
5137 case 0x0007: return "WM_SETFOCUS";
5138 case 0x0008: return "WM_KILLFOCUS";
5139 case 0x000A: return "WM_ENABLE";
5140 case 0x000B: return "WM_SETREDRAW";
5141 case 0x000C: return "WM_SETTEXT";
5142 case 0x000D: return "WM_GETTEXT";
5143 case 0x000E: return "WM_GETTEXTLENGTH";
5144 case 0x000F: return "WM_PAINT";
5145 case 0x0010: return "WM_CLOSE";
5146 case 0x0011: return "WM_QUERYENDSESSION";
5147 case 0x0012: return "WM_QUIT";
5148 case 0x0013: return "WM_QUERYOPEN";
5149 case 0x0014: return "WM_ERASEBKGND";
5150 case 0x0015: return "WM_SYSCOLORCHANGE";
5151 case 0x0016: return "WM_ENDSESSION";
5152 case 0x0017: return "WM_SYSTEMERROR";
5153 case 0x0018: return "WM_SHOWWINDOW";
5154 case 0x0019: return "WM_CTLCOLOR";
5155 case 0x001A: return "WM_WININICHANGE";
5156 case 0x001B: return "WM_DEVMODECHANGE";
5157 case 0x001C: return "WM_ACTIVATEAPP";
5158 case 0x001D: return "WM_FONTCHANGE";
5159 case 0x001E: return "WM_TIMECHANGE";
5160 case 0x001F: return "WM_CANCELMODE";
5161 case 0x0020: return "WM_SETCURSOR";
5162 case 0x0021: return "WM_MOUSEACTIVATE";
5163 case 0x0022: return "WM_CHILDACTIVATE";
5164 case 0x0023: return "WM_QUEUESYNC";
5165 case 0x0024: return "WM_GETMINMAXINFO";
5166 case 0x0026: return "WM_PAINTICON";
5167 case 0x0027: return "WM_ICONERASEBKGND";
5168 case 0x0028: return "WM_NEXTDLGCTL";
5169 case 0x002A: return "WM_SPOOLERSTATUS";
5170 case 0x002B: return "WM_DRAWITEM";
5171 case 0x002C: return "WM_MEASUREITEM";
5172 case 0x002D: return "WM_DELETEITEM";
5173 case 0x002E: return "WM_VKEYTOITEM";
5174 case 0x002F: return "WM_CHARTOITEM";
5175 case 0x0030: return "WM_SETFONT";
5176 case 0x0031: return "WM_GETFONT";
5177 case 0x0037: return "WM_QUERYDRAGICON";
5178 case 0x0039: return "WM_COMPAREITEM";
5179 case 0x0041: return "WM_COMPACTING";
5180 case 0x0044: return "WM_COMMNOTIFY";
5181 case 0x0046: return "WM_WINDOWPOSCHANGING";
5182 case 0x0047: return "WM_WINDOWPOSCHANGED";
5183 case 0x0048: return "WM_POWER";
5185 case 0x004A: return "WM_COPYDATA";
5186 case 0x004B: return "WM_CANCELJOURNAL";
5187 case 0x004E: return "WM_NOTIFY";
5188 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5189 case 0x0051: return "WM_INPUTLANGCHANGE";
5190 case 0x0052: return "WM_TCARD";
5191 case 0x0053: return "WM_HELP";
5192 case 0x0054: return "WM_USERCHANGED";
5193 case 0x0055: return "WM_NOTIFYFORMAT";
5194 case 0x007B: return "WM_CONTEXTMENU";
5195 case 0x007C: return "WM_STYLECHANGING";
5196 case 0x007D: return "WM_STYLECHANGED";
5197 case 0x007E: return "WM_DISPLAYCHANGE";
5198 case 0x007F: return "WM_GETICON";
5199 case 0x0080: return "WM_SETICON";
5201 case 0x0081: return "WM_NCCREATE";
5202 case 0x0082: return "WM_NCDESTROY";
5203 case 0x0083: return "WM_NCCALCSIZE";
5204 case 0x0084: return "WM_NCHITTEST";
5205 case 0x0085: return "WM_NCPAINT";
5206 case 0x0086: return "WM_NCACTIVATE";
5207 case 0x0087: return "WM_GETDLGCODE";
5208 case 0x00A0: return "WM_NCMOUSEMOVE";
5209 case 0x00A1: return "WM_NCLBUTTONDOWN";
5210 case 0x00A2: return "WM_NCLBUTTONUP";
5211 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5212 case 0x00A4: return "WM_NCRBUTTONDOWN";
5213 case 0x00A5: return "WM_NCRBUTTONUP";
5214 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5215 case 0x00A7: return "WM_NCMBUTTONDOWN";
5216 case 0x00A8: return "WM_NCMBUTTONUP";
5217 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5218 case 0x0100: return "WM_KEYDOWN";
5219 case 0x0101: return "WM_KEYUP";
5220 case 0x0102: return "WM_CHAR";
5221 case 0x0103: return "WM_DEADCHAR";
5222 case 0x0104: return "WM_SYSKEYDOWN";
5223 case 0x0105: return "WM_SYSKEYUP";
5224 case 0x0106: return "WM_SYSCHAR";
5225 case 0x0107: return "WM_SYSDEADCHAR";
5226 case 0x0108: return "WM_KEYLAST";
5228 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5229 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5230 case 0x010F: return "WM_IME_COMPOSITION";
5232 case 0x0110: return "WM_INITDIALOG";
5233 case 0x0111: return "WM_COMMAND";
5234 case 0x0112: return "WM_SYSCOMMAND";
5235 case 0x0113: return "WM_TIMER";
5236 case 0x0114: return "WM_HSCROLL";
5237 case 0x0115: return "WM_VSCROLL";
5238 case 0x0116: return "WM_INITMENU";
5239 case 0x0117: return "WM_INITMENUPOPUP";
5240 case 0x011F: return "WM_MENUSELECT";
5241 case 0x0120: return "WM_MENUCHAR";
5242 case 0x0121: return "WM_ENTERIDLE";
5243 case 0x0200: return "WM_MOUSEMOVE";
5244 case 0x0201: return "WM_LBUTTONDOWN";
5245 case 0x0202: return "WM_LBUTTONUP";
5246 case 0x0203: return "WM_LBUTTONDBLCLK";
5247 case 0x0204: return "WM_RBUTTONDOWN";
5248 case 0x0205: return "WM_RBUTTONUP";
5249 case 0x0206: return "WM_RBUTTONDBLCLK";
5250 case 0x0207: return "WM_MBUTTONDOWN";
5251 case 0x0208: return "WM_MBUTTONUP";
5252 case 0x0209: return "WM_MBUTTONDBLCLK";
5253 case 0x020A: return "WM_MOUSEWHEEL";
5254 case 0x0210: return "WM_PARENTNOTIFY";
5255 case 0x0211: return "WM_ENTERMENULOOP";
5256 case 0x0212: return "WM_EXITMENULOOP";
5258 case 0x0213: return "WM_NEXTMENU";
5259 case 0x0214: return "WM_SIZING";
5260 case 0x0215: return "WM_CAPTURECHANGED";
5261 case 0x0216: return "WM_MOVING";
5262 case 0x0218: return "WM_POWERBROADCAST";
5263 case 0x0219: return "WM_DEVICECHANGE";
5265 case 0x0220: return "WM_MDICREATE";
5266 case 0x0221: return "WM_MDIDESTROY";
5267 case 0x0222: return "WM_MDIACTIVATE";
5268 case 0x0223: return "WM_MDIRESTORE";
5269 case 0x0224: return "WM_MDINEXT";
5270 case 0x0225: return "WM_MDIMAXIMIZE";
5271 case 0x0226: return "WM_MDITILE";
5272 case 0x0227: return "WM_MDICASCADE";
5273 case 0x0228: return "WM_MDIICONARRANGE";
5274 case 0x0229: return "WM_MDIGETACTIVE";
5275 case 0x0230: return "WM_MDISETMENU";
5276 case 0x0233: return "WM_DROPFILES";
5278 case 0x0281: return "WM_IME_SETCONTEXT";
5279 case 0x0282: return "WM_IME_NOTIFY";
5280 case 0x0283: return "WM_IME_CONTROL";
5281 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5282 case 0x0285: return "WM_IME_SELECT";
5283 case 0x0286: return "WM_IME_CHAR";
5284 case 0x0290: return "WM_IME_KEYDOWN";
5285 case 0x0291: return "WM_IME_KEYUP";
5287 case 0x0300: return "WM_CUT";
5288 case 0x0301: return "WM_COPY";
5289 case 0x0302: return "WM_PASTE";
5290 case 0x0303: return "WM_CLEAR";
5291 case 0x0304: return "WM_UNDO";
5292 case 0x0305: return "WM_RENDERFORMAT";
5293 case 0x0306: return "WM_RENDERALLFORMATS";
5294 case 0x0307: return "WM_DESTROYCLIPBOARD";
5295 case 0x0308: return "WM_DRAWCLIPBOARD";
5296 case 0x0309: return "WM_PAINTCLIPBOARD";
5297 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5298 case 0x030B: return "WM_SIZECLIPBOARD";
5299 case 0x030C: return "WM_ASKCBFORMATNAME";
5300 case 0x030D: return "WM_CHANGECBCHAIN";
5301 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5302 case 0x030F: return "WM_QUERYNEWPALETTE";
5303 case 0x0310: return "WM_PALETTEISCHANGING";
5304 case 0x0311: return "WM_PALETTECHANGED";
5306 case 0x0312: return "WM_HOTKEY";
5309 // common controls messages - although they're not strictly speaking
5310 // standard, it's nice to decode them nevertheless
5313 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5314 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5315 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5316 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5317 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5318 case 0x1000 + 5: return "LVM_GETITEMA";
5319 case 0x1000 + 75: return "LVM_GETITEMW";
5320 case 0x1000 + 6: return "LVM_SETITEMA";
5321 case 0x1000 + 76: return "LVM_SETITEMW";
5322 case 0x1000 + 7: return "LVM_INSERTITEMA";
5323 case 0x1000 + 77: return "LVM_INSERTITEMW";
5324 case 0x1000 + 8: return "LVM_DELETEITEM";
5325 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5326 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5327 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5328 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5329 case 0x1000 + 13: return "LVM_FINDITEMA";
5330 case 0x1000 + 83: return "LVM_FINDITEMW";
5331 case 0x1000 + 14: return "LVM_GETITEMRECT";
5332 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5333 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5334 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5335 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5336 case 0x1000 + 18: return "LVM_HITTEST";
5337 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5338 case 0x1000 + 20: return "LVM_SCROLL";
5339 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5340 case 0x1000 + 22: return "LVM_ARRANGE";
5341 case 0x1000 + 23: return "LVM_EDITLABELA";
5342 case 0x1000 + 118: return "LVM_EDITLABELW";
5343 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5344 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5345 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5346 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5347 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5348 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5349 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5350 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5351 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5352 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5353 case 0x1000 + 31: return "LVM_GETHEADER";
5354 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5355 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5356 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5357 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5358 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5359 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5360 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5361 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5362 case 0x1000 + 41: return "LVM_GETORIGIN";
5363 case 0x1000 + 42: return "LVM_UPDATE";
5364 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5365 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5366 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5367 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5368 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5369 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5370 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5371 case 0x1000 + 48: return "LVM_SORTITEMS";
5372 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5373 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5374 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5375 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5376 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5377 case 0x1000 + 53: return "LVM_SETICONSPACING";
5378 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5379 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5380 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5381 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5382 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5383 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5384 case 0x1000 + 60: return "LVM_SETHOTITEM";
5385 case 0x1000 + 61: return "LVM_GETHOTITEM";
5386 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5387 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5388 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5389 case 0x1000 + 65: return "LVM_SETWORKAREA";
5392 case 0x1100 + 0: return "TVM_INSERTITEMA";
5393 case 0x1100 + 50: return "TVM_INSERTITEMW";
5394 case 0x1100 + 1: return "TVM_DELETEITEM";
5395 case 0x1100 + 2: return "TVM_EXPAND";
5396 case 0x1100 + 4: return "TVM_GETITEMRECT";
5397 case 0x1100 + 5: return "TVM_GETCOUNT";
5398 case 0x1100 + 6: return "TVM_GETINDENT";
5399 case 0x1100 + 7: return "TVM_SETINDENT";
5400 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5401 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5402 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5403 case 0x1100 + 11: return "TVM_SELECTITEM";
5404 case 0x1100 + 12: return "TVM_GETITEMA";
5405 case 0x1100 + 62: return "TVM_GETITEMW";
5406 case 0x1100 + 13: return "TVM_SETITEMA";
5407 case 0x1100 + 63: return "TVM_SETITEMW";
5408 case 0x1100 + 14: return "TVM_EDITLABELA";
5409 case 0x1100 + 65: return "TVM_EDITLABELW";
5410 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5411 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5412 case 0x1100 + 17: return "TVM_HITTEST";
5413 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5414 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5415 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5416 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5417 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5418 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5419 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5420 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5421 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5424 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5425 case 0x1200 + 1: return "HDM_INSERTITEMA";
5426 case 0x1200 + 10: return "HDM_INSERTITEMW";
5427 case 0x1200 + 2: return "HDM_DELETEITEM";
5428 case 0x1200 + 3: return "HDM_GETITEMA";
5429 case 0x1200 + 11: return "HDM_GETITEMW";
5430 case 0x1200 + 4: return "HDM_SETITEMA";
5431 case 0x1200 + 12: return "HDM_SETITEMW";
5432 case 0x1200 + 5: return "HDM_LAYOUT";
5433 case 0x1200 + 6: return "HDM_HITTEST";
5434 case 0x1200 + 7: return "HDM_GETITEMRECT";
5435 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5436 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5437 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5438 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5439 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5440 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5441 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5444 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5445 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5446 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5447 case 0x1300 + 5: return "TCM_GETITEMA";
5448 case 0x1300 + 60: return "TCM_GETITEMW";
5449 case 0x1300 + 6: return "TCM_SETITEMA";
5450 case 0x1300 + 61: return "TCM_SETITEMW";
5451 case 0x1300 + 7: return "TCM_INSERTITEMA";
5452 case 0x1300 + 62: return "TCM_INSERTITEMW";
5453 case 0x1300 + 8: return "TCM_DELETEITEM";
5454 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5455 case 0x1300 + 10: return "TCM_GETITEMRECT";
5456 case 0x1300 + 11: return "TCM_GETCURSEL";
5457 case 0x1300 + 12: return "TCM_SETCURSEL";
5458 case 0x1300 + 13: return "TCM_HITTEST";
5459 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5460 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5461 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5462 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5463 case 0x1300 + 43: return "TCM_SETPADDING";
5464 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5465 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5466 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5467 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5468 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5469 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5470 case 0x1300 + 50: return "TCM_DESELECTALL";
5473 case WM_USER
+1: return "TB_ENABLEBUTTON";
5474 case WM_USER
+2: return "TB_CHECKBUTTON";
5475 case WM_USER
+3: return "TB_PRESSBUTTON";
5476 case WM_USER
+4: return "TB_HIDEBUTTON";
5477 case WM_USER
+5: return "TB_INDETERMINATE";
5478 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5479 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5480 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5481 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5482 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5483 case WM_USER
+17: return "TB_SETSTATE";
5484 case WM_USER
+18: return "TB_GETSTATE";
5485 case WM_USER
+19: return "TB_ADDBITMAP";
5486 case WM_USER
+20: return "TB_ADDBUTTONS";
5487 case WM_USER
+21: return "TB_INSERTBUTTON";
5488 case WM_USER
+22: return "TB_DELETEBUTTON";
5489 case WM_USER
+23: return "TB_GETBUTTON";
5490 case WM_USER
+24: return "TB_BUTTONCOUNT";
5491 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5492 case WM_USER
+26: return "TB_SAVERESTOREA";
5493 case WM_USER
+76: return "TB_SAVERESTOREW";
5494 case WM_USER
+27: return "TB_CUSTOMIZE";
5495 case WM_USER
+28: return "TB_ADDSTRINGA";
5496 case WM_USER
+77: return "TB_ADDSTRINGW";
5497 case WM_USER
+29: return "TB_GETITEMRECT";
5498 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5499 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5500 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5501 case WM_USER
+33: return "TB_AUTOSIZE";
5502 case WM_USER
+35: return "TB_GETTOOLTIPS";
5503 case WM_USER
+36: return "TB_SETTOOLTIPS";
5504 case WM_USER
+37: return "TB_SETPARENT";
5505 case WM_USER
+39: return "TB_SETROWS";
5506 case WM_USER
+40: return "TB_GETROWS";
5507 case WM_USER
+42: return "TB_SETCMDID";
5508 case WM_USER
+43: return "TB_CHANGEBITMAP";
5509 case WM_USER
+44: return "TB_GETBITMAP";
5510 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5511 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5512 case WM_USER
+46: return "TB_REPLACEBITMAP";
5513 case WM_USER
+47: return "TB_SETINDENT";
5514 case WM_USER
+48: return "TB_SETIMAGELIST";
5515 case WM_USER
+49: return "TB_GETIMAGELIST";
5516 case WM_USER
+50: return "TB_LOADIMAGES";
5517 case WM_USER
+51: return "TB_GETRECT";
5518 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5519 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5520 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5521 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5522 case WM_USER
+56: return "TB_SETSTYLE";
5523 case WM_USER
+57: return "TB_GETSTYLE";
5524 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5525 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5526 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5527 case WM_USER
+61: return "TB_GETTEXTROWS";
5528 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5531 static char s_szBuf
[128];
5532 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5536 #endif //__WXDEBUG__
5538 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5539 int *x
, int *y
, WPARAM
*flags
)
5541 // construct the key mask
5542 WPARAM
& fwKeys
= *flags
;
5544 fwKeys
= MK_RBUTTON
;
5545 if ( wxIsCtrlDown() )
5546 fwKeys
|= MK_CONTROL
;
5547 if ( wxIsShiftDown() )
5550 // simulate right mouse button click
5551 DWORD dwPos
= ::GetMessagePos();
5552 *x
= GET_X_LPARAM(dwPos
);
5553 *y
= GET_Y_LPARAM(dwPos
);
5555 win
->ScreenToClient(x
, y
);
5558 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5562 HWND hwnd
= GetHwndOf(win
);
5563 HDC hdc
= ::GetDC(hwnd
);
5565 #if !wxDIALOG_UNIT_COMPATIBILITY
5566 // and select the current font into it
5567 HFONT hfont
= GetHfontOf(win
->GetFont());
5570 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5574 // finally retrieve the text metrics from it
5575 GetTextMetrics(hdc
, &tm
);
5577 #if !wxDIALOG_UNIT_COMPATIBILITY
5581 (void)::SelectObject(hdc
, hfont
);
5585 ::ReleaseDC(hwnd
, hdc
);
5590 // Find the wxWindow at the current mouse position, returning the mouse
5592 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5594 pt
= wxGetMousePosition();
5595 return wxFindWindowAtPoint(pt
);
5598 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5603 HWND hWndHit
= ::WindowFromPoint(pt2
);
5605 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5606 HWND hWnd
= hWndHit
;
5608 // Try to find a window with a wxWindow associated with it
5609 while (!win
&& (hWnd
!= 0))
5611 hWnd
= ::GetParent(hWnd
);
5612 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5617 // Get the current mouse position.
5618 wxPoint
wxGetMousePosition()
5621 GetCursorPos( & pt
);
5623 return wxPoint(pt
.x
, pt
.y
);
5628 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5630 UINT win_modifiers
=0;
5631 if ( modifiers
& wxMOD_ALT
)
5632 win_modifiers
|= MOD_ALT
;
5633 if ( modifiers
& wxMOD_SHIFT
)
5634 win_modifiers
|= MOD_SHIFT
;
5635 if ( modifiers
& wxMOD_CONTROL
)
5636 win_modifiers
|= MOD_CONTROL
;
5637 if ( modifiers
& wxMOD_WIN
)
5638 win_modifiers
|= MOD_WIN
;
5640 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5642 wxLogLastError(_T("RegisterHotKey"));
5650 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
5652 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5654 wxLogLastError(_T("UnregisterHotKey"));
5662 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5664 int hotkeyId
= wParam
;
5665 int virtualKey
= HIWORD(lParam
);
5666 int win_modifiers
= LOWORD(lParam
);
5668 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5669 event
.SetId(hotkeyId
);
5670 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5671 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5672 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5673 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5675 return GetEventHandler()->ProcessEvent(event
);
5678 #endif // wxUSE_HOTKEY