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 // ---------------------------------------------------------------------------
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/msw/winundef.h"
34 #include "wx/window.h"
39 #include "wx/dcclient.h"
40 #include "wx/dcmemory.h"
43 #include "wx/layout.h"
44 #include "wx/dialog.h"
46 #include "wx/listbox.h"
47 #include "wx/button.h"
48 #include "wx/msgdlg.h"
49 #include "wx/settings.h"
50 #include "wx/statbox.h"
54 #include "wx/ownerdrw.h"
57 #if wxUSE_DRAG_AND_DROP
61 #if wxUSE_ACCESSIBILITY
62 #include "wx/access.h"
66 #define WM_GETOBJECT 0x003D
69 #define OBJID_CLIENT 0xFFFFFFFC
73 #include "wx/menuitem.h"
76 #include "wx/msw/private.h"
79 #include "wx/tooltip.h"
87 #include "wx/spinctrl.h"
88 #endif // wxUSE_SPINCTRL
93 #include "wx/textctrl.h"
94 #include "wx/notebook.h"
98 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
100 #include <mmsystem.h>
104 #include <windowsx.h>
107 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
109 #include <commctrl.h>
111 #elif !defined(__WXMICROWIN__) // broken compiler
112 #include "wx/msw/gnuwin32/extra.h"
115 #if defined(__GNUG__)
116 #include "wx/msw/missing.h"
119 // ----------------------------------------------------------------------------
120 // standard constants not available with all compilers/headers
121 // ----------------------------------------------------------------------------
123 // This didn't appear in mingw until 2.95.2
125 #define SIF_TRACKPOS 16
129 #ifndef WM_MOUSEWHEEL
130 #define WM_MOUSEWHEEL 0x020A
133 #define WHEEL_DELTA 120
135 #ifndef SPI_GETWHEELSCROLLLINES
136 #define SPI_GETWHEELSCROLLLINES 104
138 #endif // wxUSE_MOUSEWHEEL
141 #define VK_OEM_1 0xBA
142 #define VK_OEM_2 0xBF
143 #define VK_OEM_3 0xC0
144 #define VK_OEM_4 0xDB
145 #define VK_OEM_5 0xDC
146 #define VK_OEM_6 0xDD
147 #define VK_OEM_7 0xDE
151 #define VK_OEM_PLUS 0xBB
152 #define VK_OEM_COMMA 0xBC
153 #define VK_OEM_MINUS 0xBD
154 #define VK_OEM_PERIOD 0xBE
157 // ---------------------------------------------------------------------------
159 // ---------------------------------------------------------------------------
161 // the last Windows message we got (FIXME-MT)
162 extern MSG s_currentMsg
;
164 #if wxUSE_MENUS_NATIVE
165 wxMenu
*wxCurrentPopupMenu
= NULL
;
166 #endif // wxUSE_MENUS_NATIVE
168 extern const wxChar
*wxCanvasClassName
;
170 // true if we had already created the std colour map, used by
171 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
172 static bool gs_hasStdCmap
= FALSE
;
174 // ---------------------------------------------------------------------------
176 // ---------------------------------------------------------------------------
178 // the window proc for all our windows
179 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
180 WPARAM wParam
, LPARAM lParam
);
184 const char *wxGetMessageName(int message
);
187 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
188 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
189 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
191 // this magical function is used to translate VK_APPS key presses to right
193 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
194 int *x
, int *y
, WPARAM
*flags
);
196 // get the text metrics for the current font
197 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
199 // find the window for the mouse event at the specified position
200 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
202 // wrapper around BringWindowToTop() API
203 static inline void wxBringWindowToTop(HWND hwnd
)
205 #ifdef __WXMICROWIN__
206 // It seems that MicroWindows brings the _parent_ of the window to the top,
207 // which can be the wrong one.
209 // activate (set focus to) specified window
213 // raise top level parent to top of z order
214 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
216 wxLogLastError(_T("SetWindowPos"));
220 // ---------------------------------------------------------------------------
222 // ---------------------------------------------------------------------------
224 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
226 #ifdef __WXUNIVERSAL__
227 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
229 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
230 #endif // __WXUNIVERSAL__/__WXMSW__
232 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
233 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
234 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
235 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
236 EVT_IDLE(wxWindowMSW::OnIdle
)
239 // ===========================================================================
241 // ===========================================================================
243 // ---------------------------------------------------------------------------
244 // wxWindow utility functions
245 // ---------------------------------------------------------------------------
247 // Find an item given the MS Windows id
248 wxWindow
*wxWindowMSW::FindItem(long id
) const
251 wxControl
*item
= wxDynamicCastThis(wxControl
);
254 // is it we or one of our "internal" children?
255 if ( item
->GetId() == id
256 #ifndef __WXUNIVERSAL__
257 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
258 #endif // __WXUNIVERSAL__
264 #endif // wxUSE_CONTROLS
266 wxWindowList::Node
*current
= GetChildren().GetFirst();
269 wxWindow
*childWin
= current
->GetData();
271 wxWindow
*wnd
= childWin
->FindItem(id
);
275 current
= current
->GetNext();
281 // Find an item given the MS Windows handle
282 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
284 wxWindowList::Node
*current
= GetChildren().GetFirst();
287 wxWindow
*parent
= current
->GetData();
289 // Do a recursive search.
290 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
296 || parent
->IsKindOf(CLASSINFO(wxControl
))
297 #endif // wxUSE_CONTROLS
300 wxWindow
*item
= current
->GetData();
301 if ( item
->GetHWND() == hWnd
)
305 if ( item
->ContainsHWND(hWnd
) )
310 current
= current
->GetNext();
315 // Default command handler
316 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
321 // ----------------------------------------------------------------------------
322 // constructors and such
323 // ----------------------------------------------------------------------------
325 void wxWindowMSW::Init()
331 m_isBeingDeleted
= FALSE
;
334 m_mouseInWindow
= FALSE
;
335 m_lastKeydownProcessed
= FALSE
;
337 m_childrenDisabled
= NULL
;
346 m_backgroundTransparent
= FALSE
;
348 // as all windows are created with WS_VISIBLE style...
351 #if wxUSE_MOUSEEVENT_HACK
354 m_lastMouseEvent
= -1;
355 #endif // wxUSE_MOUSEEVENT_HACK
359 wxWindowMSW::~wxWindowMSW()
361 m_isBeingDeleted
= TRUE
;
363 #ifndef __WXUNIVERSAL__
364 // VS: make sure there's no wxFrame with last focus set to us:
365 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
367 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
370 if ( frame
->GetLastFocus() == this )
372 frame
->SetLastFocus(NULL
);
377 #endif // __WXUNIVERSAL__
379 // VS: destroy children first and _then_ detach *this from its parent.
380 // If we'd do it the other way around, children wouldn't be able
381 // find their parent frame (see above).
385 m_parent
->RemoveChild(this);
389 // VZ: test temp removed to understand what really happens here
390 //if (::IsWindow(GetHwnd()))
392 if ( !::DestroyWindow(GetHwnd()) )
393 wxLogLastError(wxT("DestroyWindow"));
396 // remove hWnd <-> wxWindow association
397 wxRemoveHandleAssociation(this);
400 delete m_childrenDisabled
;
403 // real construction (Init() must have been called before!)
404 bool wxWindowMSW::Create(wxWindow
*parent
,
409 const wxString
& name
)
411 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
413 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
416 parent
->AddChild(this);
419 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
421 #ifdef __WXUNIVERSAL__
422 // no borders, we draw them ourselves
423 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
427 msflags
&= ~WS_BORDER
;
428 #endif // wxUniversal
430 // all windows are created visible by default except popup ones (which are
431 // like the wxTopLevelWindows in this aspect)
432 if ( style
& wxPOPUP_WINDOW
)
434 msflags
&= ~WS_VISIBLE
;
439 msflags
|= WS_VISIBLE
;
442 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
445 // ---------------------------------------------------------------------------
447 // ---------------------------------------------------------------------------
449 void wxWindowMSW::SetFocus()
451 HWND hWnd
= GetHwnd();
452 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
454 #ifndef __WXMICROWIN__
458 if ( !::SetFocus(hWnd
) )
460 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
461 // was there really an error?
462 DWORD dwRes
= ::GetLastError();
465 HWND hwndFocus
= ::GetFocus();
466 if ( hwndFocus
!= hWnd
)
468 wxLogApiError(_T("SetFocus"), dwRes
);
475 void wxWindowMSW::SetFocusFromKbd()
477 // when the focus is given to the control with DLGC_HASSETSEL style from
478 // keyboard its contents should be entirely selected: this is what
479 // ::IsDialogMessage() does and so we should do it as well to provide the
480 // same LNF as the native programs
481 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
483 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
486 // do this after (maybe) setting the selection as like this when
487 // wxEVT_SET_FOCUS handler is called, the selection would have been already
488 // set correctly -- this may be important
489 wxWindowBase::SetFocusFromKbd();
492 // Get the window with the focus
493 wxWindow
*wxWindowBase::FindFocus()
495 HWND hWnd
= ::GetFocus();
498 return wxGetWindowFromHWND((WXHWND
)hWnd
);
504 bool wxWindowMSW::Enable(bool enable
)
506 if ( !wxWindowBase::Enable(enable
) )
509 HWND hWnd
= GetHwnd();
511 ::EnableWindow(hWnd
, (BOOL
)enable
);
513 // the logic below doesn't apply to the top level windows -- otherwise
514 // showing a modal dialog would result in total greying out (and ungreying
515 // out later) of everything which would be really ugly
519 // when the parent is disabled, all of its children should be disabled as
520 // well but when it is enabled back, only those of the children which
521 // hadn't been already disabled in the beginning should be enabled again,
522 // so we have to keep the list of those children
523 for ( wxWindowList::Node
*node
= GetChildren().GetFirst();
525 node
= node
->GetNext() )
527 wxWindow
*child
= node
->GetData();
528 if ( child
->IsTopLevel() )
530 // the logic below doesn't apply to top level children
536 // enable the child back unless it had been disabled before us
537 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
540 else // we're being disabled
542 if ( child
->IsEnabled() )
544 // disable it as children shouldn't stay enabled while the
548 else // child already disabled, remember it
550 // have we created the list of disabled children already?
551 if ( !m_childrenDisabled
)
552 m_childrenDisabled
= new wxWindowList
;
554 m_childrenDisabled
->Append(child
);
559 if ( enable
&& m_childrenDisabled
)
561 // we don't need this list any more, don't keep unused memory
562 delete m_childrenDisabled
;
563 m_childrenDisabled
= NULL
;
569 bool wxWindowMSW::Show(bool show
)
571 if ( !wxWindowBase::Show(show
) )
574 HWND hWnd
= GetHwnd();
575 int cshow
= show
? SW_SHOW
: SW_HIDE
;
576 ::ShowWindow(hWnd
, cshow
);
578 if ( show
&& IsTopLevel() )
580 wxBringWindowToTop(hWnd
);
586 // Raise the window to the top of the Z order
587 void wxWindowMSW::Raise()
589 wxBringWindowToTop(GetHwnd());
592 // Lower the window to the bottom of the Z order
593 void wxWindowMSW::Lower()
595 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
596 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
599 void wxWindowMSW::SetTitle( const wxString
& title
)
601 SetWindowText(GetHwnd(), title
.c_str());
604 wxString
wxWindowMSW::GetTitle() const
606 return wxGetWindowText(GetHWND());
609 void wxWindowMSW::DoCaptureMouse()
611 HWND hWnd
= GetHwnd();
618 void wxWindowMSW::DoReleaseMouse()
620 if ( !::ReleaseCapture() )
622 wxLogLastError(_T("ReleaseCapture"));
626 /* static */ wxWindow
*wxWindowBase::GetCapture()
628 HWND hwnd
= ::GetCapture();
629 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
632 bool wxWindowMSW::SetFont(const wxFont
& font
)
634 if ( !wxWindowBase::SetFont(font
) )
640 HWND hWnd
= GetHwnd();
643 WXHANDLE hFont
= m_font
.GetResourceHandle();
645 wxASSERT_MSG( hFont
, wxT("should have valid font") );
647 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
652 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
654 if ( !wxWindowBase::SetCursor(cursor
) )
662 HWND hWnd
= GetHwnd();
664 // Change the cursor NOW if we're within the correct window
666 ::GetCursorPos(&point
);
668 RECT rect
= wxGetWindowRect(hWnd
);
670 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
671 ::SetCursor(GetHcursorOf(m_cursor
));
677 void wxWindowMSW::WarpPointer (int x
, int y
)
679 ClientToScreen(&x
, &y
);
681 if ( !::SetCursorPos(x
, y
) )
683 wxLogLastError(_T("SetCursorPos"));
687 #if WXWIN_COMPATIBILITY
688 void wxWindowMSW::MSWDeviceToLogical (float *x
, float *y
) const
691 #endif // WXWIN_COMPATIBILITY
693 // ---------------------------------------------------------------------------
695 // ---------------------------------------------------------------------------
697 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
698 static inline int wxDirToWinStyle(int orient
)
700 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
703 #if WXWIN_COMPATIBILITY
704 void wxWindowMSW::SetScrollRange(int orient
, int range
, bool refresh
)
708 // Try to adjust the range to cope with page size > 1
709 // - a Windows API quirk
710 int pageSize
= GetScrollPage(orient
);
711 if ( pageSize
> 1 && range
> 0)
713 range1
+= (pageSize
- 1);
716 WinStruct
<SCROLLINFO
> info
;
717 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
720 info
.fMask
= SIF_RANGE
| SIF_PAGE
;
722 HWND hWnd
= GetHwnd();
724 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
727 void wxWindowMSW::SetScrollPage(int orient
, int page
, bool refresh
)
729 WinStruct
<SCROLLINFO
> info
;
731 info
.fMask
= SIF_PAGE
;
733 HWND hWnd
= GetHwnd();
735 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
738 int wxWindowMSW::GetScrollPage(int orient
) const
740 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
743 #endif // WXWIN_COMPATIBILITY
745 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
747 #ifdef __WXMICROWIN__
748 return ::GetScrollPosWX(hWnd
, wOrient
);
750 return ::GetScrollPos(hWnd
, wOrient
);
754 int wxWindowMSW::GetScrollPos(int orient
) const
756 HWND hWnd
= GetHwnd();
757 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
759 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
762 // This now returns the whole range, not just the number
763 // of positions that we can scroll.
764 int wxWindowMSW::GetScrollRange(int orient
) const
767 HWND hWnd
= GetHwnd();
771 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
774 // undo "range - 1" done in SetScrollbar()
778 int wxWindowMSW::GetScrollThumb(int orient
) const
780 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
783 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
785 HWND hWnd
= GetHwnd();
786 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
788 WinStruct
<SCROLLINFO
> info
;
792 info
.fMask
= SIF_POS
;
794 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
798 // New function that will replace some of the above.
799 void wxWindowMSW::SetScrollbar(int orient
,
805 WinStruct
<SCROLLINFO
> info
;
806 info
.nPage
= pageSize
;
807 info
.nMin
= 0; // range is nMax - nMin + 1
808 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
810 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
812 HWND hWnd
= GetHwnd();
815 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
819 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
822 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
828 rect
.left
= prect
->x
;
830 rect
.right
= prect
->x
+ prect
->width
;
831 rect
.bottom
= prect
->y
+ prect
->height
;
839 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
842 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
844 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
847 for ( int n
= 0; n
< count
; n
++ )
849 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
851 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
854 // don't bother to continue, we're already at top/bottom
861 return pos
!= posStart
;
864 bool wxWindowMSW::ScrollLines(int lines
)
866 bool down
= lines
> 0;
868 return ScrollVertically(GetHwnd(),
869 down
? SB_LINEDOWN
: SB_LINEUP
,
870 down
? lines
: -lines
);
873 bool wxWindowMSW::ScrollPages(int pages
)
875 bool down
= pages
> 0;
877 return ScrollVertically(GetHwnd(),
878 down
? SB_PAGEDOWN
: SB_PAGEUP
,
879 down
? pages
: -pages
);
882 // ---------------------------------------------------------------------------
884 // ---------------------------------------------------------------------------
886 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
888 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
890 HWND hwnd
= (HWND
)hWnd
;
891 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
893 wxAssociateWinWithHandle(hwnd
, this);
895 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
897 // we don't need to subclass the window of our own class (in the Windows
898 // sense of the word)
899 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
901 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
905 // don't bother restoring it neither: this also makes it easy to
906 // implement IsOfStandardClass() method which returns TRUE for the
907 // standard controls and FALSE for the wxWindows own windows as it can
908 // simply check m_oldWndProc
913 void wxWindowMSW::UnsubclassWin()
915 wxRemoveHandleAssociation(this);
917 // Restore old Window proc
918 HWND hwnd
= GetHwnd();
923 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
927 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
929 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
937 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
939 // Unicows note: the code below works, but only because WNDCLASS contains
940 // original window handler rather that the unicows fake one. This may not
941 // be on purpose, though; if it stops working with future versions of
942 // unicows.dll, we can override unicows hooks by setting
943 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
944 // versions that keep track of fake<->real wnd proc mapping.
946 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
948 wxLogLastError(_T("GetClassInfo"));
953 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
956 // ----------------------------------------------------------------------------
958 // ----------------------------------------------------------------------------
960 void wxWindowMSW::SetWindowStyleFlag(long flags
)
962 long flagsOld
= GetWindowStyleFlag();
963 if ( flags
== flagsOld
)
966 // update the internal variable
967 wxWindowBase::SetWindowStyleFlag(flags
);
969 // now update the Windows style as well if needed - and if the window had
970 // been already created
974 WXDWORD exstyle
, exstyleOld
;
975 long style
= MSWGetStyle(flags
, &exstyle
),
976 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
978 if ( style
!= styleOld
)
980 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
981 // this function so instead of simply setting the style to the new
982 // value we clear the bits which were set in styleOld but are set in
983 // the new one and set the ones which were not set before
984 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
985 styleReal
&= ~styleOld
;
988 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
991 // and the extended style
992 if ( exstyle
!= exstyleOld
)
994 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
995 exstyleReal
&= ~exstyleOld
;
996 exstyleReal
|= exstyle
;
998 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1000 // we must call SetWindowPos() to flash the cached extended style and
1001 // also to make the change to wxSTAY_ON_TOP style take effect: just
1002 // setting the style simply doesn't work
1003 if ( !::SetWindowPos(GetHwnd(),
1004 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1007 SWP_NOMOVE
| SWP_NOSIZE
) )
1009 wxLogLastError(_T("SetWindowPos"));
1014 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1016 // translate the style
1017 WXDWORD style
= WS_CHILD
| WS_VISIBLE
;
1019 if ( flags
& wxCLIP_CHILDREN
)
1020 style
|= WS_CLIPCHILDREN
;
1022 if ( flags
& wxCLIP_SIBLINGS
)
1023 style
|= WS_CLIPSIBLINGS
;
1025 if ( flags
& wxVSCROLL
)
1026 style
|= WS_VSCROLL
;
1028 if ( flags
& wxHSCROLL
)
1029 style
|= WS_HSCROLL
;
1031 const wxBorder border
= GetBorder(flags
);
1033 // WS_BORDER is only required for wxBORDER_SIMPLE
1034 if ( border
== wxBORDER_SIMPLE
)
1037 // now deal with ext style if the caller wants it
1042 if ( flags
& wxTRANSPARENT_WINDOW
)
1043 *exstyle
|= WS_EX_TRANSPARENT
;
1048 case wxBORDER_DEFAULT
:
1049 wxFAIL_MSG( _T("unknown border style") );
1053 case wxBORDER_SIMPLE
:
1056 case wxBORDER_STATIC
:
1057 *exstyle
|= WS_EX_STATICEDGE
;
1060 case wxBORDER_RAISED
:
1061 *exstyle
|= WS_EX_DLGMODALFRAME
;
1064 case wxBORDER_SUNKEN
:
1065 *exstyle
|= WS_EX_CLIENTEDGE
;
1066 style
&= ~WS_BORDER
;
1069 case wxBORDER_DOUBLE
:
1070 *exstyle
|= WS_EX_DLGMODALFRAME
;
1074 // wxUniv doesn't use Windows dialog navigation functions at all
1075 #ifndef __WXUNIVERSAL__
1076 // to make the dialog navigation work with the nested panels we must
1077 // use this style (top level windows such as dialogs don't need it)
1078 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1080 *exstyle
|= WS_EX_CONTROLPARENT
;
1082 #endif // __WXUNIVERSAL__
1088 #if WXWIN_COMPATIBILITY
1089 // If nothing defined for this, try the parent.
1090 // E.g. we may be a button loaded from a resource, with no callback function
1092 void wxWindowMSW::OnCommand(wxWindow
& win
, wxCommandEvent
& event
)
1094 if ( GetEventHandler()->ProcessEvent(event
) )
1097 m_parent
->GetEventHandler()->OnCommand(win
, event
);
1099 #endif // WXWIN_COMPATIBILITY_2
1101 #if WXWIN_COMPATIBILITY
1102 wxObject
* wxWindowMSW::GetChild(int number
) const
1104 // Return a pointer to the Nth object in the Panel
1105 wxNode
*node
= GetChildren().First();
1108 node
= node
->Next();
1111 wxObject
*obj
= (wxObject
*)node
->Data();
1117 #endif // WXWIN_COMPATIBILITY
1119 // Setup background and foreground colours correctly
1120 void wxWindowMSW::SetupColours()
1123 SetBackgroundColour(GetParent()->GetBackgroundColour());
1126 bool wxWindowMSW::IsMouseInWindow() const
1128 // get the mouse position
1130 ::GetCursorPos(&pt
);
1132 // find the window which currently has the cursor and go up the window
1133 // chain until we find this window - or exhaust it
1134 HWND hwnd
= ::WindowFromPoint(pt
);
1135 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1136 hwnd
= ::GetParent(hwnd
);
1138 return hwnd
!= NULL
;
1141 void wxWindowMSW::OnIdle(wxIdleEvent
& WXUNUSED(event
))
1143 // Check if we need to send a LEAVE event
1144 if ( m_mouseInWindow
)
1146 // note that we should generate the leave event whether the window has
1147 // or doesn't have mouse capture
1148 if ( !IsMouseInWindow() )
1150 // Generate a LEAVE event
1151 m_mouseInWindow
= FALSE
;
1153 // Unfortunately the mouse button and keyboard state may have
1154 // changed by the time the OnIdle function is called, so 'state'
1155 // may be meaningless.
1157 if ( wxIsShiftDown() )
1159 if ( wxIsCtrlDown() )
1160 state
|= MK_CONTROL
;
1161 if ( GetKeyState( VK_LBUTTON
) )
1162 state
|= MK_LBUTTON
;
1163 if ( GetKeyState( VK_MBUTTON
) )
1164 state
|= MK_MBUTTON
;
1165 if ( GetKeyState( VK_RBUTTON
) )
1166 state
|= MK_RBUTTON
;
1169 if ( !::GetCursorPos(&pt
) )
1171 wxLogLastError(_T("GetCursorPos"));
1174 // we need to have client coordinates here for symmetry with
1175 // wxEVT_ENTER_WINDOW
1176 RECT rect
= wxGetWindowRect(GetHwnd());
1180 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1181 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1183 (void)GetEventHandler()->ProcessEvent(event2
);
1187 if (wxUpdateUIEvent::CanUpdate())
1191 // Set this window to be the child of 'parent'.
1192 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1194 if ( !wxWindowBase::Reparent(parent
) )
1197 HWND hWndChild
= GetHwnd();
1198 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1200 ::SetParent(hWndChild
, hWndParent
);
1205 void wxWindowMSW::Clear()
1207 wxClientDC
dc((wxWindow
*)this);
1208 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1209 dc
.SetBackground(brush
);
1213 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1215 #ifndef __WXMICROWIN__
1216 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1220 void wxWindowMSW::Freeze()
1222 SendSetRedraw(GetHwnd(), FALSE
);
1225 void wxWindowMSW::Thaw()
1227 SendSetRedraw(GetHwnd(), TRUE
);
1229 // we need to refresh everything or otherwise he invalidated area is not
1234 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1236 HWND hWnd
= GetHwnd();
1242 mswRect
.left
= rect
->x
;
1243 mswRect
.top
= rect
->y
;
1244 mswRect
.right
= rect
->x
+ rect
->width
;
1245 mswRect
.bottom
= rect
->y
+ rect
->height
;
1247 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1250 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1254 void wxWindowMSW::Update()
1256 if ( !::UpdateWindow(GetHwnd()) )
1258 wxLogLastError(_T("UpdateWindow"));
1261 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1262 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1263 // handler needs to be really drawn right now
1268 // ---------------------------------------------------------------------------
1270 // ---------------------------------------------------------------------------
1273 #if wxUSE_DRAG_AND_DROP
1274 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1276 if ( m_dropTarget
!= 0 ) {
1277 m_dropTarget
->Revoke(m_hWnd
);
1278 delete m_dropTarget
;
1281 m_dropTarget
= pDropTarget
;
1282 if ( m_dropTarget
!= 0 )
1283 m_dropTarget
->Register(m_hWnd
);
1285 #endif // wxUSE_DRAG_AND_DROP
1287 // old style file-manager drag&drop support: we retain the old-style
1288 // DragAcceptFiles in parallel with SetDropTarget.
1289 void wxWindowMSW::DragAcceptFiles(bool accept
)
1291 HWND hWnd
= GetHwnd();
1293 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1296 // ----------------------------------------------------------------------------
1298 // ----------------------------------------------------------------------------
1302 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1304 wxWindowBase::DoSetToolTip(tooltip
);
1307 m_tooltip
->SetWindow((wxWindow
*)this);
1310 #endif // wxUSE_TOOLTIPS
1312 // ---------------------------------------------------------------------------
1313 // moving and resizing
1314 // ---------------------------------------------------------------------------
1317 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1319 RECT rect
= wxGetWindowRect(GetHwnd());
1322 *x
= rect
.right
- rect
.left
;
1324 *y
= rect
.bottom
- rect
.top
;
1327 // Get size *available for subwindows* i.e. excluding menu bar etc.
1328 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1330 RECT rect
= wxGetClientRect(GetHwnd());
1338 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1340 RECT rect
= wxGetWindowRect(GetHwnd());
1343 point
.x
= rect
.left
;
1346 // we do the adjustments with respect to the parent only for the "real"
1347 // children, not for the dialogs/frames
1348 if ( !IsTopLevel() )
1350 HWND hParentWnd
= 0;
1351 wxWindow
*parent
= GetParent();
1353 hParentWnd
= GetWinHwnd(parent
);
1355 // Since we now have the absolute screen coords, if there's a parent we
1356 // must subtract its top left corner
1359 ::ScreenToClient(hParentWnd
, &point
);
1364 // We may be faking the client origin. So a window that's really at (0,
1365 // 30) may appear (to wxWin apps) to be at (0, 0).
1366 wxPoint
pt(parent
->GetClientAreaOrigin());
1378 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1386 ::ScreenToClient(GetHwnd(), &pt
);
1394 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1402 ::ClientToScreen(GetHwnd(), &pt
);
1410 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1412 // TODO: is this consistent with other platforms?
1413 // Still, negative width or height shouldn't be allowed
1418 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1420 wxLogLastError(wxT("MoveWindow"));
1424 // set the size of the window: if the dimensions are positive, just use them,
1425 // but if any of them is equal to -1, it means that we must find the value for
1426 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1427 // which case -1 is a valid value for x and y)
1429 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1430 // the width/height to best suit our contents, otherwise we reuse the current
1432 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1434 // get the current size and position...
1435 int currentX
, currentY
;
1436 GetPosition(¤tX
, ¤tY
);
1437 int currentW
,currentH
;
1438 GetSize(¤tW
, ¤tH
);
1440 // ... and don't do anything (avoiding flicker) if it's already ok
1441 if ( x
== currentX
&& y
== currentY
&&
1442 width
== currentW
&& height
== currentH
)
1447 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1449 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1452 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1454 wxSize
size(-1, -1);
1457 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1459 size
= DoGetBestSize();
1464 // just take the current one
1471 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1475 size
= DoGetBestSize();
1477 //else: already called DoGetBestSize() above
1483 // just take the current one
1488 DoMoveWindow(x
, y
, width
, height
);
1491 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1493 // setting the client size is less obvious than it it could have been
1494 // because in the result of changing the total size the window scrollbar
1495 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1496 // will not be correct as the difference between the total and client size
1497 // changes - so we keep changing it until we get it right
1499 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1500 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1501 // may become 3 if the window had 0 size originally and so we didn't
1502 // calculate the scrollbar correction correctly during the first iteration)
1503 // but just to be on the safe side we check for it instead of making it an
1504 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1505 for ( int i
= 0; i
< 4; i
++ )
1508 ::GetClientRect(GetHwnd(), &rectClient
);
1510 // if the size is already ok, stop here (rectClient.left = top = 0)
1511 if ( (rectClient
.right
== width
|| width
== -1) &&
1512 (rectClient
.bottom
== height
|| height
== -1) )
1517 int widthClient
= width
,
1518 heightClient
= height
;
1520 // Find the difference between the entire window (title bar and all)
1521 // and the client area; add this to the new client size to move the
1524 ::GetWindowRect(GetHwnd(), &rectWin
);
1526 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1527 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1530 point
.x
= rectWin
.left
;
1531 point
.y
= rectWin
.top
;
1533 // MoveWindow positions the child windows relative to the parent, so
1534 // adjust if necessary
1535 if ( !IsTopLevel() )
1537 wxWindow
*parent
= GetParent();
1540 ::ScreenToClient(GetHwndOf(parent
), &point
);
1544 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1548 // For implementation purposes - sometimes decorations make the client area
1550 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1552 return wxPoint(0, 0);
1555 // ---------------------------------------------------------------------------
1557 // ---------------------------------------------------------------------------
1559 int wxWindowMSW::GetCharHeight() const
1561 return wxGetTextMetrics(this).tmHeight
;
1564 int wxWindowMSW::GetCharWidth() const
1566 // +1 is needed because Windows apparently adds it when calculating the
1567 // dialog units size in pixels
1568 #if wxDIALOG_UNIT_COMPATIBILITY
1569 return wxGetTextMetrics(this).tmAveCharWidth
;
1571 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1575 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1577 int *descent
, int *externalLeading
,
1578 const wxFont
*theFont
) const
1580 const wxFont
*fontToUse
= theFont
;
1582 fontToUse
= &m_font
;
1584 HWND hWnd
= GetHwnd();
1585 HDC dc
= ::GetDC(hWnd
);
1589 if ( fontToUse
&& fontToUse
->Ok() )
1591 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1593 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1598 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1599 GetTextMetrics(dc
, &tm
);
1601 if ( fontToUse
&& fnt
&& hfontOld
)
1602 SelectObject(dc
, hfontOld
);
1604 ReleaseDC(hWnd
, dc
);
1611 *descent
= tm
.tmDescent
;
1612 if ( externalLeading
)
1613 *externalLeading
= tm
.tmExternalLeading
;
1616 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1617 // ---------------------------------------------------------------------------
1618 // Caret manipulation
1619 // ---------------------------------------------------------------------------
1621 void wxWindowMSW::CreateCaret(int w
, int h
)
1623 SetCaret(new wxCaret(this, w
, h
));
1626 void wxWindowMSW::CreateCaret(const wxBitmap
*WXUNUSED(bitmap
))
1628 wxFAIL_MSG("not implemented");
1631 void wxWindowMSW::ShowCaret(bool show
)
1633 wxCHECK_RET( m_caret
, "no caret to show" );
1635 m_caret
->Show(show
);
1638 void wxWindowMSW::DestroyCaret()
1643 void wxWindowMSW::SetCaretPos(int x
, int y
)
1645 wxCHECK_RET( m_caret
, "no caret to move" );
1647 m_caret
->Move(x
, y
);
1650 void wxWindowMSW::GetCaretPos(int *x
, int *y
) const
1652 wxCHECK_RET( m_caret
, "no caret to get position of" );
1654 m_caret
->GetPosition(x
, y
);
1656 #endif // wxUSE_CARET
1658 // ---------------------------------------------------------------------------
1660 // ---------------------------------------------------------------------------
1662 #if wxUSE_MENUS_NATIVE
1664 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1665 // immediately, without waiting for the next event loop iteration
1667 // NB: this function should probably be made public later as it can almost
1668 // surely replace wxYield() elsewhere as well
1669 static void wxYieldForCommandsOnly()
1671 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1672 // want to process it here)
1674 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1675 && msg
.message
!= WM_QUIT
)
1677 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1680 // If we retrieved a WM_QUIT, insert back into the message queue.
1681 if (msg
.message
== WM_QUIT
)
1682 ::PostQuitMessage(0);
1685 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1687 menu
->SetInvokingWindow(this);
1690 HWND hWnd
= GetHwnd();
1691 HMENU hMenu
= GetHmenuOf(menu
);
1695 ::ClientToScreen(hWnd
, &point
);
1696 wxCurrentPopupMenu
= menu
;
1697 ::TrackPopupMenu(hMenu
, TPM_RIGHTBUTTON
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1699 // we need to do it righ now as otherwise the events are never going to be
1700 // sent to wxCurrentPopupMenu from HandleCommand()
1702 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1703 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1704 // destroyed as soon as we return (it can be a local variable in the caller
1705 // for example) and so we do need to process the event immediately
1706 wxYieldForCommandsOnly();
1708 wxCurrentPopupMenu
= NULL
;
1710 menu
->SetInvokingWindow(NULL
);
1715 #endif // wxUSE_MENUS_NATIVE
1717 // ===========================================================================
1718 // pre/post message processing
1719 // ===========================================================================
1721 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1724 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1726 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1729 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1731 // wxUniversal implements tab traversal itself
1732 #ifndef __WXUNIVERSAL__
1733 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1735 // intercept dialog navigation keys
1736 MSG
*msg
= (MSG
*)pMsg
;
1738 // here we try to do all the job which ::IsDialogMessage() usually does
1741 if ( msg
->message
== WM_KEYDOWN
)
1743 bool bCtrlDown
= wxIsCtrlDown();
1744 bool bShiftDown
= wxIsShiftDown();
1746 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1747 // don't process it if it's the case (except for Ctrl-Tab/Enter
1748 // combinations which are always processed)
1752 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1754 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1755 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1756 // it, of course, implies them
1757 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1759 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1763 bool bForward
= TRUE
,
1764 bWindowChange
= FALSE
;
1766 // should we process this message specially?
1767 bool bProcess
= TRUE
;
1768 switch ( msg
->wParam
)
1771 // assume that nobody wants Shift-TAB for himself - if we
1772 // don't do it there is no easy way for a control to grab
1773 // TABs but still let Shift-TAB work as navugation key
1774 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1778 // Ctrl-Tab cycles thru notebook pages
1779 bWindowChange
= bCtrlDown
;
1780 bForward
= !bShiftDown
;
1786 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1794 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1800 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1802 // control wants to process Enter itself, don't
1803 // call IsDialogMessage() which would interpret
1807 else if ( lDlgCode
& DLGC_BUTTON
)
1809 // let IsDialogMessage() handle this for all
1810 // buttons except the owner-drawn ones which it
1811 // just seems to ignore
1812 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1813 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1815 // emulate the button click
1816 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1818 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1823 // FIXME: this should be handled by
1824 // wxNavigationKeyEvent handler and not here!!
1828 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1830 if ( btn
&& btn
->IsEnabled() )
1832 // if we do have a default button, do press it
1833 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1837 else // no default button
1839 #endif // wxUSE_BUTTON
1840 // this is a quick and dirty test for a text
1842 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1844 // don't process Enter, the control might
1845 // need it for itself and don't let
1846 // ::IsDialogMessage() have it as it can
1847 // eat the Enter events sometimes
1850 else if (!IsTopLevel())
1852 // if not a top level window, let parent
1856 //else: treat Enter as TAB: pass to the next
1857 // control as this is the best thing to do
1858 // if the text doesn't handle Enter itself
1870 wxNavigationKeyEvent event
;
1871 event
.SetDirection(bForward
);
1872 event
.SetWindowChange(bWindowChange
);
1873 event
.SetEventObject(this);
1875 if ( GetEventHandler()->ProcessEvent(event
) )
1882 // let ::IsDialogMessage() do almost everything and handle just the
1883 // things it doesn't here: Ctrl-TAB for switching notebook pages
1884 if ( msg
->message
== WM_KEYDOWN
)
1886 // don't process system keys here
1887 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1889 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1891 // find the first notebook parent and change its page
1892 wxWindow
*win
= this;
1893 wxNotebook
*nbook
= NULL
;
1894 while ( win
&& !nbook
)
1896 nbook
= wxDynamicCast(win
, wxNotebook
);
1897 win
= win
->GetParent();
1902 bool forward
= !wxIsShiftDown();
1904 nbook
->AdvanceSelection(forward
);
1911 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1912 // shouldn't let IsDialogMessage() get it as it _always_ eats the
1913 // message even when there is no cancel button and when the message is
1914 // needed by the control itself: in particular, it prevents the tree in
1915 // place edit control from being closed with Escape in a dialog
1916 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
1918 // ::IsDialogMessage() is broken and may sometimes hang the
1919 // application by going into an infinite loop, so we try to detect
1920 // [some of] the situatations when this may happen and not call it
1923 // assume we can call it by default
1924 bool canSafelyCallIsDlgMsg
= TRUE
;
1926 HWND hwndFocus
= ::GetFocus();
1928 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
1929 // an infinite loop, because it will recursively check the child
1930 // windows but not the window itself and so if none of the children
1931 // accepts focus it loops forever (as it only stops when it gets
1932 // back to the window it started from)
1934 // while it is very unusual that a window with WS_EX_CONTROLPARENT
1935 // style has the focus, it can happen. One such possibility is if
1936 // all windows are either toplevel, wxDialog, wxPanel or static
1937 // controls and no window can actually accept keyboard input.
1938 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1940 // passimistic by default
1941 canSafelyCallIsDlgMsg
= FALSE
;
1942 for ( wxWindowList::Node
*node
= GetChildren().GetFirst();
1944 node
= node
->GetNext() )
1946 if ( node
->GetData()->AcceptsFocus() )
1948 // it shouldn't hang...
1949 canSafelyCallIsDlgMsg
= TRUE
;
1956 if ( canSafelyCallIsDlgMsg
)
1958 // ::IsDialogMessage() can enter in an infinite loop when the
1959 // currently focused window is disabled or hidden and its
1960 // parent has WS_EX_CONTROLPARENT style, so don't call it in
1964 if ( !::IsWindowEnabled(hwndFocus
) ||
1965 !::IsWindowVisible(hwndFocus
) )
1967 // it would enter an infinite loop if we do this!
1968 canSafelyCallIsDlgMsg
= FALSE
;
1973 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
1975 // it's a top level window, don't go further -- e.g. even
1976 // if the parent of a dialog is disabled, this doesn't
1977 // break navigation inside the dialog
1981 hwndFocus
= ::GetParent(hwndFocus
);
1985 // let IsDialogMessage() have the message if it's safe to call it
1986 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
1988 // IsDialogMessage() did something...
1993 #endif // __WXUNIVERSAL__
1998 // relay mouse move events to the tooltip control
1999 MSG
*msg
= (MSG
*)pMsg
;
2000 if ( msg
->message
== WM_MOUSEMOVE
)
2001 m_tooltip
->RelayEvent(pMsg
);
2003 #endif // wxUSE_TOOLTIPS
2008 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2010 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2011 return m_acceleratorTable
.Translate(this, pMsg
);
2015 #endif // wxUSE_ACCEL
2018 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2020 // preprocess all messages by default
2024 // ---------------------------------------------------------------------------
2025 // message params unpackers (different for Win16 and Win32)
2026 // ---------------------------------------------------------------------------
2030 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2031 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2033 *id
= LOWORD(wParam
);
2034 *hwnd
= (WXHWND
)lParam
;
2035 *cmd
= HIWORD(wParam
);
2038 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2039 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2041 *state
= LOWORD(wParam
);
2042 *minimized
= HIWORD(wParam
);
2043 *hwnd
= (WXHWND
)lParam
;
2046 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2047 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2049 *code
= LOWORD(wParam
);
2050 *pos
= HIWORD(wParam
);
2051 *hwnd
= (WXHWND
)lParam
;
2054 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2055 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2057 #ifndef __WXMICROWIN__
2058 *nCtlColor
= CTLCOLOR_BTN
;
2059 *hwnd
= (WXHWND
)lParam
;
2060 *hdc
= (WXHDC
)wParam
;
2064 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2065 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2067 *item
= (WXWORD
)wParam
;
2068 *flags
= HIWORD(wParam
);
2069 *hmenu
= (WXHMENU
)lParam
;
2074 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2075 WXWORD
*id
, WXHWND
*hwnd
, WXWORD
*cmd
)
2077 *id
= (WXWORD
)wParam
;
2078 *hwnd
= (WXHWND
)LOWORD(lParam
);
2079 *cmd
= HIWORD(lParam
);
2082 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2083 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2085 *state
= (WXWORD
)wParam
;
2086 *minimized
= LOWORD(lParam
);
2087 *hwnd
= (WXHWND
)HIWORD(lParam
);
2090 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2091 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2093 *code
= (WXWORD
)wParam
;
2094 *pos
= LOWORD(lParam
);
2095 *hwnd
= (WXHWND
)HIWORD(lParam
);
2098 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2099 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2101 *hwnd
= (WXHWND
)LOWORD(lParam
);
2102 *nCtlColor
= (int)HIWORD(lParam
);
2103 *hdc
= (WXHDC
)wParam
;
2106 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2107 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2109 *item
= (WXWORD
)wParam
;
2110 *flags
= LOWORD(lParam
);
2111 *hmenu
= (WXHMENU
)HIWORD(lParam
);
2116 // ---------------------------------------------------------------------------
2117 // Main wxWindows window proc and the window proc for wxWindow
2118 // ---------------------------------------------------------------------------
2120 // Hook for new window just as it's being created, when the window isn't yet
2121 // associated with the handle
2122 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2124 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2125 // window being created and insures that it's always unset back later
2126 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2128 gs_winBeingCreated
= winBeingCreated
;
2131 wxWindowCreationHook::~wxWindowCreationHook()
2133 gs_winBeingCreated
= NULL
;
2137 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2139 // trace all messages - useful for the debugging
2141 wxLogTrace(wxTraceMessages
,
2142 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2143 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2144 #endif // __WXDEBUG__
2146 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2148 // when we get the first message for the HWND we just created, we associate
2149 // it with wxWindow stored in gs_winBeingCreated
2150 if ( !wnd
&& gs_winBeingCreated
)
2152 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2153 wnd
= gs_winBeingCreated
;
2154 gs_winBeingCreated
= NULL
;
2155 wnd
->SetHWND((WXHWND
)hWnd
);
2161 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2163 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2168 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2170 // did we process the message?
2171 bool processed
= FALSE
;
2182 // for most messages we should return 0 when we do process the message
2190 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2193 // return 0 to allow window creation
2194 rc
.result
= mayCreate
? 0 : -1;
2200 // never set processed to TRUE and *always* pass WM_DESTROY to
2201 // DefWindowProc() as Windows may do some internal cleanup when
2202 // processing it and failing to pass the message along may cause
2203 // memory and resource leaks!
2204 (void)HandleDestroy();
2208 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2213 LPRECT pRect
= (LPRECT
)lParam
;
2215 rc
.SetLeft(pRect
->left
);
2216 rc
.SetTop(pRect
->top
);
2217 rc
.SetRight(pRect
->right
);
2218 rc
.SetBottom(pRect
->bottom
);
2219 processed
= HandleMoving(rc
);
2221 pRect
->left
= rc
.GetLeft();
2222 pRect
->top
= rc
.GetTop();
2223 pRect
->right
= rc
.GetRight();
2224 pRect
->bottom
= rc
.GetBottom();
2234 // we're not interested in these messages at all
2237 case SIZE_MINIMIZED
:
2238 // we shouldn't send sizev events for these messages as the
2239 // client size may be negative which breaks existing code
2241 // OTOH we might send another (wxMinimizedEvent?) one or
2242 // add an additional parameter to wxSizeEvent if this is
2243 // useful to anybody
2247 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2248 // fall through nevertheless
2250 case SIZE_MAXIMIZED
:
2252 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2259 LPRECT pRect
= (LPRECT
)lParam
;
2261 rc
.SetLeft(pRect
->left
);
2262 rc
.SetTop(pRect
->top
);
2263 rc
.SetRight(pRect
->right
);
2264 rc
.SetBottom(pRect
->bottom
);
2265 processed
= HandleSizing(rc
);
2267 pRect
->left
= rc
.GetLeft();
2268 pRect
->top
= rc
.GetTop();
2269 pRect
->right
= rc
.GetRight();
2270 pRect
->bottom
= rc
.GetBottom();
2275 #ifndef __WXMICROWIN__
2276 case WM_ACTIVATEAPP
:
2277 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2283 WXWORD state
, minimized
;
2285 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2287 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2292 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2296 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2300 processed
= HandlePaint();
2304 #ifdef __WXUNIVERSAL__
2305 // Universal uses its own wxFrame/wxDialog, so we don't receive
2306 // close events unless we have this.
2311 // don't let the DefWindowProc() destroy our window - we'll do it
2312 // ourselves in ~wxWindow
2319 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2323 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2324 GET_Y_LPARAM(lParam
),
2328 #if wxUSE_MOUSEWHEEL
2330 processed
= HandleMouseWheel(wParam
, lParam
);
2334 case WM_LBUTTONDOWN
:
2336 case WM_LBUTTONDBLCLK
:
2337 case WM_RBUTTONDOWN
:
2339 case WM_RBUTTONDBLCLK
:
2340 case WM_MBUTTONDOWN
:
2342 case WM_MBUTTONDBLCLK
:
2344 #ifdef __WXMICROWIN__
2345 // MicroWindows seems to ignore the fact that a window is
2346 // disabled. So catch mouse events and throw them away if
2348 wxWindowMSW
* win
= this;
2351 if (!win
->IsEnabled())
2357 win
= win
->GetParent();
2358 if ( !win
|| win
->IsTopLevel() )
2365 #endif // __WXMICROWIN__
2366 int x
= GET_X_LPARAM(lParam
),
2367 y
= GET_Y_LPARAM(lParam
);
2369 // redirect the event to a static control if necessary by
2370 // finding one under mouse
2372 if ( GetCapture() == this )
2374 // but don't do it if the mouse is captured by this window
2375 // because then it should really get this event itself
2380 win
= FindWindowForMouseEvent(this, &x
, &y
);
2382 // this should never happen
2383 wxCHECK_MSG( win
, 0,
2384 _T("FindWindowForMouseEvent() returned NULL") );
2386 // for the standard classes their WndProc sets the focus to
2387 // them anyhow and doing it from here results in some weird
2388 // problems, but for our windows we want them to acquire
2389 // focus when clicked
2390 if ( !win
->IsOfStandardClass() )
2392 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2397 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2406 case MM_JOY1BUTTONDOWN
:
2407 case MM_JOY2BUTTONDOWN
:
2408 case MM_JOY1BUTTONUP
:
2409 case MM_JOY2BUTTONUP
:
2410 processed
= HandleJoystickEvent(message
,
2411 GET_X_LPARAM(lParam
),
2412 GET_Y_LPARAM(lParam
),
2415 #endif // __WXMICROWIN__
2418 processed
= HandleSysCommand(wParam
, lParam
);
2425 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2427 processed
= HandleCommand(id
, cmd
, hwnd
);
2433 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2437 // for these messages we must return TRUE if process the message
2440 case WM_MEASUREITEM
:
2442 int idCtrl
= (UINT
)wParam
;
2443 if ( message
== WM_DRAWITEM
)
2445 processed
= MSWOnDrawItem(idCtrl
,
2446 (WXDRAWITEMSTRUCT
*)lParam
);
2450 processed
= MSWOnMeasureItem(idCtrl
,
2451 (WXMEASUREITEMSTRUCT
*)lParam
);
2458 #endif // defined(WM_DRAWITEM)
2461 if ( !IsOfStandardClass() )
2463 // we always want to get the char events
2464 rc
.result
= DLGC_WANTCHARS
;
2466 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2468 // in fact, we want everything
2469 rc
.result
|= DLGC_WANTARROWS
|
2476 //else: get the dlg code from the DefWindowProc()
2481 // If this has been processed by an event handler, return 0 now
2482 // (we've handled it).
2483 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2484 if ( m_lastKeydownProcessed
)
2493 // we consider these message "not interesting" to OnChar, so
2494 // just don't do anything more with them
2504 // avoid duplicate messages to OnChar for these ASCII keys:
2505 // they will be translated by TranslateMessage() and received
2527 // but set processed to FALSE, not TRUE to still pass them
2528 // to the control's default window proc - otherwise
2529 // built-in keyboard handling won't work
2534 // special case of VK_APPS: treat it the same as right mouse
2535 // click because both usually pop up a context menu
2541 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2542 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2548 // do generate a CHAR event
2549 processed
= HandleChar((WORD
)wParam
, lParam
);
2552 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2559 // special case of VK_APPS: treat it the same as right mouse button
2560 if ( wParam
== VK_APPS
)
2565 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2566 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2571 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2576 case WM_CHAR
: // Always an ASCII character
2577 if ( m_lastKeydownProcessed
)
2579 // The key was handled in the EVT_KEY_DOWN and handling
2580 // a key in an EVT_KEY_DOWN handler is meant, by
2581 // design, to prevent EVT_CHARs from happening
2582 m_lastKeydownProcessed
= FALSE
;
2587 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2596 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2598 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2604 // CTLCOLOR messages are sent by children to query the parent for their
2605 // colors#ifndef __WXMICROWIN__
2606 #ifndef __WXMICROWIN__
2608 case WM_CTLCOLORMSGBOX
:
2609 case WM_CTLCOLOREDIT
:
2610 case WM_CTLCOLORLISTBOX
:
2611 case WM_CTLCOLORBTN
:
2612 case WM_CTLCOLORDLG
:
2613 case WM_CTLCOLORSCROLLBAR
:
2614 case WM_CTLCOLORSTATIC
:
2622 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2624 processed
= HandleCtlColor(&rc
.hBrush
,
2633 #endif // !__WXMICROWIN__
2635 case WM_SYSCOLORCHANGE
:
2636 // the return value for this message is ignored
2637 processed
= HandleSysColorChange();
2640 case WM_DISPLAYCHANGE
:
2641 processed
= HandleDisplayChange();
2644 case WM_PALETTECHANGED
:
2645 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2648 case WM_CAPTURECHANGED
:
2649 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2652 case WM_QUERYNEWPALETTE
:
2653 processed
= HandleQueryNewPalette();
2657 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2660 // we processed the message, i.e. erased the background
2666 processed
= HandleDropFiles(wParam
);
2670 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2674 // we never set focus from here
2679 case WM_QUERYENDSESSION
:
2680 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2684 processed
= HandleEndSession(wParam
!= 0, lParam
);
2687 case WM_GETMINMAXINFO
:
2688 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2692 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2693 LOWORD(lParam
), // hit test
2694 HIWORD(lParam
)); // mouse msg
2698 // returning TRUE stops the DefWindowProc() from further
2699 // processing this message - exactly what we need because we've
2700 // just set the cursor.
2705 #if wxUSE_ACCESSIBILITY
2708 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2709 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2711 if (dwObjId
== OBJID_CLIENT
&& GetOrCreateAccessible())
2713 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2719 #if defined(__WIN32__) && defined(WM_HELP)
2722 HELPINFO
* info
= (HELPINFO
*) lParam
;
2723 // Don't yet process menu help events, just windows
2724 if (info
->iContextType
== HELPINFO_WINDOW
)
2726 wxWindowMSW
* subjectOfHelp
= this;
2727 bool eventProcessed
= FALSE
;
2728 while (subjectOfHelp
&& !eventProcessed
)
2730 wxHelpEvent
helpEvent(wxEVT_HELP
,
2731 subjectOfHelp
->GetId(),
2732 wxPoint(info
->MousePos
.x
,
2733 info
->MousePos
.y
) );
2734 helpEvent
.SetEventObject(this);
2736 GetEventHandler()->ProcessEvent(helpEvent
);
2738 // Go up the window hierarchy until the event is
2740 subjectOfHelp
= subjectOfHelp
->GetParent();
2743 processed
= eventProcessed
;
2745 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2747 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2748 helpEvent
.SetEventObject(this);
2749 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2752 //else: processed is already FALSE
2756 case WM_CONTEXTMENU
:
2758 // we don't convert from screen to client coordinates as
2759 // the event may be handled by a parent window
2760 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2762 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2763 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2768 // we're only interested in our own menus, not MF_SYSMENU
2769 if ( HIWORD(wParam
) == MF_POPUP
)
2771 // handle menu chars for ownerdrawn menu items
2772 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2773 if ( i
!= wxNOT_FOUND
)
2775 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2786 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2787 wxGetMessageName(message
));
2788 #endif // __WXDEBUG__
2789 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2795 // ----------------------------------------------------------------------------
2796 // wxWindow <-> HWND map
2797 // ----------------------------------------------------------------------------
2799 wxWinHashTable
*wxWinHandleHash
= NULL
;
2801 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2803 return wxWinHandleHash
->Get((long)hWnd
);
2806 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2808 // adding NULL hWnd is (first) surely a result of an error and
2809 // (secondly) breaks menu command processing
2810 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2811 wxT("attempt to add a NULL hWnd to window list ignored") );
2813 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2815 if ( oldWin
&& (oldWin
!= win
) )
2817 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2818 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2821 #endif // __WXDEBUG__
2824 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2828 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2830 wxWinHandleHash
->Delete((long)win
->GetHWND());
2833 // ----------------------------------------------------------------------------
2834 // various MSW speciic class dependent functions
2835 // ----------------------------------------------------------------------------
2837 // Default destroyer - override if you destroy it in some other way
2838 // (e.g. with MDI child windows)
2839 void wxWindowMSW::MSWDestroyWindow()
2843 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2846 int& w
, int& h
) const
2848 static const int DEFAULT_Y
= 200;
2849 static const int DEFAULT_H
= 250;
2851 bool nonDefault
= FALSE
;
2855 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2856 // just as well set it to CW_USEDEFAULT as well
2862 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2863 // neither because it is not handled as a special value by Windows then
2864 // and so we have to choose some default value for it
2866 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2872 NB: there used to be some code here which set the initial size of the
2873 window to the client size of the parent if no explicit size was
2874 specified. This was wrong because wxWindows programs often assume
2875 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2876 it. To see why, you should understand that Windows sends WM_SIZE from
2877 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2878 from some base class ctor and so this WM_SIZE is not processed in the
2879 real class' OnSize() (because it's not fully constructed yet and the
2880 event goes to some base class OnSize() instead). So the WM_SIZE we
2881 rely on is the one sent when the parent frame resizes its children
2882 but here is the problem: if the child already has just the right
2883 size, nothing will happen as both wxWindows and Windows check for
2884 this and ignore any attempts to change the window size to the size it
2885 already has - so no WM_SIZE would be sent.
2889 // as above, h is not used at all in this case anyhow
2895 // and, again as above, we can't set the height to CW_USEDEFAULT here
2897 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2905 WXHWND
wxWindowMSW::MSWGetParent() const
2907 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
2910 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
2911 const wxChar
*title
,
2915 WXDWORD extendedStyle
)
2917 // choose the position/size for the new window
2919 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
2921 // controlId is menu handle for the top level windows, so set it to 0
2922 // unless we're creating a child window
2923 int controlId
= style
& WS_CHILD
? GetId() : 0;
2925 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2926 // which is the same but without CS_[HV]REDRAW class styles so using it
2927 // ensures that the window is not fully repainted on each resize
2928 wxString
className(wclass
);
2929 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
2931 className
+= wxT("NR");
2934 // do create the window
2935 wxWindowCreationHook
hook(this);
2937 m_hWnd
= (WXHWND
)::CreateWindowEx
2941 title
? title
: wxT(""),
2944 (HWND
)MSWGetParent(),
2947 NULL
// no extra data
2952 wxLogSysError(_("Can't create window of class %s"), wclass
);
2957 SubclassWin(m_hWnd
);
2959 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
2964 // ===========================================================================
2965 // MSW message handlers
2966 // ===========================================================================
2968 // ---------------------------------------------------------------------------
2970 // ---------------------------------------------------------------------------
2974 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
2976 #ifndef __WXMICROWIN__
2977 LPNMHDR hdr
= (LPNMHDR
)lParam
;
2978 HWND hWnd
= hdr
->hwndFrom
;
2979 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
2981 // if the control is one of our windows, let it handle the message itself
2984 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
2987 // VZ: why did we do it? normally this is unnecessary and, besides, it
2988 // breaks the message processing for the toolbars because the tooltip
2989 // notifications were being forwarded to the toolbar child controls
2990 // (if it had any) before being passed to the toolbar itself, so in my
2991 // example the tooltip for the combobox was always shown instead of the
2992 // correct button tooltips
2994 // try all our children
2995 wxWindowList::Node
*node
= GetChildren().GetFirst();
2998 wxWindow
*child
= node
->GetData();
2999 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3004 node
= node
->GetNext();
3008 // by default, handle it ourselves
3009 return MSWOnNotify(idCtrl
, lParam
, result
);
3010 #else // __WXMICROWIN__
3017 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3019 const wxString
& ttip
)
3021 // I don't know why it happens, but the versions of comctl32.dll starting
3022 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3023 // this message is supposed to be sent to Unicode programs only) -- hence
3024 // we need to handle it as well, otherwise no tooltips will be shown in
3027 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
3029 // not a tooltip message or no tooltip to show anyhow
3033 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3036 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
3038 // we pass just the pointer as we store the string internally anyhow
3039 ttText
->lpszText
= (char *)ttip
.c_str();
3041 else // TTN_NEEDTEXTW
3045 // in Unicode mode this is just what we need
3046 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3048 MultiByteToWideChar(CP_ACP
, 0, ttip
, ttip
.length()+1,
3049 (wchar_t *)ttText
->szText
,
3050 sizeof(ttText
->szText
) / sizeof(wchar_t));
3051 #endif // Unicode/!Unicode
3057 #endif // wxUSE_TOOLTIPS
3059 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3061 WXLPARAM
* WXUNUSED(result
))
3066 NMHDR
* hdr
= (NMHDR
*)lParam
;
3067 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3073 #endif // wxUSE_TOOLTIPS
3080 // ---------------------------------------------------------------------------
3081 // end session messages
3082 // ---------------------------------------------------------------------------
3084 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3086 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3087 event
.SetEventObject(wxTheApp
);
3088 event
.SetCanVeto(TRUE
);
3089 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3091 bool rc
= wxTheApp
->ProcessEvent(event
);
3095 // we may end only if the app didn't veto session closing (double
3097 *mayEnd
= !event
.GetVeto();
3103 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3105 // do nothing if the session isn't ending
3110 if ( (this != wxTheApp
->GetTopWindow()) )
3113 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3114 event
.SetEventObject(wxTheApp
);
3115 event
.SetCanVeto(FALSE
);
3116 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3118 return wxTheApp
->ProcessEvent(event
);
3121 // ---------------------------------------------------------------------------
3122 // window creation/destruction
3123 // ---------------------------------------------------------------------------
3125 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3127 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3128 // parent as well as otherwise several Win32 functions using
3129 // GetNextDlgTabItem() to iterate over all controls such as
3130 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3131 // all of them iterate over all the controls starting from the focus and
3132 // stop iterating when they get back to the focus but unless all parents
3133 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3134 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3136 // there is no need to do anything for the top level windows
3137 const wxWindow
*parent
= GetParent();
3138 while ( parent
&& !parent
->IsTopLevel() )
3140 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
3141 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
3143 // force the parent to have this style
3144 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
3145 exStyle
| WS_EX_CONTROLPARENT
);
3148 parent
= parent
->GetParent();
3152 // TODO: should generate this event from WM_NCCREATE
3153 wxWindowCreateEvent
event((wxWindow
*)this);
3154 (void)GetEventHandler()->ProcessEvent(event
);
3161 bool wxWindowMSW::HandleDestroy()
3165 // delete our drop target if we've got one
3166 #if wxUSE_DRAG_AND_DROP
3167 if ( m_dropTarget
!= NULL
)
3169 m_dropTarget
->Revoke(m_hWnd
);
3171 delete m_dropTarget
;
3172 m_dropTarget
= NULL
;
3174 #endif // wxUSE_DRAG_AND_DROP
3176 // WM_DESTROY handled
3180 // ---------------------------------------------------------------------------
3182 // ---------------------------------------------------------------------------
3184 bool wxWindowMSW::HandleActivate(int state
,
3185 bool WXUNUSED(minimized
),
3186 WXHWND
WXUNUSED(activate
))
3188 wxActivateEvent
event(wxEVT_ACTIVATE
,
3189 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3191 event
.SetEventObject(this);
3193 return GetEventHandler()->ProcessEvent(event
);
3196 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3198 // notify the parent keeping track of focus for the kbd navigation
3199 // purposes that we got it
3200 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3201 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3207 m_caret
->OnSetFocus();
3209 #endif // wxUSE_CARET
3212 // If it's a wxTextCtrl don't send the event as it will be done
3213 // after the control gets to process it from EN_FOCUS handler
3214 if ( wxDynamicCastThis(wxTextCtrl
) )
3218 #endif // wxUSE_TEXTCTRL
3220 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3221 event
.SetEventObject(this);
3223 // wxFindWinFromHandle() may return NULL, it is ok
3224 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3226 return GetEventHandler()->ProcessEvent(event
);
3229 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3235 m_caret
->OnKillFocus();
3237 #endif // wxUSE_CARET
3240 // If it's a wxTextCtrl don't send the event as it will be done
3241 // after the control gets to process it.
3242 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3249 // Don't send the event when in the process of being deleted. This can
3250 // only cause problems if the event handler tries to access the object.
3251 if ( m_isBeingDeleted
)
3256 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3257 event
.SetEventObject(this);
3259 // wxFindWinFromHandle() may return NULL, it is ok
3260 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3262 return GetEventHandler()->ProcessEvent(event
);
3265 // ---------------------------------------------------------------------------
3267 // ---------------------------------------------------------------------------
3269 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3271 wxShowEvent
event(GetId(), show
);
3272 event
.m_eventObject
= this;
3274 return GetEventHandler()->ProcessEvent(event
);
3277 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3279 wxInitDialogEvent
event(GetId());
3280 event
.m_eventObject
= this;
3282 return GetEventHandler()->ProcessEvent(event
);
3285 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3287 #if defined (__WXMICROWIN__)
3289 #else // __WXMICROWIN__
3290 HDROP hFilesInfo
= (HDROP
) wParam
;
3292 // Get the total number of files dropped
3293 UINT gwFilesDropped
= ::DragQueryFile
3301 wxString
*files
= new wxString
[gwFilesDropped
];
3302 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3304 // first get the needed buffer length (+1 for terminating NUL)
3305 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3307 // and now get the file name
3308 ::DragQueryFile(hFilesInfo
, wIndex
,
3309 files
[wIndex
].GetWriteBuf(len
), len
);
3311 files
[wIndex
].UngetWriteBuf();
3313 DragFinish (hFilesInfo
);
3315 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3316 event
.m_eventObject
= this;
3319 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3320 event
.m_pos
.x
= dropPoint
.x
;
3321 event
.m_pos
.y
= dropPoint
.y
;
3323 return GetEventHandler()->ProcessEvent(event
);
3328 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3330 int WXUNUSED(mouseMsg
))
3332 #ifndef __WXMICROWIN__
3333 // the logic is as follows:
3334 // -1. don't set cursor for non client area, including but not limited to
3335 // the title bar, scrollbars, &c
3336 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3337 // 1. if we have the cursor set it unless wxIsBusy()
3338 // 2. if we're a top level window, set some cursor anyhow
3339 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3341 if ( nHitTest
!= HTCLIENT
)
3346 HCURSOR hcursor
= 0;
3348 // first ask the user code - it may wish to set the cursor in some very
3349 // specific way (for example, depending on the current position)
3352 if ( !::GetCursorPos(&pt
) )
3354 wxLogLastError(wxT("GetCursorPos"));
3357 // In WIN16 it doesn't return a value.
3358 ::GetCursorPos(&pt
);
3363 ScreenToClient(&x
, &y
);
3364 wxSetCursorEvent
event(x
, y
);
3366 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3367 if ( processedEvtSetCursor
&& event
.HasCursor() )
3369 hcursor
= GetHcursorOf(event
.GetCursor());
3374 bool isBusy
= wxIsBusy();
3376 // the test for processedEvtSetCursor is here to prevent using m_cursor
3377 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3378 // it - this is a way to say that our cursor shouldn't be used for this
3380 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3382 hcursor
= GetHcursorOf(m_cursor
);
3389 hcursor
= wxGetCurrentBusyCursor();
3391 else if ( !hcursor
)
3393 const wxCursor
*cursor
= wxGetGlobalCursor();
3394 if ( cursor
&& cursor
->Ok() )
3396 hcursor
= GetHcursorOf(*cursor
);
3404 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3406 ::SetCursor(hcursor
);
3408 // cursor set, stop here
3411 #endif // __WXMICROWIN__
3413 // pass up the window chain
3417 // ---------------------------------------------------------------------------
3418 // owner drawn stuff
3419 // ---------------------------------------------------------------------------
3421 bool wxWindowMSW::MSWOnDrawItem(int id
, WXDRAWITEMSTRUCT
*itemStruct
)
3423 #if wxUSE_OWNER_DRAWN
3425 #if wxUSE_MENUS_NATIVE
3426 // is it a menu item?
3427 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3428 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3430 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3432 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3434 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3435 // the DC from being released
3436 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3437 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3438 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3439 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3441 return pMenuItem
->OnDrawItem
3445 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3446 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3449 #endif // wxUSE_MENUS_NATIVE
3451 #endif // USE_OWNER_DRAWN
3455 #if wxUSE_OWNER_DRAWN
3456 wxWindow
*item
= FindItem(id
);
3457 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3458 return ((wxControl
*)item
)->MSWOnDraw(itemStruct
);
3459 #elif !defined(__WXUNIVERSAL__)
3460 // we may still have owner-drawn buttons internally because we have to make
3461 // them owner-drawn to support colour change
3462 wxWindow
*item
= FindItem(id
);
3463 if ( item
&& item
->IsKindOf(CLASSINFO(wxButton
)) )
3464 return ((wxButton
*)item
)->MSWOnDraw(itemStruct
);
3465 #endif // USE_OWNER_DRAWN
3467 #endif // wxUSE_CONTROLS
3472 bool wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3474 #if wxUSE_OWNER_DRAWN
3475 // is it a menu item?
3476 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3477 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3479 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3481 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3483 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3484 &pMeasureStruct
->itemHeight
);
3487 wxWindow
*item
= FindItem(id
);
3488 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3490 return ((wxControl
*)item
)->MSWOnMeasure(itemStruct
);
3492 #endif // owner-drawn menus
3496 // ---------------------------------------------------------------------------
3497 // colours and palettes
3498 // ---------------------------------------------------------------------------
3500 bool wxWindowMSW::HandleSysColorChange()
3502 wxSysColourChangedEvent event
;
3503 event
.SetEventObject(this);
3505 (void)GetEventHandler()->ProcessEvent(event
);
3507 // always let the system carry on the default processing to allow the
3508 // native controls to react to the colours update
3512 bool wxWindowMSW::HandleDisplayChange()
3514 wxDisplayChangedEvent event
;
3515 event
.SetEventObject(this);
3517 return GetEventHandler()->ProcessEvent(event
);
3520 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3528 #ifndef __WXMICROWIN__
3529 WXHBRUSH hBrush
= 0;
3531 if ( nCtlColor
== CTLCOLOR_DLG
)
3533 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3538 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3540 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3542 #endif // wxUSE_CONTROLS
3548 #else // __WXMICROWIN__
3553 // Define for each class of dialog and control
3554 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3555 WXHWND
WXUNUSED(hWnd
),
3556 WXUINT
WXUNUSED(nCtlColor
),
3557 WXUINT
WXUNUSED(message
),
3558 WXWPARAM
WXUNUSED(wParam
),
3559 WXLPARAM
WXUNUSED(lParam
))
3564 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3567 // same as below except we don't respond to our own messages
3568 if ( hWndPalChange
!= GetHWND() )
3570 // check to see if we our our parents have a custom palette
3571 wxWindowMSW
*win
= this;
3572 while ( win
&& !win
->HasCustomPalette() )
3574 win
= win
->GetParent();
3577 if ( win
&& win
->HasCustomPalette() )
3579 // realize the palette to see whether redrawing is needed
3580 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3581 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3582 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3584 int result
= ::RealizePalette(hdc
);
3586 // restore the palette (before releasing the DC)
3587 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3588 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3589 ::RealizePalette(hdc
);
3590 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3592 // now check for the need to redraw
3594 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3598 #endif // wxUSE_PALETTE
3600 wxPaletteChangedEvent
event(GetId());
3601 event
.SetEventObject(this);
3602 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3604 return GetEventHandler()->ProcessEvent(event
);
3607 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3609 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3610 event
.SetEventObject(this);
3612 return GetEventHandler()->ProcessEvent(event
);
3615 bool wxWindowMSW::HandleQueryNewPalette()
3619 // check to see if we our our parents have a custom palette
3620 wxWindowMSW
*win
= this;
3621 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3622 if (win
->HasCustomPalette()) {
3623 /* realize the palette to see whether redrawing is needed */
3624 HDC hdc
= GetDC((HWND
) GetHWND());
3625 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3626 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3628 int result
= ::RealizePalette(hdc
);
3629 /* restore the palette (before releasing the DC) */
3630 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3631 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3632 ::RealizePalette(hdc
);
3633 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3634 /* now check for the need to redraw */
3636 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3638 #endif // wxUSE_PALETTE
3640 wxQueryNewPaletteEvent
event(GetId());
3641 event
.SetEventObject(this);
3643 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3646 // Responds to colour changes: passes event on to children.
3647 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3649 // the top level window also reset the standard colour map as it might have
3650 // changed (there is no need to do it for the non top level windows as we
3651 // only have to do it once)
3655 gs_hasStdCmap
= FALSE
;
3657 wxWindowList::Node
*node
= GetChildren().GetFirst();
3660 // Only propagate to non-top-level windows because Windows already
3661 // sends this event to all top-level ones
3662 wxWindow
*win
= node
->GetData();
3663 if ( !win
->IsTopLevel() )
3665 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3666 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3667 // the standard controls
3668 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3671 node
= node
->GetNext();
3674 // update the colours we use if they were not set explicitly by the user:
3675 // this must be done or OnCtlColor() would continue to use the old colours
3678 m_foregroundColour
= wxSystemSettings::
3679 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3684 m_backgroundColour
= wxSystemSettings::
3685 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3689 extern wxCOLORMAP
*wxGetStdColourMap()
3691 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3692 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3694 if ( !gs_hasStdCmap
)
3696 static bool s_coloursInit
= FALSE
;
3698 if ( !s_coloursInit
)
3700 // When a bitmap is loaded, the RGB values can change (apparently
3701 // because Windows adjusts them to care for the old programs always
3702 // using 0xc0c0c0 while the transparent colour for the new Windows
3703 // versions is different). But we do this adjustment ourselves so
3704 // we want to avoid Windows' "help" and for this we need to have a
3705 // reference bitmap which can tell us what the RGB values change
3707 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3708 if ( stdColourBitmap
.Ok() )
3710 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3711 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3712 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3715 memDC
.SelectObject(stdColourBitmap
);
3718 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3720 memDC
.GetPixel(i
, 0, &colour
);
3721 s_stdColours
[i
] = wxColourToRGB(colour
);
3724 else // wxBITMAP_STD_COLOURS couldn't be loaded
3726 s_stdColours
[0] = RGB(000,000,000); // black
3727 s_stdColours
[1] = RGB(128,128,128); // dark grey
3728 s_stdColours
[2] = RGB(192,192,192); // light grey
3729 s_stdColours
[3] = RGB(255,255,255); // white
3730 //s_stdColours[4] = RGB(000,000,255); // blue
3731 //s_stdColours[5] = RGB(255,000,255); // magenta
3734 s_coloursInit
= TRUE
;
3737 gs_hasStdCmap
= TRUE
;
3739 // create the colour map
3740 #define INIT_CMAP_ENTRY(col) \
3741 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3742 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3744 INIT_CMAP_ENTRY(BTNTEXT
);
3745 INIT_CMAP_ENTRY(BTNSHADOW
);
3746 INIT_CMAP_ENTRY(BTNFACE
);
3747 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3749 #undef INIT_CMAP_ENTRY
3755 // ---------------------------------------------------------------------------
3757 // ---------------------------------------------------------------------------
3759 bool wxWindowMSW::HandlePaint()
3761 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3765 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3767 wxLogLastError(wxT("CreateRectRgn"));
3768 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3769 wxLogLastError(wxT("GetUpdateRgn"));
3771 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3774 ::GetUpdateRect(GetHwnd(), &updateRect
, FALSE
);
3776 m_updateRegion
= wxRegion(updateRect
.left
, updateRect
.top
,
3777 updateRect
.right
- updateRect
.left
,
3778 updateRect
.bottom
- updateRect
.top
);
3781 wxPaintEvent
event(m_windowId
);
3782 event
.SetEventObject(this);
3784 bool processed
= GetEventHandler()->ProcessEvent(event
);
3786 // note that we must generate NC event after the normal one as otherwise
3787 // BeginPaint() will happily overwrite our decorations with the background
3789 wxNcPaintEvent
eventNc(m_windowId
);
3790 eventNc
.SetEventObject(this);
3791 GetEventHandler()->ProcessEvent(eventNc
);
3796 // Can be called from an application's OnPaint handler
3797 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3799 #ifdef __WXUNIVERSAL__
3802 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3805 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3810 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3812 // Prevents flicker when dragging
3813 if ( ::IsIconic(GetHwnd()) )
3817 if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3822 if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3824 if (wxUxThemeEngine::Get())
3826 WXHTHEME hTheme
= wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L
"TAB");
3830 ::GetClientRect((HWND
) GetHWND(), (RECT
*) & rect
);
3831 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme
, hdc
, 10 /* TABP_BODY */, 0, &rect
, &rect
);
3832 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme
);
3842 dc
.SetWindow((wxWindow
*)this);
3845 wxEraseEvent
event(m_windowId
, &dc
);
3846 event
.SetEventObject(this);
3847 bool rc
= GetEventHandler()->ProcessEvent(event
);
3851 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3852 dc
.SelectOldObjects(hdc
);
3857 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3860 ::GetClientRect(GetHwnd(), &rect
);
3862 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3863 m_backgroundColour
.Green(),
3864 m_backgroundColour
.Blue());
3865 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3867 wxLogLastError(wxT("CreateSolidBrush"));
3869 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
3871 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
3873 ::FillRect(hdc
, &rect
, hBrush
);
3874 ::DeleteObject(hBrush
);
3875 ::SetMapMode(hdc
, mode
);
3878 // ---------------------------------------------------------------------------
3879 // moving and resizing
3880 // ---------------------------------------------------------------------------
3882 bool wxWindowMSW::HandleMinimize()
3884 wxIconizeEvent
event(m_windowId
);
3885 event
.SetEventObject(this);
3887 return GetEventHandler()->ProcessEvent(event
);
3890 bool wxWindowMSW::HandleMaximize()
3892 wxMaximizeEvent
event(m_windowId
);
3893 event
.SetEventObject(this);
3895 return GetEventHandler()->ProcessEvent(event
);
3898 bool wxWindowMSW::HandleMove(int x
, int y
)
3900 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
3901 event
.SetEventObject(this);
3903 return GetEventHandler()->ProcessEvent(event
);
3906 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
3908 wxMoveEvent
event(rect
, m_windowId
);
3909 event
.SetEventObject(this);
3911 bool rc
= GetEventHandler()->ProcessEvent(event
);
3913 rect
= event
.GetRect();
3917 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
3918 WXUINT
WXUNUSED(flag
))
3920 // don't use w and h parameters as they specify the client size while
3921 // according to the docs EVT_SIZE handler is supposed to receive the total
3923 wxSizeEvent
event(GetSize(), m_windowId
);
3924 event
.SetEventObject(this);
3926 return GetEventHandler()->ProcessEvent(event
);
3929 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
3931 wxSizeEvent
event(rect
, m_windowId
);
3932 event
.SetEventObject(this);
3934 bool rc
= GetEventHandler()->ProcessEvent(event
);
3936 rect
= event
.GetRect();
3940 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
3942 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
3946 int minWidth
= GetMinWidth(),
3947 minHeight
= GetMinHeight(),
3948 maxWidth
= GetMaxWidth(),
3949 maxHeight
= GetMaxHeight();
3951 if ( minWidth
!= -1 )
3953 info
->ptMinTrackSize
.x
= minWidth
;
3957 if ( minHeight
!= -1 )
3959 info
->ptMinTrackSize
.y
= minHeight
;
3963 if ( maxWidth
!= -1 )
3965 info
->ptMaxTrackSize
.x
= maxWidth
;
3969 if ( maxHeight
!= -1 )
3971 info
->ptMaxTrackSize
.y
= maxHeight
;
3978 // ---------------------------------------------------------------------------
3980 // ---------------------------------------------------------------------------
3982 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
3984 #if wxUSE_MENUS_NATIVE
3985 if ( !cmd
&& wxCurrentPopupMenu
)
3987 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
3988 wxCurrentPopupMenu
= NULL
;
3990 return popupMenu
->MSWCommand(cmd
, id
);
3992 #endif // wxUSE_MENUS_NATIVE
3994 wxWindow
*win
= NULL
;
3996 // first try to find it from HWND - this works even with the broken
3997 // programs using the same ids for different controls
4000 win
= wxFindWinFromHandle(control
);
4006 // must cast to a signed type before comparing with other ids!
4007 win
= FindItem((signed short)id
);
4012 return win
->MSWCommand(cmd
, id
);
4015 // the messages sent from the in-place edit control used by the treectrl
4016 // for label editing have id == 0, but they should _not_ be treated as menu
4017 // messages (they are EN_XXX ones, in fact) so don't translate anything
4018 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4021 // If no child window, it may be an accelerator, e.g. for a popup menu
4024 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4025 event
.SetEventObject(this);
4029 return GetEventHandler()->ProcessEvent(event
);
4031 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4034 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4035 // notifications to its parent which we want to reflect back to
4037 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4038 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4041 #endif // wxUSE_SPINCTRL
4046 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4048 // 4 bits are reserved
4049 switch ( wParam
& 0xFFFFFFF0 )
4052 return HandleMaximize();
4055 return HandleMinimize();
4061 // ---------------------------------------------------------------------------
4063 // ---------------------------------------------------------------------------
4065 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4069 // our client coords are not quite the same as Windows ones
4070 wxPoint pt
= GetClientAreaOrigin();
4071 event
.m_x
= x
- pt
.x
;
4072 event
.m_y
= y
- pt
.y
;
4074 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4075 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4076 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4077 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4078 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4079 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4080 // Returns different negative values on WinME and WinNT,
4081 // so simply test for negative value.
4082 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4084 event
.SetTimestamp(s_currentMsg
.time
);
4085 event
.m_eventObject
= this;
4086 event
.SetId(GetId());
4088 #if wxUSE_MOUSEEVENT_HACK
4091 m_lastMouseEvent
= event
.GetEventType();
4092 #endif // wxUSE_MOUSEEVENT_HACK
4095 // Windows doesn't send the mouse events to the static controls (which are
4096 // transparent in the sense that their WM_NCHITTEST handler returns
4097 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4098 // and so we manually check if we don't have a child window under mouse and if
4099 // we do, send the event to it instead of the window Windows had sent WM_XXX
4102 // Notice that this is not done for the mouse move events because this could
4103 // (would?) be too slow, but only for clicks which means that the static texts
4104 // still don't get move, enter nor leave events.
4105 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4107 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4109 // first try to find a non transparent child: this allows us to send events
4110 // to a static text which is inside a static box, for example
4111 POINT pt
= { *x
, *y
};
4112 HWND hwnd
= GetHwndOf(win
),
4116 hwndUnderMouse
= ::ChildWindowFromPointEx
4125 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4128 // now try any child window at all
4129 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4132 // check that we have a child window which is susceptible to receive mouse
4133 // events: for this it must be shown and enabled
4134 if ( hwndUnderMouse
&&
4135 hwndUnderMouse
!= hwnd
&&
4136 ::IsWindowVisible(hwndUnderMouse
) &&
4137 ::IsWindowEnabled(hwndUnderMouse
) )
4139 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4140 if ( winUnderMouse
)
4142 // translate the mouse coords to the other window coords
4143 win
->ClientToScreen(x
, y
);
4144 winUnderMouse
->ScreenToClient(x
, y
);
4146 win
= winUnderMouse
;
4153 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4155 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4156 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4157 // from the message id and take the value in the table to get wxWin event
4159 static const wxEventType eventsMouse
[] =
4173 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4174 InitMouseEvent(event
, x
, y
, flags
);
4176 return GetEventHandler()->ProcessEvent(event
);
4179 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4181 if ( !m_mouseInWindow
)
4183 // it would be wrong to assume that just because we get a mouse move
4184 // event that the mouse is inside the window: although this is usually
4185 // true, it is not if we had captured the mouse, so we need to check
4186 // the mouse coordinates here
4187 if ( !HasCapture() || IsMouseInWindow() )
4189 // Generate an ENTER event
4190 m_mouseInWindow
= TRUE
;
4192 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4193 InitMouseEvent(event
, x
, y
, flags
);
4195 (void)GetEventHandler()->ProcessEvent(event
);
4199 #if wxUSE_MOUSEEVENT_HACK
4200 // Window gets a click down message followed by a mouse move message even
4201 // if position isn't changed! We want to discard the trailing move event
4202 // if x and y are the same.
4203 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4204 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4205 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4206 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4208 m_lastMouseEvent
= wxEVT_MOTION
;
4212 #endif // wxUSE_MOUSEEVENT_HACK
4214 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4218 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4220 #if wxUSE_MOUSEWHEEL
4221 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4222 InitMouseEvent(event
,
4223 GET_X_LPARAM(lParam
),
4224 GET_Y_LPARAM(lParam
),
4226 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4227 event
.m_wheelDelta
= WHEEL_DELTA
;
4230 static int s_linesPerRotation
= -1;
4231 if ( s_linesPerRotation
== -1 )
4233 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4234 &s_linesPerRotation
, 0))
4236 // this is not supposed to happen
4237 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4239 // the default is 3, so use it if SystemParametersInfo() failed
4240 s_linesPerRotation
= 3;
4244 // no SystemParametersInfo() under Win16
4245 static const int s_linesPerRotation
= 3;
4248 event
.m_linesPerAction
= s_linesPerRotation
;
4249 return GetEventHandler()->ProcessEvent(event
);
4260 // ---------------------------------------------------------------------------
4261 // keyboard handling
4262 // ---------------------------------------------------------------------------
4264 // create the key event of the given type for the given key - used by
4265 // HandleChar and HandleKeyDown/Up
4266 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4269 WXWPARAM wParam
) const
4271 wxKeyEvent
event(evType
);
4272 event
.SetId(GetId());
4273 event
.m_shiftDown
= wxIsShiftDown();
4274 event
.m_controlDown
= wxIsCtrlDown();
4275 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4277 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4278 event
.m_keyCode
= id
;
4279 event
.m_rawCode
= (wxUint32
) wParam
;
4280 event
.m_rawFlags
= (wxUint32
) lParam
;
4281 event
.SetTimestamp(s_currentMsg
.time
);
4283 // translate the position to client coords
4287 GetWindowRect(GetHwnd(),&rect
);
4297 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4299 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4301 bool ctrlDown
= FALSE
;
4306 // If 1 -> 26, translate to either special keycode or just set
4307 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4308 // ControlDown() == TRUE.
4310 if ( (id
> 0) && (id
< 27) )
4332 else // we're called from WM_KEYDOWN
4334 id
= wxCharCodeMSWToWX(wParam
);
4337 // it's ASCII and will be processed here only when called from
4338 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4343 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4345 // the alphanumeric keys produced by pressing AltGr+something on European
4346 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4347 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4348 // alphanumeric, so pretend that there are no modifiers at all (the
4349 // KEY_DOWN event would still have the correct modifiers if they're really
4351 if ( event
.m_controlDown
&& event
.m_altDown
&&
4352 (id
>= 32 && id
< 256) )
4354 event
.m_controlDown
=
4355 event
.m_altDown
= FALSE
;
4358 return GetEventHandler()->ProcessEvent(event
);
4361 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4363 int id
= wxCharCodeMSWToWX(wParam
);
4367 // normal ASCII char
4371 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4373 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4374 if ( GetEventHandler()->ProcessEvent(event
) )
4383 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4385 int id
= wxCharCodeMSWToWX(wParam
);
4389 // normal ASCII char
4393 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4395 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4396 if ( GetEventHandler()->ProcessEvent(event
) )
4405 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4407 const HMENU hmenu
= (HMENU
)lParam
;
4411 mii
.cbSize
= sizeof(MENUITEMINFO
);
4412 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4414 // find if we have this letter in any owner drawn item
4415 const int count
= ::GetMenuItemCount(hmenu
);
4416 for ( int i
= 0; i
< count
; i
++ )
4418 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4420 if ( mii
.fType
== MFT_OWNERDRAW
)
4422 // dwItemData member of the MENUITEMINFO is a
4423 // pointer to the associated wxMenuItem -- see the
4424 // menu creation code
4425 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4427 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4430 if ( *p
== _T('&') )
4432 // this is not the accel char, find the real one
4433 p
= wxStrchr(p
+ 1, _T('&'));
4435 else // got the accel char
4437 // FIXME-UNICODE: this comparison doesn't risk to work
4438 // for non ASCII accelerator characters I'm afraid, but
4440 if ( wxToupper(*p
) == chAccel
)
4446 // this one doesn't match
4453 else // failed ot get the menu text?
4455 // it's not fatal, so don't show error, but still log
4457 wxLogLastError(_T("GetMenuItemInfo"));
4466 // ---------------------------------------------------------------------------
4468 // ---------------------------------------------------------------------------
4470 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4474 if ( flags
& JOY_BUTTON1CHG
)
4475 change
= wxJOY_BUTTON1
;
4476 if ( flags
& JOY_BUTTON2CHG
)
4477 change
= wxJOY_BUTTON2
;
4478 if ( flags
& JOY_BUTTON3CHG
)
4479 change
= wxJOY_BUTTON3
;
4480 if ( flags
& JOY_BUTTON4CHG
)
4481 change
= wxJOY_BUTTON4
;
4484 if ( flags
& JOY_BUTTON1
)
4485 buttons
|= wxJOY_BUTTON1
;
4486 if ( flags
& JOY_BUTTON2
)
4487 buttons
|= wxJOY_BUTTON2
;
4488 if ( flags
& JOY_BUTTON3
)
4489 buttons
|= wxJOY_BUTTON3
;
4490 if ( flags
& JOY_BUTTON4
)
4491 buttons
|= wxJOY_BUTTON4
;
4493 // the event ids aren't consecutive so we can't use table based lookup
4495 wxEventType eventType
;
4500 eventType
= wxEVT_JOY_MOVE
;
4505 eventType
= wxEVT_JOY_MOVE
;
4510 eventType
= wxEVT_JOY_ZMOVE
;
4515 eventType
= wxEVT_JOY_ZMOVE
;
4518 case MM_JOY1BUTTONDOWN
:
4520 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4523 case MM_JOY2BUTTONDOWN
:
4525 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4528 case MM_JOY1BUTTONUP
:
4530 eventType
= wxEVT_JOY_BUTTON_UP
;
4533 case MM_JOY2BUTTONUP
:
4535 eventType
= wxEVT_JOY_BUTTON_UP
;
4539 wxFAIL_MSG(wxT("no such joystick event"));
4544 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4545 event
.SetPosition(wxPoint(x
, y
));
4546 event
.SetEventObject(this);
4548 return GetEventHandler()->ProcessEvent(event
);
4554 // ---------------------------------------------------------------------------
4556 // ---------------------------------------------------------------------------
4558 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4559 WXWORD pos
, WXHWND control
)
4563 wxWindow
*child
= wxFindWinFromHandle(control
);
4565 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4568 wxScrollWinEvent event
;
4569 event
.SetPosition(pos
);
4570 event
.SetOrientation(orientation
);
4571 event
.m_eventObject
= this;
4576 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4580 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4584 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4588 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4592 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4596 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4599 case SB_THUMBPOSITION
:
4602 // under Win32, the scrollbar range and position are 32 bit integers,
4603 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4604 // explicitly query the scrollbar for the correct position (this must
4605 // be done only for these two SB_ events as they are the only one
4606 // carrying the scrollbar position)
4608 WinStruct
<SCROLLINFO
> scrollInfo
;
4609 scrollInfo
.fMask
= SIF_TRACKPOS
;
4611 if ( !::GetScrollInfo(GetHwnd(),
4612 orientation
== wxHORIZONTAL
? SB_HORZ
4616 wxLogLastError(_T("GetScrollInfo"));
4619 event
.SetPosition(scrollInfo
.nTrackPos
);
4623 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4624 ? wxEVT_SCROLLWIN_THUMBRELEASE
4625 : wxEVT_SCROLLWIN_THUMBTRACK
;
4632 return GetEventHandler()->ProcessEvent(event
);
4635 // ===========================================================================
4637 // ===========================================================================
4639 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4642 HDC dc
= ::GetDC((HWND
) wnd
);
4647 // the_font->UseResource();
4648 // the_font->RealizeResource();
4649 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4651 was
= (HFONT
) SelectObject(dc
,fnt
);
4653 GetTextMetrics(dc
, &tm
);
4654 if ( the_font
&& fnt
&& was
)
4656 SelectObject(dc
,was
);
4658 ReleaseDC((HWND
)wnd
, dc
);
4661 *x
= tm
.tmAveCharWidth
;
4663 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4666 // the_font->ReleaseResource();
4669 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4670 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4671 int wxCharCodeMSWToWX(int keySym
)
4676 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4677 case VK_BACK
: id
= WXK_BACK
; break;
4678 case VK_TAB
: id
= WXK_TAB
; break;
4679 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4680 case VK_RETURN
: id
= WXK_RETURN
; break;
4681 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4682 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4683 case VK_MENU
: id
= WXK_MENU
; break;
4684 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4685 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4686 case VK_SPACE
: id
= WXK_SPACE
; break;
4687 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4688 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4689 case VK_NEXT
: id
= WXK_NEXT
; break;
4690 case VK_END
: id
= WXK_END
; break;
4691 case VK_HOME
: id
= WXK_HOME
; break;
4692 case VK_LEFT
: id
= WXK_LEFT
; break;
4693 case VK_UP
: id
= WXK_UP
; break;
4694 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4695 case VK_DOWN
: id
= WXK_DOWN
; break;
4696 case VK_SELECT
: id
= WXK_SELECT
; break;
4697 case VK_PRINT
: id
= WXK_PRINT
; break;
4698 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4699 case VK_INSERT
: id
= WXK_INSERT
; break;
4700 case VK_DELETE
: id
= WXK_DELETE
; break;
4701 case VK_HELP
: id
= WXK_HELP
; break;
4702 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4703 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4704 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4705 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4706 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4707 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4708 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4709 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4710 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4711 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4712 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4713 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4714 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4715 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4716 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4717 case VK_F1
: id
= WXK_F1
; break;
4718 case VK_F2
: id
= WXK_F2
; break;
4719 case VK_F3
: id
= WXK_F3
; break;
4720 case VK_F4
: id
= WXK_F4
; break;
4721 case VK_F5
: id
= WXK_F5
; break;
4722 case VK_F6
: id
= WXK_F6
; break;
4723 case VK_F7
: id
= WXK_F7
; break;
4724 case VK_F8
: id
= WXK_F8
; break;
4725 case VK_F9
: id
= WXK_F9
; break;
4726 case VK_F10
: id
= WXK_F10
; break;
4727 case VK_F11
: id
= WXK_F11
; break;
4728 case VK_F12
: id
= WXK_F12
; break;
4729 case VK_F13
: id
= WXK_F13
; break;
4730 case VK_F14
: id
= WXK_F14
; break;
4731 case VK_F15
: id
= WXK_F15
; break;
4732 case VK_F16
: id
= WXK_F16
; break;
4733 case VK_F17
: id
= WXK_F17
; break;
4734 case VK_F18
: id
= WXK_F18
; break;
4735 case VK_F19
: id
= WXK_F19
; break;
4736 case VK_F20
: id
= WXK_F20
; break;
4737 case VK_F21
: id
= WXK_F21
; break;
4738 case VK_F22
: id
= WXK_F22
; break;
4739 case VK_F23
: id
= WXK_F23
; break;
4740 case VK_F24
: id
= WXK_F24
; break;
4741 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4742 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4744 case VK_OEM_1
: id
= ';'; break;
4745 case VK_OEM_PLUS
: id
= '+'; break;
4746 case VK_OEM_COMMA
: id
= ','; break;
4747 case VK_OEM_MINUS
: id
= '-'; break;
4748 case VK_OEM_PERIOD
: id
= '.'; break;
4749 case VK_OEM_2
: id
= '/'; break;
4750 case VK_OEM_3
: id
= '~'; break;
4751 case VK_OEM_4
: id
= '['; break;
4752 case VK_OEM_5
: id
= '\\'; break;
4753 case VK_OEM_6
: id
= ']'; break;
4754 case VK_OEM_7
: id
= '\''; break;
4757 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4758 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4759 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4760 #endif // VK_APPS defined
4769 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4775 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4776 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4777 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4778 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4779 case WXK_MENU
: keySym
= VK_MENU
; break;
4780 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4781 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4782 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4783 case WXK_END
: keySym
= VK_END
; break;
4784 case WXK_HOME
: keySym
= VK_HOME
; break;
4785 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4786 case WXK_UP
: keySym
= VK_UP
; break;
4787 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4788 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4789 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4790 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4791 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4792 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4793 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4794 case WXK_HELP
: keySym
= VK_HELP
; break;
4795 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4796 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4797 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4798 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4799 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4800 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4801 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4802 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4803 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4804 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4805 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4806 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4807 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4808 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4809 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4810 case WXK_F1
: keySym
= VK_F1
; break;
4811 case WXK_F2
: keySym
= VK_F2
; break;
4812 case WXK_F3
: keySym
= VK_F3
; break;
4813 case WXK_F4
: keySym
= VK_F4
; break;
4814 case WXK_F5
: keySym
= VK_F5
; break;
4815 case WXK_F6
: keySym
= VK_F6
; break;
4816 case WXK_F7
: keySym
= VK_F7
; break;
4817 case WXK_F8
: keySym
= VK_F8
; break;
4818 case WXK_F9
: keySym
= VK_F9
; break;
4819 case WXK_F10
: keySym
= VK_F10
; break;
4820 case WXK_F11
: keySym
= VK_F11
; break;
4821 case WXK_F12
: keySym
= VK_F12
; break;
4822 case WXK_F13
: keySym
= VK_F13
; break;
4823 case WXK_F14
: keySym
= VK_F14
; break;
4824 case WXK_F15
: keySym
= VK_F15
; break;
4825 case WXK_F16
: keySym
= VK_F16
; break;
4826 case WXK_F17
: keySym
= VK_F17
; break;
4827 case WXK_F18
: keySym
= VK_F18
; break;
4828 case WXK_F19
: keySym
= VK_F19
; break;
4829 case WXK_F20
: keySym
= VK_F20
; break;
4830 case WXK_F21
: keySym
= VK_F21
; break;
4831 case WXK_F22
: keySym
= VK_F22
; break;
4832 case WXK_F23
: keySym
= VK_F23
; break;
4833 case WXK_F24
: keySym
= VK_F24
; break;
4834 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4835 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4846 wxWindow
*wxGetActiveWindow()
4848 HWND hWnd
= GetActiveWindow();
4851 return wxFindWinFromHandle((WXHWND
) hWnd
);
4856 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4858 HWND hwnd
= (HWND
)hWnd
;
4860 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4861 // by code in msw/radiobox.cpp), for all the others we just search up the
4863 wxWindow
*win
= (wxWindow
*)NULL
;
4866 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4869 // all these hacks only work under Win32 anyhow
4873 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4874 // wxWindow class which overrides WM_GETDLGCODE processing to
4875 // do it as well, win would be already non NULL
4876 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
4878 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
4880 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4881 #endif // wxUSE_RADIOBOX
4883 // spin control text buddy window should be mapped to spin ctrl
4884 // itself so try it too
4885 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4888 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
4890 #endif // wxUSE_SPINCTRL
4896 while ( hwnd
&& !win
)
4898 // this is a really ugly hack needed to avoid mistakenly returning the
4899 // parent frame wxWindow for the find/replace modeless dialog HWND -
4900 // this, in turn, is needed to call IsDialogMessage() from
4901 // wxApp::ProcessMessage() as for this we must return NULL from here
4903 // FIXME: this is clearly not the best way to do it but I think we'll
4904 // need to change HWND <-> wxWindow code more heavily than I can
4905 // do it now to fix it
4906 #ifndef __WXMICROWIN__
4907 if ( ::GetWindow(hwnd
, GW_OWNER
) )
4909 // it's a dialog box, don't go upwards
4914 hwnd
= ::GetParent(hwnd
);
4915 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4921 #ifndef __WXMICROWIN__
4923 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4924 // in active frames and dialogs, regardless of where the focus is.
4925 static HHOOK wxTheKeyboardHook
= 0;
4926 static FARPROC wxTheKeyboardHookProc
= 0;
4927 int APIENTRY _EXPORT
4928 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
4930 void wxSetKeyboardHook(bool doIt
)
4934 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
4935 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
4937 #if defined(__WIN32__)
4938 GetCurrentThreadId()
4939 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4947 UnhookWindowsHookEx(wxTheKeyboardHook
);
4949 // avoids warning about statement with no effect (FreeProcInstance
4950 // doesn't do anything under Win32)
4951 #if !defined(__WIN32__) && !defined(__NT__)
4952 FreeProcInstance(wxTheKeyboardHookProc
);
4957 int APIENTRY _EXPORT
4958 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
4960 DWORD hiWord
= HIWORD(lParam
);
4961 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
4963 int id
= wxCharCodeMSWToWX(wParam
);
4966 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
4967 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
4968 event
.m_altDown
= TRUE
;
4970 event
.m_eventObject
= NULL
;
4971 event
.m_keyCode
= id
;
4972 event
.m_shiftDown
= wxIsShiftDown();
4973 event
.m_controlDown
= wxIsCtrlDown();
4974 event
.SetTimestamp(s_currentMsg
.time
);
4976 wxWindow
*win
= wxGetActiveWindow();
4977 wxEvtHandler
*handler
;
4980 handler
= win
->GetEventHandler();
4981 event
.SetId(win
->GetId());
4989 if ( handler
&& handler
->ProcessEvent(event
) )
4997 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5000 #endif // !__WXMICROWIN__
5003 const char *wxGetMessageName(int message
)
5007 case 0x0000: return "WM_NULL";
5008 case 0x0001: return "WM_CREATE";
5009 case 0x0002: return "WM_DESTROY";
5010 case 0x0003: return "WM_MOVE";
5011 case 0x0005: return "WM_SIZE";
5012 case 0x0006: return "WM_ACTIVATE";
5013 case 0x0007: return "WM_SETFOCUS";
5014 case 0x0008: return "WM_KILLFOCUS";
5015 case 0x000A: return "WM_ENABLE";
5016 case 0x000B: return "WM_SETREDRAW";
5017 case 0x000C: return "WM_SETTEXT";
5018 case 0x000D: return "WM_GETTEXT";
5019 case 0x000E: return "WM_GETTEXTLENGTH";
5020 case 0x000F: return "WM_PAINT";
5021 case 0x0010: return "WM_CLOSE";
5022 case 0x0011: return "WM_QUERYENDSESSION";
5023 case 0x0012: return "WM_QUIT";
5024 case 0x0013: return "WM_QUERYOPEN";
5025 case 0x0014: return "WM_ERASEBKGND";
5026 case 0x0015: return "WM_SYSCOLORCHANGE";
5027 case 0x0016: return "WM_ENDSESSION";
5028 case 0x0017: return "WM_SYSTEMERROR";
5029 case 0x0018: return "WM_SHOWWINDOW";
5030 case 0x0019: return "WM_CTLCOLOR";
5031 case 0x001A: return "WM_WININICHANGE";
5032 case 0x001B: return "WM_DEVMODECHANGE";
5033 case 0x001C: return "WM_ACTIVATEAPP";
5034 case 0x001D: return "WM_FONTCHANGE";
5035 case 0x001E: return "WM_TIMECHANGE";
5036 case 0x001F: return "WM_CANCELMODE";
5037 case 0x0020: return "WM_SETCURSOR";
5038 case 0x0021: return "WM_MOUSEACTIVATE";
5039 case 0x0022: return "WM_CHILDACTIVATE";
5040 case 0x0023: return "WM_QUEUESYNC";
5041 case 0x0024: return "WM_GETMINMAXINFO";
5042 case 0x0026: return "WM_PAINTICON";
5043 case 0x0027: return "WM_ICONERASEBKGND";
5044 case 0x0028: return "WM_NEXTDLGCTL";
5045 case 0x002A: return "WM_SPOOLERSTATUS";
5046 case 0x002B: return "WM_DRAWITEM";
5047 case 0x002C: return "WM_MEASUREITEM";
5048 case 0x002D: return "WM_DELETEITEM";
5049 case 0x002E: return "WM_VKEYTOITEM";
5050 case 0x002F: return "WM_CHARTOITEM";
5051 case 0x0030: return "WM_SETFONT";
5052 case 0x0031: return "WM_GETFONT";
5053 case 0x0037: return "WM_QUERYDRAGICON";
5054 case 0x0039: return "WM_COMPAREITEM";
5055 case 0x0041: return "WM_COMPACTING";
5056 case 0x0044: return "WM_COMMNOTIFY";
5057 case 0x0046: return "WM_WINDOWPOSCHANGING";
5058 case 0x0047: return "WM_WINDOWPOSCHANGED";
5059 case 0x0048: return "WM_POWER";
5062 case 0x004A: return "WM_COPYDATA";
5063 case 0x004B: return "WM_CANCELJOURNAL";
5064 case 0x004E: return "WM_NOTIFY";
5065 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5066 case 0x0051: return "WM_INPUTLANGCHANGE";
5067 case 0x0052: return "WM_TCARD";
5068 case 0x0053: return "WM_HELP";
5069 case 0x0054: return "WM_USERCHANGED";
5070 case 0x0055: return "WM_NOTIFYFORMAT";
5071 case 0x007B: return "WM_CONTEXTMENU";
5072 case 0x007C: return "WM_STYLECHANGING";
5073 case 0x007D: return "WM_STYLECHANGED";
5074 case 0x007E: return "WM_DISPLAYCHANGE";
5075 case 0x007F: return "WM_GETICON";
5076 case 0x0080: return "WM_SETICON";
5079 case 0x0081: return "WM_NCCREATE";
5080 case 0x0082: return "WM_NCDESTROY";
5081 case 0x0083: return "WM_NCCALCSIZE";
5082 case 0x0084: return "WM_NCHITTEST";
5083 case 0x0085: return "WM_NCPAINT";
5084 case 0x0086: return "WM_NCACTIVATE";
5085 case 0x0087: return "WM_GETDLGCODE";
5086 case 0x00A0: return "WM_NCMOUSEMOVE";
5087 case 0x00A1: return "WM_NCLBUTTONDOWN";
5088 case 0x00A2: return "WM_NCLBUTTONUP";
5089 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5090 case 0x00A4: return "WM_NCRBUTTONDOWN";
5091 case 0x00A5: return "WM_NCRBUTTONUP";
5092 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5093 case 0x00A7: return "WM_NCMBUTTONDOWN";
5094 case 0x00A8: return "WM_NCMBUTTONUP";
5095 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5096 case 0x0100: return "WM_KEYDOWN";
5097 case 0x0101: return "WM_KEYUP";
5098 case 0x0102: return "WM_CHAR";
5099 case 0x0103: return "WM_DEADCHAR";
5100 case 0x0104: return "WM_SYSKEYDOWN";
5101 case 0x0105: return "WM_SYSKEYUP";
5102 case 0x0106: return "WM_SYSCHAR";
5103 case 0x0107: return "WM_SYSDEADCHAR";
5104 case 0x0108: return "WM_KEYLAST";
5107 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5108 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5109 case 0x010F: return "WM_IME_COMPOSITION";
5112 case 0x0110: return "WM_INITDIALOG";
5113 case 0x0111: return "WM_COMMAND";
5114 case 0x0112: return "WM_SYSCOMMAND";
5115 case 0x0113: return "WM_TIMER";
5116 case 0x0114: return "WM_HSCROLL";
5117 case 0x0115: return "WM_VSCROLL";
5118 case 0x0116: return "WM_INITMENU";
5119 case 0x0117: return "WM_INITMENUPOPUP";
5120 case 0x011F: return "WM_MENUSELECT";
5121 case 0x0120: return "WM_MENUCHAR";
5122 case 0x0121: return "WM_ENTERIDLE";
5123 case 0x0200: return "WM_MOUSEMOVE";
5124 case 0x0201: return "WM_LBUTTONDOWN";
5125 case 0x0202: return "WM_LBUTTONUP";
5126 case 0x0203: return "WM_LBUTTONDBLCLK";
5127 case 0x0204: return "WM_RBUTTONDOWN";
5128 case 0x0205: return "WM_RBUTTONUP";
5129 case 0x0206: return "WM_RBUTTONDBLCLK";
5130 case 0x0207: return "WM_MBUTTONDOWN";
5131 case 0x0208: return "WM_MBUTTONUP";
5132 case 0x0209: return "WM_MBUTTONDBLCLK";
5133 case 0x020A: return "WM_MOUSEWHEEL";
5134 case 0x0210: return "WM_PARENTNOTIFY";
5135 case 0x0211: return "WM_ENTERMENULOOP";
5136 case 0x0212: return "WM_EXITMENULOOP";
5139 case 0x0213: return "WM_NEXTMENU";
5140 case 0x0214: return "WM_SIZING";
5141 case 0x0215: return "WM_CAPTURECHANGED";
5142 case 0x0216: return "WM_MOVING";
5143 case 0x0218: return "WM_POWERBROADCAST";
5144 case 0x0219: return "WM_DEVICECHANGE";
5147 case 0x0220: return "WM_MDICREATE";
5148 case 0x0221: return "WM_MDIDESTROY";
5149 case 0x0222: return "WM_MDIACTIVATE";
5150 case 0x0223: return "WM_MDIRESTORE";
5151 case 0x0224: return "WM_MDINEXT";
5152 case 0x0225: return "WM_MDIMAXIMIZE";
5153 case 0x0226: return "WM_MDITILE";
5154 case 0x0227: return "WM_MDICASCADE";
5155 case 0x0228: return "WM_MDIICONARRANGE";
5156 case 0x0229: return "WM_MDIGETACTIVE";
5157 case 0x0230: return "WM_MDISETMENU";
5158 case 0x0233: return "WM_DROPFILES";
5161 case 0x0281: return "WM_IME_SETCONTEXT";
5162 case 0x0282: return "WM_IME_NOTIFY";
5163 case 0x0283: return "WM_IME_CONTROL";
5164 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5165 case 0x0285: return "WM_IME_SELECT";
5166 case 0x0286: return "WM_IME_CHAR";
5167 case 0x0290: return "WM_IME_KEYDOWN";
5168 case 0x0291: return "WM_IME_KEYUP";
5171 case 0x0300: return "WM_CUT";
5172 case 0x0301: return "WM_COPY";
5173 case 0x0302: return "WM_PASTE";
5174 case 0x0303: return "WM_CLEAR";
5175 case 0x0304: return "WM_UNDO";
5176 case 0x0305: return "WM_RENDERFORMAT";
5177 case 0x0306: return "WM_RENDERALLFORMATS";
5178 case 0x0307: return "WM_DESTROYCLIPBOARD";
5179 case 0x0308: return "WM_DRAWCLIPBOARD";
5180 case 0x0309: return "WM_PAINTCLIPBOARD";
5181 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5182 case 0x030B: return "WM_SIZECLIPBOARD";
5183 case 0x030C: return "WM_ASKCBFORMATNAME";
5184 case 0x030D: return "WM_CHANGECBCHAIN";
5185 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5186 case 0x030F: return "WM_QUERYNEWPALETTE";
5187 case 0x0310: return "WM_PALETTEISCHANGING";
5188 case 0x0311: return "WM_PALETTECHANGED";
5191 // common controls messages - although they're not strictly speaking
5192 // standard, it's nice to decode them nevertheless
5195 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5196 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5197 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5198 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5199 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5200 case 0x1000 + 5: return "LVM_GETITEMA";
5201 case 0x1000 + 75: return "LVM_GETITEMW";
5202 case 0x1000 + 6: return "LVM_SETITEMA";
5203 case 0x1000 + 76: return "LVM_SETITEMW";
5204 case 0x1000 + 7: return "LVM_INSERTITEMA";
5205 case 0x1000 + 77: return "LVM_INSERTITEMW";
5206 case 0x1000 + 8: return "LVM_DELETEITEM";
5207 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5208 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5209 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5210 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5211 case 0x1000 + 13: return "LVM_FINDITEMA";
5212 case 0x1000 + 83: return "LVM_FINDITEMW";
5213 case 0x1000 + 14: return "LVM_GETITEMRECT";
5214 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5215 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5216 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5217 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5218 case 0x1000 + 18: return "LVM_HITTEST";
5219 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5220 case 0x1000 + 20: return "LVM_SCROLL";
5221 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5222 case 0x1000 + 22: return "LVM_ARRANGE";
5223 case 0x1000 + 23: return "LVM_EDITLABELA";
5224 case 0x1000 + 118: return "LVM_EDITLABELW";
5225 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5226 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5227 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5228 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5229 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5230 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5231 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5232 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5233 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5234 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5235 case 0x1000 + 31: return "LVM_GETHEADER";
5236 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5237 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5238 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5239 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5240 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5241 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5242 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5243 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5244 case 0x1000 + 41: return "LVM_GETORIGIN";
5245 case 0x1000 + 42: return "LVM_UPDATE";
5246 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5247 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5248 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5249 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5250 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5251 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5252 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5253 case 0x1000 + 48: return "LVM_SORTITEMS";
5254 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5255 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5256 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5257 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5258 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5259 case 0x1000 + 53: return "LVM_SETICONSPACING";
5260 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5261 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5262 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5263 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5264 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5265 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5266 case 0x1000 + 60: return "LVM_SETHOTITEM";
5267 case 0x1000 + 61: return "LVM_GETHOTITEM";
5268 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5269 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5270 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5271 case 0x1000 + 65: return "LVM_SETWORKAREA";
5274 case 0x1100 + 0: return "TVM_INSERTITEMA";
5275 case 0x1100 + 50: return "TVM_INSERTITEMW";
5276 case 0x1100 + 1: return "TVM_DELETEITEM";
5277 case 0x1100 + 2: return "TVM_EXPAND";
5278 case 0x1100 + 4: return "TVM_GETITEMRECT";
5279 case 0x1100 + 5: return "TVM_GETCOUNT";
5280 case 0x1100 + 6: return "TVM_GETINDENT";
5281 case 0x1100 + 7: return "TVM_SETINDENT";
5282 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5283 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5284 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5285 case 0x1100 + 11: return "TVM_SELECTITEM";
5286 case 0x1100 + 12: return "TVM_GETITEMA";
5287 case 0x1100 + 62: return "TVM_GETITEMW";
5288 case 0x1100 + 13: return "TVM_SETITEMA";
5289 case 0x1100 + 63: return "TVM_SETITEMW";
5290 case 0x1100 + 14: return "TVM_EDITLABELA";
5291 case 0x1100 + 65: return "TVM_EDITLABELW";
5292 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5293 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5294 case 0x1100 + 17: return "TVM_HITTEST";
5295 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5296 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5297 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5298 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5299 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5300 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5301 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5302 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5303 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5306 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5307 case 0x1200 + 1: return "HDM_INSERTITEMA";
5308 case 0x1200 + 10: return "HDM_INSERTITEMW";
5309 case 0x1200 + 2: return "HDM_DELETEITEM";
5310 case 0x1200 + 3: return "HDM_GETITEMA";
5311 case 0x1200 + 11: return "HDM_GETITEMW";
5312 case 0x1200 + 4: return "HDM_SETITEMA";
5313 case 0x1200 + 12: return "HDM_SETITEMW";
5314 case 0x1200 + 5: return "HDM_LAYOUT";
5315 case 0x1200 + 6: return "HDM_HITTEST";
5316 case 0x1200 + 7: return "HDM_GETITEMRECT";
5317 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5318 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5319 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5320 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5321 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5322 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5323 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5326 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5327 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5328 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5329 case 0x1300 + 5: return "TCM_GETITEMA";
5330 case 0x1300 + 60: return "TCM_GETITEMW";
5331 case 0x1300 + 6: return "TCM_SETITEMA";
5332 case 0x1300 + 61: return "TCM_SETITEMW";
5333 case 0x1300 + 7: return "TCM_INSERTITEMA";
5334 case 0x1300 + 62: return "TCM_INSERTITEMW";
5335 case 0x1300 + 8: return "TCM_DELETEITEM";
5336 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5337 case 0x1300 + 10: return "TCM_GETITEMRECT";
5338 case 0x1300 + 11: return "TCM_GETCURSEL";
5339 case 0x1300 + 12: return "TCM_SETCURSEL";
5340 case 0x1300 + 13: return "TCM_HITTEST";
5341 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5342 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5343 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5344 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5345 case 0x1300 + 43: return "TCM_SETPADDING";
5346 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5347 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5348 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5349 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5350 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5351 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5352 case 0x1300 + 50: return "TCM_DESELECTALL";
5355 case WM_USER
+1: return "TB_ENABLEBUTTON";
5356 case WM_USER
+2: return "TB_CHECKBUTTON";
5357 case WM_USER
+3: return "TB_PRESSBUTTON";
5358 case WM_USER
+4: return "TB_HIDEBUTTON";
5359 case WM_USER
+5: return "TB_INDETERMINATE";
5360 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5361 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5362 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5363 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5364 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5365 case WM_USER
+17: return "TB_SETSTATE";
5366 case WM_USER
+18: return "TB_GETSTATE";
5367 case WM_USER
+19: return "TB_ADDBITMAP";
5368 case WM_USER
+20: return "TB_ADDBUTTONS";
5369 case WM_USER
+21: return "TB_INSERTBUTTON";
5370 case WM_USER
+22: return "TB_DELETEBUTTON";
5371 case WM_USER
+23: return "TB_GETBUTTON";
5372 case WM_USER
+24: return "TB_BUTTONCOUNT";
5373 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5374 case WM_USER
+26: return "TB_SAVERESTOREA";
5375 case WM_USER
+76: return "TB_SAVERESTOREW";
5376 case WM_USER
+27: return "TB_CUSTOMIZE";
5377 case WM_USER
+28: return "TB_ADDSTRINGA";
5378 case WM_USER
+77: return "TB_ADDSTRINGW";
5379 case WM_USER
+29: return "TB_GETITEMRECT";
5380 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5381 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5382 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5383 case WM_USER
+33: return "TB_AUTOSIZE";
5384 case WM_USER
+35: return "TB_GETTOOLTIPS";
5385 case WM_USER
+36: return "TB_SETTOOLTIPS";
5386 case WM_USER
+37: return "TB_SETPARENT";
5387 case WM_USER
+39: return "TB_SETROWS";
5388 case WM_USER
+40: return "TB_GETROWS";
5389 case WM_USER
+42: return "TB_SETCMDID";
5390 case WM_USER
+43: return "TB_CHANGEBITMAP";
5391 case WM_USER
+44: return "TB_GETBITMAP";
5392 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5393 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5394 case WM_USER
+46: return "TB_REPLACEBITMAP";
5395 case WM_USER
+47: return "TB_SETINDENT";
5396 case WM_USER
+48: return "TB_SETIMAGELIST";
5397 case WM_USER
+49: return "TB_GETIMAGELIST";
5398 case WM_USER
+50: return "TB_LOADIMAGES";
5399 case WM_USER
+51: return "TB_GETRECT";
5400 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5401 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5402 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5403 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5404 case WM_USER
+56: return "TB_SETSTYLE";
5405 case WM_USER
+57: return "TB_GETSTYLE";
5406 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5407 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5408 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5409 case WM_USER
+61: return "TB_GETTEXTROWS";
5410 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5415 static char s_szBuf
[128];
5416 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5420 #endif //__WXDEBUG__
5422 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5423 int *x
, int *y
, WPARAM
*flags
)
5425 // construct the key mask
5426 WPARAM
& fwKeys
= *flags
;
5428 fwKeys
= MK_RBUTTON
;
5429 if ( wxIsCtrlDown() )
5430 fwKeys
|= MK_CONTROL
;
5431 if ( wxIsShiftDown() )
5434 // simulate right mouse button click
5435 DWORD dwPos
= ::GetMessagePos();
5436 *x
= GET_X_LPARAM(dwPos
);
5437 *y
= GET_Y_LPARAM(dwPos
);
5439 win
->ScreenToClient(x
, y
);
5442 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5446 HWND hwnd
= GetHwndOf(win
);
5447 HDC hdc
= ::GetDC(hwnd
);
5449 #if !wxDIALOG_UNIT_COMPATIBILITY
5450 // and select the current font into it
5451 HFONT hfont
= GetHfontOf(win
->GetFont());
5454 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5458 // finally retrieve the text metrics from it
5459 GetTextMetrics(hdc
, &tm
);
5461 #if !wxDIALOG_UNIT_COMPATIBILITY
5465 (void)::SelectObject(hdc
, hfont
);
5469 ::ReleaseDC(hwnd
, hdc
);
5474 // Find the wxWindow at the current mouse position, returning the mouse
5476 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5478 pt
= wxGetMousePosition();
5479 return wxFindWindowAtPoint(pt
);
5482 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5487 HWND hWndHit
= ::WindowFromPoint(pt2
);
5489 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5490 HWND hWnd
= hWndHit
;
5492 // Try to find a window with a wxWindow associated with it
5493 while (!win
&& (hWnd
!= 0))
5495 hWnd
= ::GetParent(hWnd
);
5496 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5501 // Get the current mouse position.
5502 wxPoint
wxGetMousePosition()
5505 GetCursorPos( & pt
);
5507 return wxPoint(pt
.x
, pt
.y
);