1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
38 #include "wx/dcclient.h"
39 #include "wx/dcmemory.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
47 #include "wx/msgdlg.h"
48 #include "wx/settings.h"
49 #include "wx/statbox.h"
52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
53 #include "wx/ownerdrw.h"
56 #if wxUSE_DRAG_AND_DROP
60 #if wxUSE_ACCESSIBILITY
61 #include "wx/access.h"
65 #define WM_GETOBJECT 0x003D
68 #define OBJID_CLIENT 0xFFFFFFFC
72 #include "wx/menuitem.h"
75 #include "wx/msw/private.h"
78 #include "wx/tooltip.h"
86 #include "wx/spinctrl.h"
87 #endif // wxUSE_SPINCTRL
92 #include "wx/textctrl.h"
93 #include "wx/notebook.h"
97 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
103 #include <windowsx.h>
106 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
108 #include <commctrl.h>
110 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
111 #include "wx/msw/gnuwin32/extra.h"
114 #if defined(__GNUG__)
115 #include "wx/msw/missing.h"
118 #if defined(__WXWINCE__)
119 #include "wx/msw/wince/missing.h"
122 // ----------------------------------------------------------------------------
123 // standard constants not available with all compilers/headers
124 // ----------------------------------------------------------------------------
126 // This didn't appear in mingw until 2.95.2
128 #define SIF_TRACKPOS 16
132 #ifndef WM_MOUSEWHEEL
133 #define WM_MOUSEWHEEL 0x020A
136 #define WHEEL_DELTA 120
138 #ifndef SPI_GETWHEELSCROLLLINES
139 #define SPI_GETWHEELSCROLLLINES 104
141 #endif // wxUSE_MOUSEWHEEL
144 #define VK_OEM_1 0xBA
145 #define VK_OEM_2 0xBF
146 #define VK_OEM_3 0xC0
147 #define VK_OEM_4 0xDB
148 #define VK_OEM_5 0xDC
149 #define VK_OEM_6 0xDD
150 #define VK_OEM_7 0xDE
154 #define VK_OEM_PLUS 0xBB
155 #define VK_OEM_COMMA 0xBC
156 #define VK_OEM_MINUS 0xBD
157 #define VK_OEM_PERIOD 0xBE
160 // ---------------------------------------------------------------------------
162 // ---------------------------------------------------------------------------
164 // the last Windows message we got (FIXME-MT)
165 extern MSG s_currentMsg
;
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 // ---------------------------------------------------------------------------
225 // ---------------------------------------------------------------------------
227 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
229 #ifdef __WXUNIVERSAL__
230 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
232 #if wxUSE_EXTENDED_RTTI
233 IMPLEMENT_DYNAMIC_CLASS_XTI(wxWindow
, wxWindowBase
,"wx/window.h")
235 WX_BEGIN_PROPERTIES_TABLE(wxWindow
)
236 // WX_DEFAULT_CHILD_PARENT_RELATION( Parent , Children ) ;
237 WX_READONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, )
238 WX_PROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 )
239 // MaxHeight, Width , MinHeight , Width
240 // TODO switch label to control and title to toplevels
241 WX_PROPERTY_SET_BY_REF( Title
,wxString
, SetTitle
, GetTitle
, wxT("") )
242 WX_PROPERTY_SET_BY_REF( Label
,wxString
, SetLabel
, GetLabel
, wxT("") )
243 WX_PROPERTY_SET_BY_REF( Position
,wxPoint
, SetPosition
, GetPosition
, wxPoint(-1,-1) ) // pos
244 WX_PROPERTY_SET_BY_REF( Size
,wxSize
, SetSize
, GetSize
, wxSize(-1,-1) ) // size
245 WX_PROPERTY( WindowStyle
, long , SetWindowStyle
, GetWindowStyle
, ) // style
246 WX_PROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, ) // extstyle
247 WX_PROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
248 WX_PROPERTY_SET_BY_REF_RET_BOOL( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, ) // bg
249 WX_PROPERTY_SET_BY_REF_RET_BOOL( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, ) // fg
250 //WX_PROPERTY_SET_BY_REF( Cursor , wxCursor , SetCursor , GetCursor , )
251 WX_PROPERTY_SET_AND_GET_BY_REF_RET_BOOL( Font
, wxFont
, SetFont
, GetFont
, )
252 // WX_PROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
253 WX_PROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
254 WX_PROPERTY_SET_RET_BOOL( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) )
255 WX_PROPERTY_SET_RET_BOOL( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) )
256 WX_END_PROPERTIES_TABLE()
258 WX_BEGIN_HANDLERS_TABLE(wxWindow
)
259 WX_END_HANDLERS_TABLE()
261 WX_CONSTRUCTOR_DUMMY(wxWindow
)
263 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
265 #endif // __WXUNIVERSAL__/__WXMSW__
267 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
268 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
269 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
270 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
273 // ===========================================================================
275 // ===========================================================================
277 // ---------------------------------------------------------------------------
278 // wxWindow utility functions
279 // ---------------------------------------------------------------------------
281 // Find an item given the MS Windows id
282 wxWindow
*wxWindowMSW::FindItem(long id
) const
285 wxControl
*item
= wxDynamicCastThis(wxControl
);
288 // is it we or one of our "internal" children?
289 if ( item
->GetId() == id
290 #ifndef __WXUNIVERSAL__
291 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
292 #endif // __WXUNIVERSAL__
298 #endif // wxUSE_CONTROLS
300 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
303 wxWindow
*childWin
= current
->GetData();
305 wxWindow
*wnd
= childWin
->FindItem(id
);
309 current
= current
->GetNext();
315 // Find an item given the MS Windows handle
316 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
318 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
321 wxWindow
*parent
= current
->GetData();
323 // Do a recursive search.
324 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
330 || parent
->IsKindOf(CLASSINFO(wxControl
))
331 #endif // wxUSE_CONTROLS
334 wxWindow
*item
= current
->GetData();
335 if ( item
->GetHWND() == hWnd
)
339 if ( item
->ContainsHWND(hWnd
) )
344 current
= current
->GetNext();
349 // Default command handler
350 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
355 // ----------------------------------------------------------------------------
356 // constructors and such
357 // ----------------------------------------------------------------------------
359 void wxWindowMSW::Init()
365 m_isBeingDeleted
= FALSE
;
367 m_mouseInWindow
= FALSE
;
368 m_lastKeydownProcessed
= FALSE
;
370 m_childrenDisabled
= NULL
;
380 // as all windows are created with WS_VISIBLE style...
383 #if wxUSE_MOUSEEVENT_HACK
386 m_lastMouseEvent
= -1;
387 #endif // wxUSE_MOUSEEVENT_HACK
391 wxWindowMSW::~wxWindowMSW()
393 m_isBeingDeleted
= TRUE
;
395 #ifndef __WXUNIVERSAL__
396 // VS: make sure there's no wxFrame with last focus set to us:
397 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
399 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
402 if ( frame
->GetLastFocus() == this )
404 frame
->SetLastFocus(NULL
);
409 #endif // __WXUNIVERSAL__
411 // VS: destroy children first and _then_ detach *this from its parent.
412 // If we'd do it the other way around, children wouldn't be able
413 // find their parent frame (see above).
417 m_parent
->RemoveChild(this);
421 // VZ: test temp removed to understand what really happens here
422 //if (::IsWindow(GetHwnd()))
424 if ( !::DestroyWindow(GetHwnd()) )
425 wxLogLastError(wxT("DestroyWindow"));
428 // remove hWnd <-> wxWindow association
429 wxRemoveHandleAssociation(this);
432 delete m_childrenDisabled
;
435 // real construction (Init() must have been called before!)
436 bool wxWindowMSW::Create(wxWindow
*parent
,
441 const wxString
& name
)
443 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
445 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
448 parent
->AddChild(this);
451 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
453 #ifdef __WXUNIVERSAL__
454 // no borders, we draw them ourselves
455 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
459 msflags
&= ~WS_BORDER
;
460 #endif // wxUniversal
462 // all windows are created visible by default except popup ones (which are
463 // like the wxTopLevelWindows in this aspect)
464 if ( style
& wxPOPUP_WINDOW
)
466 msflags
&= ~WS_VISIBLE
;
471 msflags
|= WS_VISIBLE
;
474 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
477 // ---------------------------------------------------------------------------
479 // ---------------------------------------------------------------------------
481 void wxWindowMSW::SetFocus()
483 HWND hWnd
= GetHwnd();
484 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
486 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
490 if ( !::SetFocus(hWnd
) )
492 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
493 // was there really an error?
494 DWORD dwRes
= ::GetLastError();
497 HWND hwndFocus
= ::GetFocus();
498 if ( hwndFocus
!= hWnd
)
500 wxLogApiError(_T("SetFocus"), dwRes
);
507 void wxWindowMSW::SetFocusFromKbd()
509 // when the focus is given to the control with DLGC_HASSETSEL style from
510 // keyboard its contents should be entirely selected: this is what
511 // ::IsDialogMessage() does and so we should do it as well to provide the
512 // same LNF as the native programs
513 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
515 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
518 // do this after (maybe) setting the selection as like this when
519 // wxEVT_SET_FOCUS handler is called, the selection would have been already
520 // set correctly -- this may be important
521 wxWindowBase::SetFocusFromKbd();
524 // Get the window with the focus
525 wxWindow
*wxWindowBase::FindFocus()
527 HWND hWnd
= ::GetFocus();
530 return wxGetWindowFromHWND((WXHWND
)hWnd
);
536 bool wxWindowMSW::Enable(bool enable
)
538 if ( !wxWindowBase::Enable(enable
) )
541 HWND hWnd
= GetHwnd();
543 ::EnableWindow(hWnd
, (BOOL
)enable
);
545 // the logic below doesn't apply to the top level windows -- otherwise
546 // showing a modal dialog would result in total greying out (and ungreying
547 // out later) of everything which would be really ugly
551 // when the parent is disabled, all of its children should be disabled as
552 // well but when it is enabled back, only those of the children which
553 // hadn't been already disabled in the beginning should be enabled again,
554 // so we have to keep the list of those children
555 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
557 node
= node
->GetNext() )
559 wxWindow
*child
= node
->GetData();
560 if ( child
->IsTopLevel() )
562 // the logic below doesn't apply to top level children
568 // enable the child back unless it had been disabled before us
569 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
572 else // we're being disabled
574 if ( child
->IsEnabled() )
576 // disable it as children shouldn't stay enabled while the
580 else // child already disabled, remember it
582 // have we created the list of disabled children already?
583 if ( !m_childrenDisabled
)
584 m_childrenDisabled
= new wxWindowList
;
586 m_childrenDisabled
->Append(child
);
591 if ( enable
&& m_childrenDisabled
)
593 // we don't need this list any more, don't keep unused memory
594 delete m_childrenDisabled
;
595 m_childrenDisabled
= NULL
;
601 bool wxWindowMSW::Show(bool show
)
603 if ( !wxWindowBase::Show(show
) )
606 HWND hWnd
= GetHwnd();
607 int cshow
= show
? SW_SHOW
: SW_HIDE
;
608 ::ShowWindow(hWnd
, cshow
);
610 if ( show
&& IsTopLevel() )
612 wxBringWindowToTop(hWnd
);
618 // Raise the window to the top of the Z order
619 void wxWindowMSW::Raise()
621 wxBringWindowToTop(GetHwnd());
624 // Lower the window to the bottom of the Z order
625 void wxWindowMSW::Lower()
627 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
628 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
631 void wxWindowMSW::SetTitle( const wxString
& title
)
633 SetWindowText(GetHwnd(), title
.c_str());
636 wxString
wxWindowMSW::GetTitle() const
638 return wxGetWindowText(GetHWND());
641 void wxWindowMSW::DoCaptureMouse()
643 HWND hWnd
= GetHwnd();
650 void wxWindowMSW::DoReleaseMouse()
652 if ( !::ReleaseCapture() )
654 wxLogLastError(_T("ReleaseCapture"));
658 /* static */ wxWindow
*wxWindowBase::GetCapture()
660 HWND hwnd
= ::GetCapture();
661 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
664 bool wxWindowMSW::SetFont(const wxFont
& font
)
666 if ( !wxWindowBase::SetFont(font
) )
672 HWND hWnd
= GetHwnd();
675 WXHANDLE hFont
= m_font
.GetResourceHandle();
677 wxASSERT_MSG( hFont
, wxT("should have valid font") );
679 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
684 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
686 if ( !wxWindowBase::SetCursor(cursor
) )
694 HWND hWnd
= GetHwnd();
696 // Change the cursor NOW if we're within the correct window
698 ::GetCursorPos(&point
);
700 RECT rect
= wxGetWindowRect(hWnd
);
702 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
703 ::SetCursor(GetHcursorOf(m_cursor
));
709 void wxWindowMSW::WarpPointer (int x
, int y
)
711 ClientToScreen(&x
, &y
);
713 if ( !::SetCursorPos(x
, y
) )
715 wxLogLastError(_T("SetCursorPos"));
719 #if WXWIN_COMPATIBILITY
720 void wxWindowMSW::MSWDeviceToLogical (float *x
, float *y
) const
723 #endif // WXWIN_COMPATIBILITY
725 // ---------------------------------------------------------------------------
727 // ---------------------------------------------------------------------------
729 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
730 static inline int wxDirToWinStyle(int orient
)
732 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
735 #if WXWIN_COMPATIBILITY
736 void wxWindowMSW::SetScrollRange(int orient
, int range
, bool refresh
)
740 // Try to adjust the range to cope with page size > 1
741 // - a Windows API quirk
742 int pageSize
= GetScrollPage(orient
);
743 if ( pageSize
> 1 && range
> 0)
745 range1
+= (pageSize
- 1);
748 WinStruct
<SCROLLINFO
> info
;
749 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
752 info
.fMask
= SIF_RANGE
| SIF_PAGE
;
754 HWND hWnd
= GetHwnd();
756 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
759 void wxWindowMSW::SetScrollPage(int orient
, int page
, bool refresh
)
761 WinStruct
<SCROLLINFO
> info
;
763 info
.fMask
= SIF_PAGE
;
765 HWND hWnd
= GetHwnd();
767 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
770 int wxWindowMSW::GetScrollPage(int orient
) const
772 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
775 #endif // WXWIN_COMPATIBILITY
777 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
779 #ifdef __WXMICROWIN__
780 return ::GetScrollPosWX(hWnd
, wOrient
);
782 WinStruct
<SCROLLINFO
> scrollInfo
;
783 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
784 scrollInfo
.fMask
= SIF_POS
;
785 if ( !::GetScrollInfo(hWnd
,
789 // Not neccessarily an error, if there are no scrollbars yet.
790 // wxLogLastError(_T("GetScrollInfo"));
792 return scrollInfo
.nPos
;
793 // return ::GetScrollPos(hWnd, wOrient);
797 int wxWindowMSW::GetScrollPos(int orient
) const
799 HWND hWnd
= GetHwnd();
800 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
802 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
805 // This now returns the whole range, not just the number
806 // of positions that we can scroll.
807 int wxWindowMSW::GetScrollRange(int orient
) const
810 HWND hWnd
= GetHwnd();
814 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
817 WinStruct
<SCROLLINFO
> scrollInfo
;
818 scrollInfo
.fMask
= SIF_RANGE
;
819 if ( !::GetScrollInfo(hWnd
,
820 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
823 // Most of the time this is not really an error, since the return
824 // value can also be zero when there is no scrollbar yet.
825 // wxLogLastError(_T("GetScrollInfo"));
827 maxPos
= scrollInfo
.nMax
;
829 // undo "range - 1" done in SetScrollbar()
833 int wxWindowMSW::GetScrollThumb(int orient
) const
835 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
838 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
840 HWND hWnd
= GetHwnd();
841 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
843 WinStruct
<SCROLLINFO
> info
;
847 info
.fMask
= SIF_POS
;
848 if ( HasFlag(wxALWAYS_SHOW_SB
) )
850 // disable scrollbar instead of removing it then
851 info
.fMask
|= SIF_DISABLENOSCROLL
;
854 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
858 // New function that will replace some of the above.
859 void wxWindowMSW::SetScrollbar(int orient
,
865 WinStruct
<SCROLLINFO
> info
;
866 info
.nPage
= pageSize
;
867 info
.nMin
= 0; // range is nMax - nMin + 1
868 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
870 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
871 if ( HasFlag(wxALWAYS_SHOW_SB
) )
873 // disable scrollbar instead of removing it then
874 info
.fMask
|= SIF_DISABLENOSCROLL
;
877 HWND hWnd
= GetHwnd();
880 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
884 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
887 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
893 rect
.left
= prect
->x
;
895 rect
.right
= prect
->x
+ prect
->width
;
896 rect
.bottom
= prect
->y
+ prect
->height
;
905 // FIXME: is this the exact equivalent of the line below?
906 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_ERASE
|SW_INVALIDATE
);
908 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
912 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
914 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
917 for ( int n
= 0; n
< count
; n
++ )
919 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
921 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
924 // don't bother to continue, we're already at top/bottom
931 return pos
!= posStart
;
934 bool wxWindowMSW::ScrollLines(int lines
)
936 bool down
= lines
> 0;
938 return ScrollVertically(GetHwnd(),
939 down
? SB_LINEDOWN
: SB_LINEUP
,
940 down
? lines
: -lines
);
943 bool wxWindowMSW::ScrollPages(int pages
)
945 bool down
= pages
> 0;
947 return ScrollVertically(GetHwnd(),
948 down
? SB_PAGEDOWN
: SB_PAGEUP
,
949 down
? pages
: -pages
);
952 // ---------------------------------------------------------------------------
954 // ---------------------------------------------------------------------------
956 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
958 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
960 HWND hwnd
= (HWND
)hWnd
;
961 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
963 wxAssociateWinWithHandle(hwnd
, this);
965 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
967 // we don't need to subclass the window of our own class (in the Windows
968 // sense of the word)
969 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
971 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
975 // don't bother restoring it neither: this also makes it easy to
976 // implement IsOfStandardClass() method which returns TRUE for the
977 // standard controls and FALSE for the wxWindows own windows as it can
978 // simply check m_oldWndProc
983 void wxWindowMSW::UnsubclassWin()
985 wxRemoveHandleAssociation(this);
987 // Restore old Window proc
988 HWND hwnd
= GetHwnd();
993 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
997 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
999 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
1002 m_oldWndProc
= NULL
;
1007 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1009 // Unicows note: the code below works, but only because WNDCLASS contains
1010 // original window handler rather that the unicows fake one. This may not
1011 // be on purpose, though; if it stops working with future versions of
1012 // unicows.dll, we can override unicows hooks by setting
1013 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1014 // versions that keep track of fake<->real wnd proc mapping.
1016 // On WinCE (at least), the wndproc comparison doesn't work,
1017 // so have to use something like this.
1019 extern const wxChar
*wxCanvasClassName
;
1020 extern const wxChar
*wxCanvasClassNameNR
;
1021 extern const wxChar
*wxMDIFrameClassName
;
1022 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1023 extern const wxChar
*wxMDIChildFrameClassName
;
1024 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1025 wxString
str(wxGetWindowClass(hWnd
));
1026 if (str
== wxCanvasClassName
||
1027 str
== wxCanvasClassNameNR
||
1028 str
== wxMDIFrameClassName
||
1029 str
== wxMDIFrameClassNameNoRedraw
||
1030 str
== wxMDIChildFrameClassName
||
1031 str
== wxMDIChildFrameClassNameNoRedraw
||
1032 str
== _T("wxTLWHiddenParent"))
1033 return TRUE
; // Effectively means don't subclass
1038 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1040 wxLogLastError(_T("GetClassInfo"));
1045 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1049 // ----------------------------------------------------------------------------
1051 // ----------------------------------------------------------------------------
1053 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1055 long flagsOld
= GetWindowStyleFlag();
1056 if ( flags
== flagsOld
)
1059 // update the internal variable
1060 wxWindowBase::SetWindowStyleFlag(flags
);
1062 // now update the Windows style as well if needed - and if the window had
1063 // been already created
1067 WXDWORD exstyle
, exstyleOld
;
1068 long style
= MSWGetStyle(flags
, &exstyle
),
1069 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1071 if ( style
!= styleOld
)
1073 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1074 // this function so instead of simply setting the style to the new
1075 // value we clear the bits which were set in styleOld but are set in
1076 // the new one and set the ones which were not set before
1077 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1078 styleReal
&= ~styleOld
;
1081 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1084 // and the extended style
1085 if ( exstyle
!= exstyleOld
)
1087 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1088 exstyleReal
&= ~exstyleOld
;
1089 exstyleReal
|= exstyle
;
1091 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1093 // we must call SetWindowPos() to flash the cached extended style and
1094 // also to make the change to wxSTAY_ON_TOP style take effect: just
1095 // setting the style simply doesn't work
1096 if ( !::SetWindowPos(GetHwnd(),
1097 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1100 SWP_NOMOVE
| SWP_NOSIZE
) )
1102 wxLogLastError(_T("SetWindowPos"));
1107 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1109 // translate the style
1110 WXDWORD style
= WS_CHILD
| WS_VISIBLE
;
1112 if ( flags
& wxCLIP_CHILDREN
)
1113 style
|= WS_CLIPCHILDREN
;
1115 if ( flags
& wxCLIP_SIBLINGS
)
1116 style
|= WS_CLIPSIBLINGS
;
1118 if ( flags
& wxVSCROLL
)
1119 style
|= WS_VSCROLL
;
1121 if ( flags
& wxHSCROLL
)
1122 style
|= WS_HSCROLL
;
1124 const wxBorder border
= GetBorder(flags
);
1126 // WS_BORDER is only required for wxBORDER_SIMPLE
1127 if ( border
== wxBORDER_SIMPLE
)
1130 // now deal with ext style if the caller wants it
1136 if ( flags
& wxTRANSPARENT_WINDOW
)
1137 *exstyle
|= WS_EX_TRANSPARENT
;
1143 case wxBORDER_DEFAULT
:
1144 wxFAIL_MSG( _T("unknown border style") );
1148 case wxBORDER_SIMPLE
:
1151 case wxBORDER_STATIC
:
1152 *exstyle
|= WS_EX_STATICEDGE
;
1155 case wxBORDER_RAISED
:
1156 *exstyle
|= WS_EX_DLGMODALFRAME
;
1159 case wxBORDER_SUNKEN
:
1160 *exstyle
|= WS_EX_CLIENTEDGE
;
1161 style
&= ~WS_BORDER
;
1164 case wxBORDER_DOUBLE
:
1165 *exstyle
|= WS_EX_DLGMODALFRAME
;
1169 // wxUniv doesn't use Windows dialog navigation functions at all
1170 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1171 // to make the dialog navigation work with the nested panels we must
1172 // use this style (top level windows such as dialogs don't need it)
1173 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1175 *exstyle
|= WS_EX_CONTROLPARENT
;
1177 #endif // __WXUNIVERSAL__
1183 #if WXWIN_COMPATIBILITY
1184 // If nothing defined for this, try the parent.
1185 // E.g. we may be a button loaded from a resource, with no callback function
1187 void wxWindowMSW::OnCommand(wxWindow
& win
, wxCommandEvent
& event
)
1189 if ( GetEventHandler()->ProcessEvent(event
) )
1192 m_parent
->GetEventHandler()->OnCommand(win
, event
);
1194 #endif // WXWIN_COMPATIBILITY_2
1196 #if WXWIN_COMPATIBILITY
1197 wxObject
* wxWindowMSW::GetChild(int number
) const
1199 // Return a pointer to the Nth object in the Panel
1200 wxNode
*node
= GetChildren().First();
1203 node
= node
->Next();
1206 wxObject
*obj
= (wxObject
*)node
->Data();
1212 #endif // WXWIN_COMPATIBILITY
1214 // Setup background and foreground colours correctly
1215 void wxWindowMSW::SetupColours()
1218 SetBackgroundColour(GetParent()->GetBackgroundColour());
1221 bool wxWindowMSW::IsMouseInWindow() const
1223 // get the mouse position
1225 ::GetCursorPos(&pt
);
1227 // find the window which currently has the cursor and go up the window
1228 // chain until we find this window - or exhaust it
1229 HWND hwnd
= ::WindowFromPoint(pt
);
1230 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1231 hwnd
= ::GetParent(hwnd
);
1233 return hwnd
!= NULL
;
1236 void wxWindowMSW::OnInternalIdle()
1238 // Check if we need to send a LEAVE event
1239 if ( m_mouseInWindow
)
1241 // note that we should generate the leave event whether the window has
1242 // or doesn't have mouse capture
1243 if ( !IsMouseInWindow() )
1245 // Generate a LEAVE event
1246 m_mouseInWindow
= FALSE
;
1248 // Unfortunately the mouse button and keyboard state may have
1249 // changed by the time the OnInternalIdle function is called, so 'state'
1250 // may be meaningless.
1252 if ( wxIsShiftDown() )
1254 if ( wxIsCtrlDown() )
1255 state
|= MK_CONTROL
;
1256 if ( GetKeyState( VK_LBUTTON
) )
1257 state
|= MK_LBUTTON
;
1258 if ( GetKeyState( VK_MBUTTON
) )
1259 state
|= MK_MBUTTON
;
1260 if ( GetKeyState( VK_RBUTTON
) )
1261 state
|= MK_RBUTTON
;
1264 if ( !::GetCursorPos(&pt
) )
1266 wxLogLastError(_T("GetCursorPos"));
1269 // we need to have client coordinates here for symmetry with
1270 // wxEVT_ENTER_WINDOW
1271 RECT rect
= wxGetWindowRect(GetHwnd());
1275 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1276 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1278 (void)GetEventHandler()->ProcessEvent(event2
);
1282 if (wxUpdateUIEvent::CanUpdate(this))
1283 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1286 // Set this window to be the child of 'parent'.
1287 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1289 if ( !wxWindowBase::Reparent(parent
) )
1292 HWND hWndChild
= GetHwnd();
1293 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1295 ::SetParent(hWndChild
, hWndParent
);
1300 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1302 #ifndef __WXMICROWIN__
1303 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1307 void wxWindowMSW::Freeze()
1309 SendSetRedraw(GetHwnd(), FALSE
);
1312 void wxWindowMSW::Thaw()
1314 SendSetRedraw(GetHwnd(), TRUE
);
1316 // we need to refresh everything or otherwise he invalidated area is not
1321 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1323 HWND hWnd
= GetHwnd();
1329 mswRect
.left
= rect
->x
;
1330 mswRect
.top
= rect
->y
;
1331 mswRect
.right
= rect
->x
+ rect
->width
;
1332 mswRect
.bottom
= rect
->y
+ rect
->height
;
1334 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1337 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1341 void wxWindowMSW::Update()
1343 if ( !::UpdateWindow(GetHwnd()) )
1345 wxLogLastError(_T("UpdateWindow"));
1348 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1349 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1350 // handler needs to be really drawn right now
1355 // ---------------------------------------------------------------------------
1357 // ---------------------------------------------------------------------------
1360 #if wxUSE_DRAG_AND_DROP
1361 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1363 if ( m_dropTarget
!= 0 ) {
1364 m_dropTarget
->Revoke(m_hWnd
);
1365 delete m_dropTarget
;
1368 m_dropTarget
= pDropTarget
;
1369 if ( m_dropTarget
!= 0 )
1370 m_dropTarget
->Register(m_hWnd
);
1372 #endif // wxUSE_DRAG_AND_DROP
1374 // old style file-manager drag&drop support: we retain the old-style
1375 // DragAcceptFiles in parallel with SetDropTarget.
1376 void wxWindowMSW::DragAcceptFiles(bool accept
)
1378 #if !defined(__WXWINCE__)
1379 HWND hWnd
= GetHwnd();
1381 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1385 // ----------------------------------------------------------------------------
1387 // ----------------------------------------------------------------------------
1391 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1393 wxWindowBase::DoSetToolTip(tooltip
);
1396 m_tooltip
->SetWindow((wxWindow
*)this);
1399 #endif // wxUSE_TOOLTIPS
1401 // ---------------------------------------------------------------------------
1402 // moving and resizing
1403 // ---------------------------------------------------------------------------
1406 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1408 RECT rect
= wxGetWindowRect(GetHwnd());
1411 *x
= rect
.right
- rect
.left
;
1413 *y
= rect
.bottom
- rect
.top
;
1416 // Get size *available for subwindows* i.e. excluding menu bar etc.
1417 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1419 RECT rect
= wxGetClientRect(GetHwnd());
1427 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1429 RECT rect
= wxGetWindowRect(GetHwnd());
1432 point
.x
= rect
.left
;
1435 // we do the adjustments with respect to the parent only for the "real"
1436 // children, not for the dialogs/frames
1437 if ( !IsTopLevel() )
1439 HWND hParentWnd
= 0;
1440 wxWindow
*parent
= GetParent();
1442 hParentWnd
= GetWinHwnd(parent
);
1444 // Since we now have the absolute screen coords, if there's a parent we
1445 // must subtract its top left corner
1448 ::ScreenToClient(hParentWnd
, &point
);
1453 // We may be faking the client origin. So a window that's really at (0,
1454 // 30) may appear (to wxWin apps) to be at (0, 0).
1455 wxPoint
pt(parent
->GetClientAreaOrigin());
1467 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1475 ::ScreenToClient(GetHwnd(), &pt
);
1483 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1491 ::ClientToScreen(GetHwnd(), &pt
);
1499 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1501 // TODO: is this consistent with other platforms?
1502 // Still, negative width or height shouldn't be allowed
1507 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1509 wxLogLastError(wxT("MoveWindow"));
1513 // set the size of the window: if the dimensions are positive, just use them,
1514 // but if any of them is equal to -1, it means that we must find the value for
1515 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1516 // which case -1 is a valid value for x and y)
1518 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1519 // the width/height to best suit our contents, otherwise we reuse the current
1521 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1523 // get the current size and position...
1524 int currentX
, currentY
;
1525 GetPosition(¤tX
, ¤tY
);
1526 int currentW
,currentH
;
1527 GetSize(¤tW
, ¤tH
);
1529 // ... and don't do anything (avoiding flicker) if it's already ok
1530 if ( x
== currentX
&& y
== currentY
&&
1531 width
== currentW
&& height
== currentH
)
1536 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1538 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1541 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1543 wxSize
size(-1, -1);
1546 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1548 size
= DoGetBestSize();
1553 // just take the current one
1560 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1564 size
= DoGetBestSize();
1566 //else: already called DoGetBestSize() above
1572 // just take the current one
1577 DoMoveWindow(x
, y
, width
, height
);
1580 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1582 // setting the client size is less obvious than it it could have been
1583 // because in the result of changing the total size the window scrollbar
1584 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1585 // will not be correct as the difference between the total and client size
1586 // changes - so we keep changing it until we get it right
1588 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1589 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1590 // may become 3 if the window had 0 size originally and so we didn't
1591 // calculate the scrollbar correction correctly during the first iteration)
1592 // but just to be on the safe side we check for it instead of making it an
1593 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1594 for ( int i
= 0; i
< 4; i
++ )
1597 ::GetClientRect(GetHwnd(), &rectClient
);
1599 // if the size is already ok, stop here (rectClient.left = top = 0)
1600 if ( (rectClient
.right
== width
|| width
== -1) &&
1601 (rectClient
.bottom
== height
|| height
== -1) )
1606 int widthClient
= width
,
1607 heightClient
= height
;
1609 // Find the difference between the entire window (title bar and all)
1610 // and the client area; add this to the new client size to move the
1613 ::GetWindowRect(GetHwnd(), &rectWin
);
1615 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1616 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1619 point
.x
= rectWin
.left
;
1620 point
.y
= rectWin
.top
;
1622 // MoveWindow positions the child windows relative to the parent, so
1623 // adjust if necessary
1624 if ( !IsTopLevel() )
1626 wxWindow
*parent
= GetParent();
1629 ::ScreenToClient(GetHwndOf(parent
), &point
);
1633 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1637 // For implementation purposes - sometimes decorations make the client area
1639 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1641 return wxPoint(0, 0);
1644 // ---------------------------------------------------------------------------
1646 // ---------------------------------------------------------------------------
1648 int wxWindowMSW::GetCharHeight() const
1650 return wxGetTextMetrics(this).tmHeight
;
1653 int wxWindowMSW::GetCharWidth() const
1655 // +1 is needed because Windows apparently adds it when calculating the
1656 // dialog units size in pixels
1657 #if wxDIALOG_UNIT_COMPATIBILITY
1658 return wxGetTextMetrics(this).tmAveCharWidth
;
1660 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1664 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1666 int *descent
, int *externalLeading
,
1667 const wxFont
*theFont
) const
1669 const wxFont
*fontToUse
= theFont
;
1671 fontToUse
= &m_font
;
1673 HWND hWnd
= GetHwnd();
1674 HDC dc
= ::GetDC(hWnd
);
1678 if ( fontToUse
&& fontToUse
->Ok() )
1680 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1682 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1687 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1688 GetTextMetrics(dc
, &tm
);
1690 if ( fontToUse
&& fnt
&& hfontOld
)
1691 SelectObject(dc
, hfontOld
);
1693 ReleaseDC(hWnd
, dc
);
1700 *descent
= tm
.tmDescent
;
1701 if ( externalLeading
)
1702 *externalLeading
= tm
.tmExternalLeading
;
1705 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1706 // ---------------------------------------------------------------------------
1707 // Caret manipulation
1708 // ---------------------------------------------------------------------------
1710 void wxWindowMSW::CreateCaret(int w
, int h
)
1712 SetCaret(new wxCaret(this, w
, h
));
1715 void wxWindowMSW::CreateCaret(const wxBitmap
*WXUNUSED(bitmap
))
1717 wxFAIL_MSG("not implemented");
1720 void wxWindowMSW::ShowCaret(bool show
)
1722 wxCHECK_RET( m_caret
, "no caret to show" );
1724 m_caret
->Show(show
);
1727 void wxWindowMSW::DestroyCaret()
1732 void wxWindowMSW::SetCaretPos(int x
, int y
)
1734 wxCHECK_RET( m_caret
, "no caret to move" );
1736 m_caret
->Move(x
, y
);
1739 void wxWindowMSW::GetCaretPos(int *x
, int *y
) const
1741 wxCHECK_RET( m_caret
, "no caret to get position of" );
1743 m_caret
->GetPosition(x
, y
);
1745 #endif // wxUSE_CARET
1747 // ---------------------------------------------------------------------------
1749 // ---------------------------------------------------------------------------
1751 #if wxUSE_MENUS_NATIVE
1753 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1754 // immediately, without waiting for the next event loop iteration
1756 // NB: this function should probably be made public later as it can almost
1757 // surely replace wxYield() elsewhere as well
1758 static void wxYieldForCommandsOnly()
1760 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1761 // want to process it here)
1763 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1764 && msg
.message
!= WM_QUIT
)
1766 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1769 // If we retrieved a WM_QUIT, insert back into the message queue.
1770 if (msg
.message
== WM_QUIT
)
1771 ::PostQuitMessage(0);
1774 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1776 menu
->SetInvokingWindow(this);
1779 HWND hWnd
= GetHwnd();
1780 HMENU hMenu
= GetHmenuOf(menu
);
1784 ::ClientToScreen(hWnd
, &point
);
1785 wxCurrentPopupMenu
= menu
;
1787 #if !defined(__WXWINCE__)
1788 flags
= TPM_RIGHTBUTTON
;
1790 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1792 // we need to do it righ now as otherwise the events are never going to be
1793 // sent to wxCurrentPopupMenu from HandleCommand()
1795 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1796 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1797 // destroyed as soon as we return (it can be a local variable in the caller
1798 // for example) and so we do need to process the event immediately
1799 wxYieldForCommandsOnly();
1801 wxCurrentPopupMenu
= NULL
;
1803 menu
->SetInvokingWindow(NULL
);
1808 #endif // wxUSE_MENUS_NATIVE
1810 // ===========================================================================
1811 // pre/post message processing
1812 // ===========================================================================
1814 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1817 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1819 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1822 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1824 // wxUniversal implements tab traversal itself
1825 #ifndef __WXUNIVERSAL__
1826 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1828 // intercept dialog navigation keys
1829 MSG
*msg
= (MSG
*)pMsg
;
1831 // here we try to do all the job which ::IsDialogMessage() usually does
1834 if ( msg
->message
== WM_KEYDOWN
)
1836 bool bCtrlDown
= wxIsCtrlDown();
1837 bool bShiftDown
= wxIsShiftDown();
1839 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1840 // don't process it if it's the case (except for Ctrl-Tab/Enter
1841 // combinations which are always processed)
1845 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1847 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1848 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1849 // it, of course, implies them
1850 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1852 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1856 bool bForward
= TRUE
,
1857 bWindowChange
= FALSE
;
1859 // should we process this message specially?
1860 bool bProcess
= TRUE
;
1861 switch ( msg
->wParam
)
1864 // assume that nobody wants Shift-TAB for himself - if we
1865 // don't do it there is no easy way for a control to grab
1866 // TABs but still let Shift-TAB work as navugation key
1867 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1871 // Ctrl-Tab cycles thru notebook pages
1872 bWindowChange
= bCtrlDown
;
1873 bForward
= !bShiftDown
;
1879 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1887 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1893 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1895 // control wants to process Enter itself, don't
1896 // call IsDialogMessage() which would interpret
1900 else if ( lDlgCode
& DLGC_BUTTON
)
1902 // let IsDialogMessage() handle this for all
1903 // buttons except the owner-drawn ones which it
1904 // just seems to ignore
1905 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1906 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1908 // emulate the button click
1909 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1911 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1916 // FIXME: this should be handled by
1917 // wxNavigationKeyEvent handler and not here!!
1921 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1923 if ( btn
&& btn
->IsEnabled() )
1925 // if we do have a default button, do press it
1926 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1930 else // no default button
1932 #endif // wxUSE_BUTTON
1933 // this is a quick and dirty test for a text
1935 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1937 // don't process Enter, the control might
1938 // need it for itself and don't let
1939 // ::IsDialogMessage() have it as it can
1940 // eat the Enter events sometimes
1943 else if (!IsTopLevel())
1945 // if not a top level window, let parent
1949 //else: treat Enter as TAB: pass to the next
1950 // control as this is the best thing to do
1951 // if the text doesn't handle Enter itself
1963 wxNavigationKeyEvent event
;
1964 event
.SetDirection(bForward
);
1965 event
.SetWindowChange(bWindowChange
);
1966 event
.SetEventObject(this);
1968 if ( GetEventHandler()->ProcessEvent(event
) )
1975 // let ::IsDialogMessage() do almost everything and handle just the
1976 // things it doesn't here: Ctrl-TAB for switching notebook pages
1977 if ( msg
->message
== WM_KEYDOWN
)
1979 // don't process system keys here
1980 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1982 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1984 // find the first notebook parent and change its page
1985 wxWindow
*win
= this;
1986 wxNotebook
*nbook
= NULL
;
1987 while ( win
&& !nbook
)
1989 nbook
= wxDynamicCast(win
, wxNotebook
);
1990 win
= win
->GetParent();
1995 bool forward
= !wxIsShiftDown();
1997 nbook
->AdvanceSelection(forward
);
2004 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
2005 // shouldn't let IsDialogMessage() get it as it _always_ eats the
2006 // message even when there is no cancel button and when the message is
2007 // needed by the control itself: in particular, it prevents the tree in
2008 // place edit control from being closed with Escape in a dialog
2009 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2011 // ::IsDialogMessage() is broken and may sometimes hang the
2012 // application by going into an infinite loop, so we try to detect
2013 // [some of] the situatations when this may happen and not call it
2016 // assume we can call it by default
2017 bool canSafelyCallIsDlgMsg
= TRUE
;
2019 HWND hwndFocus
= ::GetFocus();
2021 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2022 // an infinite loop, because it will recursively check the child
2023 // windows but not the window itself and so if none of the children
2024 // accepts focus it loops forever (as it only stops when it gets
2025 // back to the window it started from)
2027 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2028 // style has the focus, it can happen. One such possibility is if
2029 // all windows are either toplevel, wxDialog, wxPanel or static
2030 // controls and no window can actually accept keyboard input.
2031 #if !defined(__WXWINCE__)
2032 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2034 // passimistic by default
2035 canSafelyCallIsDlgMsg
= FALSE
;
2036 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2038 node
= node
->GetNext() )
2040 wxWindow
* const win
= node
->GetData();
2041 if ( win
->AcceptsFocus() &&
2042 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2043 WS_EX_CONTROLPARENT
) )
2045 // it shouldn't hang...
2046 canSafelyCallIsDlgMsg
= TRUE
;
2052 #endif // !__WXWINCE__
2054 if ( canSafelyCallIsDlgMsg
)
2056 // ::IsDialogMessage() can enter in an infinite loop when the
2057 // currently focused window is disabled or hidden and its
2058 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2062 if ( !::IsWindowEnabled(hwndFocus
) ||
2063 !::IsWindowVisible(hwndFocus
) )
2065 // it would enter an infinite loop if we do this!
2066 canSafelyCallIsDlgMsg
= FALSE
;
2071 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2073 // it's a top level window, don't go further -- e.g. even
2074 // if the parent of a dialog is disabled, this doesn't
2075 // break navigation inside the dialog
2079 hwndFocus
= ::GetParent(hwndFocus
);
2083 // let IsDialogMessage() have the message if it's safe to call it
2084 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2086 // IsDialogMessage() did something...
2091 #endif // __WXUNIVERSAL__
2096 // relay mouse move events to the tooltip control
2097 MSG
*msg
= (MSG
*)pMsg
;
2098 if ( msg
->message
== WM_MOUSEMOVE
)
2099 m_tooltip
->RelayEvent(pMsg
);
2101 #endif // wxUSE_TOOLTIPS
2106 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2108 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2109 return m_acceleratorTable
.Translate(this, pMsg
);
2113 #endif // wxUSE_ACCEL
2116 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2118 // preprocess all messages by default
2122 // ---------------------------------------------------------------------------
2123 // message params unpackers
2124 // ---------------------------------------------------------------------------
2126 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2127 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2129 *id
= LOWORD(wParam
);
2130 *hwnd
= (WXHWND
)lParam
;
2131 *cmd
= HIWORD(wParam
);
2134 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2135 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2137 *state
= LOWORD(wParam
);
2138 *minimized
= HIWORD(wParam
);
2139 *hwnd
= (WXHWND
)lParam
;
2142 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2143 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2145 *code
= LOWORD(wParam
);
2146 *pos
= HIWORD(wParam
);
2147 *hwnd
= (WXHWND
)lParam
;
2150 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2151 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2153 #ifndef __WXMICROWIN__
2154 *nCtlColor
= CTLCOLOR_BTN
;
2155 *hwnd
= (WXHWND
)lParam
;
2156 *hdc
= (WXHDC
)wParam
;
2160 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2161 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2163 *item
= (WXWORD
)wParam
;
2164 *flags
= HIWORD(wParam
);
2165 *hmenu
= (WXHMENU
)lParam
;
2168 // ---------------------------------------------------------------------------
2169 // Main wxWindows window proc and the window proc for wxWindow
2170 // ---------------------------------------------------------------------------
2172 // Hook for new window just as it's being created, when the window isn't yet
2173 // associated with the handle
2174 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2176 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2177 // window being created and insures that it's always unset back later
2178 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2180 gs_winBeingCreated
= winBeingCreated
;
2183 wxWindowCreationHook::~wxWindowCreationHook()
2185 gs_winBeingCreated
= NULL
;
2189 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2191 // trace all messages - useful for the debugging
2193 wxLogTrace(wxTraceMessages
,
2194 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2195 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2196 #endif // __WXDEBUG__
2198 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2200 // when we get the first message for the HWND we just created, we associate
2201 // it with wxWindow stored in gs_winBeingCreated
2202 if ( !wnd
&& gs_winBeingCreated
)
2204 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2205 wnd
= gs_winBeingCreated
;
2206 gs_winBeingCreated
= NULL
;
2207 wnd
->SetHWND((WXHWND
)hWnd
);
2213 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2215 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2220 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2222 // did we process the message?
2223 bool processed
= FALSE
;
2234 // for most messages we should return 0 when we do process the message
2242 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2245 // return 0 to allow window creation
2246 rc
.result
= mayCreate
? 0 : -1;
2252 // never set processed to TRUE and *always* pass WM_DESTROY to
2253 // DefWindowProc() as Windows may do some internal cleanup when
2254 // processing it and failing to pass the message along may cause
2255 // memory and resource leaks!
2256 (void)HandleDestroy();
2260 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2263 #if !defined(__WXWINCE__)
2266 LPRECT pRect
= (LPRECT
)lParam
;
2268 rc
.SetLeft(pRect
->left
);
2269 rc
.SetTop(pRect
->top
);
2270 rc
.SetRight(pRect
->right
);
2271 rc
.SetBottom(pRect
->bottom
);
2272 processed
= HandleMoving(rc
);
2274 pRect
->left
= rc
.GetLeft();
2275 pRect
->top
= rc
.GetTop();
2276 pRect
->right
= rc
.GetRight();
2277 pRect
->bottom
= rc
.GetBottom();
2288 // we're not interested in these messages at all
2291 case SIZE_MINIMIZED
:
2292 // we shouldn't send sizev events for these messages as the
2293 // client size may be negative which breaks existing code
2295 // OTOH we might send another (wxMinimizedEvent?) one or
2296 // add an additional parameter to wxSizeEvent if this is
2297 // useful to anybody
2301 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2302 // fall through nevertheless
2304 case SIZE_MAXIMIZED
:
2306 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2311 #if !defined(__WXWINCE__)
2314 LPRECT pRect
= (LPRECT
)lParam
;
2316 rc
.SetLeft(pRect
->left
);
2317 rc
.SetTop(pRect
->top
);
2318 rc
.SetRight(pRect
->right
);
2319 rc
.SetBottom(pRect
->bottom
);
2320 processed
= HandleSizing(rc
);
2322 pRect
->left
= rc
.GetLeft();
2323 pRect
->top
= rc
.GetTop();
2324 pRect
->right
= rc
.GetRight();
2325 pRect
->bottom
= rc
.GetBottom();
2331 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2332 case WM_ACTIVATEAPP
:
2333 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2339 WXWORD state
, minimized
;
2341 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2343 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2348 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2352 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2359 // cast to wxWindow is needed for wxUniv
2360 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2361 processed
= HandlePaint();
2365 processed
= HandlePaint();
2371 #ifdef __WXUNIVERSAL__
2372 // Universal uses its own wxFrame/wxDialog, so we don't receive
2373 // close events unless we have this.
2378 // don't let the DefWindowProc() destroy our window - we'll do it
2379 // ourselves in ~wxWindow
2386 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2390 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2391 GET_Y_LPARAM(lParam
),
2395 #if wxUSE_MOUSEWHEEL
2397 processed
= HandleMouseWheel(wParam
, lParam
);
2401 case WM_LBUTTONDOWN
:
2403 case WM_LBUTTONDBLCLK
:
2404 case WM_RBUTTONDOWN
:
2406 case WM_RBUTTONDBLCLK
:
2407 case WM_MBUTTONDOWN
:
2409 case WM_MBUTTONDBLCLK
:
2411 #ifdef __WXMICROWIN__
2412 // MicroWindows seems to ignore the fact that a window is
2413 // disabled. So catch mouse events and throw them away if
2415 wxWindowMSW
* win
= this;
2418 if (!win
->IsEnabled())
2424 win
= win
->GetParent();
2425 if ( !win
|| win
->IsTopLevel() )
2432 #endif // __WXMICROWIN__
2433 int x
= GET_X_LPARAM(lParam
),
2434 y
= GET_Y_LPARAM(lParam
);
2436 // redirect the event to a static control if necessary by
2437 // finding one under mouse
2439 if ( GetCapture() == this )
2441 // but don't do it if the mouse is captured by this window
2442 // because then it should really get this event itself
2447 win
= FindWindowForMouseEvent(this, &x
, &y
);
2449 // this should never happen
2450 wxCHECK_MSG( win
, 0,
2451 _T("FindWindowForMouseEvent() returned NULL") );
2453 // for the standard classes their WndProc sets the focus to
2454 // them anyhow and doing it from here results in some weird
2455 // problems, but for our windows we want them to acquire
2456 // focus when clicked
2457 if ( !win
->IsOfStandardClass() )
2459 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2464 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2473 case MM_JOY1BUTTONDOWN
:
2474 case MM_JOY2BUTTONDOWN
:
2475 case MM_JOY1BUTTONUP
:
2476 case MM_JOY2BUTTONUP
:
2477 processed
= HandleJoystickEvent(message
,
2478 GET_X_LPARAM(lParam
),
2479 GET_Y_LPARAM(lParam
),
2482 #endif // __WXMICROWIN__
2485 processed
= HandleSysCommand(wParam
, lParam
);
2492 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2494 processed
= HandleCommand(id
, cmd
, hwnd
);
2499 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2502 // for these messages we must return TRUE if process the message
2505 case WM_MEASUREITEM
:
2507 int idCtrl
= (UINT
)wParam
;
2508 if ( message
== WM_DRAWITEM
)
2510 processed
= MSWOnDrawItem(idCtrl
,
2511 (WXDRAWITEMSTRUCT
*)lParam
);
2515 processed
= MSWOnMeasureItem(idCtrl
,
2516 (WXMEASUREITEMSTRUCT
*)lParam
);
2523 #endif // defined(WM_DRAWITEM)
2526 if ( !IsOfStandardClass() )
2528 // we always want to get the char events
2529 rc
.result
= DLGC_WANTCHARS
;
2531 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2533 // in fact, we want everything
2534 rc
.result
|= DLGC_WANTARROWS
|
2541 //else: get the dlg code from the DefWindowProc()
2546 // If this has been processed by an event handler, return 0 now
2547 // (we've handled it).
2548 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2549 if ( m_lastKeydownProcessed
)
2558 // we consider these message "not interesting" to OnChar, so
2559 // just don't do anything more with them
2569 // avoid duplicate messages to OnChar for these ASCII keys:
2570 // they will be translated by TranslateMessage() and received
2592 // but set processed to FALSE, not TRUE to still pass them
2593 // to the control's default window proc - otherwise
2594 // built-in keyboard handling won't work
2599 // special case of VK_APPS: treat it the same as right mouse
2600 // click because both usually pop up a context menu
2606 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2607 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2613 // do generate a CHAR event
2614 processed
= HandleChar((WORD
)wParam
, lParam
);
2617 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2624 // special case of VK_APPS: treat it the same as right mouse button
2625 if ( wParam
== VK_APPS
)
2630 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2631 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2636 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2641 case WM_CHAR
: // Always an ASCII character
2642 if ( m_lastKeydownProcessed
)
2644 // The key was handled in the EVT_KEY_DOWN and handling
2645 // a key in an EVT_KEY_DOWN handler is meant, by
2646 // design, to prevent EVT_CHARs from happening
2647 m_lastKeydownProcessed
= FALSE
;
2652 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2658 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2660 #endif // wxUSE_HOTKEY
2667 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2669 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2675 // CTLCOLOR messages are sent by children to query the parent for their
2676 // colors#ifndef __WXMICROWIN__
2677 #ifndef __WXMICROWIN__
2678 case WM_CTLCOLORMSGBOX
:
2679 case WM_CTLCOLOREDIT
:
2680 case WM_CTLCOLORLISTBOX
:
2681 case WM_CTLCOLORBTN
:
2682 case WM_CTLCOLORDLG
:
2683 case WM_CTLCOLORSCROLLBAR
:
2684 case WM_CTLCOLORSTATIC
:
2689 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2691 processed
= HandleCtlColor(&rc
.hBrush
,
2700 #endif // !__WXMICROWIN__
2702 case WM_SYSCOLORCHANGE
:
2703 // the return value for this message is ignored
2704 processed
= HandleSysColorChange();
2707 #if !defined(__WXWINCE__)
2708 case WM_DISPLAYCHANGE
:
2709 processed
= HandleDisplayChange();
2713 case WM_PALETTECHANGED
:
2714 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2717 case WM_CAPTURECHANGED
:
2718 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2721 case WM_QUERYNEWPALETTE
:
2722 processed
= HandleQueryNewPalette();
2726 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2729 // we processed the message, i.e. erased the background
2734 #if !defined(__WXWINCE__)
2736 processed
= HandleDropFiles(wParam
);
2741 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2745 // we never set focus from here
2750 #if !defined(__WXWINCE__)
2751 case WM_QUERYENDSESSION
:
2752 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2756 processed
= HandleEndSession(wParam
!= 0, lParam
);
2759 case WM_GETMINMAXINFO
:
2760 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2765 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2766 LOWORD(lParam
), // hit test
2767 HIWORD(lParam
)); // mouse msg
2771 // returning TRUE stops the DefWindowProc() from further
2772 // processing this message - exactly what we need because we've
2773 // just set the cursor.
2778 #if wxUSE_ACCESSIBILITY
2781 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2782 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2784 if (dwObjId
== OBJID_CLIENT
&& GetOrCreateAccessible())
2786 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2792 #if defined(WM_HELP)
2795 // HELPINFO doesn't seem to be supported on WinCE.
2797 HELPINFO
* info
= (HELPINFO
*) lParam
;
2798 // Don't yet process menu help events, just windows
2799 if (info
->iContextType
== HELPINFO_WINDOW
)
2802 wxWindowMSW
* subjectOfHelp
= this;
2803 bool eventProcessed
= FALSE
;
2804 while (subjectOfHelp
&& !eventProcessed
)
2806 wxHelpEvent
helpEvent(wxEVT_HELP
,
2807 subjectOfHelp
->GetId(),
2811 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2815 helpEvent
.SetEventObject(this);
2817 GetEventHandler()->ProcessEvent(helpEvent
);
2819 // Go up the window hierarchy until the event is
2821 subjectOfHelp
= subjectOfHelp
->GetParent();
2824 processed
= eventProcessed
;
2827 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2829 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2830 helpEvent
.SetEventObject(this);
2831 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2834 //else: processed is already FALSE
2840 #if !defined(__WXWINCE__)
2841 case WM_CONTEXTMENU
:
2843 // we don't convert from screen to client coordinates as
2844 // the event may be handled by a parent window
2845 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2847 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2848 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2854 // we're only interested in our own menus, not MF_SYSMENU
2855 if ( HIWORD(wParam
) == MF_POPUP
)
2857 // handle menu chars for ownerdrawn menu items
2858 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2859 if ( i
!= wxNOT_FOUND
)
2861 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2871 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2872 wxGetMessageName(message
));
2873 #endif // __WXDEBUG__
2874 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2880 // ----------------------------------------------------------------------------
2881 // wxWindow <-> HWND map
2882 // ----------------------------------------------------------------------------
2884 wxWinHashTable
*wxWinHandleHash
= NULL
;
2886 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2888 return wxWinHandleHash
->Get((long)hWnd
);
2891 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2893 // adding NULL hWnd is (first) surely a result of an error and
2894 // (secondly) breaks menu command processing
2895 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2896 wxT("attempt to add a NULL hWnd to window list ignored") );
2898 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2900 if ( oldWin
&& (oldWin
!= win
) )
2902 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2903 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2906 #endif // __WXDEBUG__
2909 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2913 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2915 wxWinHandleHash
->Delete((long)win
->GetHWND());
2918 // ----------------------------------------------------------------------------
2919 // various MSW speciic class dependent functions
2920 // ----------------------------------------------------------------------------
2922 // Default destroyer - override if you destroy it in some other way
2923 // (e.g. with MDI child windows)
2924 void wxWindowMSW::MSWDestroyWindow()
2928 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2931 int& w
, int& h
) const
2933 static const int DEFAULT_Y
= 200;
2934 static const int DEFAULT_H
= 250;
2936 bool nonDefault
= FALSE
;
2940 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2941 // just as well set it to CW_USEDEFAULT as well
2947 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2948 // neither because it is not handled as a special value by Windows then
2949 // and so we have to choose some default value for it
2951 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2957 NB: there used to be some code here which set the initial size of the
2958 window to the client size of the parent if no explicit size was
2959 specified. This was wrong because wxWindows programs often assume
2960 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2961 it. To see why, you should understand that Windows sends WM_SIZE from
2962 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2963 from some base class ctor and so this WM_SIZE is not processed in the
2964 real class' OnSize() (because it's not fully constructed yet and the
2965 event goes to some base class OnSize() instead). So the WM_SIZE we
2966 rely on is the one sent when the parent frame resizes its children
2967 but here is the problem: if the child already has just the right
2968 size, nothing will happen as both wxWindows and Windows check for
2969 this and ignore any attempts to change the window size to the size it
2970 already has - so no WM_SIZE would be sent.
2974 // as above, h is not used at all in this case anyhow
2980 // and, again as above, we can't set the height to CW_USEDEFAULT here
2982 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2990 WXHWND
wxWindowMSW::MSWGetParent() const
2992 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
2995 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
2996 const wxChar
*title
,
3000 WXDWORD extendedStyle
)
3002 // choose the position/size for the new window
3004 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3006 // controlId is menu handle for the top level windows, so set it to 0
3007 // unless we're creating a child window
3008 int controlId
= style
& WS_CHILD
? GetId() : 0;
3010 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3011 // which is the same but without CS_[HV]REDRAW class styles so using it
3012 // ensures that the window is not fully repainted on each resize
3013 wxString
className(wclass
);
3014 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
3016 className
+= wxT("NR");
3019 // do create the window
3020 wxWindowCreationHook
hook(this);
3023 if (extendedStyle
== 0)
3025 m_hWnd
= (WXHWND
)::CreateWindow
3028 title
? title
: wxEmptyString
,
3031 (HWND
)MSWGetParent(),
3034 NULL
// no extra data
3040 m_hWnd
= (WXHWND
)::CreateWindowEx
3044 title
? title
: wxEmptyString
,
3047 (HWND
)MSWGetParent(),
3050 NULL
// no extra data
3056 wxLogSysError(_("Can't create window of class %s"), wclass
);
3061 SubclassWin(m_hWnd
);
3063 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
3068 // ===========================================================================
3069 // MSW message handlers
3070 // ===========================================================================
3072 // ---------------------------------------------------------------------------
3074 // ---------------------------------------------------------------------------
3078 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3080 #ifndef __WXMICROWIN__
3081 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3082 HWND hWnd
= hdr
->hwndFrom
;
3083 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3085 // if the control is one of our windows, let it handle the message itself
3088 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3091 // VZ: why did we do it? normally this is unnecessary and, besides, it
3092 // breaks the message processing for the toolbars because the tooltip
3093 // notifications were being forwarded to the toolbar child controls
3094 // (if it had any) before being passed to the toolbar itself, so in my
3095 // example the tooltip for the combobox was always shown instead of the
3096 // correct button tooltips
3098 // try all our children
3099 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3102 wxWindow
*child
= node
->GetData();
3103 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3108 node
= node
->GetNext();
3112 // by default, handle it ourselves
3113 return MSWOnNotify(idCtrl
, lParam
, result
);
3114 #else // __WXMICROWIN__
3121 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3123 const wxString
& ttip
)
3125 // I don't know why it happens, but the versions of comctl32.dll starting
3126 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3127 // this message is supposed to be sent to Unicode programs only) -- hence
3128 // we need to handle it as well, otherwise no tooltips will be shown in
3131 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
3133 // not a tooltip message or no tooltip to show anyhow
3138 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3141 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
3143 // we pass just the pointer as we store the string internally anyhow
3144 ttText
->lpszText
= (char *)ttip
.c_str();
3146 else // TTN_NEEDTEXTW
3150 // in Unicode mode this is just what we need
3151 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3153 MultiByteToWideChar(CP_ACP
, 0, ttip
, ttip
.length()+1,
3154 (wchar_t *)ttText
->szText
,
3155 sizeof(ttText
->szText
) / sizeof(wchar_t));
3156 #endif // Unicode/!Unicode
3162 #endif // wxUSE_TOOLTIPS
3164 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3166 WXLPARAM
* WXUNUSED(result
))
3171 NMHDR
* hdr
= (NMHDR
*)lParam
;
3172 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3178 #endif // wxUSE_TOOLTIPS
3185 // ---------------------------------------------------------------------------
3186 // end session messages
3187 // ---------------------------------------------------------------------------
3189 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3192 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3193 event
.SetEventObject(wxTheApp
);
3194 event
.SetCanVeto(TRUE
);
3195 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3197 bool rc
= wxTheApp
->ProcessEvent(event
);
3201 // we may end only if the app didn't veto session closing (double
3203 *mayEnd
= !event
.GetVeto();
3212 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3215 // do nothing if the session isn't ending
3220 if ( (this != wxTheApp
->GetTopWindow()) )
3223 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3224 event
.SetEventObject(wxTheApp
);
3225 event
.SetCanVeto(FALSE
);
3226 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3228 return wxTheApp
->ProcessEvent(event
);
3234 // ---------------------------------------------------------------------------
3235 // window creation/destruction
3236 // ---------------------------------------------------------------------------
3238 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3240 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3241 // parent as well as otherwise several Win32 functions using
3242 // GetNextDlgTabItem() to iterate over all controls such as
3243 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3244 // all of them iterate over all the controls starting from the focus and
3245 // stop iterating when they get back to the focus but unless all parents
3246 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3248 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3250 // there is no need to do anything for the top level windows
3251 const wxWindow
*parent
= GetParent();
3252 while ( parent
&& !parent
->IsTopLevel() )
3254 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
3255 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
3257 // force the parent to have this style
3258 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
3259 exStyle
| WS_EX_CONTROLPARENT
);
3262 parent
= parent
->GetParent();
3267 // TODO: should generate this event from WM_NCCREATE
3268 wxWindowCreateEvent
event((wxWindow
*)this);
3269 (void)GetEventHandler()->ProcessEvent(event
);
3276 bool wxWindowMSW::HandleDestroy()
3280 // delete our drop target if we've got one
3281 #if wxUSE_DRAG_AND_DROP
3282 if ( m_dropTarget
!= NULL
)
3284 m_dropTarget
->Revoke(m_hWnd
);
3286 delete m_dropTarget
;
3287 m_dropTarget
= NULL
;
3289 #endif // wxUSE_DRAG_AND_DROP
3291 // WM_DESTROY handled
3295 // ---------------------------------------------------------------------------
3297 // ---------------------------------------------------------------------------
3299 bool wxWindowMSW::HandleActivate(int state
,
3300 bool WXUNUSED(minimized
),
3301 WXHWND
WXUNUSED(activate
))
3303 wxActivateEvent
event(wxEVT_ACTIVATE
,
3304 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3306 event
.SetEventObject(this);
3308 return GetEventHandler()->ProcessEvent(event
);
3311 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3313 // notify the parent keeping track of focus for the kbd navigation
3314 // purposes that we got it
3315 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3316 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3322 m_caret
->OnSetFocus();
3324 #endif // wxUSE_CARET
3327 // If it's a wxTextCtrl don't send the event as it will be done
3328 // after the control gets to process it from EN_FOCUS handler
3329 if ( wxDynamicCastThis(wxTextCtrl
) )
3333 #endif // wxUSE_TEXTCTRL
3335 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3336 event
.SetEventObject(this);
3338 // wxFindWinFromHandle() may return NULL, it is ok
3339 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3341 return GetEventHandler()->ProcessEvent(event
);
3344 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3350 m_caret
->OnKillFocus();
3352 #endif // wxUSE_CARET
3355 // If it's a wxTextCtrl don't send the event as it will be done
3356 // after the control gets to process it.
3357 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3364 // Don't send the event when in the process of being deleted. This can
3365 // only cause problems if the event handler tries to access the object.
3366 if ( m_isBeingDeleted
)
3371 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3372 event
.SetEventObject(this);
3374 // wxFindWinFromHandle() may return NULL, it is ok
3375 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3377 return GetEventHandler()->ProcessEvent(event
);
3380 // ---------------------------------------------------------------------------
3382 // ---------------------------------------------------------------------------
3384 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3386 wxShowEvent
event(GetId(), show
);
3387 event
.m_eventObject
= this;
3389 return GetEventHandler()->ProcessEvent(event
);
3392 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3394 wxInitDialogEvent
event(GetId());
3395 event
.m_eventObject
= this;
3397 return GetEventHandler()->ProcessEvent(event
);
3400 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3402 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3404 #else // __WXMICROWIN__
3405 HDROP hFilesInfo
= (HDROP
) wParam
;
3407 // Get the total number of files dropped
3408 UINT gwFilesDropped
= ::DragQueryFile
3416 wxString
*files
= new wxString
[gwFilesDropped
];
3417 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3419 // first get the needed buffer length (+1 for terminating NUL)
3420 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3422 // and now get the file name
3423 ::DragQueryFile(hFilesInfo
, wIndex
,
3424 wxStringBuffer(files
[wIndex
], len
), len
);
3426 DragFinish (hFilesInfo
);
3428 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3429 event
.m_eventObject
= this;
3432 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3433 event
.m_pos
.x
= dropPoint
.x
;
3434 event
.m_pos
.y
= dropPoint
.y
;
3436 return GetEventHandler()->ProcessEvent(event
);
3441 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3443 int WXUNUSED(mouseMsg
))
3445 #ifndef __WXMICROWIN__
3446 // the logic is as follows:
3447 // -1. don't set cursor for non client area, including but not limited to
3448 // the title bar, scrollbars, &c
3449 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3450 // 1. if we have the cursor set it unless wxIsBusy()
3451 // 2. if we're a top level window, set some cursor anyhow
3452 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3454 if ( nHitTest
!= HTCLIENT
)
3459 HCURSOR hcursor
= 0;
3461 // first ask the user code - it may wish to set the cursor in some very
3462 // specific way (for example, depending on the current position)
3464 if ( !::GetCursorPos(&pt
) )
3466 wxLogLastError(wxT("GetCursorPos"));
3471 ScreenToClient(&x
, &y
);
3472 wxSetCursorEvent
event(x
, y
);
3474 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3475 if ( processedEvtSetCursor
&& event
.HasCursor() )
3477 hcursor
= GetHcursorOf(event
.GetCursor());
3482 bool isBusy
= wxIsBusy();
3484 // the test for processedEvtSetCursor is here to prevent using m_cursor
3485 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3486 // it - this is a way to say that our cursor shouldn't be used for this
3488 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3490 hcursor
= GetHcursorOf(m_cursor
);
3497 hcursor
= wxGetCurrentBusyCursor();
3499 else if ( !hcursor
)
3501 const wxCursor
*cursor
= wxGetGlobalCursor();
3502 if ( cursor
&& cursor
->Ok() )
3504 hcursor
= GetHcursorOf(*cursor
);
3512 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3514 ::SetCursor(hcursor
);
3516 // cursor set, stop here
3519 #endif // __WXMICROWIN__
3521 // pass up the window chain
3525 // ---------------------------------------------------------------------------
3526 // owner drawn stuff
3527 // ---------------------------------------------------------------------------
3529 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3530 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3531 #define WXUNUSED_UNLESS_ODRAWN(param) param
3533 #define WXUNUSED_UNLESS_ODRAWN(param)
3537 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3538 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3540 #if wxUSE_OWNER_DRAWN
3542 #if wxUSE_MENUS_NATIVE
3543 // is it a menu item?
3544 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3545 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3547 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3549 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3551 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3552 // the DC from being released
3553 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3554 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3555 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3556 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3558 return pMenuItem
->OnDrawItem
3562 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3563 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3566 #endif // wxUSE_MENUS_NATIVE
3568 #endif // USE_OWNER_DRAWN
3570 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3572 #if wxUSE_OWNER_DRAWN
3573 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3574 #else // !wxUSE_OWNER_DRAWN
3575 // we may still have owner-drawn buttons internally because we have to make
3576 // them owner-drawn to support colour change
3577 wxControl
*item
= wxDynamicCast(FindItem(id
), wxButton
);
3578 #endif // USE_OWNER_DRAWN
3582 return item
->MSWOnDraw(itemStruct
);
3585 #endif // wxUSE_CONTROLS
3591 wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3592 WXMEASUREITEMSTRUCT
*
3593 WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3595 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3596 // is it a menu item?
3597 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3598 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3600 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3602 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3604 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3605 &pMeasureStruct
->itemHeight
);
3608 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3611 return item
->MSWOnMeasure(itemStruct
);
3613 #endif // wxUSE_OWNER_DRAWN
3618 // ---------------------------------------------------------------------------
3619 // colours and palettes
3620 // ---------------------------------------------------------------------------
3622 bool wxWindowMSW::HandleSysColorChange()
3624 wxSysColourChangedEvent event
;
3625 event
.SetEventObject(this);
3627 (void)GetEventHandler()->ProcessEvent(event
);
3629 // always let the system carry on the default processing to allow the
3630 // native controls to react to the colours update
3634 bool wxWindowMSW::HandleDisplayChange()
3636 wxDisplayChangedEvent event
;
3637 event
.SetEventObject(this);
3639 return GetEventHandler()->ProcessEvent(event
);
3642 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3650 #ifndef __WXMICROWIN__
3651 WXHBRUSH hBrush
= 0;
3656 if ( nCtlColor
== CTLCOLOR_DLG
)
3659 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3664 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3666 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3668 #endif // wxUSE_CONTROLS
3674 #else // __WXMICROWIN__
3679 // Define for each class of dialog and control
3680 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3681 WXHWND
WXUNUSED(hWnd
),
3682 WXUINT
WXUNUSED(nCtlColor
),
3683 WXUINT
WXUNUSED(message
),
3684 WXWPARAM
WXUNUSED(wParam
),
3685 WXLPARAM
WXUNUSED(lParam
))
3690 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3693 // same as below except we don't respond to our own messages
3694 if ( hWndPalChange
!= GetHWND() )
3696 // check to see if we our our parents have a custom palette
3697 wxWindowMSW
*win
= this;
3698 while ( win
&& !win
->HasCustomPalette() )
3700 win
= win
->GetParent();
3703 if ( win
&& win
->HasCustomPalette() )
3705 // realize the palette to see whether redrawing is needed
3706 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3707 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3708 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3710 int result
= ::RealizePalette(hdc
);
3712 // restore the palette (before releasing the DC)
3713 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3714 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3715 ::RealizePalette(hdc
);
3716 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3718 // now check for the need to redraw
3720 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3724 #endif // wxUSE_PALETTE
3726 wxPaletteChangedEvent
event(GetId());
3727 event
.SetEventObject(this);
3728 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3730 return GetEventHandler()->ProcessEvent(event
);
3733 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3735 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3736 event
.SetEventObject(this);
3738 return GetEventHandler()->ProcessEvent(event
);
3741 bool wxWindowMSW::HandleQueryNewPalette()
3745 // check to see if we our our parents have a custom palette
3746 wxWindowMSW
*win
= this;
3747 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3748 if (win
->HasCustomPalette()) {
3749 /* realize the palette to see whether redrawing is needed */
3750 HDC hdc
= GetDC((HWND
) GetHWND());
3751 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3752 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3754 int result
= ::RealizePalette(hdc
);
3755 /* restore the palette (before releasing the DC) */
3756 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3757 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3758 ::RealizePalette(hdc
);
3759 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3760 /* now check for the need to redraw */
3762 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3764 #endif // wxUSE_PALETTE
3766 wxQueryNewPaletteEvent
event(GetId());
3767 event
.SetEventObject(this);
3769 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3772 // Responds to colour changes: passes event on to children.
3773 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3775 // the top level window also reset the standard colour map as it might have
3776 // changed (there is no need to do it for the non top level windows as we
3777 // only have to do it once)
3781 gs_hasStdCmap
= FALSE
;
3783 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3786 // Only propagate to non-top-level windows because Windows already
3787 // sends this event to all top-level ones
3788 wxWindow
*win
= node
->GetData();
3789 if ( !win
->IsTopLevel() )
3791 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3792 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3793 // the standard controls
3794 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3797 node
= node
->GetNext();
3800 // update the colours we use if they were not set explicitly by the user:
3801 // this must be done or OnCtlColor() would continue to use the old colours
3804 m_foregroundColour
= wxSystemSettings::
3805 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3810 m_backgroundColour
= wxSystemSettings::
3811 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3815 extern wxCOLORMAP
*wxGetStdColourMap()
3817 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3818 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3820 if ( !gs_hasStdCmap
)
3822 static bool s_coloursInit
= FALSE
;
3824 if ( !s_coloursInit
)
3826 // When a bitmap is loaded, the RGB values can change (apparently
3827 // because Windows adjusts them to care for the old programs always
3828 // using 0xc0c0c0 while the transparent colour for the new Windows
3829 // versions is different). But we do this adjustment ourselves so
3830 // we want to avoid Windows' "help" and for this we need to have a
3831 // reference bitmap which can tell us what the RGB values change
3833 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3834 if ( stdColourBitmap
.Ok() )
3836 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3837 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3838 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3841 memDC
.SelectObject(stdColourBitmap
);
3844 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3846 memDC
.GetPixel(i
, 0, &colour
);
3847 s_stdColours
[i
] = wxColourToRGB(colour
);
3850 else // wxBITMAP_STD_COLOURS couldn't be loaded
3852 s_stdColours
[0] = RGB(000,000,000); // black
3853 s_stdColours
[1] = RGB(128,128,128); // dark grey
3854 s_stdColours
[2] = RGB(192,192,192); // light grey
3855 s_stdColours
[3] = RGB(255,255,255); // white
3856 //s_stdColours[4] = RGB(000,000,255); // blue
3857 //s_stdColours[5] = RGB(255,000,255); // magenta
3860 s_coloursInit
= TRUE
;
3863 gs_hasStdCmap
= TRUE
;
3865 // create the colour map
3866 #define INIT_CMAP_ENTRY(col) \
3867 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3868 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3870 INIT_CMAP_ENTRY(BTNTEXT
);
3871 INIT_CMAP_ENTRY(BTNSHADOW
);
3872 INIT_CMAP_ENTRY(BTNFACE
);
3873 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3875 #undef INIT_CMAP_ENTRY
3881 // ---------------------------------------------------------------------------
3883 // ---------------------------------------------------------------------------
3885 bool wxWindowMSW::HandlePaint()
3887 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3890 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3892 wxLogLastError(wxT("CreateRectRgn"));
3893 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3894 wxLogLastError(wxT("GetUpdateRgn"));
3896 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3898 wxPaintEvent
event(m_windowId
);
3899 event
.SetEventObject(this);
3901 bool processed
= GetEventHandler()->ProcessEvent(event
);
3903 // note that we must generate NC event after the normal one as otherwise
3904 // BeginPaint() will happily overwrite our decorations with the background
3906 wxNcPaintEvent
eventNc(m_windowId
);
3907 eventNc
.SetEventObject(this);
3908 GetEventHandler()->ProcessEvent(eventNc
);
3913 // Can be called from an application's OnPaint handler
3914 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3916 #ifdef __WXUNIVERSAL__
3919 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3922 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3927 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3929 // Prevents flicker when dragging
3930 if ( ::IsIconic(GetHwnd()) )
3934 if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3939 if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3941 if (wxUxThemeEngine::Get())
3943 WXHTHEME hTheme
= wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L
"TAB");
3947 ::GetClientRect((HWND
) GetHWND(), (RECT
*) & rect
);
3948 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme
, hdc
, 10 /* TABP_BODY */, 0, &rect
, &rect
);
3949 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme
);
3959 dc
.SetWindow((wxWindow
*)this);
3962 wxEraseEvent
event(m_windowId
, &dc
);
3963 event
.SetEventObject(this);
3964 bool rc
= GetEventHandler()->ProcessEvent(event
);
3968 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3969 dc
.SelectOldObjects(hdc
);
3974 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3977 ::GetClientRect(GetHwnd(), &rect
);
3979 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3980 m_backgroundColour
.Green(),
3981 m_backgroundColour
.Blue());
3982 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3984 wxLogLastError(wxT("CreateSolidBrush"));
3986 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
3989 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
3992 ::FillRect(hdc
, &rect
, hBrush
);
3993 ::DeleteObject(hBrush
);
3996 ::SetMapMode(hdc
, mode
);
4000 // ---------------------------------------------------------------------------
4001 // moving and resizing
4002 // ---------------------------------------------------------------------------
4004 bool wxWindowMSW::HandleMinimize()
4006 wxIconizeEvent
event(m_windowId
);
4007 event
.SetEventObject(this);
4009 return GetEventHandler()->ProcessEvent(event
);
4012 bool wxWindowMSW::HandleMaximize()
4014 wxMaximizeEvent
event(m_windowId
);
4015 event
.SetEventObject(this);
4017 return GetEventHandler()->ProcessEvent(event
);
4020 bool wxWindowMSW::HandleMove(int x
, int y
)
4022 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
4023 event
.SetEventObject(this);
4025 return GetEventHandler()->ProcessEvent(event
);
4028 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4030 wxMoveEvent
event(rect
, m_windowId
);
4031 event
.SetEventObject(this);
4033 bool rc
= GetEventHandler()->ProcessEvent(event
);
4035 rect
= event
.GetRect();
4039 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
4040 WXUINT
WXUNUSED(flag
))
4042 // don't use w and h parameters as they specify the client size while
4043 // according to the docs EVT_SIZE handler is supposed to receive the total
4045 wxSizeEvent
event(GetSize(), m_windowId
);
4046 event
.SetEventObject(this);
4048 return GetEventHandler()->ProcessEvent(event
);
4051 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4053 wxSizeEvent
event(rect
, m_windowId
);
4054 event
.SetEventObject(this);
4056 bool rc
= GetEventHandler()->ProcessEvent(event
);
4058 rect
= event
.GetRect();
4062 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
4067 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4071 int minWidth
= GetMinWidth(),
4072 minHeight
= GetMinHeight(),
4073 maxWidth
= GetMaxWidth(),
4074 maxHeight
= GetMaxHeight();
4076 if ( minWidth
!= -1 )
4078 info
->ptMinTrackSize
.x
= minWidth
;
4082 if ( minHeight
!= -1 )
4084 info
->ptMinTrackSize
.y
= minHeight
;
4088 if ( maxWidth
!= -1 )
4090 info
->ptMaxTrackSize
.x
= maxWidth
;
4094 if ( maxHeight
!= -1 )
4096 info
->ptMaxTrackSize
.y
= maxHeight
;
4104 // ---------------------------------------------------------------------------
4106 // ---------------------------------------------------------------------------
4108 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4110 #if wxUSE_MENUS_NATIVE
4111 if ( !cmd
&& wxCurrentPopupMenu
)
4113 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4114 wxCurrentPopupMenu
= NULL
;
4116 return popupMenu
->MSWCommand(cmd
, id
);
4118 #endif // wxUSE_MENUS_NATIVE
4120 wxWindow
*win
= NULL
;
4122 // first try to find it from HWND - this works even with the broken
4123 // programs using the same ids for different controls
4126 win
= wxFindWinFromHandle(control
);
4132 // must cast to a signed type before comparing with other ids!
4133 win
= FindItem((signed short)id
);
4138 return win
->MSWCommand(cmd
, id
);
4141 // the messages sent from the in-place edit control used by the treectrl
4142 // for label editing have id == 0, but they should _not_ be treated as menu
4143 // messages (they are EN_XXX ones, in fact) so don't translate anything
4144 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4147 // If no child window, it may be an accelerator, e.g. for a popup menu
4150 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4151 event
.SetEventObject(this);
4155 return GetEventHandler()->ProcessEvent(event
);
4157 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4160 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4161 // notifications to its parent which we want to reflect back to
4163 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4164 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4167 #endif // wxUSE_SPINCTRL
4172 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4175 // 4 bits are reserved
4176 switch ( wParam
& 0xFFFFFFF0 )
4179 return HandleMaximize();
4182 return HandleMinimize();
4189 // ---------------------------------------------------------------------------
4191 // ---------------------------------------------------------------------------
4193 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4197 // our client coords are not quite the same as Windows ones
4198 wxPoint pt
= GetClientAreaOrigin();
4199 event
.m_x
= x
- pt
.x
;
4200 event
.m_y
= y
- pt
.y
;
4202 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4203 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4204 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4205 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4206 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4207 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4208 // Returns different negative values on WinME and WinNT,
4209 // so simply test for negative value.
4210 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4212 event
.SetTimestamp(s_currentMsg
.time
);
4213 event
.m_eventObject
= this;
4214 event
.SetId(GetId());
4216 #if wxUSE_MOUSEEVENT_HACK
4219 m_lastMouseEvent
= event
.GetEventType();
4220 #endif // wxUSE_MOUSEEVENT_HACK
4223 // Windows doesn't send the mouse events to the static controls (which are
4224 // transparent in the sense that their WM_NCHITTEST handler returns
4225 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4226 // and so we manually check if we don't have a child window under mouse and if
4227 // we do, send the event to it instead of the window Windows had sent WM_XXX
4230 // Notice that this is not done for the mouse move events because this could
4231 // (would?) be too slow, but only for clicks which means that the static texts
4232 // still don't get move, enter nor leave events.
4233 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4235 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4237 // first try to find a non transparent child: this allows us to send events
4238 // to a static text which is inside a static box, for example
4239 POINT pt
= { *x
, *y
};
4240 HWND hwnd
= GetHwndOf(win
),
4244 hwndUnderMouse
= ::ChildWindowFromPoint
4250 hwndUnderMouse
= ::ChildWindowFromPointEx
4260 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4262 // now try any child window at all
4263 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4266 // check that we have a child window which is susceptible to receive mouse
4267 // events: for this it must be shown and enabled
4268 if ( hwndUnderMouse
&&
4269 hwndUnderMouse
!= hwnd
&&
4270 ::IsWindowVisible(hwndUnderMouse
) &&
4271 ::IsWindowEnabled(hwndUnderMouse
) )
4273 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4274 if ( winUnderMouse
)
4276 // translate the mouse coords to the other window coords
4277 win
->ClientToScreen(x
, y
);
4278 winUnderMouse
->ScreenToClient(x
, y
);
4280 win
= winUnderMouse
;
4287 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4289 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4290 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4291 // from the message id and take the value in the table to get wxWin event
4293 static const wxEventType eventsMouse
[] =
4307 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4308 InitMouseEvent(event
, x
, y
, flags
);
4310 return GetEventHandler()->ProcessEvent(event
);
4313 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4315 if ( !m_mouseInWindow
)
4317 // it would be wrong to assume that just because we get a mouse move
4318 // event that the mouse is inside the window: although this is usually
4319 // true, it is not if we had captured the mouse, so we need to check
4320 // the mouse coordinates here
4321 if ( !HasCapture() || IsMouseInWindow() )
4323 // Generate an ENTER event
4324 m_mouseInWindow
= TRUE
;
4326 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4327 InitMouseEvent(event
, x
, y
, flags
);
4329 (void)GetEventHandler()->ProcessEvent(event
);
4333 #if wxUSE_MOUSEEVENT_HACK
4334 // Window gets a click down message followed by a mouse move message even
4335 // if position isn't changed! We want to discard the trailing move event
4336 // if x and y are the same.
4337 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4338 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4339 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4340 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4342 m_lastMouseEvent
= wxEVT_MOTION
;
4346 #endif // wxUSE_MOUSEEVENT_HACK
4348 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4352 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4354 #if wxUSE_MOUSEWHEEL
4355 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4356 InitMouseEvent(event
,
4357 GET_X_LPARAM(lParam
),
4358 GET_Y_LPARAM(lParam
),
4360 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4361 event
.m_wheelDelta
= WHEEL_DELTA
;
4363 static int s_linesPerRotation
= -1;
4364 if ( s_linesPerRotation
== -1 )
4366 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4367 &s_linesPerRotation
, 0))
4369 // this is not supposed to happen
4370 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4372 // the default is 3, so use it if SystemParametersInfo() failed
4373 s_linesPerRotation
= 3;
4377 event
.m_linesPerAction
= s_linesPerRotation
;
4378 return GetEventHandler()->ProcessEvent(event
);
4389 // ---------------------------------------------------------------------------
4390 // keyboard handling
4391 // ---------------------------------------------------------------------------
4393 // create the key event of the given type for the given key - used by
4394 // HandleChar and HandleKeyDown/Up
4395 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4398 WXWPARAM wParam
) const
4400 wxKeyEvent
event(evType
);
4401 event
.SetId(GetId());
4402 event
.m_shiftDown
= wxIsShiftDown();
4403 event
.m_controlDown
= wxIsCtrlDown();
4404 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4406 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4407 event
.m_keyCode
= id
;
4408 event
.m_rawCode
= (wxUint32
) wParam
;
4409 event
.m_rawFlags
= (wxUint32
) lParam
;
4410 event
.SetTimestamp(s_currentMsg
.time
);
4412 // translate the position to client coords
4416 GetWindowRect(GetHwnd(),&rect
);
4426 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4428 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4433 // If 1 -> 26, translate to either special keycode or just set
4434 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4435 // ControlDown() == TRUE.
4437 if ( (id
> 0) && (id
< 27) )
4459 else // we're called from WM_KEYDOWN
4461 id
= wxCharCodeMSWToWX(wParam
);
4464 // it's ASCII and will be processed here only when called from
4465 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4470 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4472 // the alphanumeric keys produced by pressing AltGr+something on European
4473 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4474 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4475 // alphanumeric, so pretend that there are no modifiers at all (the
4476 // KEY_DOWN event would still have the correct modifiers if they're really
4478 if ( event
.m_controlDown
&& event
.m_altDown
&&
4479 (id
>= 32 && id
< 256) )
4481 event
.m_controlDown
=
4482 event
.m_altDown
= FALSE
;
4485 return GetEventHandler()->ProcessEvent(event
);
4488 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4490 int id
= wxCharCodeMSWToWX(wParam
);
4494 // normal ASCII char
4498 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4500 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4501 if ( GetEventHandler()->ProcessEvent(event
) )
4510 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4512 int id
= wxCharCodeMSWToWX(wParam
);
4516 // normal ASCII char
4520 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4522 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4523 if ( GetEventHandler()->ProcessEvent(event
) )
4530 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4532 // FIXME: implement GetMenuItemCount for WinCE, possibly
4533 // in terms of GetMenuItemInfo
4535 const HMENU hmenu
= (HMENU
)lParam
;
4539 mii
.cbSize
= sizeof(MENUITEMINFO
);
4540 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4542 // find if we have this letter in any owner drawn item
4543 const int count
= ::GetMenuItemCount(hmenu
);
4544 for ( int i
= 0; i
< count
; i
++ )
4546 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4548 if ( mii
.fType
== MFT_OWNERDRAW
)
4550 // dwItemData member of the MENUITEMINFO is a
4551 // pointer to the associated wxMenuItem -- see the
4552 // menu creation code
4553 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4555 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4558 if ( *p
== _T('&') )
4560 // this is not the accel char, find the real one
4561 p
= wxStrchr(p
+ 1, _T('&'));
4563 else // got the accel char
4565 // FIXME-UNICODE: this comparison doesn't risk to work
4566 // for non ASCII accelerator characters I'm afraid, but
4568 if ( wxToupper(*p
) == chAccel
)
4574 // this one doesn't match
4581 else // failed to get the menu text?
4583 // it's not fatal, so don't show error, but still log
4585 wxLogLastError(_T("GetMenuItemInfo"));
4592 // ---------------------------------------------------------------------------
4594 // ---------------------------------------------------------------------------
4596 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4600 if ( flags
& JOY_BUTTON1CHG
)
4601 change
= wxJOY_BUTTON1
;
4602 if ( flags
& JOY_BUTTON2CHG
)
4603 change
= wxJOY_BUTTON2
;
4604 if ( flags
& JOY_BUTTON3CHG
)
4605 change
= wxJOY_BUTTON3
;
4606 if ( flags
& JOY_BUTTON4CHG
)
4607 change
= wxJOY_BUTTON4
;
4610 if ( flags
& JOY_BUTTON1
)
4611 buttons
|= wxJOY_BUTTON1
;
4612 if ( flags
& JOY_BUTTON2
)
4613 buttons
|= wxJOY_BUTTON2
;
4614 if ( flags
& JOY_BUTTON3
)
4615 buttons
|= wxJOY_BUTTON3
;
4616 if ( flags
& JOY_BUTTON4
)
4617 buttons
|= wxJOY_BUTTON4
;
4619 // the event ids aren't consecutive so we can't use table based lookup
4621 wxEventType eventType
;
4626 eventType
= wxEVT_JOY_MOVE
;
4631 eventType
= wxEVT_JOY_MOVE
;
4636 eventType
= wxEVT_JOY_ZMOVE
;
4641 eventType
= wxEVT_JOY_ZMOVE
;
4644 case MM_JOY1BUTTONDOWN
:
4646 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4649 case MM_JOY2BUTTONDOWN
:
4651 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4654 case MM_JOY1BUTTONUP
:
4656 eventType
= wxEVT_JOY_BUTTON_UP
;
4659 case MM_JOY2BUTTONUP
:
4661 eventType
= wxEVT_JOY_BUTTON_UP
;
4665 wxFAIL_MSG(wxT("no such joystick event"));
4670 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4671 event
.SetPosition(wxPoint(x
, y
));
4672 event
.SetEventObject(this);
4674 return GetEventHandler()->ProcessEvent(event
);
4680 // ---------------------------------------------------------------------------
4682 // ---------------------------------------------------------------------------
4684 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4685 WXWORD pos
, WXHWND control
)
4689 wxWindow
*child
= wxFindWinFromHandle(control
);
4691 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4694 wxScrollWinEvent event
;
4695 event
.SetPosition(pos
);
4696 event
.SetOrientation(orientation
);
4697 event
.m_eventObject
= this;
4702 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4706 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4710 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4714 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4718 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4722 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4725 case SB_THUMBPOSITION
:
4727 // under Win32, the scrollbar range and position are 32 bit integers,
4728 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4729 // explicitly query the scrollbar for the correct position (this must
4730 // be done only for these two SB_ events as they are the only one
4731 // carrying the scrollbar position)
4733 WinStruct
<SCROLLINFO
> scrollInfo
;
4734 scrollInfo
.fMask
= SIF_TRACKPOS
;
4736 if ( !::GetScrollInfo(GetHwnd(),
4737 orientation
== wxHORIZONTAL
? SB_HORZ
4741 // Not neccessarily an error, if there are no scrollbars yet.
4742 // wxLogLastError(_T("GetScrollInfo"));
4745 event
.SetPosition(scrollInfo
.nTrackPos
);
4748 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4749 ? wxEVT_SCROLLWIN_THUMBRELEASE
4750 : wxEVT_SCROLLWIN_THUMBTRACK
;
4757 return GetEventHandler()->ProcessEvent(event
);
4760 // ===========================================================================
4762 // ===========================================================================
4764 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4767 HDC dc
= ::GetDC((HWND
) wnd
);
4772 // the_font->UseResource();
4773 // the_font->RealizeResource();
4774 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4776 was
= (HFONT
) SelectObject(dc
,fnt
);
4778 GetTextMetrics(dc
, &tm
);
4779 if ( the_font
&& fnt
&& was
)
4781 SelectObject(dc
,was
);
4783 ReleaseDC((HWND
)wnd
, dc
);
4786 *x
= tm
.tmAveCharWidth
;
4788 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4791 // the_font->ReleaseResource();
4794 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4795 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4796 int wxCharCodeMSWToWX(int keySym
)
4801 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4802 case VK_BACK
: id
= WXK_BACK
; break;
4803 case VK_TAB
: id
= WXK_TAB
; break;
4804 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4805 case VK_RETURN
: id
= WXK_RETURN
; break;
4806 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4807 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4808 case VK_MENU
: id
= WXK_MENU
; break;
4809 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4810 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4811 case VK_SPACE
: id
= WXK_SPACE
; break;
4812 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4813 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4814 case VK_NEXT
: id
= WXK_NEXT
; break;
4815 case VK_END
: id
= WXK_END
; break;
4816 case VK_HOME
: id
= WXK_HOME
; break;
4817 case VK_LEFT
: id
= WXK_LEFT
; break;
4818 case VK_UP
: id
= WXK_UP
; break;
4819 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4820 case VK_DOWN
: id
= WXK_DOWN
; break;
4821 case VK_SELECT
: id
= WXK_SELECT
; break;
4822 case VK_PRINT
: id
= WXK_PRINT
; break;
4823 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4824 case VK_INSERT
: id
= WXK_INSERT
; break;
4825 case VK_DELETE
: id
= WXK_DELETE
; break;
4826 case VK_HELP
: id
= WXK_HELP
; break;
4827 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4828 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4829 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4830 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4831 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4832 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4833 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4834 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4835 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4836 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4837 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4838 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4839 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4840 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4841 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4842 case VK_F1
: id
= WXK_F1
; break;
4843 case VK_F2
: id
= WXK_F2
; break;
4844 case VK_F3
: id
= WXK_F3
; break;
4845 case VK_F4
: id
= WXK_F4
; break;
4846 case VK_F5
: id
= WXK_F5
; break;
4847 case VK_F6
: id
= WXK_F6
; break;
4848 case VK_F7
: id
= WXK_F7
; break;
4849 case VK_F8
: id
= WXK_F8
; break;
4850 case VK_F9
: id
= WXK_F9
; break;
4851 case VK_F10
: id
= WXK_F10
; break;
4852 case VK_F11
: id
= WXK_F11
; break;
4853 case VK_F12
: id
= WXK_F12
; break;
4854 case VK_F13
: id
= WXK_F13
; break;
4855 case VK_F14
: id
= WXK_F14
; break;
4856 case VK_F15
: id
= WXK_F15
; break;
4857 case VK_F16
: id
= WXK_F16
; break;
4858 case VK_F17
: id
= WXK_F17
; break;
4859 case VK_F18
: id
= WXK_F18
; break;
4860 case VK_F19
: id
= WXK_F19
; break;
4861 case VK_F20
: id
= WXK_F20
; break;
4862 case VK_F21
: id
= WXK_F21
; break;
4863 case VK_F22
: id
= WXK_F22
; break;
4864 case VK_F23
: id
= WXK_F23
; break;
4865 case VK_F24
: id
= WXK_F24
; break;
4866 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4867 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4869 case VK_OEM_1
: id
= ';'; break;
4870 case VK_OEM_PLUS
: id
= '+'; break;
4871 case VK_OEM_COMMA
: id
= ','; break;
4872 case VK_OEM_MINUS
: id
= '-'; break;
4873 case VK_OEM_PERIOD
: id
= '.'; break;
4874 case VK_OEM_2
: id
= '/'; break;
4875 case VK_OEM_3
: id
= '~'; break;
4876 case VK_OEM_4
: id
= '['; break;
4877 case VK_OEM_5
: id
= '\\'; break;
4878 case VK_OEM_6
: id
= ']'; break;
4879 case VK_OEM_7
: id
= '\''; break;
4882 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4883 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4884 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4885 #endif // VK_APPS defined
4894 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4900 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4901 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4902 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4903 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4904 case WXK_MENU
: keySym
= VK_MENU
; break;
4905 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4906 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4907 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4908 case WXK_END
: keySym
= VK_END
; break;
4909 case WXK_HOME
: keySym
= VK_HOME
; break;
4910 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4911 case WXK_UP
: keySym
= VK_UP
; break;
4912 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4913 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4914 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4915 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4916 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4917 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4918 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4919 case WXK_HELP
: keySym
= VK_HELP
; break;
4920 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4921 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4922 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4923 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4924 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4925 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4926 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4927 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4928 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4929 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4930 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4931 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4932 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4933 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4934 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4935 case WXK_F1
: keySym
= VK_F1
; break;
4936 case WXK_F2
: keySym
= VK_F2
; break;
4937 case WXK_F3
: keySym
= VK_F3
; break;
4938 case WXK_F4
: keySym
= VK_F4
; break;
4939 case WXK_F5
: keySym
= VK_F5
; break;
4940 case WXK_F6
: keySym
= VK_F6
; break;
4941 case WXK_F7
: keySym
= VK_F7
; break;
4942 case WXK_F8
: keySym
= VK_F8
; break;
4943 case WXK_F9
: keySym
= VK_F9
; break;
4944 case WXK_F10
: keySym
= VK_F10
; break;
4945 case WXK_F11
: keySym
= VK_F11
; break;
4946 case WXK_F12
: keySym
= VK_F12
; break;
4947 case WXK_F13
: keySym
= VK_F13
; break;
4948 case WXK_F14
: keySym
= VK_F14
; break;
4949 case WXK_F15
: keySym
= VK_F15
; break;
4950 case WXK_F16
: keySym
= VK_F16
; break;
4951 case WXK_F17
: keySym
= VK_F17
; break;
4952 case WXK_F18
: keySym
= VK_F18
; break;
4953 case WXK_F19
: keySym
= VK_F19
; break;
4954 case WXK_F20
: keySym
= VK_F20
; break;
4955 case WXK_F21
: keySym
= VK_F21
; break;
4956 case WXK_F22
: keySym
= VK_F22
; break;
4957 case WXK_F23
: keySym
= VK_F23
; break;
4958 case WXK_F24
: keySym
= VK_F24
; break;
4959 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4960 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4971 wxWindow
*wxGetActiveWindow()
4973 HWND hWnd
= GetActiveWindow();
4976 return wxFindWinFromHandle((WXHWND
) hWnd
);
4981 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4983 HWND hwnd
= (HWND
)hWnd
;
4985 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4986 // by code in msw/radiobox.cpp), for all the others we just search up the
4988 wxWindow
*win
= (wxWindow
*)NULL
;
4991 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4995 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4996 // wxWindow class which overrides WM_GETDLGCODE processing to
4997 // do it as well, win would be already non NULL
4998 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5000 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
5002 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5003 #endif // wxUSE_RADIOBOX
5005 // spin control text buddy window should be mapped to spin ctrl
5006 // itself so try it too
5007 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5010 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5012 #endif // wxUSE_SPINCTRL
5016 while ( hwnd
&& !win
)
5018 // this is a really ugly hack needed to avoid mistakenly returning the
5019 // parent frame wxWindow for the find/replace modeless dialog HWND -
5020 // this, in turn, is needed to call IsDialogMessage() from
5021 // wxApp::ProcessMessage() as for this we must return NULL from here
5023 // FIXME: this is clearly not the best way to do it but I think we'll
5024 // need to change HWND <-> wxWindow code more heavily than I can
5025 // do it now to fix it
5026 #ifndef __WXMICROWIN__
5027 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5029 // it's a dialog box, don't go upwards
5034 hwnd
= ::GetParent(hwnd
);
5035 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5041 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5043 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5044 // in active frames and dialogs, regardless of where the focus is.
5045 static HHOOK wxTheKeyboardHook
= 0;
5046 static FARPROC wxTheKeyboardHookProc
= 0;
5047 int APIENTRY _EXPORT
5048 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5050 void wxSetKeyboardHook(bool doIt
)
5054 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5055 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5057 GetCurrentThreadId()
5058 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5063 UnhookWindowsHookEx(wxTheKeyboardHook
);
5067 int APIENTRY _EXPORT
5068 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5070 DWORD hiWord
= HIWORD(lParam
);
5071 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5073 int id
= wxCharCodeMSWToWX(wParam
);
5076 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5077 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5078 event
.m_altDown
= TRUE
;
5080 event
.m_eventObject
= NULL
;
5081 event
.m_keyCode
= id
;
5082 event
.m_shiftDown
= wxIsShiftDown();
5083 event
.m_controlDown
= wxIsCtrlDown();
5084 event
.SetTimestamp(s_currentMsg
.time
);
5086 wxWindow
*win
= wxGetActiveWindow();
5087 wxEvtHandler
*handler
;
5090 handler
= win
->GetEventHandler();
5091 event
.SetId(win
->GetId());
5099 if ( handler
&& handler
->ProcessEvent(event
) )
5107 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5110 #endif // !__WXMICROWIN__
5113 const char *wxGetMessageName(int message
)
5117 case 0x0000: return "WM_NULL";
5118 case 0x0001: return "WM_CREATE";
5119 case 0x0002: return "WM_DESTROY";
5120 case 0x0003: return "WM_MOVE";
5121 case 0x0005: return "WM_SIZE";
5122 case 0x0006: return "WM_ACTIVATE";
5123 case 0x0007: return "WM_SETFOCUS";
5124 case 0x0008: return "WM_KILLFOCUS";
5125 case 0x000A: return "WM_ENABLE";
5126 case 0x000B: return "WM_SETREDRAW";
5127 case 0x000C: return "WM_SETTEXT";
5128 case 0x000D: return "WM_GETTEXT";
5129 case 0x000E: return "WM_GETTEXTLENGTH";
5130 case 0x000F: return "WM_PAINT";
5131 case 0x0010: return "WM_CLOSE";
5132 case 0x0011: return "WM_QUERYENDSESSION";
5133 case 0x0012: return "WM_QUIT";
5134 case 0x0013: return "WM_QUERYOPEN";
5135 case 0x0014: return "WM_ERASEBKGND";
5136 case 0x0015: return "WM_SYSCOLORCHANGE";
5137 case 0x0016: return "WM_ENDSESSION";
5138 case 0x0017: return "WM_SYSTEMERROR";
5139 case 0x0018: return "WM_SHOWWINDOW";
5140 case 0x0019: return "WM_CTLCOLOR";
5141 case 0x001A: return "WM_WININICHANGE";
5142 case 0x001B: return "WM_DEVMODECHANGE";
5143 case 0x001C: return "WM_ACTIVATEAPP";
5144 case 0x001D: return "WM_FONTCHANGE";
5145 case 0x001E: return "WM_TIMECHANGE";
5146 case 0x001F: return "WM_CANCELMODE";
5147 case 0x0020: return "WM_SETCURSOR";
5148 case 0x0021: return "WM_MOUSEACTIVATE";
5149 case 0x0022: return "WM_CHILDACTIVATE";
5150 case 0x0023: return "WM_QUEUESYNC";
5151 case 0x0024: return "WM_GETMINMAXINFO";
5152 case 0x0026: return "WM_PAINTICON";
5153 case 0x0027: return "WM_ICONERASEBKGND";
5154 case 0x0028: return "WM_NEXTDLGCTL";
5155 case 0x002A: return "WM_SPOOLERSTATUS";
5156 case 0x002B: return "WM_DRAWITEM";
5157 case 0x002C: return "WM_MEASUREITEM";
5158 case 0x002D: return "WM_DELETEITEM";
5159 case 0x002E: return "WM_VKEYTOITEM";
5160 case 0x002F: return "WM_CHARTOITEM";
5161 case 0x0030: return "WM_SETFONT";
5162 case 0x0031: return "WM_GETFONT";
5163 case 0x0037: return "WM_QUERYDRAGICON";
5164 case 0x0039: return "WM_COMPAREITEM";
5165 case 0x0041: return "WM_COMPACTING";
5166 case 0x0044: return "WM_COMMNOTIFY";
5167 case 0x0046: return "WM_WINDOWPOSCHANGING";
5168 case 0x0047: return "WM_WINDOWPOSCHANGED";
5169 case 0x0048: return "WM_POWER";
5171 case 0x004A: return "WM_COPYDATA";
5172 case 0x004B: return "WM_CANCELJOURNAL";
5173 case 0x004E: return "WM_NOTIFY";
5174 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5175 case 0x0051: return "WM_INPUTLANGCHANGE";
5176 case 0x0052: return "WM_TCARD";
5177 case 0x0053: return "WM_HELP";
5178 case 0x0054: return "WM_USERCHANGED";
5179 case 0x0055: return "WM_NOTIFYFORMAT";
5180 case 0x007B: return "WM_CONTEXTMENU";
5181 case 0x007C: return "WM_STYLECHANGING";
5182 case 0x007D: return "WM_STYLECHANGED";
5183 case 0x007E: return "WM_DISPLAYCHANGE";
5184 case 0x007F: return "WM_GETICON";
5185 case 0x0080: return "WM_SETICON";
5187 case 0x0081: return "WM_NCCREATE";
5188 case 0x0082: return "WM_NCDESTROY";
5189 case 0x0083: return "WM_NCCALCSIZE";
5190 case 0x0084: return "WM_NCHITTEST";
5191 case 0x0085: return "WM_NCPAINT";
5192 case 0x0086: return "WM_NCACTIVATE";
5193 case 0x0087: return "WM_GETDLGCODE";
5194 case 0x00A0: return "WM_NCMOUSEMOVE";
5195 case 0x00A1: return "WM_NCLBUTTONDOWN";
5196 case 0x00A2: return "WM_NCLBUTTONUP";
5197 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5198 case 0x00A4: return "WM_NCRBUTTONDOWN";
5199 case 0x00A5: return "WM_NCRBUTTONUP";
5200 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5201 case 0x00A7: return "WM_NCMBUTTONDOWN";
5202 case 0x00A8: return "WM_NCMBUTTONUP";
5203 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5204 case 0x0100: return "WM_KEYDOWN";
5205 case 0x0101: return "WM_KEYUP";
5206 case 0x0102: return "WM_CHAR";
5207 case 0x0103: return "WM_DEADCHAR";
5208 case 0x0104: return "WM_SYSKEYDOWN";
5209 case 0x0105: return "WM_SYSKEYUP";
5210 case 0x0106: return "WM_SYSCHAR";
5211 case 0x0107: return "WM_SYSDEADCHAR";
5212 case 0x0108: return "WM_KEYLAST";
5214 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5215 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5216 case 0x010F: return "WM_IME_COMPOSITION";
5218 case 0x0110: return "WM_INITDIALOG";
5219 case 0x0111: return "WM_COMMAND";
5220 case 0x0112: return "WM_SYSCOMMAND";
5221 case 0x0113: return "WM_TIMER";
5222 case 0x0114: return "WM_HSCROLL";
5223 case 0x0115: return "WM_VSCROLL";
5224 case 0x0116: return "WM_INITMENU";
5225 case 0x0117: return "WM_INITMENUPOPUP";
5226 case 0x011F: return "WM_MENUSELECT";
5227 case 0x0120: return "WM_MENUCHAR";
5228 case 0x0121: return "WM_ENTERIDLE";
5229 case 0x0200: return "WM_MOUSEMOVE";
5230 case 0x0201: return "WM_LBUTTONDOWN";
5231 case 0x0202: return "WM_LBUTTONUP";
5232 case 0x0203: return "WM_LBUTTONDBLCLK";
5233 case 0x0204: return "WM_RBUTTONDOWN";
5234 case 0x0205: return "WM_RBUTTONUP";
5235 case 0x0206: return "WM_RBUTTONDBLCLK";
5236 case 0x0207: return "WM_MBUTTONDOWN";
5237 case 0x0208: return "WM_MBUTTONUP";
5238 case 0x0209: return "WM_MBUTTONDBLCLK";
5239 case 0x020A: return "WM_MOUSEWHEEL";
5240 case 0x0210: return "WM_PARENTNOTIFY";
5241 case 0x0211: return "WM_ENTERMENULOOP";
5242 case 0x0212: return "WM_EXITMENULOOP";
5244 case 0x0213: return "WM_NEXTMENU";
5245 case 0x0214: return "WM_SIZING";
5246 case 0x0215: return "WM_CAPTURECHANGED";
5247 case 0x0216: return "WM_MOVING";
5248 case 0x0218: return "WM_POWERBROADCAST";
5249 case 0x0219: return "WM_DEVICECHANGE";
5251 case 0x0220: return "WM_MDICREATE";
5252 case 0x0221: return "WM_MDIDESTROY";
5253 case 0x0222: return "WM_MDIACTIVATE";
5254 case 0x0223: return "WM_MDIRESTORE";
5255 case 0x0224: return "WM_MDINEXT";
5256 case 0x0225: return "WM_MDIMAXIMIZE";
5257 case 0x0226: return "WM_MDITILE";
5258 case 0x0227: return "WM_MDICASCADE";
5259 case 0x0228: return "WM_MDIICONARRANGE";
5260 case 0x0229: return "WM_MDIGETACTIVE";
5261 case 0x0230: return "WM_MDISETMENU";
5262 case 0x0233: return "WM_DROPFILES";
5264 case 0x0281: return "WM_IME_SETCONTEXT";
5265 case 0x0282: return "WM_IME_NOTIFY";
5266 case 0x0283: return "WM_IME_CONTROL";
5267 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5268 case 0x0285: return "WM_IME_SELECT";
5269 case 0x0286: return "WM_IME_CHAR";
5270 case 0x0290: return "WM_IME_KEYDOWN";
5271 case 0x0291: return "WM_IME_KEYUP";
5273 case 0x0300: return "WM_CUT";
5274 case 0x0301: return "WM_COPY";
5275 case 0x0302: return "WM_PASTE";
5276 case 0x0303: return "WM_CLEAR";
5277 case 0x0304: return "WM_UNDO";
5278 case 0x0305: return "WM_RENDERFORMAT";
5279 case 0x0306: return "WM_RENDERALLFORMATS";
5280 case 0x0307: return "WM_DESTROYCLIPBOARD";
5281 case 0x0308: return "WM_DRAWCLIPBOARD";
5282 case 0x0309: return "WM_PAINTCLIPBOARD";
5283 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5284 case 0x030B: return "WM_SIZECLIPBOARD";
5285 case 0x030C: return "WM_ASKCBFORMATNAME";
5286 case 0x030D: return "WM_CHANGECBCHAIN";
5287 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5288 case 0x030F: return "WM_QUERYNEWPALETTE";
5289 case 0x0310: return "WM_PALETTEISCHANGING";
5290 case 0x0311: return "WM_PALETTECHANGED";
5292 case 0x0312: return "WM_HOTKEY";
5295 // common controls messages - although they're not strictly speaking
5296 // standard, it's nice to decode them nevertheless
5299 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5300 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5301 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5302 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5303 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5304 case 0x1000 + 5: return "LVM_GETITEMA";
5305 case 0x1000 + 75: return "LVM_GETITEMW";
5306 case 0x1000 + 6: return "LVM_SETITEMA";
5307 case 0x1000 + 76: return "LVM_SETITEMW";
5308 case 0x1000 + 7: return "LVM_INSERTITEMA";
5309 case 0x1000 + 77: return "LVM_INSERTITEMW";
5310 case 0x1000 + 8: return "LVM_DELETEITEM";
5311 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5312 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5313 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5314 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5315 case 0x1000 + 13: return "LVM_FINDITEMA";
5316 case 0x1000 + 83: return "LVM_FINDITEMW";
5317 case 0x1000 + 14: return "LVM_GETITEMRECT";
5318 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5319 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5320 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5321 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5322 case 0x1000 + 18: return "LVM_HITTEST";
5323 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5324 case 0x1000 + 20: return "LVM_SCROLL";
5325 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5326 case 0x1000 + 22: return "LVM_ARRANGE";
5327 case 0x1000 + 23: return "LVM_EDITLABELA";
5328 case 0x1000 + 118: return "LVM_EDITLABELW";
5329 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5330 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5331 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5332 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5333 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5334 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5335 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5336 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5337 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5338 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5339 case 0x1000 + 31: return "LVM_GETHEADER";
5340 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5341 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5342 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5343 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5344 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5345 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5346 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5347 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5348 case 0x1000 + 41: return "LVM_GETORIGIN";
5349 case 0x1000 + 42: return "LVM_UPDATE";
5350 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5351 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5352 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5353 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5354 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5355 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5356 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5357 case 0x1000 + 48: return "LVM_SORTITEMS";
5358 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5359 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5360 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5361 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5362 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5363 case 0x1000 + 53: return "LVM_SETICONSPACING";
5364 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5365 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5366 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5367 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5368 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5369 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5370 case 0x1000 + 60: return "LVM_SETHOTITEM";
5371 case 0x1000 + 61: return "LVM_GETHOTITEM";
5372 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5373 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5374 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5375 case 0x1000 + 65: return "LVM_SETWORKAREA";
5378 case 0x1100 + 0: return "TVM_INSERTITEMA";
5379 case 0x1100 + 50: return "TVM_INSERTITEMW";
5380 case 0x1100 + 1: return "TVM_DELETEITEM";
5381 case 0x1100 + 2: return "TVM_EXPAND";
5382 case 0x1100 + 4: return "TVM_GETITEMRECT";
5383 case 0x1100 + 5: return "TVM_GETCOUNT";
5384 case 0x1100 + 6: return "TVM_GETINDENT";
5385 case 0x1100 + 7: return "TVM_SETINDENT";
5386 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5387 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5388 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5389 case 0x1100 + 11: return "TVM_SELECTITEM";
5390 case 0x1100 + 12: return "TVM_GETITEMA";
5391 case 0x1100 + 62: return "TVM_GETITEMW";
5392 case 0x1100 + 13: return "TVM_SETITEMA";
5393 case 0x1100 + 63: return "TVM_SETITEMW";
5394 case 0x1100 + 14: return "TVM_EDITLABELA";
5395 case 0x1100 + 65: return "TVM_EDITLABELW";
5396 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5397 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5398 case 0x1100 + 17: return "TVM_HITTEST";
5399 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5400 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5401 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5402 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5403 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5404 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5405 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5406 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5407 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5410 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5411 case 0x1200 + 1: return "HDM_INSERTITEMA";
5412 case 0x1200 + 10: return "HDM_INSERTITEMW";
5413 case 0x1200 + 2: return "HDM_DELETEITEM";
5414 case 0x1200 + 3: return "HDM_GETITEMA";
5415 case 0x1200 + 11: return "HDM_GETITEMW";
5416 case 0x1200 + 4: return "HDM_SETITEMA";
5417 case 0x1200 + 12: return "HDM_SETITEMW";
5418 case 0x1200 + 5: return "HDM_LAYOUT";
5419 case 0x1200 + 6: return "HDM_HITTEST";
5420 case 0x1200 + 7: return "HDM_GETITEMRECT";
5421 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5422 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5423 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5424 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5425 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5426 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5427 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5430 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5431 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5432 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5433 case 0x1300 + 5: return "TCM_GETITEMA";
5434 case 0x1300 + 60: return "TCM_GETITEMW";
5435 case 0x1300 + 6: return "TCM_SETITEMA";
5436 case 0x1300 + 61: return "TCM_SETITEMW";
5437 case 0x1300 + 7: return "TCM_INSERTITEMA";
5438 case 0x1300 + 62: return "TCM_INSERTITEMW";
5439 case 0x1300 + 8: return "TCM_DELETEITEM";
5440 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5441 case 0x1300 + 10: return "TCM_GETITEMRECT";
5442 case 0x1300 + 11: return "TCM_GETCURSEL";
5443 case 0x1300 + 12: return "TCM_SETCURSEL";
5444 case 0x1300 + 13: return "TCM_HITTEST";
5445 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5446 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5447 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5448 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5449 case 0x1300 + 43: return "TCM_SETPADDING";
5450 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5451 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5452 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5453 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5454 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5455 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5456 case 0x1300 + 50: return "TCM_DESELECTALL";
5459 case WM_USER
+1: return "TB_ENABLEBUTTON";
5460 case WM_USER
+2: return "TB_CHECKBUTTON";
5461 case WM_USER
+3: return "TB_PRESSBUTTON";
5462 case WM_USER
+4: return "TB_HIDEBUTTON";
5463 case WM_USER
+5: return "TB_INDETERMINATE";
5464 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5465 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5466 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5467 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5468 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5469 case WM_USER
+17: return "TB_SETSTATE";
5470 case WM_USER
+18: return "TB_GETSTATE";
5471 case WM_USER
+19: return "TB_ADDBITMAP";
5472 case WM_USER
+20: return "TB_ADDBUTTONS";
5473 case WM_USER
+21: return "TB_INSERTBUTTON";
5474 case WM_USER
+22: return "TB_DELETEBUTTON";
5475 case WM_USER
+23: return "TB_GETBUTTON";
5476 case WM_USER
+24: return "TB_BUTTONCOUNT";
5477 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5478 case WM_USER
+26: return "TB_SAVERESTOREA";
5479 case WM_USER
+76: return "TB_SAVERESTOREW";
5480 case WM_USER
+27: return "TB_CUSTOMIZE";
5481 case WM_USER
+28: return "TB_ADDSTRINGA";
5482 case WM_USER
+77: return "TB_ADDSTRINGW";
5483 case WM_USER
+29: return "TB_GETITEMRECT";
5484 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5485 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5486 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5487 case WM_USER
+33: return "TB_AUTOSIZE";
5488 case WM_USER
+35: return "TB_GETTOOLTIPS";
5489 case WM_USER
+36: return "TB_SETTOOLTIPS";
5490 case WM_USER
+37: return "TB_SETPARENT";
5491 case WM_USER
+39: return "TB_SETROWS";
5492 case WM_USER
+40: return "TB_GETROWS";
5493 case WM_USER
+42: return "TB_SETCMDID";
5494 case WM_USER
+43: return "TB_CHANGEBITMAP";
5495 case WM_USER
+44: return "TB_GETBITMAP";
5496 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5497 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5498 case WM_USER
+46: return "TB_REPLACEBITMAP";
5499 case WM_USER
+47: return "TB_SETINDENT";
5500 case WM_USER
+48: return "TB_SETIMAGELIST";
5501 case WM_USER
+49: return "TB_GETIMAGELIST";
5502 case WM_USER
+50: return "TB_LOADIMAGES";
5503 case WM_USER
+51: return "TB_GETRECT";
5504 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5505 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5506 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5507 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5508 case WM_USER
+56: return "TB_SETSTYLE";
5509 case WM_USER
+57: return "TB_GETSTYLE";
5510 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5511 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5512 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5513 case WM_USER
+61: return "TB_GETTEXTROWS";
5514 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5517 static char s_szBuf
[128];
5518 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5522 #endif //__WXDEBUG__
5524 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5525 int *x
, int *y
, WPARAM
*flags
)
5527 // construct the key mask
5528 WPARAM
& fwKeys
= *flags
;
5530 fwKeys
= MK_RBUTTON
;
5531 if ( wxIsCtrlDown() )
5532 fwKeys
|= MK_CONTROL
;
5533 if ( wxIsShiftDown() )
5536 // simulate right mouse button click
5537 DWORD dwPos
= ::GetMessagePos();
5538 *x
= GET_X_LPARAM(dwPos
);
5539 *y
= GET_Y_LPARAM(dwPos
);
5541 win
->ScreenToClient(x
, y
);
5544 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5548 HWND hwnd
= GetHwndOf(win
);
5549 HDC hdc
= ::GetDC(hwnd
);
5551 #if !wxDIALOG_UNIT_COMPATIBILITY
5552 // and select the current font into it
5553 HFONT hfont
= GetHfontOf(win
->GetFont());
5556 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5560 // finally retrieve the text metrics from it
5561 GetTextMetrics(hdc
, &tm
);
5563 #if !wxDIALOG_UNIT_COMPATIBILITY
5567 (void)::SelectObject(hdc
, hfont
);
5571 ::ReleaseDC(hwnd
, hdc
);
5576 // Find the wxWindow at the current mouse position, returning the mouse
5578 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5580 pt
= wxGetMousePosition();
5581 return wxFindWindowAtPoint(pt
);
5584 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5589 HWND hWndHit
= ::WindowFromPoint(pt2
);
5591 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5592 HWND hWnd
= hWndHit
;
5594 // Try to find a window with a wxWindow associated with it
5595 while (!win
&& (hWnd
!= 0))
5597 hWnd
= ::GetParent(hWnd
);
5598 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5603 // Get the current mouse position.
5604 wxPoint
wxGetMousePosition()
5607 GetCursorPos( & pt
);
5609 return wxPoint(pt
.x
, pt
.y
);
5614 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5616 UINT win_modifiers
=0;
5617 if ( modifiers
& wxMOD_ALT
)
5618 win_modifiers
|= MOD_ALT
;
5619 if ( modifiers
& wxMOD_SHIFT
)
5620 win_modifiers
|= MOD_SHIFT
;
5621 if ( modifiers
& wxMOD_CONTROL
)
5622 win_modifiers
|= MOD_CONTROL
;
5623 if ( modifiers
& wxMOD_WIN
)
5624 win_modifiers
|= MOD_WIN
;
5626 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5628 wxLogLastError(_T("RegisterHotKey"));
5636 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
5638 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5640 wxLogLastError(_T("UnregisterHotKey"));
5648 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5650 int hotkeyId
= wParam
;
5651 int virtualKey
= HIWORD(lParam
);
5652 int win_modifiers
= LOWORD(lParam
);
5654 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5655 event
.SetId(hotkeyId
);
5656 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5657 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5658 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5659 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5661 return GetEventHandler()->ProcessEvent(event
);
5664 #endif // wxUSE_HOTKEY