1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
38 #include "wx/dcclient.h"
39 #include "wx/dcmemory.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
47 #include "wx/msgdlg.h"
48 #include "wx/settings.h"
49 #include "wx/statbox.h"
52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
53 #include "wx/ownerdrw.h"
56 #include "wx/module.h"
58 #if wxUSE_DRAG_AND_DROP
62 #if wxUSE_ACCESSIBILITY
63 #include "wx/access.h"
67 #define WM_GETOBJECT 0x003D
70 #define OBJID_CLIENT 0xFFFFFFFC
74 #include "wx/menuitem.h"
77 #include "wx/msw/private.h"
80 #include "wx/tooltip.h"
88 #include "wx/spinctrl.h"
89 #endif // wxUSE_SPINCTRL
94 #include "wx/textctrl.h"
95 #include "wx/notebook.h"
96 #include "wx/listctrl.h"
100 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
101 #include <shellapi.h>
102 #include <mmsystem.h>
106 #include <windowsx.h>
109 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
111 #include <commctrl.h>
113 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
114 #include "wx/msw/gnuwin32/extra.h"
117 #if defined(__GNUG__)
118 #include "wx/msw/missing.h"
121 #if defined(__WXWINCE__)
122 #include "wx/msw/wince/missing.h"
125 // ----------------------------------------------------------------------------
126 // standard constants not available with all compilers/headers
127 // ----------------------------------------------------------------------------
129 // This didn't appear in mingw until 2.95.2
131 #define SIF_TRACKPOS 16
135 #ifndef WM_MOUSEWHEEL
136 #define WM_MOUSEWHEEL 0x020A
139 #define WHEEL_DELTA 120
141 #ifndef SPI_GETWHEELSCROLLLINES
142 #define SPI_GETWHEELSCROLLLINES 104
144 #endif // wxUSE_MOUSEWHEEL
147 #define VK_OEM_1 0xBA
148 #define VK_OEM_2 0xBF
149 #define VK_OEM_3 0xC0
150 #define VK_OEM_4 0xDB
151 #define VK_OEM_5 0xDC
152 #define VK_OEM_6 0xDD
153 #define VK_OEM_7 0xDE
157 #define VK_OEM_PLUS 0xBB
158 #define VK_OEM_COMMA 0xBC
159 #define VK_OEM_MINUS 0xBD
160 #define VK_OEM_PERIOD 0xBE
163 // ---------------------------------------------------------------------------
165 // ---------------------------------------------------------------------------
167 #if wxUSE_MENUS_NATIVE
168 wxMenu
*wxCurrentPopupMenu
= NULL
;
169 #endif // wxUSE_MENUS_NATIVE
171 extern const wxChar
*wxCanvasClassName
;
173 // true if we had already created the std colour map, used by
174 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
175 static bool gs_hasStdCmap
= FALSE
;
177 // ---------------------------------------------------------------------------
179 // ---------------------------------------------------------------------------
181 // the window proc for all our windows
182 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
183 WPARAM wParam
, LPARAM lParam
);
187 const char *wxGetMessageName(int message
);
190 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
191 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
192 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
194 // this magical function is used to translate VK_APPS key presses to right
196 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
197 int *x
, int *y
, WPARAM
*flags
);
199 // get the text metrics for the current font
200 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
202 // find the window for the mouse event at the specified position
203 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
205 // wrapper around BringWindowToTop() API
206 static inline void wxBringWindowToTop(HWND hwnd
)
208 #ifdef __WXMICROWIN__
209 // It seems that MicroWindows brings the _parent_ of the window to the top,
210 // which can be the wrong one.
212 // activate (set focus to) specified window
216 // raise top level parent to top of z order
217 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
219 wxLogLastError(_T("SetWindowPos"));
223 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
224 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
227 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
228 parent as well as otherwise several Win32 functions using
229 GetNextDlgTabItem() to iterate over all controls such as
230 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
231 all of them iterate over all the controls starting from the currently
232 focused one and stop iterating when they get back to the focus but
233 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
234 get back to the initial (focused) window: as we do have this style,
235 GetNextDlgTabItem() will leave this window and continue in its parent,
236 but if the parent doesn't have it, it wouldn't recurse inside it later
237 on and so wouldn't have a chance of getting back to this window neither.
240 while ( parent
&& !parent
->IsTopLevel() )
242 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
243 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
245 // force the parent to have this style
246 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
247 exStyle
| WS_EX_CONTROLPARENT
);
250 parent
= parent
->GetParent();
252 #endif // !__WXWINCE__
255 // ---------------------------------------------------------------------------
257 // ---------------------------------------------------------------------------
259 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
261 #ifdef __WXUNIVERSAL__
262 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
264 #if wxUSE_EXTENDED_RTTI
266 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
267 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
268 // windows with negative ids never can be recreated anyway
270 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
272 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
273 if ( win
&& win
->GetId() < 0 )
278 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
280 // make wxWindowList known before the property is used
282 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
284 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
286 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
289 WX_DEFINE_FLAGS( wxWindowStyle
)
291 wxBEGIN_FLAGS( wxWindowStyle
)
292 // new style border flags, we put them first to
293 // use them for streaming out
295 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
296 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
297 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
298 wxFLAGS_MEMBER(wxBORDER_RAISED
)
299 wxFLAGS_MEMBER(wxBORDER_STATIC
)
300 wxFLAGS_MEMBER(wxBORDER_NONE
)
302 // old style border flags
303 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
304 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
305 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
306 wxFLAGS_MEMBER(wxRAISED_BORDER
)
307 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
308 wxFLAGS_MEMBER(wxBORDER
)
310 // standard window styles
311 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
312 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
313 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
314 wxFLAGS_MEMBER(wxWANTS_CHARS
)
315 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
316 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
317 wxFLAGS_MEMBER(wxVSCROLL
)
318 wxFLAGS_MEMBER(wxHSCROLL
)
320 wxEND_FLAGS( wxWindowStyle
)
322 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
323 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
324 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
325 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
326 // Always constructor Properties first
328 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
329 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
330 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxPoint(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
331 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxSize(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
332 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
334 // Then all relations of the object graph
336 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
338 // and finally all other properties
340 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
341 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
342 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
343 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
344 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
346 // possible property candidates (not in xrc) or not valid in all subclasses
347 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxT("") )
348 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
349 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxT("") )
350 // MaxHeight, Width , MinHeight , Width
351 // TODO switch label to control and title to toplevels
353 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
354 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
355 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
356 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
361 wxEND_PROPERTIES_TABLE()
363 wxBEGIN_HANDLERS_TABLE(wxWindow
)
364 wxEND_HANDLERS_TABLE()
366 wxCONSTRUCTOR_DUMMY(wxWindow
)
369 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
371 #endif // __WXUNIVERSAL__/__WXMSW__
373 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
374 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
375 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
376 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
379 // ===========================================================================
381 // ===========================================================================
383 // ---------------------------------------------------------------------------
384 // wxWindow utility functions
385 // ---------------------------------------------------------------------------
387 // Find an item given the MS Windows id
388 wxWindow
*wxWindowMSW::FindItem(long id
) const
391 wxControl
*item
= wxDynamicCastThis(wxControl
);
394 // is it we or one of our "internal" children?
395 if ( item
->GetId() == id
396 #ifndef __WXUNIVERSAL__
397 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
398 #endif // __WXUNIVERSAL__
404 #endif // wxUSE_CONTROLS
406 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
409 wxWindow
*childWin
= current
->GetData();
411 wxWindow
*wnd
= childWin
->FindItem(id
);
415 current
= current
->GetNext();
421 // Find an item given the MS Windows handle
422 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
424 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
427 wxWindow
*parent
= current
->GetData();
429 // Do a recursive search.
430 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
436 || parent
->IsKindOf(CLASSINFO(wxControl
))
437 #endif // wxUSE_CONTROLS
440 wxWindow
*item
= current
->GetData();
441 if ( item
->GetHWND() == hWnd
)
445 if ( item
->ContainsHWND(hWnd
) )
450 current
= current
->GetNext();
455 // Default command handler
456 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
461 // ----------------------------------------------------------------------------
462 // constructors and such
463 // ----------------------------------------------------------------------------
465 void wxWindowMSW::Init()
468 m_isBeingDeleted
= FALSE
;
470 m_mouseInWindow
= FALSE
;
471 m_lastKeydownProcessed
= FALSE
;
473 m_childrenDisabled
= NULL
;
483 // as all windows are created with WS_VISIBLE style...
486 #if wxUSE_MOUSEEVENT_HACK
489 m_lastMouseEvent
= -1;
490 #endif // wxUSE_MOUSEEVENT_HACK
494 wxWindowMSW::~wxWindowMSW()
496 m_isBeingDeleted
= TRUE
;
498 #ifndef __WXUNIVERSAL__
499 // VS: make sure there's no wxFrame with last focus set to us:
500 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
502 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
505 if ( frame
->GetLastFocus() == this )
507 frame
->SetLastFocus(NULL
);
512 #endif // __WXUNIVERSAL__
514 // VS: destroy children first and _then_ detach *this from its parent.
515 // If we'd do it the other way around, children wouldn't be able
516 // find their parent frame (see above).
521 // VZ: test temp removed to understand what really happens here
522 //if (::IsWindow(GetHwnd()))
524 if ( !::DestroyWindow(GetHwnd()) )
525 wxLogLastError(wxT("DestroyWindow"));
528 // remove hWnd <-> wxWindow association
529 wxRemoveHandleAssociation(this);
532 delete m_childrenDisabled
;
535 // real construction (Init() must have been called before!)
536 bool wxWindowMSW::Create(wxWindow
*parent
,
541 const wxString
& name
)
543 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
545 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
548 parent
->AddChild(this);
551 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
553 #ifdef __WXUNIVERSAL__
554 // no borders, we draw them ourselves
555 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
559 msflags
&= ~WS_BORDER
;
560 #endif // wxUniversal
562 // all windows are created visible by default except popup ones (which are
563 // like the wxTopLevelWindows in this aspect)
564 if ( style
& wxPOPUP_WINDOW
)
566 msflags
&= ~WS_VISIBLE
;
571 msflags
|= WS_VISIBLE
;
574 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
577 // ---------------------------------------------------------------------------
579 // ---------------------------------------------------------------------------
581 void wxWindowMSW::SetFocus()
583 HWND hWnd
= GetHwnd();
584 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
586 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
590 if ( !::SetFocus(hWnd
) )
592 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
593 // was there really an error?
594 DWORD dwRes
= ::GetLastError();
597 HWND hwndFocus
= ::GetFocus();
598 if ( hwndFocus
!= hWnd
)
600 wxLogApiError(_T("SetFocus"), dwRes
);
607 void wxWindowMSW::SetFocusFromKbd()
609 // when the focus is given to the control with DLGC_HASSETSEL style from
610 // keyboard its contents should be entirely selected: this is what
611 // ::IsDialogMessage() does and so we should do it as well to provide the
612 // same LNF as the native programs
613 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
615 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
618 // do this after (maybe) setting the selection as like this when
619 // wxEVT_SET_FOCUS handler is called, the selection would have been already
620 // set correctly -- this may be important
621 wxWindowBase::SetFocusFromKbd();
624 // Get the window with the focus
625 wxWindow
*wxWindowBase::FindFocus()
627 HWND hWnd
= ::GetFocus();
630 return wxGetWindowFromHWND((WXHWND
)hWnd
);
636 bool wxWindowMSW::Enable(bool enable
)
638 if ( !wxWindowBase::Enable(enable
) )
641 HWND hWnd
= GetHwnd();
643 ::EnableWindow(hWnd
, (BOOL
)enable
);
645 // the logic below doesn't apply to the top level windows -- otherwise
646 // showing a modal dialog would result in total greying out (and ungreying
647 // out later) of everything which would be really ugly
651 // when the parent is disabled, all of its children should be disabled as
652 // well but when it is enabled back, only those of the children which
653 // hadn't been already disabled in the beginning should be enabled again,
654 // so we have to keep the list of those children
655 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
657 node
= node
->GetNext() )
659 wxWindow
*child
= node
->GetData();
660 if ( child
->IsTopLevel() )
662 // the logic below doesn't apply to top level children
668 // enable the child back unless it had been disabled before us
669 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
672 else // we're being disabled
674 if ( child
->IsEnabled() )
676 // disable it as children shouldn't stay enabled while the
680 else // child already disabled, remember it
682 // have we created the list of disabled children already?
683 if ( !m_childrenDisabled
)
684 m_childrenDisabled
= new wxWindowList
;
686 m_childrenDisabled
->Append(child
);
691 if ( enable
&& m_childrenDisabled
)
693 // we don't need this list any more, don't keep unused memory
694 delete m_childrenDisabled
;
695 m_childrenDisabled
= NULL
;
701 bool wxWindowMSW::Show(bool show
)
703 if ( !wxWindowBase::Show(show
) )
706 HWND hWnd
= GetHwnd();
707 int cshow
= show
? SW_SHOW
: SW_HIDE
;
708 ::ShowWindow(hWnd
, cshow
);
710 if ( show
&& IsTopLevel() )
712 wxBringWindowToTop(hWnd
);
718 // Raise the window to the top of the Z order
719 void wxWindowMSW::Raise()
721 wxBringWindowToTop(GetHwnd());
724 // Lower the window to the bottom of the Z order
725 void wxWindowMSW::Lower()
727 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
728 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
731 void wxWindowMSW::SetTitle( const wxString
& title
)
733 SetWindowText(GetHwnd(), title
.c_str());
736 wxString
wxWindowMSW::GetTitle() const
738 return wxGetWindowText(GetHWND());
741 void wxWindowMSW::DoCaptureMouse()
743 HWND hWnd
= GetHwnd();
750 void wxWindowMSW::DoReleaseMouse()
752 if ( !::ReleaseCapture() )
754 wxLogLastError(_T("ReleaseCapture"));
758 /* static */ wxWindow
*wxWindowBase::GetCapture()
760 HWND hwnd
= ::GetCapture();
761 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
764 bool wxWindowMSW::SetFont(const wxFont
& font
)
766 if ( !wxWindowBase::SetFont(font
) )
772 HWND hWnd
= GetHwnd();
775 WXHANDLE hFont
= m_font
.GetResourceHandle();
777 wxASSERT_MSG( hFont
, wxT("should have valid font") );
779 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
784 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
786 if ( !wxWindowBase::SetCursor(cursor
) )
794 HWND hWnd
= GetHwnd();
796 // Change the cursor NOW if we're within the correct window
798 ::GetCursorPos(&point
);
800 RECT rect
= wxGetWindowRect(hWnd
);
802 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
803 ::SetCursor(GetHcursorOf(m_cursor
));
809 void wxWindowMSW::WarpPointer (int x
, int y
)
811 ClientToScreen(&x
, &y
);
813 if ( !::SetCursorPos(x
, y
) )
815 wxLogLastError(_T("SetCursorPos"));
819 // ---------------------------------------------------------------------------
821 // ---------------------------------------------------------------------------
823 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
824 static inline int wxDirToWinStyle(int orient
)
826 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
829 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
831 #ifdef __WXMICROWIN__
832 return ::GetScrollPosWX(hWnd
, wOrient
);
834 WinStruct
<SCROLLINFO
> scrollInfo
;
835 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
836 scrollInfo
.fMask
= SIF_POS
;
837 if ( !::GetScrollInfo(hWnd
,
841 // Not neccessarily an error, if there are no scrollbars yet.
842 // wxLogLastError(_T("GetScrollInfo"));
844 return scrollInfo
.nPos
;
845 // return ::GetScrollPos(hWnd, wOrient);
849 int wxWindowMSW::GetScrollPos(int orient
) const
851 HWND hWnd
= GetHwnd();
852 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
854 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
857 // This now returns the whole range, not just the number
858 // of positions that we can scroll.
859 int wxWindowMSW::GetScrollRange(int orient
) const
862 HWND hWnd
= GetHwnd();
866 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
869 WinStruct
<SCROLLINFO
> scrollInfo
;
870 scrollInfo
.fMask
= SIF_RANGE
;
871 if ( !::GetScrollInfo(hWnd
,
872 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
875 // Most of the time this is not really an error, since the return
876 // value can also be zero when there is no scrollbar yet.
877 // wxLogLastError(_T("GetScrollInfo"));
879 maxPos
= scrollInfo
.nMax
;
881 // undo "range - 1" done in SetScrollbar()
885 int wxWindowMSW::GetScrollThumb(int orient
) const
887 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
890 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
892 HWND hWnd
= GetHwnd();
893 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
895 WinStruct
<SCROLLINFO
> info
;
899 info
.fMask
= SIF_POS
;
900 if ( HasFlag(wxALWAYS_SHOW_SB
) )
902 // disable scrollbar instead of removing it then
903 info
.fMask
|= SIF_DISABLENOSCROLL
;
906 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
910 // New function that will replace some of the above.
911 void wxWindowMSW::SetScrollbar(int orient
,
917 WinStruct
<SCROLLINFO
> info
;
918 info
.nPage
= pageSize
;
919 info
.nMin
= 0; // range is nMax - nMin + 1
920 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
922 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
923 if ( HasFlag(wxALWAYS_SHOW_SB
) )
925 // disable scrollbar instead of removing it then
926 info
.fMask
|= SIF_DISABLENOSCROLL
;
929 HWND hWnd
= GetHwnd();
932 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
936 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
939 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
945 rect
.left
= prect
->x
;
947 rect
.right
= prect
->x
+ prect
->width
;
948 rect
.bottom
= prect
->y
+ prect
->height
;
957 // FIXME: is this the exact equivalent of the line below?
958 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_ERASE
|SW_INVALIDATE
);
960 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
964 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
966 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
969 for ( int n
= 0; n
< count
; n
++ )
971 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
973 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
976 // don't bother to continue, we're already at top/bottom
983 return pos
!= posStart
;
986 bool wxWindowMSW::ScrollLines(int lines
)
988 bool down
= lines
> 0;
990 return ScrollVertically(GetHwnd(),
991 down
? SB_LINEDOWN
: SB_LINEUP
,
992 down
? lines
: -lines
);
995 bool wxWindowMSW::ScrollPages(int pages
)
997 bool down
= pages
> 0;
999 return ScrollVertically(GetHwnd(),
1000 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1001 down
? pages
: -pages
);
1004 // ---------------------------------------------------------------------------
1006 // ---------------------------------------------------------------------------
1008 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1010 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1012 HWND hwnd
= (HWND
)hWnd
;
1013 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1015 wxAssociateWinWithHandle(hwnd
, this);
1017 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
1019 // we don't need to subclass the window of our own class (in the Windows
1020 // sense of the word)
1021 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1023 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
1027 // don't bother restoring it neither: this also makes it easy to
1028 // implement IsOfStandardClass() method which returns TRUE for the
1029 // standard controls and FALSE for the wxWindows own windows as it can
1030 // simply check m_oldWndProc
1031 m_oldWndProc
= NULL
;
1035 void wxWindowMSW::UnsubclassWin()
1037 wxRemoveHandleAssociation(this);
1039 // Restore old Window proc
1040 HWND hwnd
= GetHwnd();
1045 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1049 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1051 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
1054 m_oldWndProc
= NULL
;
1059 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1061 // Unicows note: the code below works, but only because WNDCLASS contains
1062 // original window handler rather that the unicows fake one. This may not
1063 // be on purpose, though; if it stops working with future versions of
1064 // unicows.dll, we can override unicows hooks by setting
1065 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1066 // versions that keep track of fake<->real wnd proc mapping.
1068 // On WinCE (at least), the wndproc comparison doesn't work,
1069 // so have to use something like this.
1071 extern const wxChar
*wxCanvasClassName
;
1072 extern const wxChar
*wxCanvasClassNameNR
;
1073 extern const wxChar
*wxMDIFrameClassName
;
1074 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1075 extern const wxChar
*wxMDIChildFrameClassName
;
1076 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1077 wxString
str(wxGetWindowClass(hWnd
));
1078 if (str
== wxCanvasClassName
||
1079 str
== wxCanvasClassNameNR
||
1080 str
== wxMDIFrameClassName
||
1081 str
== wxMDIFrameClassNameNoRedraw
||
1082 str
== wxMDIChildFrameClassName
||
1083 str
== wxMDIChildFrameClassNameNoRedraw
||
1084 str
== _T("wxTLWHiddenParent"))
1085 return TRUE
; // Effectively means don't subclass
1090 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1092 wxLogLastError(_T("GetClassInfo"));
1097 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1101 // ----------------------------------------------------------------------------
1103 // ----------------------------------------------------------------------------
1105 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1107 long flagsOld
= GetWindowStyleFlag();
1108 if ( flags
== flagsOld
)
1111 // update the internal variable
1112 wxWindowBase::SetWindowStyleFlag(flags
);
1114 // now update the Windows style as well if needed - and if the window had
1115 // been already created
1119 WXDWORD exstyle
, exstyleOld
;
1120 long style
= MSWGetStyle(flags
, &exstyle
),
1121 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1123 if ( style
!= styleOld
)
1125 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1126 // this function so instead of simply setting the style to the new
1127 // value we clear the bits which were set in styleOld but are set in
1128 // the new one and set the ones which were not set before
1129 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1130 styleReal
&= ~styleOld
;
1133 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1136 // and the extended style
1137 if ( exstyle
!= exstyleOld
)
1139 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1140 exstyleReal
&= ~exstyleOld
;
1141 exstyleReal
|= exstyle
;
1143 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1145 // we must call SetWindowPos() to flash the cached extended style and
1146 // also to make the change to wxSTAY_ON_TOP style take effect: just
1147 // setting the style simply doesn't work
1148 if ( !::SetWindowPos(GetHwnd(),
1149 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1152 SWP_NOMOVE
| SWP_NOSIZE
) )
1154 wxLogLastError(_T("SetWindowPos"));
1159 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1161 // translate the style
1162 WXDWORD style
= WS_CHILD
| WS_VISIBLE
;
1164 if ( flags
& wxCLIP_CHILDREN
)
1165 style
|= WS_CLIPCHILDREN
;
1167 if ( flags
& wxCLIP_SIBLINGS
)
1168 style
|= WS_CLIPSIBLINGS
;
1170 if ( flags
& wxVSCROLL
)
1171 style
|= WS_VSCROLL
;
1173 if ( flags
& wxHSCROLL
)
1174 style
|= WS_HSCROLL
;
1176 const wxBorder border
= GetBorder(flags
);
1178 // WS_BORDER is only required for wxBORDER_SIMPLE
1179 if ( border
== wxBORDER_SIMPLE
)
1182 // now deal with ext style if the caller wants it
1188 if ( flags
& wxTRANSPARENT_WINDOW
)
1189 *exstyle
|= WS_EX_TRANSPARENT
;
1195 case wxBORDER_DEFAULT
:
1196 wxFAIL_MSG( _T("unknown border style") );
1200 case wxBORDER_SIMPLE
:
1203 case wxBORDER_STATIC
:
1204 *exstyle
|= WS_EX_STATICEDGE
;
1207 case wxBORDER_RAISED
:
1208 *exstyle
|= WS_EX_DLGMODALFRAME
;
1211 case wxBORDER_SUNKEN
:
1212 *exstyle
|= WS_EX_CLIENTEDGE
;
1213 style
&= ~WS_BORDER
;
1216 case wxBORDER_DOUBLE
:
1217 *exstyle
|= WS_EX_DLGMODALFRAME
;
1221 // wxUniv doesn't use Windows dialog navigation functions at all
1222 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1223 // to make the dialog navigation work with the nested panels we must
1224 // use this style (top level windows such as dialogs don't need it)
1225 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1227 *exstyle
|= WS_EX_CONTROLPARENT
;
1229 #endif // __WXUNIVERSAL__
1235 // Setup background and foreground colours correctly
1236 void wxWindowMSW::SetupColours()
1239 SetBackgroundColour(GetParent()->GetBackgroundColour());
1242 bool wxWindowMSW::IsMouseInWindow() const
1244 // get the mouse position
1246 ::GetCursorPos(&pt
);
1248 // find the window which currently has the cursor and go up the window
1249 // chain until we find this window - or exhaust it
1250 HWND hwnd
= ::WindowFromPoint(pt
);
1251 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1252 hwnd
= ::GetParent(hwnd
);
1254 return hwnd
!= NULL
;
1257 void wxWindowMSW::OnInternalIdle()
1259 // Check if we need to send a LEAVE event
1260 if ( m_mouseInWindow
)
1262 // note that we should generate the leave event whether the window has
1263 // or doesn't have mouse capture
1264 if ( !IsMouseInWindow() )
1266 // Generate a LEAVE event
1267 m_mouseInWindow
= FALSE
;
1269 // Unfortunately the mouse button and keyboard state may have
1270 // changed by the time the OnInternalIdle function is called, so 'state'
1271 // may be meaningless.
1273 if ( wxIsShiftDown() )
1275 if ( wxIsCtrlDown() )
1276 state
|= MK_CONTROL
;
1277 if ( GetKeyState( VK_LBUTTON
) )
1278 state
|= MK_LBUTTON
;
1279 if ( GetKeyState( VK_MBUTTON
) )
1280 state
|= MK_MBUTTON
;
1281 if ( GetKeyState( VK_RBUTTON
) )
1282 state
|= MK_RBUTTON
;
1285 if ( !::GetCursorPos(&pt
) )
1287 wxLogLastError(_T("GetCursorPos"));
1290 // we need to have client coordinates here for symmetry with
1291 // wxEVT_ENTER_WINDOW
1292 RECT rect
= wxGetWindowRect(GetHwnd());
1296 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1297 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1299 (void)GetEventHandler()->ProcessEvent(event2
);
1303 if (wxUpdateUIEvent::CanUpdate(this))
1304 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1307 // Set this window to be the child of 'parent'.
1308 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1310 if ( !wxWindowBase::Reparent(parent
) )
1313 HWND hWndChild
= GetHwnd();
1314 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1316 ::SetParent(hWndChild
, hWndParent
);
1319 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1321 EnsureParentHasControlParentStyle(GetParent());
1323 #endif // !__WXWINCE__
1328 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1330 #ifndef __WXMICROWIN__
1331 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1335 void wxWindowMSW::Freeze()
1337 SendSetRedraw(GetHwnd(), FALSE
);
1340 void wxWindowMSW::Thaw()
1342 SendSetRedraw(GetHwnd(), TRUE
);
1344 // we need to refresh everything or otherwise he invalidated area is not
1349 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1351 HWND hWnd
= GetHwnd();
1357 mswRect
.left
= rect
->x
;
1358 mswRect
.top
= rect
->y
;
1359 mswRect
.right
= rect
->x
+ rect
->width
;
1360 mswRect
.bottom
= rect
->y
+ rect
->height
;
1362 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1365 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1369 void wxWindowMSW::Update()
1371 if ( !::UpdateWindow(GetHwnd()) )
1373 wxLogLastError(_T("UpdateWindow"));
1376 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1377 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1378 // handler needs to be really drawn right now
1383 // ---------------------------------------------------------------------------
1385 // ---------------------------------------------------------------------------
1388 #if wxUSE_DRAG_AND_DROP
1389 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1391 if ( m_dropTarget
!= 0 ) {
1392 m_dropTarget
->Revoke(m_hWnd
);
1393 delete m_dropTarget
;
1396 m_dropTarget
= pDropTarget
;
1397 if ( m_dropTarget
!= 0 )
1398 m_dropTarget
->Register(m_hWnd
);
1400 #endif // wxUSE_DRAG_AND_DROP
1402 // old style file-manager drag&drop support: we retain the old-style
1403 // DragAcceptFiles in parallel with SetDropTarget.
1404 void wxWindowMSW::DragAcceptFiles(bool accept
)
1406 #if !defined(__WXWINCE__)
1407 HWND hWnd
= GetHwnd();
1409 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1413 // ----------------------------------------------------------------------------
1415 // ----------------------------------------------------------------------------
1419 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1421 wxWindowBase::DoSetToolTip(tooltip
);
1424 m_tooltip
->SetWindow((wxWindow
*)this);
1427 #endif // wxUSE_TOOLTIPS
1429 // ---------------------------------------------------------------------------
1430 // moving and resizing
1431 // ---------------------------------------------------------------------------
1434 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1436 RECT rect
= wxGetWindowRect(GetHwnd());
1439 *x
= rect
.right
- rect
.left
;
1441 *y
= rect
.bottom
- rect
.top
;
1444 // Get size *available for subwindows* i.e. excluding menu bar etc.
1445 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1447 RECT rect
= wxGetClientRect(GetHwnd());
1455 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1457 RECT rect
= wxGetWindowRect(GetHwnd());
1460 point
.x
= rect
.left
;
1463 // we do the adjustments with respect to the parent only for the "real"
1464 // children, not for the dialogs/frames
1465 if ( !IsTopLevel() )
1467 HWND hParentWnd
= 0;
1468 wxWindow
*parent
= GetParent();
1470 hParentWnd
= GetWinHwnd(parent
);
1472 // Since we now have the absolute screen coords, if there's a parent we
1473 // must subtract its top left corner
1476 ::ScreenToClient(hParentWnd
, &point
);
1481 // We may be faking the client origin. So a window that's really at (0,
1482 // 30) may appear (to wxWin apps) to be at (0, 0).
1483 wxPoint
pt(parent
->GetClientAreaOrigin());
1495 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1503 ::ScreenToClient(GetHwnd(), &pt
);
1511 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1519 ::ClientToScreen(GetHwnd(), &pt
);
1527 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1529 // TODO: is this consistent with other platforms?
1530 // Still, negative width or height shouldn't be allowed
1535 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1537 wxLogLastError(wxT("MoveWindow"));
1541 // set the size of the window: if the dimensions are positive, just use them,
1542 // but if any of them is equal to -1, it means that we must find the value for
1543 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1544 // which case -1 is a valid value for x and y)
1546 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1547 // the width/height to best suit our contents, otherwise we reuse the current
1549 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1551 // get the current size and position...
1552 int currentX
, currentY
;
1553 GetPosition(¤tX
, ¤tY
);
1554 int currentW
,currentH
;
1555 GetSize(¤tW
, ¤tH
);
1557 // ... and don't do anything (avoiding flicker) if it's already ok
1558 if ( x
== currentX
&& y
== currentY
&&
1559 width
== currentW
&& height
== currentH
)
1564 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1566 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1569 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1571 wxSize
size(-1, -1);
1574 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1576 size
= DoGetBestSize();
1581 // just take the current one
1588 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1592 size
= DoGetBestSize();
1594 //else: already called DoGetBestSize() above
1600 // just take the current one
1605 DoMoveWindow(x
, y
, width
, height
);
1608 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1610 // setting the client size is less obvious than it it could have been
1611 // because in the result of changing the total size the window scrollbar
1612 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1613 // will not be correct as the difference between the total and client size
1614 // changes - so we keep changing it until we get it right
1616 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1617 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1618 // may become 3 if the window had 0 size originally and so we didn't
1619 // calculate the scrollbar correction correctly during the first iteration)
1620 // but just to be on the safe side we check for it instead of making it an
1621 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1622 for ( int i
= 0; i
< 4; i
++ )
1625 ::GetClientRect(GetHwnd(), &rectClient
);
1627 // if the size is already ok, stop here (rectClient.left = top = 0)
1628 if ( (rectClient
.right
== width
|| width
== -1) &&
1629 (rectClient
.bottom
== height
|| height
== -1) )
1634 int widthClient
= width
,
1635 heightClient
= height
;
1637 // Find the difference between the entire window (title bar and all)
1638 // and the client area; add this to the new client size to move the
1641 ::GetWindowRect(GetHwnd(), &rectWin
);
1643 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1644 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1647 point
.x
= rectWin
.left
;
1648 point
.y
= rectWin
.top
;
1650 // MoveWindow positions the child windows relative to the parent, so
1651 // adjust if necessary
1652 if ( !IsTopLevel() )
1654 wxWindow
*parent
= GetParent();
1657 ::ScreenToClient(GetHwndOf(parent
), &point
);
1661 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1665 // For implementation purposes - sometimes decorations make the client area
1667 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1669 return wxPoint(0, 0);
1672 // ---------------------------------------------------------------------------
1674 // ---------------------------------------------------------------------------
1676 int wxWindowMSW::GetCharHeight() const
1678 return wxGetTextMetrics(this).tmHeight
;
1681 int wxWindowMSW::GetCharWidth() const
1683 // +1 is needed because Windows apparently adds it when calculating the
1684 // dialog units size in pixels
1685 #if wxDIALOG_UNIT_COMPATIBILITY
1686 return wxGetTextMetrics(this).tmAveCharWidth
;
1688 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1692 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1694 int *descent
, int *externalLeading
,
1695 const wxFont
*theFont
) const
1697 const wxFont
*fontToUse
= theFont
;
1699 fontToUse
= &m_font
;
1701 HWND hWnd
= GetHwnd();
1702 HDC dc
= ::GetDC(hWnd
);
1706 if ( fontToUse
&& fontToUse
->Ok() )
1708 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1710 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1715 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1716 GetTextMetrics(dc
, &tm
);
1718 if ( fontToUse
&& fnt
&& hfontOld
)
1719 SelectObject(dc
, hfontOld
);
1721 ReleaseDC(hWnd
, dc
);
1728 *descent
= tm
.tmDescent
;
1729 if ( externalLeading
)
1730 *externalLeading
= tm
.tmExternalLeading
;
1733 // ---------------------------------------------------------------------------
1735 // ---------------------------------------------------------------------------
1737 #if wxUSE_MENUS_NATIVE
1739 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1740 // immediately, without waiting for the next event loop iteration
1742 // NB: this function should probably be made public later as it can almost
1743 // surely replace wxYield() elsewhere as well
1744 static void wxYieldForCommandsOnly()
1746 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1747 // want to process it here)
1749 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1751 if ( msg
.message
== WM_QUIT
)
1753 // if we retrieved a WM_QUIT, insert back into the message queue.
1754 ::PostQuitMessage(0);
1758 // luckily (as we don't have access to wxEventLoopImpl method from here
1759 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1761 ::TranslateMessage(&msg
);
1762 ::DispatchMessage(&msg
);
1766 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1768 menu
->SetInvokingWindow(this);
1771 HWND hWnd
= GetHwnd();
1772 HMENU hMenu
= GetHmenuOf(menu
);
1776 ::ClientToScreen(hWnd
, &point
);
1777 wxCurrentPopupMenu
= menu
;
1779 #if !defined(__WXWINCE__)
1780 flags
= TPM_RIGHTBUTTON
;
1782 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1784 // we need to do it righ now as otherwise the events are never going to be
1785 // sent to wxCurrentPopupMenu from HandleCommand()
1787 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1788 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1789 // destroyed as soon as we return (it can be a local variable in the caller
1790 // for example) and so we do need to process the event immediately
1791 wxYieldForCommandsOnly();
1793 wxCurrentPopupMenu
= NULL
;
1795 menu
->SetInvokingWindow(NULL
);
1800 #endif // wxUSE_MENUS_NATIVE
1802 // ===========================================================================
1803 // pre/post message processing
1804 // ===========================================================================
1806 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1809 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1811 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1814 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1816 // wxUniversal implements tab traversal itself
1817 #ifndef __WXUNIVERSAL__
1818 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1820 // intercept dialog navigation keys
1821 MSG
*msg
= (MSG
*)pMsg
;
1823 // here we try to do all the job which ::IsDialogMessage() usually does
1826 if ( msg
->message
== WM_KEYDOWN
)
1828 bool bCtrlDown
= wxIsCtrlDown();
1829 bool bShiftDown
= wxIsShiftDown();
1831 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1832 // don't process it if it's the case (except for Ctrl-Tab/Enter
1833 // combinations which are always processed)
1837 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1839 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1840 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1841 // it, of course, implies them
1842 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1844 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1848 bool bForward
= TRUE
,
1849 bWindowChange
= FALSE
;
1851 // should we process this message specially?
1852 bool bProcess
= TRUE
;
1853 switch ( msg
->wParam
)
1856 // assume that nobody wants Shift-TAB for himself - if we
1857 // don't do it there is no easy way for a control to grab
1858 // TABs but still let Shift-TAB work as navugation key
1859 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1863 // Ctrl-Tab cycles thru notebook pages
1864 bWindowChange
= bCtrlDown
;
1865 bForward
= !bShiftDown
;
1871 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1879 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1885 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1887 // control wants to process Enter itself, don't
1888 // call IsDialogMessage() which would interpret
1892 else if ( lDlgCode
& DLGC_BUTTON
)
1894 // let IsDialogMessage() handle this for all
1895 // buttons except the owner-drawn ones which it
1896 // just seems to ignore
1897 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1898 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1900 // emulate the button click
1901 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1903 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1908 // FIXME: this should be handled by
1909 // wxNavigationKeyEvent handler and not here!!
1913 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1915 if ( btn
&& btn
->IsEnabled() )
1917 // if we do have a default button, do press it
1918 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1922 else // no default button
1924 #endif // wxUSE_BUTTON
1925 // this is a quick and dirty test for a text
1927 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1929 // don't process Enter, the control might
1930 // need it for itself and don't let
1931 // ::IsDialogMessage() have it as it can
1932 // eat the Enter events sometimes
1935 else if (!IsTopLevel())
1937 // if not a top level window, let parent
1941 //else: treat Enter as TAB: pass to the next
1942 // control as this is the best thing to do
1943 // if the text doesn't handle Enter itself
1955 wxNavigationKeyEvent event
;
1956 event
.SetDirection(bForward
);
1957 event
.SetWindowChange(bWindowChange
);
1958 event
.SetEventObject(this);
1960 if ( GetEventHandler()->ProcessEvent(event
) )
1967 // let ::IsDialogMessage() do almost everything and handle just the
1968 // things it doesn't here: Ctrl-TAB for switching notebook pages
1969 if ( msg
->message
== WM_KEYDOWN
)
1971 // don't process system keys here
1972 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1974 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1976 // find the first notebook parent and change its page
1977 wxWindow
*win
= this;
1978 wxNotebook
*nbook
= NULL
;
1979 while ( win
&& !nbook
)
1981 nbook
= wxDynamicCast(win
, wxNotebook
);
1982 win
= win
->GetParent();
1987 bool forward
= !wxIsShiftDown();
1989 nbook
->AdvanceSelection(forward
);
1996 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1997 // shouldn't let IsDialogMessage() get it as it _always_ eats the
1998 // message even when there is no cancel button and when the message is
1999 // needed by the control itself: in particular, it prevents the tree in
2000 // place edit control from being closed with Escape in a dialog
2001 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2003 // ::IsDialogMessage() is broken and may sometimes hang the
2004 // application by going into an infinite loop, so we try to detect
2005 // [some of] the situatations when this may happen and not call it
2008 // assume we can call it by default
2009 bool canSafelyCallIsDlgMsg
= TRUE
;
2011 HWND hwndFocus
= ::GetFocus();
2013 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2014 // an infinite loop, because it will recursively check the child
2015 // windows but not the window itself and so if none of the children
2016 // accepts focus it loops forever (as it only stops when it gets
2017 // back to the window it started from)
2019 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2020 // style has the focus, it can happen. One such possibility is if
2021 // all windows are either toplevel, wxDialog, wxPanel or static
2022 // controls and no window can actually accept keyboard input.
2023 #if !defined(__WXWINCE__)
2024 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2026 // passimistic by default
2027 canSafelyCallIsDlgMsg
= FALSE
;
2028 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2030 node
= node
->GetNext() )
2032 wxWindow
* const win
= node
->GetData();
2033 if ( win
->AcceptsFocus() &&
2034 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2035 WS_EX_CONTROLPARENT
) )
2037 // it shouldn't hang...
2038 canSafelyCallIsDlgMsg
= TRUE
;
2044 #endif // !__WXWINCE__
2046 if ( canSafelyCallIsDlgMsg
)
2048 // ::IsDialogMessage() can enter in an infinite loop when the
2049 // currently focused window is disabled or hidden and its
2050 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2054 if ( !::IsWindowEnabled(hwndFocus
) ||
2055 !::IsWindowVisible(hwndFocus
) )
2057 // it would enter an infinite loop if we do this!
2058 canSafelyCallIsDlgMsg
= FALSE
;
2063 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2065 // it's a top level window, don't go further -- e.g. even
2066 // if the parent of a dialog is disabled, this doesn't
2067 // break navigation inside the dialog
2071 hwndFocus
= ::GetParent(hwndFocus
);
2075 // let IsDialogMessage() have the message if it's safe to call it
2076 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2078 // IsDialogMessage() did something...
2083 #endif // __WXUNIVERSAL__
2088 // relay mouse move events to the tooltip control
2089 MSG
*msg
= (MSG
*)pMsg
;
2090 if ( msg
->message
== WM_MOUSEMOVE
)
2091 m_tooltip
->RelayEvent(pMsg
);
2093 #endif // wxUSE_TOOLTIPS
2098 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2100 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2101 return m_acceleratorTable
.Translate(this, pMsg
);
2105 #endif // wxUSE_ACCEL
2108 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2110 // preprocess all messages by default
2114 // ---------------------------------------------------------------------------
2115 // message params unpackers
2116 // ---------------------------------------------------------------------------
2118 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2119 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2121 *id
= LOWORD(wParam
);
2122 *hwnd
= (WXHWND
)lParam
;
2123 *cmd
= HIWORD(wParam
);
2126 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2127 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2129 *state
= LOWORD(wParam
);
2130 *minimized
= HIWORD(wParam
);
2131 *hwnd
= (WXHWND
)lParam
;
2134 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2135 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2137 *code
= LOWORD(wParam
);
2138 *pos
= HIWORD(wParam
);
2139 *hwnd
= (WXHWND
)lParam
;
2142 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2143 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2145 #ifndef __WXMICROWIN__
2146 *nCtlColor
= CTLCOLOR_BTN
;
2147 *hwnd
= (WXHWND
)lParam
;
2148 *hdc
= (WXHDC
)wParam
;
2152 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2153 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2155 *item
= (WXWORD
)wParam
;
2156 *flags
= HIWORD(wParam
);
2157 *hmenu
= (WXHMENU
)lParam
;
2160 // ---------------------------------------------------------------------------
2161 // Main wxWindows window proc and the window proc for wxWindow
2162 // ---------------------------------------------------------------------------
2164 // Hook for new window just as it's being created, when the window isn't yet
2165 // associated with the handle
2166 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2168 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2169 // window being created and insures that it's always unset back later
2170 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2172 gs_winBeingCreated
= winBeingCreated
;
2175 wxWindowCreationHook::~wxWindowCreationHook()
2177 gs_winBeingCreated
= NULL
;
2181 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2183 // trace all messages - useful for the debugging
2185 wxLogTrace(wxTraceMessages
,
2186 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2187 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2188 #endif // __WXDEBUG__
2190 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2192 // when we get the first message for the HWND we just created, we associate
2193 // it with wxWindow stored in gs_winBeingCreated
2194 if ( !wnd
&& gs_winBeingCreated
)
2196 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2197 wnd
= gs_winBeingCreated
;
2198 gs_winBeingCreated
= NULL
;
2199 wnd
->SetHWND((WXHWND
)hWnd
);
2205 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2207 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2212 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2214 // did we process the message?
2215 bool processed
= FALSE
;
2226 // for most messages we should return 0 when we do process the message
2234 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2237 // return 0 to allow window creation
2238 rc
.result
= mayCreate
? 0 : -1;
2244 // never set processed to TRUE and *always* pass WM_DESTROY to
2245 // DefWindowProc() as Windows may do some internal cleanup when
2246 // processing it and failing to pass the message along may cause
2247 // memory and resource leaks!
2248 (void)HandleDestroy();
2252 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2255 #if !defined(__WXWINCE__)
2258 LPRECT pRect
= (LPRECT
)lParam
;
2260 rc
.SetLeft(pRect
->left
);
2261 rc
.SetTop(pRect
->top
);
2262 rc
.SetRight(pRect
->right
);
2263 rc
.SetBottom(pRect
->bottom
);
2264 processed
= HandleMoving(rc
);
2266 pRect
->left
= rc
.GetLeft();
2267 pRect
->top
= rc
.GetTop();
2268 pRect
->right
= rc
.GetRight();
2269 pRect
->bottom
= rc
.GetBottom();
2280 // we're not interested in these messages at all
2283 case SIZE_MINIMIZED
:
2284 // we shouldn't send sizev events for these messages as the
2285 // client size may be negative which breaks existing code
2287 // OTOH we might send another (wxMinimizedEvent?) one or
2288 // add an additional parameter to wxSizeEvent if this is
2289 // useful to anybody
2293 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2294 // fall through nevertheless
2296 case SIZE_MAXIMIZED
:
2298 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2303 #if !defined(__WXWINCE__)
2306 LPRECT pRect
= (LPRECT
)lParam
;
2308 rc
.SetLeft(pRect
->left
);
2309 rc
.SetTop(pRect
->top
);
2310 rc
.SetRight(pRect
->right
);
2311 rc
.SetBottom(pRect
->bottom
);
2312 processed
= HandleSizing(rc
);
2314 pRect
->left
= rc
.GetLeft();
2315 pRect
->top
= rc
.GetTop();
2316 pRect
->right
= rc
.GetRight();
2317 pRect
->bottom
= rc
.GetBottom();
2323 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2324 case WM_ACTIVATEAPP
:
2325 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2331 WXWORD state
, minimized
;
2333 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2335 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2340 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2344 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2351 // cast to wxWindow is needed for wxUniv
2352 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2353 processed
= HandlePaint();
2357 processed
= HandlePaint();
2365 // Don't call the wx handlers in this case
2366 if ( wxIsKindOf(this, wxListCtrl
) )
2369 if ( lParam
& PRF_ERASEBKGND
)
2370 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2372 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2373 processed
= HandlePaint();
2379 #ifdef __WXUNIVERSAL__
2380 // Universal uses its own wxFrame/wxDialog, so we don't receive
2381 // close events unless we have this.
2386 // don't let the DefWindowProc() destroy our window - we'll do it
2387 // ourselves in ~wxWindow
2394 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2398 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2399 GET_Y_LPARAM(lParam
),
2403 #if wxUSE_MOUSEWHEEL
2405 processed
= HandleMouseWheel(wParam
, lParam
);
2409 case WM_LBUTTONDOWN
:
2411 case WM_LBUTTONDBLCLK
:
2412 case WM_RBUTTONDOWN
:
2414 case WM_RBUTTONDBLCLK
:
2415 case WM_MBUTTONDOWN
:
2417 case WM_MBUTTONDBLCLK
:
2419 #ifdef __WXMICROWIN__
2420 // MicroWindows seems to ignore the fact that a window is
2421 // disabled. So catch mouse events and throw them away if
2423 wxWindowMSW
* win
= this;
2426 if (!win
->IsEnabled())
2432 win
= win
->GetParent();
2433 if ( !win
|| win
->IsTopLevel() )
2440 #endif // __WXMICROWIN__
2441 int x
= GET_X_LPARAM(lParam
),
2442 y
= GET_Y_LPARAM(lParam
);
2444 // redirect the event to a static control if necessary by
2445 // finding one under mouse
2447 if ( GetCapture() == this )
2449 // but don't do it if the mouse is captured by this window
2450 // because then it should really get this event itself
2455 win
= FindWindowForMouseEvent(this, &x
, &y
);
2457 // this should never happen
2458 wxCHECK_MSG( win
, 0,
2459 _T("FindWindowForMouseEvent() returned NULL") );
2461 // for the standard classes their WndProc sets the focus to
2462 // them anyhow and doing it from here results in some weird
2463 // problems, but for our windows we want them to acquire
2464 // focus when clicked
2465 if ( !win
->IsOfStandardClass() )
2467 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2472 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2481 case MM_JOY1BUTTONDOWN
:
2482 case MM_JOY2BUTTONDOWN
:
2483 case MM_JOY1BUTTONUP
:
2484 case MM_JOY2BUTTONUP
:
2485 processed
= HandleJoystickEvent(message
,
2486 GET_X_LPARAM(lParam
),
2487 GET_Y_LPARAM(lParam
),
2490 #endif // __WXMICROWIN__
2493 processed
= HandleSysCommand(wParam
, lParam
);
2500 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2502 processed
= HandleCommand(id
, cmd
, hwnd
);
2507 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2510 // for these messages we must return TRUE if process the message
2513 case WM_MEASUREITEM
:
2515 int idCtrl
= (UINT
)wParam
;
2516 if ( message
== WM_DRAWITEM
)
2518 processed
= MSWOnDrawItem(idCtrl
,
2519 (WXDRAWITEMSTRUCT
*)lParam
);
2523 processed
= MSWOnMeasureItem(idCtrl
,
2524 (WXMEASUREITEMSTRUCT
*)lParam
);
2531 #endif // defined(WM_DRAWITEM)
2534 if ( !IsOfStandardClass() )
2536 // we always want to get the char events
2537 rc
.result
= DLGC_WANTCHARS
;
2539 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2541 // in fact, we want everything
2542 rc
.result
|= DLGC_WANTARROWS
|
2549 //else: get the dlg code from the DefWindowProc()
2554 // If this has been processed by an event handler, return 0 now
2555 // (we've handled it).
2556 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2557 if ( m_lastKeydownProcessed
)
2566 // we consider these message "not interesting" to OnChar, so
2567 // just don't do anything more with them
2577 // avoid duplicate messages to OnChar for these ASCII keys:
2578 // they will be translated by TranslateMessage() and received
2600 // but set processed to FALSE, not TRUE to still pass them
2601 // to the control's default window proc - otherwise
2602 // built-in keyboard handling won't work
2607 // special case of VK_APPS: treat it the same as right mouse
2608 // click because both usually pop up a context menu
2614 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2615 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2621 // do generate a CHAR event
2622 processed
= HandleChar((WORD
)wParam
, lParam
);
2625 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2632 // special case of VK_APPS: treat it the same as right mouse button
2633 if ( wParam
== VK_APPS
)
2638 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2639 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2644 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2649 case WM_CHAR
: // Always an ASCII character
2650 if ( m_lastKeydownProcessed
)
2652 // The key was handled in the EVT_KEY_DOWN and handling
2653 // a key in an EVT_KEY_DOWN handler is meant, by
2654 // design, to prevent EVT_CHARs from happening
2655 m_lastKeydownProcessed
= FALSE
;
2660 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2666 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2668 #endif // wxUSE_HOTKEY
2675 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2677 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2683 // CTLCOLOR messages are sent by children to query the parent for their
2684 // colors#ifndef __WXMICROWIN__
2685 #ifndef __WXMICROWIN__
2686 case WM_CTLCOLORMSGBOX
:
2687 case WM_CTLCOLOREDIT
:
2688 case WM_CTLCOLORLISTBOX
:
2689 case WM_CTLCOLORBTN
:
2690 case WM_CTLCOLORDLG
:
2691 case WM_CTLCOLORSCROLLBAR
:
2692 case WM_CTLCOLORSTATIC
:
2697 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2699 processed
= HandleCtlColor(&rc
.hBrush
,
2708 #endif // !__WXMICROWIN__
2710 case WM_SYSCOLORCHANGE
:
2711 // the return value for this message is ignored
2712 processed
= HandleSysColorChange();
2715 #if !defined(__WXWINCE__)
2716 case WM_DISPLAYCHANGE
:
2717 processed
= HandleDisplayChange();
2721 case WM_PALETTECHANGED
:
2722 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2725 case WM_CAPTURECHANGED
:
2726 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2729 case WM_QUERYNEWPALETTE
:
2730 processed
= HandleQueryNewPalette();
2734 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2737 // we processed the message, i.e. erased the background
2742 #if !defined(__WXWINCE__)
2744 processed
= HandleDropFiles(wParam
);
2749 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2753 // we never set focus from here
2758 #if !defined(__WXWINCE__)
2759 case WM_QUERYENDSESSION
:
2760 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2764 processed
= HandleEndSession(wParam
!= 0, lParam
);
2767 case WM_GETMINMAXINFO
:
2768 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2773 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2774 LOWORD(lParam
), // hit test
2775 HIWORD(lParam
)); // mouse msg
2779 // returning TRUE stops the DefWindowProc() from further
2780 // processing this message - exactly what we need because we've
2781 // just set the cursor.
2786 #if wxUSE_ACCESSIBILITY
2789 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2790 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2792 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2794 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2800 #if defined(WM_HELP)
2803 // HELPINFO doesn't seem to be supported on WinCE.
2805 HELPINFO
* info
= (HELPINFO
*) lParam
;
2806 // Don't yet process menu help events, just windows
2807 if (info
->iContextType
== HELPINFO_WINDOW
)
2810 wxWindowMSW
* subjectOfHelp
= this;
2811 bool eventProcessed
= FALSE
;
2812 while (subjectOfHelp
&& !eventProcessed
)
2814 wxHelpEvent
helpEvent(wxEVT_HELP
,
2815 subjectOfHelp
->GetId(),
2819 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2823 helpEvent
.SetEventObject(this);
2825 GetEventHandler()->ProcessEvent(helpEvent
);
2827 // Go up the window hierarchy until the event is
2829 subjectOfHelp
= subjectOfHelp
->GetParent();
2832 processed
= eventProcessed
;
2835 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2837 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2838 helpEvent
.SetEventObject(this);
2839 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2842 //else: processed is already FALSE
2848 #if !defined(__WXWINCE__)
2849 case WM_CONTEXTMENU
:
2851 // we don't convert from screen to client coordinates as
2852 // the event may be handled by a parent window
2853 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2855 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2856 evtCtx
.SetEventObject(this);
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
;
2996 AdjustForParentClientOrigin(x
, y
);
3001 WXHWND
wxWindowMSW::MSWGetParent() const
3003 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3006 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3007 const wxChar
*title
,
3011 WXDWORD extendedStyle
)
3013 // choose the position/size for the new window
3015 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3017 // controlId is menu handle for the top level windows, so set it to 0
3018 // unless we're creating a child window
3019 int controlId
= style
& WS_CHILD
? GetId() : 0;
3021 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3022 // which is the same but without CS_[HV]REDRAW class styles so using it
3023 // ensures that the window is not fully repainted on each resize
3024 wxString
className(wclass
);
3025 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3027 className
+= wxT("NR");
3030 // do create the window
3031 wxWindowCreationHook
hook(this);
3034 if (extendedStyle
== 0)
3036 m_hWnd
= (WXHWND
)::CreateWindow
3039 title
? title
: wxEmptyString
,
3042 (HWND
)MSWGetParent(),
3045 NULL
// no extra data
3051 m_hWnd
= (WXHWND
)::CreateWindowEx
3055 title
? title
: wxEmptyString
,
3058 (HWND
)MSWGetParent(),
3061 NULL
// no extra data
3067 wxLogSysError(_("Can't create window of class %s"), wclass
);
3072 SubclassWin(m_hWnd
);
3074 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
3079 // ===========================================================================
3080 // MSW message handlers
3081 // ===========================================================================
3083 // ---------------------------------------------------------------------------
3085 // ---------------------------------------------------------------------------
3089 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3091 #ifndef __WXMICROWIN__
3092 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3093 HWND hWnd
= hdr
->hwndFrom
;
3094 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3096 // if the control is one of our windows, let it handle the message itself
3099 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3102 // VZ: why did we do it? normally this is unnecessary and, besides, it
3103 // breaks the message processing for the toolbars because the tooltip
3104 // notifications were being forwarded to the toolbar child controls
3105 // (if it had any) before being passed to the toolbar itself, so in my
3106 // example the tooltip for the combobox was always shown instead of the
3107 // correct button tooltips
3109 // try all our children
3110 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3113 wxWindow
*child
= node
->GetData();
3114 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3119 node
= node
->GetNext();
3123 // by default, handle it ourselves
3124 return MSWOnNotify(idCtrl
, lParam
, result
);
3125 #else // __WXMICROWIN__
3132 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3134 const wxString
& ttip
)
3136 // I don't know why it happens, but the versions of comctl32.dll starting
3137 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3138 // this message is supposed to be sent to Unicode programs only) -- hence
3139 // we need to handle it as well, otherwise no tooltips will be shown in
3142 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
3144 // not a tooltip message or no tooltip to show anyhow
3149 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3152 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
3154 // we pass just the pointer as we store the string internally anyhow
3155 ttText
->lpszText
= (char *)ttip
.c_str();
3157 else // TTN_NEEDTEXTW
3161 // in Unicode mode this is just what we need
3162 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3165 MultiByteToWideChar(CP_ACP, 0, ttip, ttip.length()+1,
3166 (wchar_t *)ttText->szText,
3167 sizeof(ttText->szText) / sizeof(wchar_t));
3169 // Fix by dimitrishortcut: see patch 771772
3171 // FIXME: szText has a max of 80 bytes, so limit the tooltip string
3172 // length accordingly. Ideally lpszText should be used, but who
3173 // would be responsible for freeing the buffer?
3175 // Maximum length of a tip is 39 characters. 39 is 80/2 minus 1 byte
3176 // needed for NULL character.
3177 size_t tipLength
= wxMin(ttip
.Len(), 39);
3179 // Convert to WideChar without adding the NULL character. The NULL
3180 // character is added afterwards (Could have used ttip.Left(tipLength)
3181 // and a cchMultiByte parameter of tipLength+1, but this is more
3183 ::MultiByteToWideChar(CP_ACP
, 0, ttip
, tipLength
,
3184 (wchar_t *)ttText
->szText
,
3185 sizeof(ttText
->szText
) / sizeof(wchar_t));
3187 // Add the NULL character.
3188 ttText
->szText
[tipLength
*2+0] = '\0';
3189 ttText
->szText
[tipLength
*2+1] = '\0';
3191 #endif // Unicode/!Unicode
3197 #endif // wxUSE_TOOLTIPS
3199 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3201 WXLPARAM
* WXUNUSED(result
))
3206 NMHDR
* hdr
= (NMHDR
*)lParam
;
3207 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3213 #endif // wxUSE_TOOLTIPS
3220 // ---------------------------------------------------------------------------
3221 // end session messages
3222 // ---------------------------------------------------------------------------
3224 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3227 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3228 event
.SetEventObject(wxTheApp
);
3229 event
.SetCanVeto(TRUE
);
3230 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3232 bool rc
= wxTheApp
->ProcessEvent(event
);
3236 // we may end only if the app didn't veto session closing (double
3238 *mayEnd
= !event
.GetVeto();
3247 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3250 // do nothing if the session isn't ending
3255 if ( (this != wxTheApp
->GetTopWindow()) )
3258 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3259 event
.SetEventObject(wxTheApp
);
3260 event
.SetCanVeto(FALSE
);
3261 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3263 return wxTheApp
->ProcessEvent(event
);
3269 // ---------------------------------------------------------------------------
3270 // window creation/destruction
3271 // ---------------------------------------------------------------------------
3273 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3275 // VZ: why is this commented out for WinCE? If it doesn't support
3276 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3277 // not with multiple #ifdef's!
3279 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3280 EnsureParentHasControlParentStyle(GetParent());
3281 #endif // !__WXWINCE__
3283 // TODO: should generate this event from WM_NCCREATE
3284 wxWindowCreateEvent
event((wxWindow
*)this);
3285 (void)GetEventHandler()->ProcessEvent(event
);
3292 bool wxWindowMSW::HandleDestroy()
3296 // delete our drop target if we've got one
3297 #if wxUSE_DRAG_AND_DROP
3298 if ( m_dropTarget
!= NULL
)
3300 m_dropTarget
->Revoke(m_hWnd
);
3302 delete m_dropTarget
;
3303 m_dropTarget
= NULL
;
3305 #endif // wxUSE_DRAG_AND_DROP
3307 // WM_DESTROY handled
3311 // ---------------------------------------------------------------------------
3313 // ---------------------------------------------------------------------------
3315 bool wxWindowMSW::HandleActivate(int state
,
3316 bool WXUNUSED(minimized
),
3317 WXHWND
WXUNUSED(activate
))
3319 wxActivateEvent
event(wxEVT_ACTIVATE
,
3320 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3322 event
.SetEventObject(this);
3324 return GetEventHandler()->ProcessEvent(event
);
3327 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3329 // notify the parent keeping track of focus for the kbd navigation
3330 // purposes that we got it
3331 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3332 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3338 m_caret
->OnSetFocus();
3340 #endif // wxUSE_CARET
3343 // If it's a wxTextCtrl don't send the event as it will be done
3344 // after the control gets to process it from EN_FOCUS handler
3345 if ( wxDynamicCastThis(wxTextCtrl
) )
3349 #endif // wxUSE_TEXTCTRL
3351 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3352 event
.SetEventObject(this);
3354 // wxFindWinFromHandle() may return NULL, it is ok
3355 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3357 return GetEventHandler()->ProcessEvent(event
);
3360 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3366 m_caret
->OnKillFocus();
3368 #endif // wxUSE_CARET
3371 // If it's a wxTextCtrl don't send the event as it will be done
3372 // after the control gets to process it.
3373 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3380 // Don't send the event when in the process of being deleted. This can
3381 // only cause problems if the event handler tries to access the object.
3382 if ( m_isBeingDeleted
)
3387 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3388 event
.SetEventObject(this);
3390 // wxFindWinFromHandle() may return NULL, it is ok
3391 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3393 return GetEventHandler()->ProcessEvent(event
);
3396 // ---------------------------------------------------------------------------
3398 // ---------------------------------------------------------------------------
3400 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3402 wxShowEvent
event(GetId(), show
);
3403 event
.m_eventObject
= this;
3405 return GetEventHandler()->ProcessEvent(event
);
3408 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3410 wxInitDialogEvent
event(GetId());
3411 event
.m_eventObject
= this;
3413 return GetEventHandler()->ProcessEvent(event
);
3416 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3418 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3420 #else // __WXMICROWIN__
3421 HDROP hFilesInfo
= (HDROP
) wParam
;
3423 // Get the total number of files dropped
3424 UINT gwFilesDropped
= ::DragQueryFile
3432 wxString
*files
= new wxString
[gwFilesDropped
];
3433 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3435 // first get the needed buffer length (+1 for terminating NUL)
3436 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3438 // and now get the file name
3439 ::DragQueryFile(hFilesInfo
, wIndex
,
3440 wxStringBuffer(files
[wIndex
], len
), len
);
3442 DragFinish (hFilesInfo
);
3444 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3445 event
.m_eventObject
= this;
3448 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3449 event
.m_pos
.x
= dropPoint
.x
;
3450 event
.m_pos
.y
= dropPoint
.y
;
3452 return GetEventHandler()->ProcessEvent(event
);
3457 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3459 int WXUNUSED(mouseMsg
))
3461 #ifndef __WXMICROWIN__
3462 // the logic is as follows:
3463 // -1. don't set cursor for non client area, including but not limited to
3464 // the title bar, scrollbars, &c
3465 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3466 // 1. if we have the cursor set it unless wxIsBusy()
3467 // 2. if we're a top level window, set some cursor anyhow
3468 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3470 if ( nHitTest
!= HTCLIENT
)
3475 HCURSOR hcursor
= 0;
3477 // first ask the user code - it may wish to set the cursor in some very
3478 // specific way (for example, depending on the current position)
3480 if ( !::GetCursorPos(&pt
) )
3482 wxLogLastError(wxT("GetCursorPos"));
3487 ScreenToClient(&x
, &y
);
3488 wxSetCursorEvent
event(x
, y
);
3490 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3491 if ( processedEvtSetCursor
&& event
.HasCursor() )
3493 hcursor
= GetHcursorOf(event
.GetCursor());
3498 bool isBusy
= wxIsBusy();
3500 // the test for processedEvtSetCursor is here to prevent using m_cursor
3501 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3502 // it - this is a way to say that our cursor shouldn't be used for this
3504 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3506 hcursor
= GetHcursorOf(m_cursor
);
3513 hcursor
= wxGetCurrentBusyCursor();
3515 else if ( !hcursor
)
3517 const wxCursor
*cursor
= wxGetGlobalCursor();
3518 if ( cursor
&& cursor
->Ok() )
3520 hcursor
= GetHcursorOf(*cursor
);
3528 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3530 ::SetCursor(hcursor
);
3532 // cursor set, stop here
3535 #endif // __WXMICROWIN__
3537 // pass up the window chain
3541 // ---------------------------------------------------------------------------
3542 // owner drawn stuff
3543 // ---------------------------------------------------------------------------
3545 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3546 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3547 #define WXUNUSED_UNLESS_ODRAWN(param) param
3549 #define WXUNUSED_UNLESS_ODRAWN(param)
3553 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3554 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3556 #if wxUSE_OWNER_DRAWN
3558 #if wxUSE_MENUS_NATIVE
3559 // is it a menu item?
3560 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3561 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3563 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3565 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3567 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3568 // the DC from being released
3569 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3570 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3571 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3572 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3574 return pMenuItem
->OnDrawItem
3578 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3579 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3582 #endif // wxUSE_MENUS_NATIVE
3584 #endif // USE_OWNER_DRAWN
3586 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3588 #if wxUSE_OWNER_DRAWN
3589 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3590 #else // !wxUSE_OWNER_DRAWN
3591 // we may still have owner-drawn buttons internally because we have to make
3592 // them owner-drawn to support colour change
3593 wxControl
*item
= wxDynamicCast(FindItem(id
), wxButton
);
3594 #endif // USE_OWNER_DRAWN
3598 return item
->MSWOnDraw(itemStruct
);
3601 #endif // wxUSE_CONTROLS
3607 wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3608 WXMEASUREITEMSTRUCT
*
3609 WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3611 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3612 // is it a menu item?
3613 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3614 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3616 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3618 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3620 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3621 &pMeasureStruct
->itemHeight
);
3624 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3627 return item
->MSWOnMeasure(itemStruct
);
3629 #endif // wxUSE_OWNER_DRAWN
3634 // ---------------------------------------------------------------------------
3635 // colours and palettes
3636 // ---------------------------------------------------------------------------
3638 bool wxWindowMSW::HandleSysColorChange()
3640 wxSysColourChangedEvent event
;
3641 event
.SetEventObject(this);
3643 (void)GetEventHandler()->ProcessEvent(event
);
3645 // always let the system carry on the default processing to allow the
3646 // native controls to react to the colours update
3650 bool wxWindowMSW::HandleDisplayChange()
3652 wxDisplayChangedEvent event
;
3653 event
.SetEventObject(this);
3655 return GetEventHandler()->ProcessEvent(event
);
3658 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3666 #ifndef __WXMICROWIN__
3667 WXHBRUSH hBrush
= 0;
3672 if ( nCtlColor
== CTLCOLOR_DLG
)
3675 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3680 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3682 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3684 #endif // wxUSE_CONTROLS
3690 #else // __WXMICROWIN__
3695 // Define for each class of dialog and control
3696 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3697 WXHWND
WXUNUSED(hWnd
),
3698 WXUINT
WXUNUSED(nCtlColor
),
3699 WXUINT
WXUNUSED(message
),
3700 WXWPARAM
WXUNUSED(wParam
),
3701 WXLPARAM
WXUNUSED(lParam
))
3706 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3709 // same as below except we don't respond to our own messages
3710 if ( hWndPalChange
!= GetHWND() )
3712 // check to see if we our our parents have a custom palette
3713 wxWindowMSW
*win
= this;
3714 while ( win
&& !win
->HasCustomPalette() )
3716 win
= win
->GetParent();
3719 if ( win
&& win
->HasCustomPalette() )
3721 // realize the palette to see whether redrawing is needed
3722 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3723 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3724 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3726 int result
= ::RealizePalette(hdc
);
3728 // restore the palette (before releasing the DC)
3729 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3730 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3731 ::RealizePalette(hdc
);
3732 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3734 // now check for the need to redraw
3736 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3740 #endif // wxUSE_PALETTE
3742 wxPaletteChangedEvent
event(GetId());
3743 event
.SetEventObject(this);
3744 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3746 return GetEventHandler()->ProcessEvent(event
);
3749 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3751 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3752 event
.SetEventObject(this);
3754 return GetEventHandler()->ProcessEvent(event
);
3757 bool wxWindowMSW::HandleQueryNewPalette()
3761 // check to see if we our our parents have a custom palette
3762 wxWindowMSW
*win
= this;
3763 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3764 if (win
->HasCustomPalette()) {
3765 /* realize the palette to see whether redrawing is needed */
3766 HDC hdc
= GetDC((HWND
) GetHWND());
3767 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3768 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3770 int result
= ::RealizePalette(hdc
);
3771 /* restore the palette (before releasing the DC) */
3772 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3773 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3774 ::RealizePalette(hdc
);
3775 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3776 /* now check for the need to redraw */
3778 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3780 #endif // wxUSE_PALETTE
3782 wxQueryNewPaletteEvent
event(GetId());
3783 event
.SetEventObject(this);
3785 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3788 // Responds to colour changes: passes event on to children.
3789 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3791 // the top level window also reset the standard colour map as it might have
3792 // changed (there is no need to do it for the non top level windows as we
3793 // only have to do it once)
3797 gs_hasStdCmap
= FALSE
;
3799 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3802 // Only propagate to non-top-level windows because Windows already
3803 // sends this event to all top-level ones
3804 wxWindow
*win
= node
->GetData();
3805 if ( !win
->IsTopLevel() )
3807 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3808 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3809 // the standard controls
3810 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3813 node
= node
->GetNext();
3816 // update the colours we use if they were not set explicitly by the user:
3817 // this must be done or OnCtlColor() would continue to use the old colours
3820 m_foregroundColour
= wxSystemSettings::
3821 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3826 m_backgroundColour
= wxSystemSettings::
3827 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3831 extern wxCOLORMAP
*wxGetStdColourMap()
3833 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3834 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3836 if ( !gs_hasStdCmap
)
3838 static bool s_coloursInit
= FALSE
;
3840 if ( !s_coloursInit
)
3842 // When a bitmap is loaded, the RGB values can change (apparently
3843 // because Windows adjusts them to care for the old programs always
3844 // using 0xc0c0c0 while the transparent colour for the new Windows
3845 // versions is different). But we do this adjustment ourselves so
3846 // we want to avoid Windows' "help" and for this we need to have a
3847 // reference bitmap which can tell us what the RGB values change
3849 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3850 if ( stdColourBitmap
.Ok() )
3852 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3853 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3854 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3857 memDC
.SelectObject(stdColourBitmap
);
3860 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3862 memDC
.GetPixel(i
, 0, &colour
);
3863 s_stdColours
[i
] = wxColourToRGB(colour
);
3866 else // wxBITMAP_STD_COLOURS couldn't be loaded
3868 s_stdColours
[0] = RGB(000,000,000); // black
3869 s_stdColours
[1] = RGB(128,128,128); // dark grey
3870 s_stdColours
[2] = RGB(192,192,192); // light grey
3871 s_stdColours
[3] = RGB(255,255,255); // white
3872 //s_stdColours[4] = RGB(000,000,255); // blue
3873 //s_stdColours[5] = RGB(255,000,255); // magenta
3876 s_coloursInit
= TRUE
;
3879 gs_hasStdCmap
= TRUE
;
3881 // create the colour map
3882 #define INIT_CMAP_ENTRY(col) \
3883 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3884 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3886 INIT_CMAP_ENTRY(BTNTEXT
);
3887 INIT_CMAP_ENTRY(BTNSHADOW
);
3888 INIT_CMAP_ENTRY(BTNFACE
);
3889 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3891 #undef INIT_CMAP_ENTRY
3897 // ---------------------------------------------------------------------------
3899 // ---------------------------------------------------------------------------
3901 bool wxWindowMSW::HandlePaint()
3903 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3906 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3908 wxLogLastError(wxT("CreateRectRgn"));
3909 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3910 wxLogLastError(wxT("GetUpdateRgn"));
3912 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3914 wxPaintEvent
event(m_windowId
);
3915 event
.SetEventObject(this);
3917 bool processed
= GetEventHandler()->ProcessEvent(event
);
3919 // note that we must generate NC event after the normal one as otherwise
3920 // BeginPaint() will happily overwrite our decorations with the background
3922 wxNcPaintEvent
eventNc(m_windowId
);
3923 eventNc
.SetEventObject(this);
3924 GetEventHandler()->ProcessEvent(eventNc
);
3929 // Can be called from an application's OnPaint handler
3930 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3932 #ifdef __WXUNIVERSAL__
3935 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3938 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3943 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3945 // Prevents flicker when dragging
3946 if ( ::IsIconic(GetHwnd()) )
3950 if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3955 if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3957 if (wxUxThemeEngine::Get())
3959 WXHTHEME hTheme
= wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L
"TAB");
3963 ::GetClientRect((HWND
) GetHWND(), (RECT
*) & rect
);
3964 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme
, hdc
, 10 /* TABP_BODY */, 0, &rect
, &rect
);
3965 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme
);
3975 dc
.SetWindow((wxWindow
*)this);
3978 wxEraseEvent
event(m_windowId
, &dc
);
3979 event
.SetEventObject(this);
3980 bool rc
= GetEventHandler()->ProcessEvent(event
);
3984 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3985 dc
.SelectOldObjects(hdc
);
3990 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3993 ::GetClientRect(GetHwnd(), &rect
);
3995 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3996 m_backgroundColour
.Green(),
3997 m_backgroundColour
.Blue());
3998 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
4000 wxLogLastError(wxT("CreateSolidBrush"));
4002 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
4005 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
4008 ::FillRect(hdc
, &rect
, hBrush
);
4009 ::DeleteObject(hBrush
);
4012 ::SetMapMode(hdc
, mode
);
4016 // ---------------------------------------------------------------------------
4017 // moving and resizing
4018 // ---------------------------------------------------------------------------
4020 bool wxWindowMSW::HandleMinimize()
4022 wxIconizeEvent
event(m_windowId
);
4023 event
.SetEventObject(this);
4025 return GetEventHandler()->ProcessEvent(event
);
4028 bool wxWindowMSW::HandleMaximize()
4030 wxMaximizeEvent
event(m_windowId
);
4031 event
.SetEventObject(this);
4033 return GetEventHandler()->ProcessEvent(event
);
4036 bool wxWindowMSW::HandleMove(int x
, int y
)
4038 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
4039 event
.SetEventObject(this);
4041 return GetEventHandler()->ProcessEvent(event
);
4044 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4046 wxMoveEvent
event(rect
, m_windowId
);
4047 event
.SetEventObject(this);
4049 bool rc
= GetEventHandler()->ProcessEvent(event
);
4051 rect
= event
.GetRect();
4055 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
4056 WXUINT
WXUNUSED(flag
))
4058 // don't use w and h parameters as they specify the client size while
4059 // according to the docs EVT_SIZE handler is supposed to receive the total
4061 wxSizeEvent
event(GetSize(), m_windowId
);
4062 event
.SetEventObject(this);
4064 return GetEventHandler()->ProcessEvent(event
);
4067 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4069 wxSizeEvent
event(rect
, m_windowId
);
4070 event
.SetEventObject(this);
4072 bool rc
= GetEventHandler()->ProcessEvent(event
);
4074 rect
= event
.GetRect();
4078 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
4083 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4087 int minWidth
= GetMinWidth(),
4088 minHeight
= GetMinHeight(),
4089 maxWidth
= GetMaxWidth(),
4090 maxHeight
= GetMaxHeight();
4092 if ( minWidth
!= -1 )
4094 info
->ptMinTrackSize
.x
= minWidth
;
4098 if ( minHeight
!= -1 )
4100 info
->ptMinTrackSize
.y
= minHeight
;
4104 if ( maxWidth
!= -1 )
4106 info
->ptMaxTrackSize
.x
= maxWidth
;
4110 if ( maxHeight
!= -1 )
4112 info
->ptMaxTrackSize
.y
= maxHeight
;
4120 // ---------------------------------------------------------------------------
4122 // ---------------------------------------------------------------------------
4124 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4126 #if wxUSE_MENUS_NATIVE
4127 if ( !cmd
&& wxCurrentPopupMenu
)
4129 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4130 wxCurrentPopupMenu
= NULL
;
4132 return popupMenu
->MSWCommand(cmd
, id
);
4134 #endif // wxUSE_MENUS_NATIVE
4136 wxWindow
*win
= NULL
;
4138 // first try to find it from HWND - this works even with the broken
4139 // programs using the same ids for different controls
4142 win
= wxFindWinFromHandle(control
);
4148 // must cast to a signed type before comparing with other ids!
4149 win
= FindItem((signed short)id
);
4154 return win
->MSWCommand(cmd
, id
);
4157 // the messages sent from the in-place edit control used by the treectrl
4158 // for label editing have id == 0, but they should _not_ be treated as menu
4159 // messages (they are EN_XXX ones, in fact) so don't translate anything
4160 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4163 // If no child window, it may be an accelerator, e.g. for a popup menu
4166 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4167 event
.SetEventObject(this);
4171 return GetEventHandler()->ProcessEvent(event
);
4173 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4176 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4177 // notifications to its parent which we want to reflect back to
4179 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4180 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4183 #endif // wxUSE_SPINCTRL
4188 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4191 // 4 bits are reserved
4192 switch ( wParam
& 0xFFFFFFF0 )
4195 return HandleMaximize();
4198 return HandleMinimize();
4205 // ---------------------------------------------------------------------------
4207 // ---------------------------------------------------------------------------
4209 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4213 // our client coords are not quite the same as Windows ones
4214 wxPoint pt
= GetClientAreaOrigin();
4215 event
.m_x
= x
- pt
.x
;
4216 event
.m_y
= y
- pt
.y
;
4218 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4219 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4220 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4221 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4222 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4223 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4224 // Returns different negative values on WinME and WinNT,
4225 // so simply test for negative value.
4226 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4229 event
.SetTimestamp(::GetMessageTime());
4232 event
.m_eventObject
= this;
4233 event
.SetId(GetId());
4235 #if wxUSE_MOUSEEVENT_HACK
4238 m_lastMouseEvent
= event
.GetEventType();
4239 #endif // wxUSE_MOUSEEVENT_HACK
4242 // Windows doesn't send the mouse events to the static controls (which are
4243 // transparent in the sense that their WM_NCHITTEST handler returns
4244 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4245 // and so we manually check if we don't have a child window under mouse and if
4246 // we do, send the event to it instead of the window Windows had sent WM_XXX
4249 // Notice that this is not done for the mouse move events because this could
4250 // (would?) be too slow, but only for clicks which means that the static texts
4251 // still don't get move, enter nor leave events.
4252 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4254 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4256 // first try to find a non transparent child: this allows us to send events
4257 // to a static text which is inside a static box, for example
4258 POINT pt
= { *x
, *y
};
4259 HWND hwnd
= GetHwndOf(win
),
4263 hwndUnderMouse
= ::ChildWindowFromPoint
4269 hwndUnderMouse
= ::ChildWindowFromPointEx
4279 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4281 // now try any child window at all
4282 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4285 // check that we have a child window which is susceptible to receive mouse
4286 // events: for this it must be shown and enabled
4287 if ( hwndUnderMouse
&&
4288 hwndUnderMouse
!= hwnd
&&
4289 ::IsWindowVisible(hwndUnderMouse
) &&
4290 ::IsWindowEnabled(hwndUnderMouse
) )
4292 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4293 if ( winUnderMouse
)
4295 // translate the mouse coords to the other window coords
4296 win
->ClientToScreen(x
, y
);
4297 winUnderMouse
->ScreenToClient(x
, y
);
4299 win
= winUnderMouse
;
4306 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4308 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4309 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4310 // from the message id and take the value in the table to get wxWin event
4312 static const wxEventType eventsMouse
[] =
4326 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4327 InitMouseEvent(event
, x
, y
, flags
);
4329 return GetEventHandler()->ProcessEvent(event
);
4332 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4334 if ( !m_mouseInWindow
)
4336 // it would be wrong to assume that just because we get a mouse move
4337 // event that the mouse is inside the window: although this is usually
4338 // true, it is not if we had captured the mouse, so we need to check
4339 // the mouse coordinates here
4340 if ( !HasCapture() || IsMouseInWindow() )
4342 // Generate an ENTER event
4343 m_mouseInWindow
= TRUE
;
4345 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4346 InitMouseEvent(event
, x
, y
, flags
);
4348 (void)GetEventHandler()->ProcessEvent(event
);
4352 #if wxUSE_MOUSEEVENT_HACK
4353 // Window gets a click down message followed by a mouse move message even
4354 // if position isn't changed! We want to discard the trailing move event
4355 // if x and y are the same.
4356 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4357 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4358 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4359 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4361 m_lastMouseEvent
= wxEVT_MOTION
;
4365 #endif // wxUSE_MOUSEEVENT_HACK
4367 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4371 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4373 #if wxUSE_MOUSEWHEEL
4374 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4375 InitMouseEvent(event
,
4376 GET_X_LPARAM(lParam
),
4377 GET_Y_LPARAM(lParam
),
4379 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4380 event
.m_wheelDelta
= WHEEL_DELTA
;
4382 static int s_linesPerRotation
= -1;
4383 if ( s_linesPerRotation
== -1 )
4385 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4386 &s_linesPerRotation
, 0))
4388 // this is not supposed to happen
4389 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4391 // the default is 3, so use it if SystemParametersInfo() failed
4392 s_linesPerRotation
= 3;
4396 event
.m_linesPerAction
= s_linesPerRotation
;
4397 return GetEventHandler()->ProcessEvent(event
);
4408 // ---------------------------------------------------------------------------
4409 // keyboard handling
4410 // ---------------------------------------------------------------------------
4412 // create the key event of the given type for the given key - used by
4413 // HandleChar and HandleKeyDown/Up
4414 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4417 WXWPARAM wParam
) const
4419 wxKeyEvent
event(evType
);
4420 event
.SetId(GetId());
4421 event
.m_shiftDown
= wxIsShiftDown();
4422 event
.m_controlDown
= wxIsCtrlDown();
4423 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4425 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4426 event
.m_keyCode
= id
;
4427 event
.m_rawCode
= (wxUint32
) wParam
;
4428 event
.m_rawFlags
= (wxUint32
) lParam
;
4430 event
.SetTimestamp(::GetMessageTime());
4433 // translate the position to client coords
4437 GetWindowRect(GetHwnd(),&rect
);
4447 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4449 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4454 // If 1 -> 26, translate to either special keycode or just set
4455 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4456 // ControlDown() == TRUE.
4458 if ( (id
> 0) && (id
< 27) )
4480 else // we're called from WM_KEYDOWN
4482 id
= wxCharCodeMSWToWX(wParam
);
4485 // it's ASCII and will be processed here only when called from
4486 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4491 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4493 // the alphanumeric keys produced by pressing AltGr+something on European
4494 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4495 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4496 // alphanumeric, so pretend that there are no modifiers at all (the
4497 // KEY_DOWN event would still have the correct modifiers if they're really
4499 if ( event
.m_controlDown
&& event
.m_altDown
&&
4500 (id
>= 32 && id
< 256) )
4502 event
.m_controlDown
=
4503 event
.m_altDown
= FALSE
;
4506 return GetEventHandler()->ProcessEvent(event
);
4509 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4511 int id
= wxCharCodeMSWToWX(wParam
);
4515 // normal ASCII char
4519 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4521 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4522 if ( GetEventHandler()->ProcessEvent(event
) )
4531 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4533 int id
= wxCharCodeMSWToWX(wParam
);
4537 // normal ASCII char
4541 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4543 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4544 if ( GetEventHandler()->ProcessEvent(event
) )
4551 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4553 // FIXME: implement GetMenuItemCount for WinCE, possibly
4554 // in terms of GetMenuItemInfo
4556 const HMENU hmenu
= (HMENU
)lParam
;
4560 mii
.cbSize
= sizeof(MENUITEMINFO
);
4561 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4563 // find if we have this letter in any owner drawn item
4564 const int count
= ::GetMenuItemCount(hmenu
);
4565 for ( int i
= 0; i
< count
; i
++ )
4567 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4569 if ( mii
.fType
== MFT_OWNERDRAW
)
4571 // dwItemData member of the MENUITEMINFO is a
4572 // pointer to the associated wxMenuItem -- see the
4573 // menu creation code
4574 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4576 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4579 if ( *p
== _T('&') )
4581 // this is not the accel char, find the real one
4582 p
= wxStrchr(p
+ 1, _T('&'));
4584 else // got the accel char
4586 // FIXME-UNICODE: this comparison doesn't risk to work
4587 // for non ASCII accelerator characters I'm afraid, but
4589 if ( wxToupper(*p
) == chAccel
)
4595 // this one doesn't match
4602 else // failed to get the menu text?
4604 // it's not fatal, so don't show error, but still log
4606 wxLogLastError(_T("GetMenuItemInfo"));
4613 // ---------------------------------------------------------------------------
4615 // ---------------------------------------------------------------------------
4617 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4621 if ( flags
& JOY_BUTTON1CHG
)
4622 change
= wxJOY_BUTTON1
;
4623 if ( flags
& JOY_BUTTON2CHG
)
4624 change
= wxJOY_BUTTON2
;
4625 if ( flags
& JOY_BUTTON3CHG
)
4626 change
= wxJOY_BUTTON3
;
4627 if ( flags
& JOY_BUTTON4CHG
)
4628 change
= wxJOY_BUTTON4
;
4631 if ( flags
& JOY_BUTTON1
)
4632 buttons
|= wxJOY_BUTTON1
;
4633 if ( flags
& JOY_BUTTON2
)
4634 buttons
|= wxJOY_BUTTON2
;
4635 if ( flags
& JOY_BUTTON3
)
4636 buttons
|= wxJOY_BUTTON3
;
4637 if ( flags
& JOY_BUTTON4
)
4638 buttons
|= wxJOY_BUTTON4
;
4640 // the event ids aren't consecutive so we can't use table based lookup
4642 wxEventType eventType
;
4647 eventType
= wxEVT_JOY_MOVE
;
4652 eventType
= wxEVT_JOY_MOVE
;
4657 eventType
= wxEVT_JOY_ZMOVE
;
4662 eventType
= wxEVT_JOY_ZMOVE
;
4665 case MM_JOY1BUTTONDOWN
:
4667 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4670 case MM_JOY2BUTTONDOWN
:
4672 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4675 case MM_JOY1BUTTONUP
:
4677 eventType
= wxEVT_JOY_BUTTON_UP
;
4680 case MM_JOY2BUTTONUP
:
4682 eventType
= wxEVT_JOY_BUTTON_UP
;
4686 wxFAIL_MSG(wxT("no such joystick event"));
4691 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4692 event
.SetPosition(wxPoint(x
, y
));
4693 event
.SetEventObject(this);
4695 return GetEventHandler()->ProcessEvent(event
);
4701 // ---------------------------------------------------------------------------
4703 // ---------------------------------------------------------------------------
4705 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4706 WXWORD pos
, WXHWND control
)
4710 wxWindow
*child
= wxFindWinFromHandle(control
);
4712 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4715 wxScrollWinEvent event
;
4716 event
.SetPosition(pos
);
4717 event
.SetOrientation(orientation
);
4718 event
.m_eventObject
= this;
4723 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4727 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4731 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4735 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4739 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4743 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4746 case SB_THUMBPOSITION
:
4748 // under Win32, the scrollbar range and position are 32 bit integers,
4749 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4750 // explicitly query the scrollbar for the correct position (this must
4751 // be done only for these two SB_ events as they are the only one
4752 // carrying the scrollbar position)
4754 WinStruct
<SCROLLINFO
> scrollInfo
;
4755 scrollInfo
.fMask
= SIF_TRACKPOS
;
4757 if ( !::GetScrollInfo(GetHwnd(),
4758 orientation
== wxHORIZONTAL
? SB_HORZ
4762 // Not neccessarily an error, if there are no scrollbars yet.
4763 // wxLogLastError(_T("GetScrollInfo"));
4766 event
.SetPosition(scrollInfo
.nTrackPos
);
4769 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4770 ? wxEVT_SCROLLWIN_THUMBRELEASE
4771 : wxEVT_SCROLLWIN_THUMBTRACK
;
4778 return GetEventHandler()->ProcessEvent(event
);
4781 // ===========================================================================
4783 // ===========================================================================
4785 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4788 HDC dc
= ::GetDC((HWND
) wnd
);
4793 // the_font->UseResource();
4794 // the_font->RealizeResource();
4795 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4797 was
= (HFONT
) SelectObject(dc
,fnt
);
4799 GetTextMetrics(dc
, &tm
);
4800 if ( the_font
&& fnt
&& was
)
4802 SelectObject(dc
,was
);
4804 ReleaseDC((HWND
)wnd
, dc
);
4807 *x
= tm
.tmAveCharWidth
;
4809 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4812 // the_font->ReleaseResource();
4815 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4816 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4817 int wxCharCodeMSWToWX(int keySym
)
4822 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4823 case VK_BACK
: id
= WXK_BACK
; break;
4824 case VK_TAB
: id
= WXK_TAB
; break;
4825 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4826 case VK_RETURN
: id
= WXK_RETURN
; break;
4827 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4828 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4829 case VK_MENU
: id
= WXK_MENU
; break;
4830 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4831 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4832 case VK_SPACE
: id
= WXK_SPACE
; break;
4833 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4834 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4835 case VK_NEXT
: id
= WXK_NEXT
; break;
4836 case VK_END
: id
= WXK_END
; break;
4837 case VK_HOME
: id
= WXK_HOME
; break;
4838 case VK_LEFT
: id
= WXK_LEFT
; break;
4839 case VK_UP
: id
= WXK_UP
; break;
4840 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4841 case VK_DOWN
: id
= WXK_DOWN
; break;
4842 case VK_SELECT
: id
= WXK_SELECT
; break;
4843 case VK_PRINT
: id
= WXK_PRINT
; break;
4844 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4845 case VK_INSERT
: id
= WXK_INSERT
; break;
4846 case VK_DELETE
: id
= WXK_DELETE
; break;
4847 case VK_HELP
: id
= WXK_HELP
; break;
4848 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4849 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4850 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4851 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4852 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4853 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4854 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4855 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4856 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4857 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4858 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4859 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4860 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4861 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4862 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4863 case VK_F1
: id
= WXK_F1
; break;
4864 case VK_F2
: id
= WXK_F2
; break;
4865 case VK_F3
: id
= WXK_F3
; break;
4866 case VK_F4
: id
= WXK_F4
; break;
4867 case VK_F5
: id
= WXK_F5
; break;
4868 case VK_F6
: id
= WXK_F6
; break;
4869 case VK_F7
: id
= WXK_F7
; break;
4870 case VK_F8
: id
= WXK_F8
; break;
4871 case VK_F9
: id
= WXK_F9
; break;
4872 case VK_F10
: id
= WXK_F10
; break;
4873 case VK_F11
: id
= WXK_F11
; break;
4874 case VK_F12
: id
= WXK_F12
; break;
4875 case VK_F13
: id
= WXK_F13
; break;
4876 case VK_F14
: id
= WXK_F14
; break;
4877 case VK_F15
: id
= WXK_F15
; break;
4878 case VK_F16
: id
= WXK_F16
; break;
4879 case VK_F17
: id
= WXK_F17
; break;
4880 case VK_F18
: id
= WXK_F18
; break;
4881 case VK_F19
: id
= WXK_F19
; break;
4882 case VK_F20
: id
= WXK_F20
; break;
4883 case VK_F21
: id
= WXK_F21
; break;
4884 case VK_F22
: id
= WXK_F22
; break;
4885 case VK_F23
: id
= WXK_F23
; break;
4886 case VK_F24
: id
= WXK_F24
; break;
4887 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4888 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4890 case VK_OEM_1
: id
= ';'; break;
4891 case VK_OEM_PLUS
: id
= '+'; break;
4892 case VK_OEM_COMMA
: id
= ','; break;
4893 case VK_OEM_MINUS
: id
= '-'; break;
4894 case VK_OEM_PERIOD
: id
= '.'; break;
4895 case VK_OEM_2
: id
= '/'; break;
4896 case VK_OEM_3
: id
= '~'; break;
4897 case VK_OEM_4
: id
= '['; break;
4898 case VK_OEM_5
: id
= '\\'; break;
4899 case VK_OEM_6
: id
= ']'; break;
4900 case VK_OEM_7
: id
= '\''; break;
4903 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4904 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4905 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4906 #endif // VK_APPS defined
4915 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4921 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4922 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4923 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4924 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4925 case WXK_MENU
: keySym
= VK_MENU
; break;
4926 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4927 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4928 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4929 case WXK_END
: keySym
= VK_END
; break;
4930 case WXK_HOME
: keySym
= VK_HOME
; break;
4931 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4932 case WXK_UP
: keySym
= VK_UP
; break;
4933 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4934 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4935 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4936 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4937 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4938 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4939 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4940 case WXK_HELP
: keySym
= VK_HELP
; break;
4941 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4942 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4943 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4944 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4945 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4946 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4947 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4948 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4949 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4950 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4951 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4952 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4953 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4954 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4955 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4956 case WXK_F1
: keySym
= VK_F1
; break;
4957 case WXK_F2
: keySym
= VK_F2
; break;
4958 case WXK_F3
: keySym
= VK_F3
; break;
4959 case WXK_F4
: keySym
= VK_F4
; break;
4960 case WXK_F5
: keySym
= VK_F5
; break;
4961 case WXK_F6
: keySym
= VK_F6
; break;
4962 case WXK_F7
: keySym
= VK_F7
; break;
4963 case WXK_F8
: keySym
= VK_F8
; break;
4964 case WXK_F9
: keySym
= VK_F9
; break;
4965 case WXK_F10
: keySym
= VK_F10
; break;
4966 case WXK_F11
: keySym
= VK_F11
; break;
4967 case WXK_F12
: keySym
= VK_F12
; break;
4968 case WXK_F13
: keySym
= VK_F13
; break;
4969 case WXK_F14
: keySym
= VK_F14
; break;
4970 case WXK_F15
: keySym
= VK_F15
; break;
4971 case WXK_F16
: keySym
= VK_F16
; break;
4972 case WXK_F17
: keySym
= VK_F17
; break;
4973 case WXK_F18
: keySym
= VK_F18
; break;
4974 case WXK_F19
: keySym
= VK_F19
; break;
4975 case WXK_F20
: keySym
= VK_F20
; break;
4976 case WXK_F21
: keySym
= VK_F21
; break;
4977 case WXK_F22
: keySym
= VK_F22
; break;
4978 case WXK_F23
: keySym
= VK_F23
; break;
4979 case WXK_F24
: keySym
= VK_F24
; break;
4980 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4981 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4992 wxWindow
*wxGetActiveWindow()
4994 HWND hWnd
= GetActiveWindow();
4997 return wxFindWinFromHandle((WXHWND
) hWnd
);
5002 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5004 HWND hwnd
= (HWND
)hWnd
;
5006 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5007 // by code in msw/radiobox.cpp), for all the others we just search up the
5009 wxWindow
*win
= (wxWindow
*)NULL
;
5012 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5016 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5017 // wxWindow class which overrides WM_GETDLGCODE processing to
5018 // do it as well, win would be already non NULL
5019 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5021 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
5023 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5024 #endif // wxUSE_RADIOBOX
5026 // spin control text buddy window should be mapped to spin ctrl
5027 // itself so try it too
5028 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5031 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5033 #endif // wxUSE_SPINCTRL
5037 while ( hwnd
&& !win
)
5039 // this is a really ugly hack needed to avoid mistakenly returning the
5040 // parent frame wxWindow for the find/replace modeless dialog HWND -
5041 // this, in turn, is needed to call IsDialogMessage() from
5042 // wxApp::ProcessMessage() as for this we must return NULL from here
5044 // FIXME: this is clearly not the best way to do it but I think we'll
5045 // need to change HWND <-> wxWindow code more heavily than I can
5046 // do it now to fix it
5047 #ifndef __WXMICROWIN__
5048 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5050 // it's a dialog box, don't go upwards
5055 hwnd
= ::GetParent(hwnd
);
5056 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5062 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5064 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5065 // in active frames and dialogs, regardless of where the focus is.
5066 static HHOOK wxTheKeyboardHook
= 0;
5067 static FARPROC wxTheKeyboardHookProc
= 0;
5068 int APIENTRY _EXPORT
5069 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5071 void wxSetKeyboardHook(bool doIt
)
5075 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5076 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5078 GetCurrentThreadId()
5079 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5084 UnhookWindowsHookEx(wxTheKeyboardHook
);
5088 int APIENTRY _EXPORT
5089 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5091 DWORD hiWord
= HIWORD(lParam
);
5092 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5094 int id
= wxCharCodeMSWToWX(wParam
);
5097 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5098 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5099 event
.m_altDown
= TRUE
;
5101 event
.m_eventObject
= NULL
;
5102 event
.m_keyCode
= id
;
5103 event
.m_shiftDown
= wxIsShiftDown();
5104 event
.m_controlDown
= wxIsCtrlDown();
5106 event
.SetTimestamp(::GetMessageTime());
5108 wxWindow
*win
= wxGetActiveWindow();
5109 wxEvtHandler
*handler
;
5112 handler
= win
->GetEventHandler();
5113 event
.SetId(win
->GetId());
5121 if ( handler
&& handler
->ProcessEvent(event
) )
5129 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5132 #endif // !__WXMICROWIN__
5135 const char *wxGetMessageName(int message
)
5139 case 0x0000: return "WM_NULL";
5140 case 0x0001: return "WM_CREATE";
5141 case 0x0002: return "WM_DESTROY";
5142 case 0x0003: return "WM_MOVE";
5143 case 0x0005: return "WM_SIZE";
5144 case 0x0006: return "WM_ACTIVATE";
5145 case 0x0007: return "WM_SETFOCUS";
5146 case 0x0008: return "WM_KILLFOCUS";
5147 case 0x000A: return "WM_ENABLE";
5148 case 0x000B: return "WM_SETREDRAW";
5149 case 0x000C: return "WM_SETTEXT";
5150 case 0x000D: return "WM_GETTEXT";
5151 case 0x000E: return "WM_GETTEXTLENGTH";
5152 case 0x000F: return "WM_PAINT";
5153 case 0x0010: return "WM_CLOSE";
5154 case 0x0011: return "WM_QUERYENDSESSION";
5155 case 0x0012: return "WM_QUIT";
5156 case 0x0013: return "WM_QUERYOPEN";
5157 case 0x0014: return "WM_ERASEBKGND";
5158 case 0x0015: return "WM_SYSCOLORCHANGE";
5159 case 0x0016: return "WM_ENDSESSION";
5160 case 0x0017: return "WM_SYSTEMERROR";
5161 case 0x0018: return "WM_SHOWWINDOW";
5162 case 0x0019: return "WM_CTLCOLOR";
5163 case 0x001A: return "WM_WININICHANGE";
5164 case 0x001B: return "WM_DEVMODECHANGE";
5165 case 0x001C: return "WM_ACTIVATEAPP";
5166 case 0x001D: return "WM_FONTCHANGE";
5167 case 0x001E: return "WM_TIMECHANGE";
5168 case 0x001F: return "WM_CANCELMODE";
5169 case 0x0020: return "WM_SETCURSOR";
5170 case 0x0021: return "WM_MOUSEACTIVATE";
5171 case 0x0022: return "WM_CHILDACTIVATE";
5172 case 0x0023: return "WM_QUEUESYNC";
5173 case 0x0024: return "WM_GETMINMAXINFO";
5174 case 0x0026: return "WM_PAINTICON";
5175 case 0x0027: return "WM_ICONERASEBKGND";
5176 case 0x0028: return "WM_NEXTDLGCTL";
5177 case 0x002A: return "WM_SPOOLERSTATUS";
5178 case 0x002B: return "WM_DRAWITEM";
5179 case 0x002C: return "WM_MEASUREITEM";
5180 case 0x002D: return "WM_DELETEITEM";
5181 case 0x002E: return "WM_VKEYTOITEM";
5182 case 0x002F: return "WM_CHARTOITEM";
5183 case 0x0030: return "WM_SETFONT";
5184 case 0x0031: return "WM_GETFONT";
5185 case 0x0037: return "WM_QUERYDRAGICON";
5186 case 0x0039: return "WM_COMPAREITEM";
5187 case 0x0041: return "WM_COMPACTING";
5188 case 0x0044: return "WM_COMMNOTIFY";
5189 case 0x0046: return "WM_WINDOWPOSCHANGING";
5190 case 0x0047: return "WM_WINDOWPOSCHANGED";
5191 case 0x0048: return "WM_POWER";
5193 case 0x004A: return "WM_COPYDATA";
5194 case 0x004B: return "WM_CANCELJOURNAL";
5195 case 0x004E: return "WM_NOTIFY";
5196 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5197 case 0x0051: return "WM_INPUTLANGCHANGE";
5198 case 0x0052: return "WM_TCARD";
5199 case 0x0053: return "WM_HELP";
5200 case 0x0054: return "WM_USERCHANGED";
5201 case 0x0055: return "WM_NOTIFYFORMAT";
5202 case 0x007B: return "WM_CONTEXTMENU";
5203 case 0x007C: return "WM_STYLECHANGING";
5204 case 0x007D: return "WM_STYLECHANGED";
5205 case 0x007E: return "WM_DISPLAYCHANGE";
5206 case 0x007F: return "WM_GETICON";
5207 case 0x0080: return "WM_SETICON";
5209 case 0x0081: return "WM_NCCREATE";
5210 case 0x0082: return "WM_NCDESTROY";
5211 case 0x0083: return "WM_NCCALCSIZE";
5212 case 0x0084: return "WM_NCHITTEST";
5213 case 0x0085: return "WM_NCPAINT";
5214 case 0x0086: return "WM_NCACTIVATE";
5215 case 0x0087: return "WM_GETDLGCODE";
5216 case 0x00A0: return "WM_NCMOUSEMOVE";
5217 case 0x00A1: return "WM_NCLBUTTONDOWN";
5218 case 0x00A2: return "WM_NCLBUTTONUP";
5219 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5220 case 0x00A4: return "WM_NCRBUTTONDOWN";
5221 case 0x00A5: return "WM_NCRBUTTONUP";
5222 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5223 case 0x00A7: return "WM_NCMBUTTONDOWN";
5224 case 0x00A8: return "WM_NCMBUTTONUP";
5225 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5226 case 0x0100: return "WM_KEYDOWN";
5227 case 0x0101: return "WM_KEYUP";
5228 case 0x0102: return "WM_CHAR";
5229 case 0x0103: return "WM_DEADCHAR";
5230 case 0x0104: return "WM_SYSKEYDOWN";
5231 case 0x0105: return "WM_SYSKEYUP";
5232 case 0x0106: return "WM_SYSCHAR";
5233 case 0x0107: return "WM_SYSDEADCHAR";
5234 case 0x0108: return "WM_KEYLAST";
5236 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5237 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5238 case 0x010F: return "WM_IME_COMPOSITION";
5240 case 0x0110: return "WM_INITDIALOG";
5241 case 0x0111: return "WM_COMMAND";
5242 case 0x0112: return "WM_SYSCOMMAND";
5243 case 0x0113: return "WM_TIMER";
5244 case 0x0114: return "WM_HSCROLL";
5245 case 0x0115: return "WM_VSCROLL";
5246 case 0x0116: return "WM_INITMENU";
5247 case 0x0117: return "WM_INITMENUPOPUP";
5248 case 0x011F: return "WM_MENUSELECT";
5249 case 0x0120: return "WM_MENUCHAR";
5250 case 0x0121: return "WM_ENTERIDLE";
5251 case 0x0200: return "WM_MOUSEMOVE";
5252 case 0x0201: return "WM_LBUTTONDOWN";
5253 case 0x0202: return "WM_LBUTTONUP";
5254 case 0x0203: return "WM_LBUTTONDBLCLK";
5255 case 0x0204: return "WM_RBUTTONDOWN";
5256 case 0x0205: return "WM_RBUTTONUP";
5257 case 0x0206: return "WM_RBUTTONDBLCLK";
5258 case 0x0207: return "WM_MBUTTONDOWN";
5259 case 0x0208: return "WM_MBUTTONUP";
5260 case 0x0209: return "WM_MBUTTONDBLCLK";
5261 case 0x020A: return "WM_MOUSEWHEEL";
5262 case 0x0210: return "WM_PARENTNOTIFY";
5263 case 0x0211: return "WM_ENTERMENULOOP";
5264 case 0x0212: return "WM_EXITMENULOOP";
5266 case 0x0213: return "WM_NEXTMENU";
5267 case 0x0214: return "WM_SIZING";
5268 case 0x0215: return "WM_CAPTURECHANGED";
5269 case 0x0216: return "WM_MOVING";
5270 case 0x0218: return "WM_POWERBROADCAST";
5271 case 0x0219: return "WM_DEVICECHANGE";
5273 case 0x0220: return "WM_MDICREATE";
5274 case 0x0221: return "WM_MDIDESTROY";
5275 case 0x0222: return "WM_MDIACTIVATE";
5276 case 0x0223: return "WM_MDIRESTORE";
5277 case 0x0224: return "WM_MDINEXT";
5278 case 0x0225: return "WM_MDIMAXIMIZE";
5279 case 0x0226: return "WM_MDITILE";
5280 case 0x0227: return "WM_MDICASCADE";
5281 case 0x0228: return "WM_MDIICONARRANGE";
5282 case 0x0229: return "WM_MDIGETACTIVE";
5283 case 0x0230: return "WM_MDISETMENU";
5284 case 0x0233: return "WM_DROPFILES";
5286 case 0x0281: return "WM_IME_SETCONTEXT";
5287 case 0x0282: return "WM_IME_NOTIFY";
5288 case 0x0283: return "WM_IME_CONTROL";
5289 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5290 case 0x0285: return "WM_IME_SELECT";
5291 case 0x0286: return "WM_IME_CHAR";
5292 case 0x0290: return "WM_IME_KEYDOWN";
5293 case 0x0291: return "WM_IME_KEYUP";
5295 case 0x0300: return "WM_CUT";
5296 case 0x0301: return "WM_COPY";
5297 case 0x0302: return "WM_PASTE";
5298 case 0x0303: return "WM_CLEAR";
5299 case 0x0304: return "WM_UNDO";
5300 case 0x0305: return "WM_RENDERFORMAT";
5301 case 0x0306: return "WM_RENDERALLFORMATS";
5302 case 0x0307: return "WM_DESTROYCLIPBOARD";
5303 case 0x0308: return "WM_DRAWCLIPBOARD";
5304 case 0x0309: return "WM_PAINTCLIPBOARD";
5305 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5306 case 0x030B: return "WM_SIZECLIPBOARD";
5307 case 0x030C: return "WM_ASKCBFORMATNAME";
5308 case 0x030D: return "WM_CHANGECBCHAIN";
5309 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5310 case 0x030F: return "WM_QUERYNEWPALETTE";
5311 case 0x0310: return "WM_PALETTEISCHANGING";
5312 case 0x0311: return "WM_PALETTECHANGED";
5314 case 0x0312: return "WM_HOTKEY";
5317 // common controls messages - although they're not strictly speaking
5318 // standard, it's nice to decode them nevertheless
5321 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5322 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5323 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5324 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5325 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5326 case 0x1000 + 5: return "LVM_GETITEMA";
5327 case 0x1000 + 75: return "LVM_GETITEMW";
5328 case 0x1000 + 6: return "LVM_SETITEMA";
5329 case 0x1000 + 76: return "LVM_SETITEMW";
5330 case 0x1000 + 7: return "LVM_INSERTITEMA";
5331 case 0x1000 + 77: return "LVM_INSERTITEMW";
5332 case 0x1000 + 8: return "LVM_DELETEITEM";
5333 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5334 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5335 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5336 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5337 case 0x1000 + 13: return "LVM_FINDITEMA";
5338 case 0x1000 + 83: return "LVM_FINDITEMW";
5339 case 0x1000 + 14: return "LVM_GETITEMRECT";
5340 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5341 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5342 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5343 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5344 case 0x1000 + 18: return "LVM_HITTEST";
5345 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5346 case 0x1000 + 20: return "LVM_SCROLL";
5347 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5348 case 0x1000 + 22: return "LVM_ARRANGE";
5349 case 0x1000 + 23: return "LVM_EDITLABELA";
5350 case 0x1000 + 118: return "LVM_EDITLABELW";
5351 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5352 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5353 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5354 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5355 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5356 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5357 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5358 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5359 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5360 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5361 case 0x1000 + 31: return "LVM_GETHEADER";
5362 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5363 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5364 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5365 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5366 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5367 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5368 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5369 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5370 case 0x1000 + 41: return "LVM_GETORIGIN";
5371 case 0x1000 + 42: return "LVM_UPDATE";
5372 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5373 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5374 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5375 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5376 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5377 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5378 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5379 case 0x1000 + 48: return "LVM_SORTITEMS";
5380 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5381 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5382 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5383 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5384 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5385 case 0x1000 + 53: return "LVM_SETICONSPACING";
5386 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5387 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5388 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5389 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5390 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5391 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5392 case 0x1000 + 60: return "LVM_SETHOTITEM";
5393 case 0x1000 + 61: return "LVM_GETHOTITEM";
5394 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5395 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5396 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5397 case 0x1000 + 65: return "LVM_SETWORKAREA";
5400 case 0x1100 + 0: return "TVM_INSERTITEMA";
5401 case 0x1100 + 50: return "TVM_INSERTITEMW";
5402 case 0x1100 + 1: return "TVM_DELETEITEM";
5403 case 0x1100 + 2: return "TVM_EXPAND";
5404 case 0x1100 + 4: return "TVM_GETITEMRECT";
5405 case 0x1100 + 5: return "TVM_GETCOUNT";
5406 case 0x1100 + 6: return "TVM_GETINDENT";
5407 case 0x1100 + 7: return "TVM_SETINDENT";
5408 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5409 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5410 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5411 case 0x1100 + 11: return "TVM_SELECTITEM";
5412 case 0x1100 + 12: return "TVM_GETITEMA";
5413 case 0x1100 + 62: return "TVM_GETITEMW";
5414 case 0x1100 + 13: return "TVM_SETITEMA";
5415 case 0x1100 + 63: return "TVM_SETITEMW";
5416 case 0x1100 + 14: return "TVM_EDITLABELA";
5417 case 0x1100 + 65: return "TVM_EDITLABELW";
5418 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5419 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5420 case 0x1100 + 17: return "TVM_HITTEST";
5421 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5422 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5423 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5424 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5425 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5426 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5427 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5428 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5429 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5432 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5433 case 0x1200 + 1: return "HDM_INSERTITEMA";
5434 case 0x1200 + 10: return "HDM_INSERTITEMW";
5435 case 0x1200 + 2: return "HDM_DELETEITEM";
5436 case 0x1200 + 3: return "HDM_GETITEMA";
5437 case 0x1200 + 11: return "HDM_GETITEMW";
5438 case 0x1200 + 4: return "HDM_SETITEMA";
5439 case 0x1200 + 12: return "HDM_SETITEMW";
5440 case 0x1200 + 5: return "HDM_LAYOUT";
5441 case 0x1200 + 6: return "HDM_HITTEST";
5442 case 0x1200 + 7: return "HDM_GETITEMRECT";
5443 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5444 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5445 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5446 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5447 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5448 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5449 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5452 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5453 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5454 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5455 case 0x1300 + 5: return "TCM_GETITEMA";
5456 case 0x1300 + 60: return "TCM_GETITEMW";
5457 case 0x1300 + 6: return "TCM_SETITEMA";
5458 case 0x1300 + 61: return "TCM_SETITEMW";
5459 case 0x1300 + 7: return "TCM_INSERTITEMA";
5460 case 0x1300 + 62: return "TCM_INSERTITEMW";
5461 case 0x1300 + 8: return "TCM_DELETEITEM";
5462 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5463 case 0x1300 + 10: return "TCM_GETITEMRECT";
5464 case 0x1300 + 11: return "TCM_GETCURSEL";
5465 case 0x1300 + 12: return "TCM_SETCURSEL";
5466 case 0x1300 + 13: return "TCM_HITTEST";
5467 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5468 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5469 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5470 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5471 case 0x1300 + 43: return "TCM_SETPADDING";
5472 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5473 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5474 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5475 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5476 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5477 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5478 case 0x1300 + 50: return "TCM_DESELECTALL";
5481 case WM_USER
+1: return "TB_ENABLEBUTTON";
5482 case WM_USER
+2: return "TB_CHECKBUTTON";
5483 case WM_USER
+3: return "TB_PRESSBUTTON";
5484 case WM_USER
+4: return "TB_HIDEBUTTON";
5485 case WM_USER
+5: return "TB_INDETERMINATE";
5486 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5487 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5488 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5489 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5490 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5491 case WM_USER
+17: return "TB_SETSTATE";
5492 case WM_USER
+18: return "TB_GETSTATE";
5493 case WM_USER
+19: return "TB_ADDBITMAP";
5494 case WM_USER
+20: return "TB_ADDBUTTONS";
5495 case WM_USER
+21: return "TB_INSERTBUTTON";
5496 case WM_USER
+22: return "TB_DELETEBUTTON";
5497 case WM_USER
+23: return "TB_GETBUTTON";
5498 case WM_USER
+24: return "TB_BUTTONCOUNT";
5499 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5500 case WM_USER
+26: return "TB_SAVERESTOREA";
5501 case WM_USER
+76: return "TB_SAVERESTOREW";
5502 case WM_USER
+27: return "TB_CUSTOMIZE";
5503 case WM_USER
+28: return "TB_ADDSTRINGA";
5504 case WM_USER
+77: return "TB_ADDSTRINGW";
5505 case WM_USER
+29: return "TB_GETITEMRECT";
5506 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5507 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5508 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5509 case WM_USER
+33: return "TB_AUTOSIZE";
5510 case WM_USER
+35: return "TB_GETTOOLTIPS";
5511 case WM_USER
+36: return "TB_SETTOOLTIPS";
5512 case WM_USER
+37: return "TB_SETPARENT";
5513 case WM_USER
+39: return "TB_SETROWS";
5514 case WM_USER
+40: return "TB_GETROWS";
5515 case WM_USER
+42: return "TB_SETCMDID";
5516 case WM_USER
+43: return "TB_CHANGEBITMAP";
5517 case WM_USER
+44: return "TB_GETBITMAP";
5518 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5519 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5520 case WM_USER
+46: return "TB_REPLACEBITMAP";
5521 case WM_USER
+47: return "TB_SETINDENT";
5522 case WM_USER
+48: return "TB_SETIMAGELIST";
5523 case WM_USER
+49: return "TB_GETIMAGELIST";
5524 case WM_USER
+50: return "TB_LOADIMAGES";
5525 case WM_USER
+51: return "TB_GETRECT";
5526 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5527 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5528 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5529 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5530 case WM_USER
+56: return "TB_SETSTYLE";
5531 case WM_USER
+57: return "TB_GETSTYLE";
5532 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5533 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5534 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5535 case WM_USER
+61: return "TB_GETTEXTROWS";
5536 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5539 static char s_szBuf
[128];
5540 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5544 #endif //__WXDEBUG__
5546 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5547 int *x
, int *y
, WPARAM
*flags
)
5549 // construct the key mask
5550 WPARAM
& fwKeys
= *flags
;
5552 fwKeys
= MK_RBUTTON
;
5553 if ( wxIsCtrlDown() )
5554 fwKeys
|= MK_CONTROL
;
5555 if ( wxIsShiftDown() )
5558 // simulate right mouse button click
5559 DWORD dwPos
= ::GetMessagePos();
5560 *x
= GET_X_LPARAM(dwPos
);
5561 *y
= GET_Y_LPARAM(dwPos
);
5563 win
->ScreenToClient(x
, y
);
5566 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5570 HWND hwnd
= GetHwndOf(win
);
5571 HDC hdc
= ::GetDC(hwnd
);
5573 #if !wxDIALOG_UNIT_COMPATIBILITY
5574 // and select the current font into it
5575 HFONT hfont
= GetHfontOf(win
->GetFont());
5578 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5582 // finally retrieve the text metrics from it
5583 GetTextMetrics(hdc
, &tm
);
5585 #if !wxDIALOG_UNIT_COMPATIBILITY
5589 (void)::SelectObject(hdc
, hfont
);
5593 ::ReleaseDC(hwnd
, hdc
);
5598 // Find the wxWindow at the current mouse position, returning the mouse
5600 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5602 pt
= wxGetMousePosition();
5603 return wxFindWindowAtPoint(pt
);
5606 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5611 HWND hWndHit
= ::WindowFromPoint(pt2
);
5613 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5614 HWND hWnd
= hWndHit
;
5616 // Try to find a window with a wxWindow associated with it
5617 while (!win
&& (hWnd
!= 0))
5619 hWnd
= ::GetParent(hWnd
);
5620 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5625 // Get the current mouse position.
5626 wxPoint
wxGetMousePosition()
5629 GetCursorPos( & pt
);
5631 return wxPoint(pt
.x
, pt
.y
);
5636 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5638 UINT win_modifiers
=0;
5639 if ( modifiers
& wxMOD_ALT
)
5640 win_modifiers
|= MOD_ALT
;
5641 if ( modifiers
& wxMOD_SHIFT
)
5642 win_modifiers
|= MOD_SHIFT
;
5643 if ( modifiers
& wxMOD_CONTROL
)
5644 win_modifiers
|= MOD_CONTROL
;
5645 if ( modifiers
& wxMOD_WIN
)
5646 win_modifiers
|= MOD_WIN
;
5648 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5650 wxLogLastError(_T("RegisterHotKey"));
5658 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
5660 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5662 wxLogLastError(_T("UnregisterHotKey"));
5670 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5672 int hotkeyId
= wParam
;
5673 int virtualKey
= HIWORD(lParam
);
5674 int win_modifiers
= LOWORD(lParam
);
5676 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5677 event
.SetId(hotkeyId
);
5678 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5679 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5680 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5681 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5683 return GetEventHandler()->ProcessEvent(event
);
5686 #endif // wxUSE_HOTKEY
5688 // Not verified for WinCE
5691 * wxEventFixModule (needs a better name) allows message handling to continute while a menu
5692 * is being shown - ie, to continue processing messages from a worker thread.
5694 * Code originally by Jason W. from wx-dev, reworked into a wxModule by Chris Mellon
5697 class wxEventFixModule
: public wxModule
{
5699 //base class virtuals
5700 virtual bool OnInit() {
5701 wxEventFixModule::s_hMsgHookProc
= SetWindowsHookEx(
5703 &wxEventFixModule::MsgHookProc
,
5705 GetCurrentThreadId());
5706 wxLogDebug(_T("Loaded event fix module"));
5709 virtual void OnExit() {
5710 UnhookWindowsHookEx(wxEventFixModule::s_hMsgHookProc
);
5713 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
) {
5714 MSG
*msg
= (MSG
*)lParam
;
5715 switch (msg
->message
)
5718 static bool bInHookProc
= false;
5722 wxTheApp
->ProcessPendingEvents();
5723 bInHookProc
= false;
5727 return CallNextHookEx(wxEventFixModule::s_hMsgHookProc
, nCode
, wParam
, lParam
);
5730 static HHOOK s_hMsgHookProc
;
5731 DECLARE_DYNAMIC_CLASS(wxEventFixModule
)
5733 HHOOK
wxEventFixModule::s_hMsgHookProc
= 0;
5735 IMPLEMENT_DYNAMIC_CLASS(wxEventFixModule
, wxModule
)