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 and Markus Holzem
9 // Licence: wxWindows license
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 #include "wx/menuitem.h"
64 #include "wx/msw/private.h"
67 #include "wx/tooltip.h"
75 #include "wx/spinctrl.h"
76 #endif // wxUSE_SPINCTRL
81 #include "wx/textctrl.h"
82 #include "wx/notebook.h"
86 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
95 #if (!defined(__GNUWIN32_OLD__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
99 #elif !defined(__WXMICROWIN__) // broken compiler
101 #include "wx/msw/gnuwin32/extra.h"
105 // ----------------------------------------------------------------------------
106 // standard constants not available with all compilers/headers
107 // ----------------------------------------------------------------------------
109 // This didn't appear in mingw until 2.95.2
111 #define SIF_TRACKPOS 16
115 #ifndef WM_MOUSEWHEEL
116 #define WM_MOUSEWHEEL 0x020A
119 #define WHEEL_DELTA 120
121 #ifndef SPI_GETWHEELSCROLLLINES
122 #define SPI_GETWHEELSCROLLLINES 104
124 #endif // wxUSE_MOUSEWHEEL
127 #define VK_OEM_1 0xBA
128 #define VK_OEM_PLUS 0xBB
129 #define VK_OEM_COMMA 0xBC
130 #define VK_OEM_MINUS 0xBD
131 #define VK_OEM_PERIOD 0xBE
132 #define VK_OEM_2 0xBF
133 #define VK_OEM_3 0xC0
134 #define VK_OEM_4 0xDB
135 #define VK_OEM_5 0xDC
136 #define VK_OEM_6 0xDD
137 #define VK_OEM_7 0xDE
140 // ---------------------------------------------------------------------------
142 // ---------------------------------------------------------------------------
144 // the last Windows message we got (FIXME-MT)
145 extern MSG s_currentMsg
;
147 #if wxUSE_MENUS_NATIVE
148 wxMenu
*wxCurrentPopupMenu
= NULL
;
149 #endif // wxUSE_MENUS_NATIVE
151 extern const wxChar
*wxCanvasClassName
;
153 // true if we had already created the std colour map, used by
154 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
155 static bool gs_hasStdCmap
= FALSE
;
157 // ---------------------------------------------------------------------------
159 // ---------------------------------------------------------------------------
161 // the window proc for all our windows
162 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
163 WPARAM wParam
, LPARAM lParam
);
166 const char *wxGetMessageName(int message
);
169 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
170 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
171 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
173 // this magical function is used to translate VK_APPS key presses to right
175 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
176 int *x
, int *y
, WPARAM
*flags
);
178 // get the text metrics for the current font
179 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
181 // find the window for the mouse event at the specified position
182 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
184 // wrapper around BringWindowToTop() API
185 static inline void wxBringWindowToTop(HWND hwnd
)
187 #ifdef __WXMICROWIN__
188 // It seems that MicroWindows brings the _parent_ of the window to the top,
189 // which can be the wrong one.
191 // activate (set focus to) specified window
194 // raise top level parent to top of z order
195 ::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
);
196 #else // !__WXMICROWIN__
197 if ( !::BringWindowToTop(hwnd
) )
199 wxLogLastError(_T("BringWindowToTop"));
201 #endif // __WXMICROWIN__/!__WXMICROWIN__
204 // ---------------------------------------------------------------------------
206 // ---------------------------------------------------------------------------
208 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
210 #ifdef __WXUNIVERSAL__
211 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
213 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
214 #endif // __WXUNIVERSAL__/__WXMSW__
216 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
217 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
218 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
219 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
220 EVT_IDLE(wxWindowMSW::OnIdle
)
223 // ===========================================================================
225 // ===========================================================================
227 // ---------------------------------------------------------------------------
228 // wxWindow utility functions
229 // ---------------------------------------------------------------------------
231 // Find an item given the MS Windows id
232 wxWindow
*wxWindowMSW::FindItem(long id
) const
235 wxControl
*item
= wxDynamicCastThis(wxControl
);
238 // is it we or one of our "internal" children?
239 if ( item
->GetId() == id
240 #ifndef __WXUNIVERSAL__
241 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
242 #endif // __WXUNIVERSAL__
248 #endif // wxUSE_CONTROLS
250 wxWindowList::Node
*current
= GetChildren().GetFirst();
253 wxWindow
*childWin
= current
->GetData();
255 wxWindow
*wnd
= childWin
->FindItem(id
);
259 current
= current
->GetNext();
265 // Find an item given the MS Windows handle
266 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
268 wxWindowList::Node
*current
= GetChildren().GetFirst();
271 wxWindow
*parent
= current
->GetData();
273 // Do a recursive search.
274 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
280 || parent
->IsKindOf(CLASSINFO(wxControl
))
281 #endif // wxUSE_CONTROLS
284 wxWindow
*item
= current
->GetData();
285 if ( item
->GetHWND() == hWnd
)
289 if ( item
->ContainsHWND(hWnd
) )
294 current
= current
->GetNext();
299 // Default command handler
300 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
305 // ----------------------------------------------------------------------------
306 // constructors and such
307 // ----------------------------------------------------------------------------
309 void wxWindowMSW::Init()
315 m_isBeingDeleted
= FALSE
;
318 m_mouseInWindow
= FALSE
;
319 m_lastKeydownProcessed
= FALSE
;
328 m_backgroundTransparent
= FALSE
;
330 // as all windows are created with WS_VISIBLE style...
333 #if wxUSE_MOUSEEVENT_HACK
336 m_lastMouseEvent
= -1;
337 #endif // wxUSE_MOUSEEVENT_HACK
341 wxWindowMSW::~wxWindowMSW()
343 m_isBeingDeleted
= TRUE
;
345 #ifndef __WXUNIVERSAL__
346 // VS: make sure there's no wxFrame with last focus set to us:
347 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
349 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
352 if ( frame
->GetLastFocus() == this )
354 frame
->SetLastFocus(NULL
);
359 #endif // __WXUNIVERSAL__
361 // VS: destroy children first and _then_ detach *this from its parent.
362 // If we'd do it the other way around, children wouldn't be able
363 // find their parent frame (see above).
367 m_parent
->RemoveChild(this);
371 // VZ: test temp removed to understand what really happens here
372 //if (::IsWindow(GetHwnd()))
374 if ( !::DestroyWindow(GetHwnd()) )
375 wxLogLastError(wxT("DestroyWindow"));
378 // remove hWnd <-> wxWindow association
379 wxRemoveHandleAssociation(this);
383 // real construction (Init() must have been called before!)
384 bool wxWindowMSW::Create(wxWindow
*parent
,
389 const wxString
& name
)
391 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
394 // wxGTK doesn't allow to create controls with static box as the parent so
395 // this will result in a crash when the program is ported to wxGTK - warn
398 // the correct solution is to create the controls as siblings of the
400 wxASSERT_MSG( !wxDynamicCast(parent
, wxStaticBox
),
401 _T("wxStaticBox can't be used as a window parent!") );
402 #endif // wxUSE_STATBOX
404 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
407 parent
->AddChild(this);
410 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
412 #ifdef __WXUNIVERSAL__
413 // no borders, we draw them ourselves
414 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
418 msflags
&= ~WS_BORDER
;
419 #endif // wxUniversal
421 // all windows are created visible by default except popup ones (which are
422 // like the wxTopLevelWindows in this aspect)
423 if ( style
& wxPOPUP_WINDOW
)
425 msflags
&= ~WS_VISIBLE
;
430 msflags
|= WS_VISIBLE
;
433 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
436 // ---------------------------------------------------------------------------
438 // ---------------------------------------------------------------------------
440 void wxWindowMSW::SetFocus()
442 HWND hWnd
= GetHwnd();
443 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
445 #ifndef __WXMICROWIN__
449 if ( !::SetFocus(hWnd
) )
451 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
452 // was there really an error?
453 DWORD dwRes
= ::GetLastError();
456 HWND hwndFocus
= ::GetFocus();
457 if ( hwndFocus
!= hWnd
)
459 wxLogApiError(_T("SetFocus"), dwRes
);
466 void wxWindowMSW::SetFocusFromKbd()
468 wxWindowBase::SetFocusFromKbd();
470 // when the focus is given to the control with DLGC_HASSETSEL style from
471 // keyboard its contents should be entirely selected: this is what
472 // ::IsDialogMessage() does and so we should do it as well to provide the
473 // same LNF as the native programs
474 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
476 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
480 // Get the window with the focus
481 wxWindow
*wxWindowBase::FindFocus()
483 HWND hWnd
= ::GetFocus();
486 return wxGetWindowFromHWND((WXHWND
)hWnd
);
492 bool wxWindowMSW::Enable(bool enable
)
494 if ( !wxWindowBase::Enable(enable
) )
497 HWND hWnd
= GetHwnd();
499 ::EnableWindow(hWnd
, (BOOL
)enable
);
501 // VZ: no, this is a bad idea: imagine that you have a dialog with some
502 // disabled controls and disable it - you really wouldn't like the
503 // disabled controls be reenabled too when you reenable the dialog!
505 wxWindowList::Node
*node
= GetChildren().GetFirst();
508 wxWindow
*child
= node
->GetData();
509 child
->Enable(enable
);
511 node
= node
->GetNext();
518 bool wxWindowMSW::Show(bool show
)
520 if ( !wxWindowBase::Show(show
) )
523 HWND hWnd
= GetHwnd();
524 int cshow
= show
? SW_SHOW
: SW_HIDE
;
525 ::ShowWindow(hWnd
, cshow
);
529 wxBringWindowToTop(hWnd
);
535 // Raise the window to the top of the Z order
536 void wxWindowMSW::Raise()
538 wxBringWindowToTop(GetHwnd());
541 // Lower the window to the bottom of the Z order
542 void wxWindowMSW::Lower()
544 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
545 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
548 void wxWindowMSW::SetTitle( const wxString
& title
)
550 SetWindowText(GetHwnd(), title
.c_str());
553 wxString
wxWindowMSW::GetTitle() const
555 return wxGetWindowText(GetHWND());
558 void wxWindowMSW::DoCaptureMouse()
560 HWND hWnd
= GetHwnd();
567 void wxWindowMSW::DoReleaseMouse()
569 if ( !::ReleaseCapture() )
571 wxLogLastError(_T("ReleaseCapture"));
575 /* static */ wxWindow
*wxWindowBase::GetCapture()
577 HWND hwnd
= ::GetCapture();
578 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
581 bool wxWindowMSW::SetFont(const wxFont
& font
)
583 if ( !wxWindowBase::SetFont(font
) )
589 HWND hWnd
= GetHwnd();
592 WXHANDLE hFont
= m_font
.GetResourceHandle();
594 wxASSERT_MSG( hFont
, wxT("should have valid font") );
596 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
601 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
603 if ( !wxWindowBase::SetCursor(cursor
) )
611 HWND hWnd
= GetHwnd();
613 // Change the cursor NOW if we're within the correct window
615 ::GetCursorPos(&point
);
617 RECT rect
= wxGetWindowRect(hWnd
);
619 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
620 ::SetCursor(GetHcursorOf(m_cursor
));
626 void wxWindowMSW::WarpPointer (int x
, int y
)
628 ClientToScreen(&x
, &y
);
630 if ( !::SetCursorPos(x
, y
) )
632 wxLogLastError(_T("SetCursorPos"));
636 #if WXWIN_COMPATIBILITY
637 void wxWindowMSW::MSWDeviceToLogical (float *x
, float *y
) const
640 #endif // WXWIN_COMPATIBILITY
642 // ---------------------------------------------------------------------------
644 // ---------------------------------------------------------------------------
646 #if WXWIN_COMPATIBILITY
647 void wxWindowMSW::SetScrollRange(int orient
, int range
, bool refresh
)
649 #if defined(__WIN95__)
653 // Try to adjust the range to cope with page size > 1
654 // - a Windows API quirk
655 int pageSize
= GetScrollPage(orient
);
656 if ( pageSize
> 1 && range
> 0)
658 range1
+= (pageSize
- 1);
664 if ( orient
== wxHORIZONTAL
) {
670 info
.cbSize
= sizeof(SCROLLINFO
);
671 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
675 info
.fMask
= SIF_RANGE
| SIF_PAGE
;
677 HWND hWnd
= GetHwnd();
679 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
682 if ( orient
== wxHORIZONTAL
)
687 HWND hWnd
= GetHwnd();
689 ::SetScrollRange(hWnd
, wOrient
, 0, range
, refresh
);
693 void wxWindowMSW::SetScrollPage(int orient
, int page
, bool refresh
)
695 #if defined(__WIN95__)
699 if ( orient
== wxHORIZONTAL
) {
707 info
.cbSize
= sizeof(SCROLLINFO
);
710 info
.fMask
= SIF_PAGE
;
712 HWND hWnd
= GetHwnd();
714 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
716 if ( orient
== wxHORIZONTAL
)
723 int wxWindowMSW::OldGetScrollRange(int orient
) const
726 if ( orient
== wxHORIZONTAL
)
731 #if __WATCOMC__ && defined(__WINDOWS_386__)
732 short minPos
, maxPos
;
736 HWND hWnd
= GetHwnd();
739 ::GetScrollRange(hWnd
, wOrient
, &minPos
, &maxPos
);
740 #if defined(__WIN95__)
741 // Try to adjust the range to cope with page size > 1
742 // - a Windows API quirk
743 int pageSize
= GetScrollPage(orient
);
746 maxPos
-= (pageSize
- 1);
755 int wxWindowMSW::GetScrollPage(int orient
) const
757 if ( orient
== wxHORIZONTAL
)
763 #endif // WXWIN_COMPATIBILITY
765 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
767 #ifdef __WXMICROWIN__
768 return ::GetScrollPosWX(hWnd
, wOrient
);
770 return ::GetScrollPos(hWnd
, wOrient
);
774 int wxWindowMSW::GetScrollPos(int orient
) const
777 if ( orient
== wxHORIZONTAL
)
782 HWND hWnd
= GetHwnd();
783 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
785 return GetScrollPosition(hWnd
, wOrient
);
788 // This now returns the whole range, not just the number
789 // of positions that we can scroll.
790 int wxWindowMSW::GetScrollRange(int orient
) const
793 if ( orient
== wxHORIZONTAL
)
798 #if __WATCOMC__ && defined(__WINDOWS_386__)
799 short minPos
, maxPos
;
803 HWND hWnd
= GetHwnd();
806 ::GetScrollRange(hWnd
, wOrient
, &minPos
, &maxPos
);
807 #if defined(__WIN95__)
808 // Try to adjust the range to cope with page size > 1
809 // - a Windows API quirk
810 int pageSize
= GetScrollThumb(orient
);
813 maxPos
-= (pageSize
- 1);
815 // October 10th: new range concept.
825 int wxWindowMSW::GetScrollThumb(int orient
) const
827 if ( orient
== wxHORIZONTAL
)
833 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
835 HWND hWnd
= GetHwnd();
836 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
838 int dir
= orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
840 #if defined(__WIN95__)
842 info
.cbSize
= sizeof(SCROLLINFO
);
846 info
.fMask
= SIF_POS
;
848 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
850 ::SetScrollPos(hWnd
, dir
, pos
, refresh
);
851 #endif // __WIN95__/!__WIN95__
854 // New function that will replace some of the above.
855 void wxWindowMSW::SetScrollbar(int orient
, int pos
, int thumbVisible
,
856 int range
, bool refresh
)
858 #if defined(__WIN95__)
859 int oldRange
= range
- thumbVisible
;
861 int range1
= oldRange
;
863 // Try to adjust the range to cope with page size > 1
864 // - a Windows API quirk
865 int pageSize
= thumbVisible
;
866 if ( pageSize
> 1 && range
> 0)
868 range1
+= (pageSize
- 1);
874 if ( orient
== wxHORIZONTAL
) {
880 info
.cbSize
= sizeof(SCROLLINFO
);
881 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
885 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
887 HWND hWnd
= GetHwnd();
889 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
892 if ( orient
== wxHORIZONTAL
)
897 HWND hWnd
= GetHwnd();
900 ::SetScrollRange(hWnd
, wOrient
, 0, range
, FALSE
);
901 ::SetScrollPos(hWnd
, wOrient
, pos
, refresh
);
904 if ( orient
== wxHORIZONTAL
) {
905 m_xThumbSize
= thumbVisible
;
907 m_yThumbSize
= thumbVisible
;
911 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
917 rect
.left
= prect
->x
;
919 rect
.right
= prect
->x
+ prect
->width
;
920 rect
.bottom
= prect
->y
+ prect
->height
;
928 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
931 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
933 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
936 for ( int n
= 0; n
< count
; n
++ )
938 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
940 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
943 // don't bother to continue, we're already at top/bottom
950 return pos
!= posStart
;
953 bool wxWindowMSW::ScrollLines(int lines
)
955 bool down
= lines
> 0;
957 return ScrollVertically(GetHwnd(),
958 down
? SB_LINEDOWN
: SB_LINEUP
,
959 down
? lines
: -lines
);
962 bool wxWindowMSW::ScrollPages(int pages
)
964 bool down
= pages
> 0;
966 return ScrollVertically(GetHwnd(),
967 down
? SB_PAGEDOWN
: SB_PAGEUP
,
968 down
? pages
: -pages
);
971 // ---------------------------------------------------------------------------
973 // ---------------------------------------------------------------------------
975 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
977 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
979 HWND hwnd
= (HWND
)hWnd
;
980 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
982 wxAssociateWinWithHandle(hwnd
, this);
984 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
986 // we don't need to subclass the window of our own class (in the Windows
987 // sense of the word)
988 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
990 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
994 // don't bother restoring it neither: this also makes it easy to
995 // implement IsOfStandardClass() method which returns TRUE for the
996 // standard controls and FALSE for the wxWindows own windows as it can
997 // simply check m_oldWndProc
1002 void wxWindowMSW::UnsubclassWin()
1004 wxRemoveHandleAssociation(this);
1006 // Restore old Window proc
1007 HWND hwnd
= GetHwnd();
1012 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1016 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1018 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
1021 m_oldWndProc
= NULL
;
1026 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1028 #if wxUSE_UNICODE_MSLU
1029 // VS: We can't use GetWindowLong(hwnd, GWL_WNDPROC) together with unicows.dll
1030 // because it doesn't return pointer to the real wnd proc but rather a handle
1031 // of a fake proc that does Unicode<->ANSI translation.
1033 // The hack bellow works, because WNDCLASS contains original window handler
1034 // rather that the unicows fake one. This may not be on purpose, though; if
1035 // it stops working with future versions of unicows.dll, we can override
1036 // unicows hooks by setting Unicows_{Set,Get}WindowLong and
1037 // Unicows_RegisterClass to our own versions that keep track of
1038 // fake<->real wnd proc mapping.
1040 // FIXME: Doesn't handle wnd procs set by SetWindowLong, only these set
1041 // with RegisterClass!!
1043 if ( wxUsingUnicowsDll() )
1045 static wxChar buffer
[512];
1048 ::GetClassName((HWND
)hWnd
, buffer
, 512);
1049 ::GetClassInfo(wxGetInstance(), buffer
, &cls
);
1050 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1055 return wndProc
== (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
1059 // ----------------------------------------------------------------------------
1061 // ----------------------------------------------------------------------------
1063 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1065 long flagsOld
= GetWindowStyleFlag();
1066 if ( flags
== flagsOld
)
1069 // update the internal variable
1070 wxWindowBase::SetWindowStyleFlag(flags
);
1072 // now update the Windows style as well if needed - and if the window had
1073 // been already created
1077 WXDWORD exstyle
, exstyleOld
;
1078 long style
= MSWGetStyle(flags
, &exstyle
),
1079 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1081 if ( style
!= styleOld
)
1083 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1084 // this function so instead of simply setting the style to the new
1085 // value we clear the bits which were set in styleOld but are set in
1086 // the new one and set the ones which were not set before
1087 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1088 styleReal
&= ~styleOld
;
1091 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1094 // and the extended style
1095 if ( exstyle
!= exstyleOld
)
1097 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1098 exstyleReal
&= ~exstyleOld
;
1099 exstyleReal
|= exstyle
;
1101 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1103 // we must call SetWindowPos() to flash the cached extended style and
1104 // also to make the change to wxSTAY_ON_TOP style take effect: just
1105 // setting the style simply doesn't work
1106 if ( !::SetWindowPos(GetHwnd(),
1107 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1110 SWP_NOMOVE
| SWP_NOSIZE
) )
1112 wxLogLastError(_T("SetWindowPos"));
1117 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1119 // translate the style
1120 WXDWORD style
= WS_CHILD
;
1122 if ( flags
& wxCLIP_CHILDREN
)
1123 style
|= WS_CLIPCHILDREN
;
1125 if ( flags
& wxCLIP_SIBLINGS
)
1126 style
|= WS_CLIPSIBLINGS
;
1128 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
1129 if ( border
!= wxBORDER_NONE
&& border
!= wxBORDER_DEFAULT
)
1132 // now deal with ext style if the caller wants it
1137 if ( flags
& wxTRANSPARENT_WINDOW
)
1138 *exstyle
|= WS_EX_TRANSPARENT
;
1140 switch ( flags
& wxBORDER_MASK
)
1143 wxFAIL_MSG( _T("unknown border style") );
1147 case wxBORDER_SIMPLE
:
1148 case wxBORDER_DEFAULT
:
1151 case wxBORDER_STATIC
:
1152 *exstyle
|= WS_EX_STATICEDGE
;
1155 case wxBORDER_RAISED
:
1156 *exstyle
|= WS_EX_WINDOWEDGE
;
1159 case wxBORDER_SUNKEN
:
1160 *exstyle
|= WS_EX_CLIENTEDGE
;
1163 case wxBORDER_DOUBLE
:
1164 *exstyle
|= WS_EX_DLGMODALFRAME
;
1168 // wxUniv doesn't use Windows dialog navigation functions at all
1169 #ifndef __WXUNIVERSAL__
1170 // to make the dialog navigation work with the nested panels we must
1171 // use this style (top level windows such as dialogs don't need it)
1172 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1174 *exstyle
|= WS_EX_CONTROLPARENT
;
1176 #endif // __WXUNIVERSAL__
1182 // Make a Windows extended style from the given wxWindows window style
1183 WXDWORD
wxWindowMSW::MakeExtendedStyle(long style
, bool eliminateBorders
)
1185 WXDWORD exStyle
= 0;
1186 if ( style
& wxTRANSPARENT_WINDOW
)
1187 exStyle
|= WS_EX_TRANSPARENT
;
1189 if ( !eliminateBorders
)
1191 if ( style
& wxSUNKEN_BORDER
)
1192 exStyle
|= WS_EX_CLIENTEDGE
;
1193 if ( style
& wxDOUBLE_BORDER
)
1194 exStyle
|= WS_EX_DLGMODALFRAME
;
1195 #if defined(__WIN95__)
1196 if ( style
& wxRAISED_BORDER
)
1197 // It seems that WS_EX_WINDOWEDGE doesn't work, but WS_EX_DLGMODALFRAME does
1198 exStyle
|= WS_EX_DLGMODALFRAME
; /* WS_EX_WINDOWEDGE */;
1199 if ( style
& wxSTATIC_BORDER
)
1200 exStyle
|= WS_EX_STATICEDGE
;
1207 // Determines whether native 3D effects or CTL3D should be used,
1208 // applying a default border style if required, and returning an extended
1209 // style to pass to CreateWindowEx.
1210 WXDWORD
wxWindowMSW::Determine3DEffects(WXDWORD defaultBorderStyle
,
1213 // If matches certain criteria, then assume no 3D effects
1214 // unless specifically requested (dealt with in MakeExtendedStyle)
1217 || !IsKindOf(CLASSINFO(wxControl
))
1218 #endif // wxUSE_CONTROLS
1219 || (m_windowStyle
& wxNO_BORDER
) )
1222 return MakeExtendedStyle(m_windowStyle
);
1225 // Determine whether we should be using 3D effects or not.
1226 bool nativeBorder
= FALSE
; // by default, we don't want a Win95 effect
1228 // 1) App can specify global 3D effects
1229 *want3D
= wxTheApp
->GetAuto3D();
1231 // 2) If the parent is being drawn with user colours, or simple border specified,
1232 // switch effects off. TODO: replace wxUSER_COLOURS with wxNO_3D
1233 if ( GetParent() && (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS
) || (m_windowStyle
& wxSIMPLE_BORDER
) )
1236 // 3) Control can override this global setting by defining
1237 // a border style, e.g. wxSUNKEN_BORDER
1238 if ( m_windowStyle
& wxSUNKEN_BORDER
)
1241 // 4) If it's a special border, CTL3D can't cope so we want a native border
1242 if ( (m_windowStyle
& wxDOUBLE_BORDER
) || (m_windowStyle
& wxRAISED_BORDER
) ||
1243 (m_windowStyle
& wxSTATIC_BORDER
) )
1246 nativeBorder
= TRUE
;
1249 // 5) If this isn't a Win95 app, and we are using CTL3D, remove border
1250 // effects from extended style
1253 nativeBorder
= FALSE
;
1256 DWORD exStyle
= MakeExtendedStyle(m_windowStyle
, !nativeBorder
);
1258 // If we want 3D, but haven't specified a border here,
1259 // apply the default border style specified.
1260 // TODO what about non-Win95 WIN32? Does it have borders?
1261 #if defined(__WIN95__) && !wxUSE_CTL3D
1262 if ( defaultBorderStyle
&& (*want3D
) && ! ((m_windowStyle
& wxDOUBLE_BORDER
) || (m_windowStyle
& wxRAISED_BORDER
) ||
1263 (m_windowStyle
& wxSTATIC_BORDER
) || (m_windowStyle
& wxSIMPLE_BORDER
) ))
1264 exStyle
|= defaultBorderStyle
; // WS_EX_CLIENTEDGE;
1270 #if WXWIN_COMPATIBILITY
1271 // If nothing defined for this, try the parent.
1272 // E.g. we may be a button loaded from a resource, with no callback function
1274 void wxWindowMSW::OnCommand(wxWindow
& win
, wxCommandEvent
& event
)
1276 if ( GetEventHandler()->ProcessEvent(event
) )
1279 m_parent
->GetEventHandler()->OnCommand(win
, event
);
1281 #endif // WXWIN_COMPATIBILITY_2
1283 #if WXWIN_COMPATIBILITY
1284 wxObject
* wxWindowMSW::GetChild(int number
) const
1286 // Return a pointer to the Nth object in the Panel
1287 wxNode
*node
= GetChildren().First();
1290 node
= node
->Next();
1293 wxObject
*obj
= (wxObject
*)node
->Data();
1299 #endif // WXWIN_COMPATIBILITY
1301 // Setup background and foreground colours correctly
1302 void wxWindowMSW::SetupColours()
1305 SetBackgroundColour(GetParent()->GetBackgroundColour());
1308 bool wxWindowMSW::IsMouseInWindow() const
1310 // get the mouse position
1312 ::GetCursorPos(&pt
);
1314 // find the window which currently has the cursor and go up the window
1315 // chain until we find this window - or exhaust it
1316 HWND hwnd
= ::WindowFromPoint(pt
);
1317 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1318 hwnd
= ::GetParent(hwnd
);
1320 return hwnd
!= NULL
;
1323 void wxWindowMSW::OnIdle(wxIdleEvent
& WXUNUSED(event
))
1325 // Check if we need to send a LEAVE event
1326 if ( m_mouseInWindow
)
1328 // note that we should generate the leave event whether the window has
1329 // or doesn't have mouse capture
1330 if ( !IsMouseInWindow() )
1332 // Generate a LEAVE event
1333 m_mouseInWindow
= FALSE
;
1335 // Unfortunately the mouse button and keyboard state may have
1336 // changed by the time the OnIdle function is called, so 'state'
1337 // may be meaningless.
1339 if ( wxIsShiftDown() )
1341 if ( wxIsCtrlDown() )
1342 state
|= MK_CONTROL
;
1343 if ( GetKeyState( VK_LBUTTON
) )
1344 state
|= MK_LBUTTON
;
1345 if ( GetKeyState( VK_MBUTTON
) )
1346 state
|= MK_MBUTTON
;
1347 if ( GetKeyState( VK_RBUTTON
) )
1348 state
|= MK_RBUTTON
;
1351 if ( !::GetCursorPos(&pt
) )
1353 wxLogLastError(_T("GetCursorPos"));
1356 // we need to have client coordinates here for symmetry with
1357 // wxEVT_ENTER_WINDOW
1358 RECT rect
= wxGetWindowRect(GetHwnd());
1362 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1363 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1365 (void)GetEventHandler()->ProcessEvent(event2
);
1372 // Set this window to be the child of 'parent'.
1373 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1375 if ( !wxWindowBase::Reparent(parent
) )
1378 HWND hWndChild
= GetHwnd();
1379 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1381 ::SetParent(hWndChild
, hWndParent
);
1386 void wxWindowMSW::Clear()
1388 wxClientDC
dc((wxWindow
*)this);
1389 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1390 dc
.SetBackground(brush
);
1394 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1396 #ifndef __WXMICROWIN__
1397 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1401 void wxWindowMSW::Freeze()
1403 SendSetRedraw(GetHwnd(), FALSE
);
1406 void wxWindowMSW::Thaw()
1408 SendSetRedraw(GetHwnd(), TRUE
);
1410 // we need to refresh everything or otherwise he invalidated area is not
1415 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1417 HWND hWnd
= GetHwnd();
1423 mswRect
.left
= rect
->x
;
1424 mswRect
.top
= rect
->y
;
1425 mswRect
.right
= rect
->x
+ rect
->width
;
1426 mswRect
.bottom
= rect
->y
+ rect
->height
;
1428 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1431 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1435 void wxWindowMSW::Update()
1437 if ( !::UpdateWindow(GetHwnd()) )
1439 wxLogLastError(_T("UpdateWindow"));
1442 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1443 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1444 // handler needs to be really drawn right now
1449 // ---------------------------------------------------------------------------
1451 // ---------------------------------------------------------------------------
1453 #if wxUSE_DRAG_AND_DROP
1455 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1457 if ( m_dropTarget
!= 0 ) {
1458 m_dropTarget
->Revoke(m_hWnd
);
1459 delete m_dropTarget
;
1462 m_dropTarget
= pDropTarget
;
1463 if ( m_dropTarget
!= 0 )
1464 m_dropTarget
->Register(m_hWnd
);
1467 #endif // wxUSE_DRAG_AND_DROP
1469 // old style file-manager drag&drop support: we retain the old-style
1470 // DragAcceptFiles in parallel with SetDropTarget.
1471 void wxWindowMSW::DragAcceptFiles(bool accept
)
1473 HWND hWnd
= GetHwnd();
1475 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1478 // ----------------------------------------------------------------------------
1480 // ----------------------------------------------------------------------------
1484 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1486 wxWindowBase::DoSetToolTip(tooltip
);
1489 m_tooltip
->SetWindow(this);
1492 #endif // wxUSE_TOOLTIPS
1494 // ---------------------------------------------------------------------------
1495 // moving and resizing
1496 // ---------------------------------------------------------------------------
1499 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1501 RECT rect
= wxGetWindowRect(GetHwnd());
1504 *x
= rect
.right
- rect
.left
;
1506 *y
= rect
.bottom
- rect
.top
;
1509 // Get size *available for subwindows* i.e. excluding menu bar etc.
1510 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1512 RECT rect
= wxGetClientRect(GetHwnd());
1520 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1522 RECT rect
= wxGetWindowRect(GetHwnd());
1525 point
.x
= rect
.left
;
1528 // we do the adjustments with respect to the parent only for the "real"
1529 // children, not for the dialogs/frames
1530 if ( !IsTopLevel() )
1532 HWND hParentWnd
= 0;
1533 wxWindow
*parent
= GetParent();
1535 hParentWnd
= GetWinHwnd(parent
);
1537 // Since we now have the absolute screen coords, if there's a parent we
1538 // must subtract its top left corner
1541 ::ScreenToClient(hParentWnd
, &point
);
1546 // We may be faking the client origin. So a window that's really at (0,
1547 // 30) may appear (to wxWin apps) to be at (0, 0).
1548 wxPoint
pt(parent
->GetClientAreaOrigin());
1560 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1568 ::ScreenToClient(GetHwnd(), &pt
);
1576 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1584 ::ClientToScreen(GetHwnd(), &pt
);
1592 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1594 // TODO: is this consistent with other platforms?
1595 // Still, negative width or height shouldn't be allowed
1600 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1602 wxLogLastError(wxT("MoveWindow"));
1606 // set the size of the window: if the dimensions are positive, just use them,
1607 // but if any of them is equal to -1, it means that we must find the value for
1608 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1609 // which case -1 is a valid value for x and y)
1611 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1612 // the width/height to best suit our contents, otherwise we reuse the current
1614 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1616 // get the current size and position...
1617 int currentX
, currentY
;
1618 GetPosition(¤tX
, ¤tY
);
1619 int currentW
,currentH
;
1620 GetSize(¤tW
, ¤tH
);
1622 // ... and don't do anything (avoiding flicker) if it's already ok
1623 if ( x
== currentX
&& y
== currentY
&&
1624 width
== currentW
&& height
== currentH
)
1629 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1631 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1634 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1636 wxSize
size(-1, -1);
1639 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1641 size
= DoGetBestSize();
1646 // just take the current one
1653 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1657 size
= DoGetBestSize();
1659 //else: already called DoGetBestSize() above
1665 // just take the current one
1670 DoMoveWindow(x
, y
, width
, height
);
1673 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1675 // setting the client size is less obvious than it it could have been
1676 // because in the result of changing the total size the window scrollbar
1677 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1678 // will not be correct as the difference between the total and client size
1679 // changes - so we keep changing it until we get it right
1681 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1682 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1683 // may become 3 if the window had 0 size originally and so we didn't
1684 // calculate the scrollbar correction correctly during the first iteration)
1685 // but just to be on the safe side we check for it instead of making it an
1686 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1687 for ( int i
= 0; i
< 4; i
++ )
1690 ::GetClientRect(GetHwnd(), &rectClient
);
1692 // if the size is already ok, stop here (rectClient.left = top = 0)
1693 if ( (rectClient
.right
== width
|| width
== -1) &&
1694 (rectClient
.bottom
== height
|| height
== -1) )
1699 int widthClient
= width
,
1700 heightClient
= height
;
1702 // Find the difference between the entire window (title bar and all)
1703 // and the client area; add this to the new client size to move the
1706 ::GetWindowRect(GetHwnd(), &rectWin
);
1708 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1709 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1712 point
.x
= rectWin
.left
;
1713 point
.y
= rectWin
.top
;
1715 // MoveWindow positions the child windows relative to the parent, so
1716 // adjust if necessary
1717 if ( !IsTopLevel() )
1719 wxWindow
*parent
= GetParent();
1722 ::ScreenToClient(GetHwndOf(parent
), &point
);
1726 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1730 // For implementation purposes - sometimes decorations make the client area
1732 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1734 return wxPoint(0, 0);
1737 // ---------------------------------------------------------------------------
1739 // ---------------------------------------------------------------------------
1741 int wxWindowMSW::GetCharHeight() const
1743 return wxGetTextMetrics(this).tmHeight
;
1746 int wxWindowMSW::GetCharWidth() const
1748 // +1 is needed because Windows apparently adds it when calculating the
1749 // dialog units size in pixels
1750 #if wxDIALOG_UNIT_COMPATIBILITY
1751 return wxGetTextMetrics(this).tmAveCharWidth
;
1753 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1757 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1759 int *descent
, int *externalLeading
,
1760 const wxFont
*theFont
) const
1762 const wxFont
*fontToUse
= theFont
;
1764 fontToUse
= &m_font
;
1766 HWND hWnd
= GetHwnd();
1767 HDC dc
= ::GetDC(hWnd
);
1771 if ( fontToUse
&& fontToUse
->Ok() )
1773 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1775 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1780 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1781 GetTextMetrics(dc
, &tm
);
1783 if ( fontToUse
&& fnt
&& hfontOld
)
1784 SelectObject(dc
, hfontOld
);
1786 ReleaseDC(hWnd
, dc
);
1793 *descent
= tm
.tmDescent
;
1794 if ( externalLeading
)
1795 *externalLeading
= tm
.tmExternalLeading
;
1798 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1799 // ---------------------------------------------------------------------------
1800 // Caret manipulation
1801 // ---------------------------------------------------------------------------
1803 void wxWindowMSW::CreateCaret(int w
, int h
)
1805 SetCaret(new wxCaret(this, w
, h
));
1808 void wxWindowMSW::CreateCaret(const wxBitmap
*WXUNUSED(bitmap
))
1810 wxFAIL_MSG("not implemented");
1813 void wxWindowMSW::ShowCaret(bool show
)
1815 wxCHECK_RET( m_caret
, "no caret to show" );
1817 m_caret
->Show(show
);
1820 void wxWindowMSW::DestroyCaret()
1825 void wxWindowMSW::SetCaretPos(int x
, int y
)
1827 wxCHECK_RET( m_caret
, "no caret to move" );
1829 m_caret
->Move(x
, y
);
1832 void wxWindowMSW::GetCaretPos(int *x
, int *y
) const
1834 wxCHECK_RET( m_caret
, "no caret to get position of" );
1836 m_caret
->GetPosition(x
, y
);
1838 #endif // wxUSE_CARET
1840 // ---------------------------------------------------------------------------
1842 // ---------------------------------------------------------------------------
1844 #if wxUSE_MENUS_NATIVE
1846 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1847 // immediately, without waiting for the next event loop iteration
1849 // NB: this function should probably be made public later as it can almost
1850 // surely replace wxYield() elsewhere as well
1851 static void wxYieldForCommandsOnly()
1853 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1854 // want to process it here)
1856 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1857 && msg
.message
!= WM_QUIT
)
1859 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1863 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1865 menu
->SetInvokingWindow(this);
1868 HWND hWnd
= GetHwnd();
1869 HMENU hMenu
= GetHmenuOf(menu
);
1873 ::ClientToScreen(hWnd
, &point
);
1874 wxCurrentPopupMenu
= menu
;
1875 ::TrackPopupMenu(hMenu
, TPM_RIGHTBUTTON
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1877 // we need to do it righ now as otherwise the events are never going to be
1878 // sent to wxCurrentPopupMenu from HandleCommand()
1880 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1881 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1882 // destroyed as soon as we return (it can be a local variable in the caller
1883 // for example) and so we do need to process the event immediately
1884 wxYieldForCommandsOnly();
1886 wxCurrentPopupMenu
= NULL
;
1888 menu
->SetInvokingWindow(NULL
);
1893 #endif // wxUSE_MENUS_NATIVE
1895 // ===========================================================================
1896 // pre/post message processing
1897 // ===========================================================================
1899 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1902 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1904 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1907 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1909 // wxUniversal implements tab traversal itself
1910 #ifndef __WXUNIVERSAL__
1911 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1913 // intercept dialog navigation keys
1914 MSG
*msg
= (MSG
*)pMsg
;
1916 // here we try to do all the job which ::IsDialogMessage() usually does
1919 if ( msg
->message
== WM_KEYDOWN
)
1921 bool bCtrlDown
= wxIsCtrlDown();
1922 bool bShiftDown
= wxIsShiftDown();
1924 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1925 // don't process it if it's the case (except for Ctrl-Tab/Enter
1926 // combinations which are always processed)
1930 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1933 bool bForward
= TRUE
,
1934 bWindowChange
= FALSE
;
1936 // should we process this message specially?
1937 bool bProcess
= TRUE
;
1938 switch ( msg
->wParam
)
1941 // assume that nobody wants Shift-TAB for himself - if we
1942 // don't do it there is no easy way for a control to grab
1943 // TABs but still let Shift-TAB work as navugation key
1944 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1948 // Ctrl-Tab cycles thru notebook pages
1949 bWindowChange
= bCtrlDown
;
1950 bForward
= !bShiftDown
;
1956 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1964 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1970 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1972 // control wants to process Enter itself, don't
1973 // call IsDialogMessage() which would interpret
1977 else if ( lDlgCode
& DLGC_BUTTON
)
1979 // let IsDialogMessage() handle this for all
1980 // buttons except the owner-drawn ones which it
1981 // just seems to ignore
1982 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1983 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1985 // emulate the button click
1986 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1988 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1993 // FIXME: this should be handled by
1994 // wxNavigationKeyEvent handler and not here!!
1998 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
2000 if ( btn
&& btn
->IsEnabled() )
2002 // if we do have a default button, do press it
2003 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2007 else // no default button
2009 #endif // wxUSE_BUTTON
2010 // this is a quick and dirty test for a text
2012 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
2014 // don't process Enter, the control might
2015 // need it for itself and don't let
2016 // ::IsDialogMessage() have it as it can
2017 // eat the Enter events sometimes
2020 //else: treat Enter as TAB: pass to the next
2021 // control as this is the best thing to do
2022 // if the text doesn't handle Enter itself
2034 wxNavigationKeyEvent event
;
2035 event
.SetDirection(bForward
);
2036 event
.SetWindowChange(bWindowChange
);
2037 event
.SetEventObject(this);
2039 if ( GetEventHandler()->ProcessEvent(event
) )
2046 // let ::IsDialogMessage() do almost everything and handle just the
2047 // things it doesn't here: Ctrl-TAB for switching notebook pages
2048 if ( msg
->message
== WM_KEYDOWN
)
2050 // don't process system keys here
2051 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
2053 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
2055 // find the first notebook parent and change its page
2056 wxWindow
*win
= this;
2057 wxNotebook
*nbook
= NULL
;
2058 while ( win
&& !nbook
)
2060 nbook
= wxDynamicCast(win
, wxNotebook
);
2061 win
= win
->GetParent();
2066 bool forward
= !wxIsShiftDown();
2068 nbook
->AdvanceSelection(forward
);
2075 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
2076 // shouldn't let IsDialogMessage() get it as it _always_ eats the
2077 // message even when there is no cancel button and when the message is
2078 // needed by the control itself: in particular, it prevents the tree in
2079 // place edit control from being closed with Escape in a dialog
2080 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2082 // ::IsDialogMessage() can enter in an infinite loop when the
2083 // currently focused window is disabled or hidden and its parent
2084 // has WS_EX_CONTROLPARENT style, so don't call it in this case
2085 bool canSafelyCallIsDlgMsg
= TRUE
;
2087 HWND hwndFocus
= ::GetFocus();
2090 if ( !::IsWindowEnabled(hwndFocus
) ||
2091 !::IsWindowVisible(hwndFocus
) )
2093 // it would enter an infinite loop if we do this!
2094 canSafelyCallIsDlgMsg
= FALSE
;
2099 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2101 // it's a top level window, don't go further -- e.g. even
2102 // if the parent of a dialog is disabled, this doesn't
2103 // break navigation inside the dialog
2107 hwndFocus
= ::GetParent(hwndFocus
);
2110 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2112 // IsDialogMessage() did something...
2117 #endif // __WXUNIVERSAL__
2122 // relay mouse move events to the tooltip control
2123 MSG
*msg
= (MSG
*)pMsg
;
2124 if ( msg
->message
== WM_MOUSEMOVE
)
2125 m_tooltip
->RelayEvent(pMsg
);
2127 #endif // wxUSE_TOOLTIPS
2132 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2134 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2135 return m_acceleratorTable
.Translate(this, pMsg
);
2139 #endif // wxUSE_ACCEL
2142 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2144 // preprocess all messages by default
2148 // ---------------------------------------------------------------------------
2149 // message params unpackers (different for Win16 and Win32)
2150 // ---------------------------------------------------------------------------
2154 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2155 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2157 *id
= LOWORD(wParam
);
2158 *hwnd
= (WXHWND
)lParam
;
2159 *cmd
= HIWORD(wParam
);
2162 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2163 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2165 *state
= LOWORD(wParam
);
2166 *minimized
= HIWORD(wParam
);
2167 *hwnd
= (WXHWND
)lParam
;
2170 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2171 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2173 *code
= LOWORD(wParam
);
2174 *pos
= HIWORD(wParam
);
2175 *hwnd
= (WXHWND
)lParam
;
2178 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2179 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2181 #ifndef __WXMICROWIN__
2182 *nCtlColor
= CTLCOLOR_BTN
;
2183 *hwnd
= (WXHWND
)lParam
;
2184 *hdc
= (WXHDC
)wParam
;
2188 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2189 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2191 *item
= (WXWORD
)wParam
;
2192 *flags
= HIWORD(wParam
);
2193 *hmenu
= (WXHMENU
)lParam
;
2198 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2199 WXWORD
*id
, WXHWND
*hwnd
, WXWORD
*cmd
)
2201 *id
= (WXWORD
)wParam
;
2202 *hwnd
= (WXHWND
)LOWORD(lParam
);
2203 *cmd
= HIWORD(lParam
);
2206 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2207 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2209 *state
= (WXWORD
)wParam
;
2210 *minimized
= LOWORD(lParam
);
2211 *hwnd
= (WXHWND
)HIWORD(lParam
);
2214 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2215 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2217 *code
= (WXWORD
)wParam
;
2218 *pos
= LOWORD(lParam
);
2219 *hwnd
= (WXHWND
)HIWORD(lParam
);
2222 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2223 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2225 *hwnd
= (WXHWND
)LOWORD(lParam
);
2226 *nCtlColor
= (int)HIWORD(lParam
);
2227 *hdc
= (WXHDC
)wParam
;
2230 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2231 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2233 *item
= (WXWORD
)wParam
;
2234 *flags
= LOWORD(lParam
);
2235 *hmenu
= (WXHMENU
)HIWORD(lParam
);
2240 // ---------------------------------------------------------------------------
2241 // Main wxWindows window proc and the window proc for wxWindow
2242 // ---------------------------------------------------------------------------
2244 // Hook for new window just as it's being created, when the window isn't yet
2245 // associated with the handle
2246 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2248 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2249 // window being created and insures that it's always unset back later
2250 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2252 gs_winBeingCreated
= winBeingCreated
;
2255 wxWindowCreationHook::~wxWindowCreationHook()
2257 gs_winBeingCreated
= NULL
;
2261 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2263 // trace all messages - useful for the debugging
2265 wxLogTrace(wxTraceMessages
, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
2266 wxGetMessageName(message
), wParam
, lParam
);
2267 #endif // __WXDEBUG__
2269 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2271 // when we get the first message for the HWND we just created, we associate
2272 // it with wxWindow stored in gs_winBeingCreated
2273 if ( !wnd
&& gs_winBeingCreated
)
2275 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2276 wnd
= gs_winBeingCreated
;
2277 gs_winBeingCreated
= NULL
;
2278 wnd
->SetHWND((WXHWND
)hWnd
);
2284 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2286 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2291 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2293 // did we process the message?
2294 bool processed
= FALSE
;
2305 // for most messages we should return 0 when we do process the message
2313 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2316 // return 0 to allow window creation
2317 rc
.result
= mayCreate
? 0 : -1;
2323 // never set processed to TRUE and *always* pass WM_DESTROY to
2324 // DefWindowProc() as Windows may do some internal cleanup when
2325 // processing it and failing to pass the message along may cause
2326 // memory and resource leaks!
2327 (void)HandleDestroy();
2331 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2339 // we're not interested in these messages at all
2342 case SIZE_MINIMIZED
:
2343 // we shouldn't send sizev events for these messages as the
2344 // client size may be negative which breaks existing code
2346 // OTOH we might send another (wxMinimizedEvent?) one or
2347 // add an additional parameter to wxSizeEvent if this is
2348 // useful to anybody
2352 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2353 // fall through nevertheless
2355 case SIZE_MAXIMIZED
:
2357 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2362 #ifndef __WXMICROWIN__
2363 case WM_ACTIVATEAPP
:
2364 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2370 WXWORD state
, minimized
;
2372 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2374 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2379 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2383 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2387 processed
= HandlePaint();
2391 #ifdef __WXUNIVERSAL__
2392 // Universal uses its own wxFrame/wxDialog, so we don't receive
2393 // close events unless we have this.
2398 // don't let the DefWindowProc() destroy our window - we'll do it
2399 // ourselves in ~wxWindow
2406 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2410 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2411 GET_Y_LPARAM(lParam
),
2415 #if wxUSE_MOUSEWHEEL
2417 processed
= HandleMouseWheel(wParam
, lParam
);
2421 case WM_LBUTTONDOWN
:
2423 case WM_LBUTTONDBLCLK
:
2424 case WM_RBUTTONDOWN
:
2426 case WM_RBUTTONDBLCLK
:
2427 case WM_MBUTTONDOWN
:
2429 case WM_MBUTTONDBLCLK
:
2431 #ifdef __WXMICROWIN__
2432 // MicroWindows seems to ignore the fact that a window is
2433 // disabled. So catch mouse events and throw them away if
2435 wxWindowMSW
* win
= this;
2438 if (!win
->IsEnabled())
2444 win
= win
->GetParent();
2445 if ( !win
|| win
->IsTopLevel() )
2452 #endif // __WXMICROWIN__
2453 // VZ: if you find a situation when this is needed, tell
2454 // me about it, do *not* uncomment this code as it
2455 // causes other strange problems
2457 if ( message
== WM_LBUTTONDOWN
&& AcceptsFocus() )
2461 int x
= GET_X_LPARAM(lParam
),
2462 y
= GET_Y_LPARAM(lParam
);
2464 // redirect the event to a static control if necessary by
2465 // finding one under mouse
2467 if ( GetCapture() == this )
2469 // but don't do it if the mouse is captured by this window
2470 // because then it should really get this event itself
2475 win
= FindWindowForMouseEvent(this, &x
, &y
);
2478 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2487 case MM_JOY1BUTTONDOWN
:
2488 case MM_JOY2BUTTONDOWN
:
2489 case MM_JOY1BUTTONUP
:
2490 case MM_JOY2BUTTONUP
:
2491 processed
= HandleJoystickEvent(message
,
2492 GET_X_LPARAM(lParam
),
2493 GET_Y_LPARAM(lParam
),
2496 #endif // __WXMICROWIN__
2499 processed
= HandleSysCommand(wParam
, lParam
);
2506 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2508 processed
= HandleCommand(id
, cmd
, hwnd
);
2514 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2518 // for these messages we must return TRUE if process the message
2521 case WM_MEASUREITEM
:
2523 int idCtrl
= (UINT
)wParam
;
2524 if ( message
== WM_DRAWITEM
)
2526 processed
= MSWOnDrawItem(idCtrl
,
2527 (WXDRAWITEMSTRUCT
*)lParam
);
2531 processed
= MSWOnMeasureItem(idCtrl
,
2532 (WXMEASUREITEMSTRUCT
*)lParam
);
2539 #endif // defined(WM_DRAWITEM)
2542 if ( !IsOfStandardClass() )
2544 // we always want to get the char events
2545 rc
.result
= DLGC_WANTCHARS
;
2547 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2549 // in fact, we want everything
2550 rc
.result
|= DLGC_WANTARROWS
|
2557 //else: get the dlg code from the DefWindowProc()
2562 // If this has been processed by an event handler, return 0 now
2563 // (we've handled it).
2564 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2565 if ( m_lastKeydownProcessed
)
2573 // we consider these message "not interesting" to OnChar, so
2574 // just don't do anything more with them
2584 // avoid duplicate messages to OnChar for these ASCII keys:
2585 // they will be translated by TranslateMessage() and received
2607 // but set processed to FALSE, not TRUE to still pass them
2608 // to the control's default window proc - otherwise
2609 // built-in keyboard handling won't work
2615 // special case of VK_APPS: treat it the same as right mouse
2616 // click because both usually pop up a context menu
2622 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2623 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2629 // do generate a CHAR event
2630 processed
= HandleChar((WORD
)wParam
, lParam
);
2638 // special case of VK_APPS: treat it the same as right mouse button
2639 if ( wParam
== VK_APPS
)
2644 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2645 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2650 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2655 case WM_CHAR
: // Always an ASCII character
2656 if ( m_lastKeydownProcessed
)
2658 // The key was handled in the EVT_KEY_DOWN and handling
2659 // a key in an EVT_KEY_DOWN handler is meant, by
2660 // design, to prevent EVT_CHARs from happening
2661 m_lastKeydownProcessed
= FALSE
;
2666 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2675 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2677 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2683 // CTLCOLOR messages are sent by children to query the parent for their
2684 // colors#ifndef __WXMICROWIN__
2685 #ifndef __WXMICROWIN__
2687 case WM_CTLCOLORMSGBOX
:
2688 case WM_CTLCOLOREDIT
:
2689 case WM_CTLCOLORLISTBOX
:
2690 case WM_CTLCOLORBTN
:
2691 case WM_CTLCOLORDLG
:
2692 case WM_CTLCOLORSCROLLBAR
:
2693 case WM_CTLCOLORSTATIC
:
2701 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2703 processed
= HandleCtlColor(&rc
.hBrush
,
2712 #endif // !__WXMICROWIN__
2714 case WM_SYSCOLORCHANGE
:
2715 // the return value for this message is ignored
2716 processed
= HandleSysColorChange();
2719 case WM_DISPLAYCHANGE
:
2720 processed
= HandleDisplayChange();
2723 case WM_PALETTECHANGED
:
2724 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2727 case WM_CAPTURECHANGED
:
2728 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2731 case WM_QUERYNEWPALETTE
:
2732 processed
= HandleQueryNewPalette();
2736 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2739 // we processed the message, i.e. erased the background
2745 processed
= HandleDropFiles(wParam
);
2749 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2753 // we never set focus from here
2758 case WM_QUERYENDSESSION
:
2759 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2763 processed
= HandleEndSession(wParam
!= 0, lParam
);
2766 case WM_GETMINMAXINFO
:
2767 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2771 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2772 LOWORD(lParam
), // hit test
2773 HIWORD(lParam
)); // mouse msg
2777 // returning TRUE stops the DefWindowProc() from further
2778 // processing this message - exactly what we need because we've
2779 // just set the cursor.
2784 #if defined(__WIN32__) && defined(WM_HELP)
2787 HELPINFO
* info
= (HELPINFO
*) lParam
;
2788 // Don't yet process menu help events, just windows
2789 if (info
->iContextType
== HELPINFO_WINDOW
)
2791 wxWindowMSW
* subjectOfHelp
= this;
2792 bool eventProcessed
= FALSE
;
2793 while (subjectOfHelp
&& !eventProcessed
)
2795 wxHelpEvent
helpEvent(wxEVT_HELP
,
2796 subjectOfHelp
->GetId(),
2797 wxPoint(info
->MousePos
.x
,
2798 info
->MousePos
.y
) );
2799 helpEvent
.SetEventObject(this);
2801 GetEventHandler()->ProcessEvent(helpEvent
);
2803 // Go up the window hierarchy until the event is
2805 subjectOfHelp
= subjectOfHelp
->GetParent();
2808 processed
= eventProcessed
;
2810 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2812 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2813 helpEvent
.SetEventObject(this);
2814 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2817 //else: processed is already FALSE
2821 case WM_CONTEXTMENU
:
2823 // we don't convert from screen to client coordinates as
2824 // the event may be handled by a parent window
2825 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2827 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2828 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2837 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2838 wxGetMessageName(message
));
2839 #endif // __WXDEBUG__
2840 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2846 // ----------------------------------------------------------------------------
2847 // wxWindow <-> HWND map
2848 // ----------------------------------------------------------------------------
2850 wxWinHashTable
*wxWinHandleHash
= NULL
;
2852 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2854 return wxWinHandleHash
->Get((long)hWnd
);
2857 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2859 // adding NULL hWnd is (first) surely a result of an error and
2860 // (secondly) breaks menu command processing
2861 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2862 wxT("attempt to add a NULL hWnd to window list ignored") );
2864 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2866 if ( oldWin
&& (oldWin
!= win
) )
2868 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2869 hWnd
, win
->GetClassInfo()->GetClassName());
2872 #endif // __WXDEBUG__
2875 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2879 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2881 wxWinHandleHash
->Delete((long)win
->GetHWND());
2884 // ----------------------------------------------------------------------------
2885 // various MSW speciic class dependent functions
2886 // ----------------------------------------------------------------------------
2888 // Default destroyer - override if you destroy it in some other way
2889 // (e.g. with MDI child windows)
2890 void wxWindowMSW::MSWDestroyWindow()
2894 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2897 int& w
, int& h
) const
2899 static const int DEFAULT_Y
= 200;
2900 static const int DEFAULT_H
= 250;
2902 bool nonDefault
= FALSE
;
2906 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2907 // just as well set it to CW_USEDEFAULT as well
2913 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2914 // neither because it is not handled as a special value by Windows then
2915 // and so we have to choose some default value for it
2917 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2923 NB: there used to be some code here which set the initial size of the
2924 window to the client size of the parent if no explicit size was
2925 specified. This was wrong because wxWindows programs often assume
2926 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2927 it. To see why, you should understand that Windows sends WM_SIZE from
2928 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2929 from some base class ctor and so this WM_SIZE is not processed in the
2930 real class' OnSize() (because it's not fully constructed yet and the
2931 event goes to some base class OnSize() instead). So the WM_SIZE we
2932 rely on is the one sent when the parent frame resizes its children
2933 but here is the problem: if the child already has just the right
2934 size, nothing will happen as both wxWindows and Windows check for
2935 this and ignore any attempts to change the window size to the size it
2936 already has - so no WM_SIZE would be sent.
2940 // as above, h is not used at all in this case anyhow
2946 // and, again as above, we can't set the height to CW_USEDEFAULT here
2948 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2956 WXHWND
wxWindowMSW::MSWGetParent() const
2958 return m_parent
? m_parent
->GetHWND() : NULL
;
2961 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
2962 const wxChar
*title
,
2966 WXDWORD extendedStyle
)
2968 // choose the position/size for the new window
2970 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
2972 // controlId is menu handle for the top level windows, so set it to 0
2973 // unless we're creating a child window
2974 int controlId
= style
& WS_CHILD
? GetId() : 0;
2976 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2977 // which is the same but without CS_[HV]REDRAW class styles so using it
2978 // ensures that the window is not fully repainted on each resize
2979 wxString
className(wclass
);
2980 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
2982 className
+= wxT("NR");
2985 // do create the window
2986 wxWindowCreationHook
hook(this);
2988 m_hWnd
= (WXHWND
)::CreateWindowEx
2992 title
? title
: wxT(""),
2995 (HWND
)MSWGetParent(),
2998 NULL
// no extra data
3003 wxLogSysError(_("Can't create window of class %s"), wclass
);
3008 SubclassWin(m_hWnd
);
3010 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
3015 // ===========================================================================
3016 // MSW message handlers
3017 // ===========================================================================
3019 // ---------------------------------------------------------------------------
3021 // ---------------------------------------------------------------------------
3024 // FIXME: VZ: I'm not sure at all that the order of processing is correct
3025 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3027 #ifndef __WXMICROWIN__
3028 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3029 HWND hWnd
= hdr
->hwndFrom
;
3030 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3032 // is this one of our windows?
3035 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3038 // try all our children
3039 wxWindowList::Node
*node
= GetChildren().GetFirst();
3042 wxWindow
*child
= node
->GetData();
3043 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3048 node
= node
->GetNext();
3051 // finally try this window too (catches toolbar case)
3052 return MSWOnNotify(idCtrl
, lParam
, result
);
3053 #else // __WXMICROWIN__
3060 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3062 const wxString
& ttip
)
3064 // I don't know why it happens, but the versions of comctl32.dll starting
3065 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3066 // this message is supposed to be sent to Unicode programs only) -- hence
3067 // we need to handle it as well, otherwise no tooltips will be shown in
3070 if ( !(code
== TTN_NEEDTEXTA
|| code
== TTN_NEEDTEXTW
) || ttip
.empty() )
3072 // not a tooltip message or no tooltip to show anyhow
3076 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3078 if ( code
== TTN_NEEDTEXTA
)
3080 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3085 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3087 size_t lenAnsi
= ttip
.length();
3089 // some compilers (MetroWerks and Cygwin) don't like calling mbstowcs
3090 // with NULL argument
3091 #if defined( __MWERKS__ ) || defined( __CYGWIN__ )
3092 size_t lenUnicode
= 2*lenAnsi
;
3094 size_t lenUnicode
= mbstowcs(NULL
, ttip
, lenAnsi
);
3097 // using the pointer of right type avoids us doing all sorts of
3098 // pointer arithmetics ourselves
3099 wchar_t *dst
= (wchar_t *)ttText
->szText
,
3100 *pwz
= new wchar_t[lenUnicode
+ 1];
3101 mbstowcs(pwz
, ttip
, lenAnsi
+ 1);
3102 memcpy(dst
, pwz
, lenUnicode
*sizeof(wchar_t));
3104 // put the terminating wide NUL
3105 dst
[lenUnicode
] = L
'\0';
3108 #endif // Unicode/!Unicode
3114 #endif // wxUSE_TOOLTIPS
3116 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3118 WXLPARAM
* WXUNUSED(result
))
3123 NMHDR
* hdr
= (NMHDR
*)lParam
;
3124 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3130 #endif // wxUSE_TOOLTIPS
3136 // ---------------------------------------------------------------------------
3137 // end session messages
3138 // ---------------------------------------------------------------------------
3140 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3142 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3143 event
.SetEventObject(wxTheApp
);
3144 event
.SetCanVeto(TRUE
);
3145 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3147 bool rc
= wxTheApp
->ProcessEvent(event
);
3151 // we may end only if the app didn't veto session closing (double
3153 *mayEnd
= !event
.GetVeto();
3159 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3161 // do nothing if the session isn't ending
3166 if ( (this != wxTheApp
->GetTopWindow()) )
3169 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3170 event
.SetEventObject(wxTheApp
);
3171 event
.SetCanVeto(FALSE
);
3172 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3174 return wxTheApp
->ProcessEvent(event
);
3177 // ---------------------------------------------------------------------------
3178 // window creation/destruction
3179 // ---------------------------------------------------------------------------
3181 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3183 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3184 // parent as well as otherwise several Win32 functions using
3185 // GetNextDlgTabItem() to iterate over all controls such as
3186 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3187 // all of them iterate over all the controls starting from the focus and
3188 // stop iterating when they get back to the focus but unless all parents
3189 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3190 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3192 // there is no need to do anything for the top level windows
3193 const wxWindow
*parent
= GetParent();
3194 while ( parent
&& !parent
->IsTopLevel() )
3196 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
3197 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
3199 // force the parent to have this style
3200 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
3201 exStyle
| WS_EX_CONTROLPARENT
);
3204 parent
= parent
->GetParent();
3208 // TODO: should generate this event from WM_NCCREATE
3209 wxWindowCreateEvent
event((wxWindow
*)this);
3210 (void)GetEventHandler()->ProcessEvent(event
);
3217 bool wxWindowMSW::HandleDestroy()
3219 wxWindowDestroyEvent
event((wxWindow
*)this);
3220 (void)GetEventHandler()->ProcessEvent(event
);
3222 // delete our drop target if we've got one
3223 #if wxUSE_DRAG_AND_DROP
3224 if ( m_dropTarget
!= NULL
)
3226 m_dropTarget
->Revoke(m_hWnd
);
3228 delete m_dropTarget
;
3229 m_dropTarget
= NULL
;
3231 #endif // wxUSE_DRAG_AND_DROP
3233 // WM_DESTROY handled
3237 // ---------------------------------------------------------------------------
3239 // ---------------------------------------------------------------------------
3241 bool wxWindowMSW::HandleActivate(int state
,
3242 bool WXUNUSED(minimized
),
3243 WXHWND
WXUNUSED(activate
))
3245 wxActivateEvent
event(wxEVT_ACTIVATE
,
3246 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3248 event
.SetEventObject(this);
3250 return GetEventHandler()->ProcessEvent(event
);
3253 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3255 // notify the parent keeping track of focus for the kbd navigation
3256 // purposes that we got it
3257 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3258 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3264 m_caret
->OnSetFocus();
3266 #endif // wxUSE_CARET
3269 // If it's a wxTextCtrl don't send the event as it will be done
3270 // after the control gets to process it from EN_FOCUS handler
3271 if ( wxDynamicCastThis(wxTextCtrl
) )
3275 #endif // wxUSE_TEXTCTRL
3277 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3278 event
.SetEventObject(this);
3280 // wxFindWinFromHandle() may return NULL, it is ok
3281 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3283 return GetEventHandler()->ProcessEvent(event
);
3286 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3292 m_caret
->OnKillFocus();
3294 #endif // wxUSE_CARET
3297 // If it's a wxTextCtrl don't send the event as it will be done
3298 // after the control gets to process it.
3299 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3306 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3307 event
.SetEventObject(this);
3309 // wxFindWinFromHandle() may return NULL, it is ok
3310 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3312 return GetEventHandler()->ProcessEvent(event
);
3315 // ---------------------------------------------------------------------------
3317 // ---------------------------------------------------------------------------
3319 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3321 wxShowEvent
event(GetId(), show
);
3322 event
.m_eventObject
= this;
3324 return GetEventHandler()->ProcessEvent(event
);
3327 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3329 wxInitDialogEvent
event(GetId());
3330 event
.m_eventObject
= this;
3332 return GetEventHandler()->ProcessEvent(event
);
3335 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3337 #ifndef __WXMICROWIN__
3338 HDROP hFilesInfo
= (HDROP
) wParam
;
3340 // Get the total number of files dropped
3341 UINT gwFilesDropped
= ::DragQueryFile
3349 wxString
*files
= new wxString
[gwFilesDropped
];
3350 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3352 // first get the needed buffer length (+1 for terminating NUL)
3353 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3355 // and now get the file name
3356 ::DragQueryFile(hFilesInfo
, wIndex
,
3357 files
[wIndex
].GetWriteBuf(len
), len
);
3359 files
[wIndex
].UngetWriteBuf();
3361 DragFinish (hFilesInfo
);
3363 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3364 event
.m_eventObject
= this;
3367 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3368 event
.m_pos
.x
= dropPoint
.x
;
3369 event
.m_pos
.y
= dropPoint
.y
;
3371 return GetEventHandler()->ProcessEvent(event
);
3372 #else // __WXMICROWIN__
3377 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3379 int WXUNUSED(mouseMsg
))
3381 #ifndef __WXMICROWIN__
3382 // the logic is as follows:
3383 // -1. don't set cursor for non client area, including but not limited to
3384 // the title bar, scrollbars, &c
3385 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3386 // 1. if we have the cursor set it unless wxIsBusy()
3387 // 2. if we're a top level window, set some cursor anyhow
3388 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3390 if ( nHitTest
!= HTCLIENT
)
3395 HCURSOR hcursor
= 0;
3397 // first ask the user code - it may wish to set the cursor in some very
3398 // specific way (for example, depending on the current position)
3401 if ( !::GetCursorPos(&pt
) )
3403 wxLogLastError(wxT("GetCursorPos"));
3406 // In WIN16 it doesn't return a value.
3407 ::GetCursorPos(&pt
);
3412 ScreenToClient(&x
, &y
);
3413 wxSetCursorEvent
event(x
, y
);
3415 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3416 if ( processedEvtSetCursor
&& event
.HasCursor() )
3418 hcursor
= GetHcursorOf(event
.GetCursor());
3423 bool isBusy
= wxIsBusy();
3425 // the test for processedEvtSetCursor is here to prevent using m_cursor
3426 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3427 // it - this is a way to say that our cursor shouldn't be used for this
3429 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3431 hcursor
= GetHcursorOf(m_cursor
);
3438 hcursor
= wxGetCurrentBusyCursor();
3440 else if ( !hcursor
)
3442 const wxCursor
*cursor
= wxGetGlobalCursor();
3443 if ( cursor
&& cursor
->Ok() )
3445 hcursor
= GetHcursorOf(*cursor
);
3453 ::SetCursor(hcursor
);
3455 // cursor set, stop here
3458 #endif // __WXMICROWIN__
3460 // pass up the window chain
3464 // ---------------------------------------------------------------------------
3465 // owner drawn stuff
3466 // ---------------------------------------------------------------------------
3468 bool wxWindowMSW::MSWOnDrawItem(int id
, WXDRAWITEMSTRUCT
*itemStruct
)
3470 #if wxUSE_OWNER_DRAWN
3472 #if wxUSE_MENUS_NATIVE
3473 // is it a menu item?
3474 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3475 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3477 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3479 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3481 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3482 // the DC from being released
3483 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3484 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3485 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3486 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3488 return pMenuItem
->OnDrawItem
3492 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3493 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3496 #endif // wxUSE_MENUS_NATIVE
3499 wxWindow
*item
= FindItem(id
);
3500 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3502 return ((wxControl
*)item
)->MSWOnDraw(itemStruct
);
3504 #endif // wxUSE_CONTROLS
3506 #endif // USE_OWNER_DRAWN
3511 bool wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3513 #if wxUSE_OWNER_DRAWN
3514 // is it a menu item?
3515 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3516 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3518 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3520 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3522 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3523 &pMeasureStruct
->itemHeight
);
3526 wxWindow
*item
= FindItem(id
);
3527 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3529 return ((wxControl
*)item
)->MSWOnMeasure(itemStruct
);
3531 #endif // owner-drawn menus
3535 // ---------------------------------------------------------------------------
3536 // colours and palettes
3537 // ---------------------------------------------------------------------------
3539 bool wxWindowMSW::HandleSysColorChange()
3541 wxSysColourChangedEvent event
;
3542 event
.SetEventObject(this);
3544 (void)GetEventHandler()->ProcessEvent(event
);
3546 // always let the system carry on the default processing to allow the
3547 // native controls to react to the colours update
3551 bool wxWindowMSW::HandleDisplayChange()
3553 wxDisplayChangedEvent event
;
3554 event
.SetEventObject(this);
3556 return GetEventHandler()->ProcessEvent(event
);
3559 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3567 #ifndef __WXMICROWIN__
3568 WXHBRUSH hBrush
= 0;
3570 if ( nCtlColor
== CTLCOLOR_DLG
)
3572 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3577 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3579 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3581 #endif // wxUSE_CONTROLS
3587 #else // __WXMICROWIN__
3592 // Define for each class of dialog and control
3593 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3594 WXHWND
WXUNUSED(hWnd
),
3595 WXUINT
WXUNUSED(nCtlColor
),
3596 WXUINT
WXUNUSED(message
),
3597 WXWPARAM
WXUNUSED(wParam
),
3598 WXLPARAM
WXUNUSED(lParam
))
3603 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3606 // same as below except we don't respond to our own messages
3607 if ( hWndPalChange
!= GetHWND() )
3609 // check to see if we our our parents have a custom palette
3610 wxWindow
*win
= this;
3611 while ( win
&& !win
->HasCustomPalette() )
3613 win
= win
->GetParent();
3616 if ( win
&& win
->HasCustomPalette() )
3618 // realize the palette to see whether redrawing is needed
3619 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3620 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3621 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3623 int result
= ::RealizePalette(hdc
);
3625 // restore the palette (before releasing the DC)
3626 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3627 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3628 ::RealizePalette(hdc
);
3629 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3631 // now check for the need to redraw
3633 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3637 #endif // wxUSE_PALETTE
3639 wxPaletteChangedEvent
event(GetId());
3640 event
.SetEventObject(this);
3641 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3643 return GetEventHandler()->ProcessEvent(event
);
3646 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3648 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3649 event
.SetEventObject(this);
3651 return GetEventHandler()->ProcessEvent(event
);
3654 bool wxWindowMSW::HandleQueryNewPalette()
3658 // check to see if we our our parents have a custom palette
3659 wxWindow
*win
= this;
3660 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3661 if (win
->HasCustomPalette()) {
3662 /* realize the palette to see whether redrawing is needed */
3663 HDC hdc
= GetDC((HWND
) GetHWND());
3664 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3665 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3667 int result
= ::RealizePalette(hdc
);
3668 /* restore the palette (before releasing the DC) */
3669 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3670 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3671 ::RealizePalette(hdc
);
3672 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3673 /* now check for the need to redraw */
3675 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3677 #endif // wxUSE_PALETTE
3679 wxQueryNewPaletteEvent
event(GetId());
3680 event
.SetEventObject(this);
3682 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3685 // Responds to colour changes: passes event on to children.
3686 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3688 // the top level window also reset the standard colour map as it might have
3689 // changed (there is no need to do it for the non top level windows as we
3690 // only have to do it once)
3694 gs_hasStdCmap
= FALSE
;
3696 wxWindowList::Node
*node
= GetChildren().GetFirst();
3699 // Only propagate to non-top-level windows because Windows already
3700 // sends this event to all top-level ones
3701 wxWindow
*win
= node
->GetData();
3702 if ( !win
->IsTopLevel() )
3704 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3705 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3706 // the standard controls
3707 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3710 node
= node
->GetNext();
3713 // update the colours we use if they were not set explicitly by the user:
3714 // this must be done or OnCtlColor() would continue to use the old colours
3717 m_foregroundColour
= wxSystemSettings::
3718 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3723 m_backgroundColour
= wxSystemSettings::
3724 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3728 extern wxCOLORMAP
*wxGetStdColourMap()
3730 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3731 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3733 if ( !gs_hasStdCmap
)
3735 static bool s_coloursInit
= FALSE
;
3737 if ( !s_coloursInit
)
3739 // When a bitmap is loaded, the RGB values can change (apparently
3740 // because Windows adjusts them to care for the old programs always
3741 // using 0xc0c0c0 while the transparent colour for the new Windows
3742 // versions is different). But we do this adjustment ourselves so
3743 // we want to avoid Windows' "help" and for this we need to have a
3744 // reference bitmap which can tell us what the RGB values change
3746 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3747 if ( stdColourBitmap
.Ok() )
3749 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3750 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3751 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3754 memDC
.SelectObject(stdColourBitmap
);
3757 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3759 memDC
.GetPixel(i
, 0, &colour
);
3760 s_stdColours
[i
] = wxColourToRGB(colour
);
3763 else // wxBITMAP_STD_COLOURS couldn't be loaded
3765 s_stdColours
[0] = RGB(000,000,000); // black
3766 s_stdColours
[1] = RGB(128,128,128); // dark grey
3767 s_stdColours
[2] = RGB(192,192,192); // light grey
3768 s_stdColours
[3] = RGB(255,255,255); // white
3769 //s_stdColours[4] = RGB(000,000,255); // blue
3770 //s_stdColours[5] = RGB(255,000,255); // magenta
3773 s_coloursInit
= TRUE
;
3776 gs_hasStdCmap
= TRUE
;
3778 // create the colour map
3779 #define INIT_CMAP_ENTRY(col) \
3780 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3781 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3783 INIT_CMAP_ENTRY(BTNTEXT
);
3784 INIT_CMAP_ENTRY(BTNSHADOW
);
3785 INIT_CMAP_ENTRY(BTNFACE
);
3786 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3788 #undef INIT_CMAP_ENTRY
3794 // ---------------------------------------------------------------------------
3796 // ---------------------------------------------------------------------------
3798 bool wxWindowMSW::HandlePaint()
3801 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3803 wxLogLastError(wxT("CreateRectRgn"));
3804 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3805 wxLogLastError(wxT("GetUpdateRgn"));
3807 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3810 ::GetUpdateRect(GetHwnd(), &updateRect
, FALSE
);
3812 m_updateRegion
= wxRegion(updateRect
.left
, updateRect
.top
,
3813 updateRect
.right
- updateRect
.left
,
3814 updateRect
.bottom
- updateRect
.top
);
3817 wxPaintEvent
event(m_windowId
);
3818 event
.SetEventObject(this);
3820 bool processed
= GetEventHandler()->ProcessEvent(event
);
3822 // note that we must generate NC event after the normal one as otherwise
3823 // BeginPaint() will happily overwrite our decorations with the background
3825 wxNcPaintEvent
eventNc(m_windowId
);
3826 eventNc
.SetEventObject(this);
3827 GetEventHandler()->ProcessEvent(eventNc
);
3832 // Can be called from an application's OnPaint handler
3833 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3835 #ifdef __WXUNIVERSAL__
3838 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3841 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3846 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3848 // Prevents flicker when dragging
3849 if ( ::IsIconic(GetHwnd()) )
3855 dc
.SetWindow((wxWindow
*)this);
3858 wxEraseEvent
event(m_windowId
, &dc
);
3859 event
.SetEventObject(this);
3860 bool rc
= GetEventHandler()->ProcessEvent(event
);
3864 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3865 dc
.SelectOldObjects(hdc
);
3870 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3873 ::GetClientRect(GetHwnd(), &rect
);
3875 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3876 m_backgroundColour
.Green(),
3877 m_backgroundColour
.Blue());
3878 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3880 wxLogLastError(wxT("CreateSolidBrush"));
3882 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
3884 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
3886 ::FillRect(hdc
, &rect
, hBrush
);
3887 ::DeleteObject(hBrush
);
3888 ::SetMapMode(hdc
, mode
);
3891 // ---------------------------------------------------------------------------
3892 // moving and resizing
3893 // ---------------------------------------------------------------------------
3895 bool wxWindowMSW::HandleMinimize()
3897 wxIconizeEvent
event(m_windowId
);
3898 event
.SetEventObject(this);
3900 return GetEventHandler()->ProcessEvent(event
);
3903 bool wxWindowMSW::HandleMaximize()
3905 wxMaximizeEvent
event(m_windowId
);
3906 event
.SetEventObject(this);
3908 return GetEventHandler()->ProcessEvent(event
);
3911 bool wxWindowMSW::HandleMove(int x
, int y
)
3913 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
3914 event
.SetEventObject(this);
3916 return GetEventHandler()->ProcessEvent(event
);
3919 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
3920 WXUINT
WXUNUSED(flag
))
3922 // don't use w and h parameters as they specify the client size while
3923 // according to the docs EVT_SIZE handler is supposed to receive the total
3925 wxSizeEvent
event(GetSize(), m_windowId
);
3926 event
.SetEventObject(this);
3928 return GetEventHandler()->ProcessEvent(event
);
3931 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
3933 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
3937 int minWidth
= GetMinWidth(),
3938 minHeight
= GetMinHeight(),
3939 maxWidth
= GetMaxWidth(),
3940 maxHeight
= GetMaxHeight();
3942 if ( minWidth
!= -1 )
3944 info
->ptMinTrackSize
.x
= minWidth
;
3948 if ( minHeight
!= -1 )
3950 info
->ptMinTrackSize
.y
= minHeight
;
3954 if ( maxWidth
!= -1 )
3956 info
->ptMaxTrackSize
.x
= maxWidth
;
3960 if ( maxHeight
!= -1 )
3962 info
->ptMaxTrackSize
.y
= maxHeight
;
3969 // ---------------------------------------------------------------------------
3971 // ---------------------------------------------------------------------------
3973 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
3975 #if wxUSE_MENUS_NATIVE
3976 if ( !cmd
&& wxCurrentPopupMenu
)
3978 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
3979 wxCurrentPopupMenu
= NULL
;
3981 return popupMenu
->MSWCommand(cmd
, id
);
3983 #endif // wxUSE_MENUS_NATIVE
3985 wxWindow
*win
= NULL
;
3987 // first try to find it from HWND - this works even with the broken
3988 // programs using the same ids for different controls
3991 win
= wxFindWinFromHandle(control
);
3997 // must cast to a signed type before comparing with other ids!
3998 win
= FindItem((signed short)id
);
4003 return win
->MSWCommand(cmd
, id
);
4006 // the messages sent from the in-place edit control used by the treectrl
4007 // for label editing have id == 0, but they should _not_ be treated as menu
4008 // messages (they are EN_XXX ones, in fact) so don't translate anything
4009 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4012 // If no child window, it may be an accelerator, e.g. for a popup menu
4015 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4016 event
.SetEventObject(this);
4020 return GetEventHandler()->ProcessEvent(event
);
4022 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4025 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4026 // notifications to its parent which we want to reflect back to
4028 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4029 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4032 #endif // wxUSE_SPINCTRL
4037 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4039 // 4 bits are reserved
4040 switch ( wParam
& 0xFFFFFFF0 )
4043 return HandleMaximize();
4046 return HandleMinimize();
4052 // ---------------------------------------------------------------------------
4054 // ---------------------------------------------------------------------------
4056 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4060 // our client coords are not quite the same as Windows ones
4061 wxPoint pt
= GetClientAreaOrigin();
4062 event
.m_x
= x
- pt
.x
;
4063 event
.m_y
= y
- pt
.y
;
4065 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4066 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4067 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4068 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4069 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4070 event
.m_altDown
= (::GetKeyState(VK_MENU
) & 0x80000000) != 0;
4072 event
.SetTimestamp(s_currentMsg
.time
);
4073 event
.m_eventObject
= this;
4074 event
.SetId(GetId());
4076 #if wxUSE_MOUSEEVENT_HACK
4079 m_lastMouseEvent
= event
.GetEventType();
4080 #endif // wxUSE_MOUSEEVENT_HACK
4083 // Windows doesn't send the mouse events to the static controls (which are
4084 // transparent in the sense that their WM_NCHITTEST handler returns
4085 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4086 // and so we manually check if we don't have a child window under mouse and if
4087 // we do, send the event to it instead of the window Windows had sent WM_XXX
4090 // Notice that this is not done for the mouse move events because this could
4091 // (would?) be too slow, but only for clicks which means that the static texts
4092 // still don't get move, enter nor leave events.
4093 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4095 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4097 // first try to find a non transparent child: this allows us to send events
4098 // to a static text which is inside a static box, for example
4099 POINT pt
= { *x
, *y
};
4100 HWND hwnd
= GetHwndOf(win
),
4104 hwndUnderMouse
= ::ChildWindowFromPointEx
4113 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4116 // now try any child window at all
4117 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4120 // check that we have a child window which is susceptible to receive mouse
4121 // events: for this it must be shown and enabled
4122 if ( hwndUnderMouse
&&
4123 hwndUnderMouse
!= hwnd
&&
4124 ::IsWindowVisible(hwndUnderMouse
) &&
4125 ::IsWindowEnabled(hwndUnderMouse
) )
4127 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4128 if ( winUnderMouse
)
4130 // translate the mouse coords to the other window coords
4131 win
->ClientToScreen(x
, y
);
4132 winUnderMouse
->ScreenToClient(x
, y
);
4134 win
= winUnderMouse
;
4141 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4143 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4144 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4145 // from the message id and take the value in the table to get wxWin event
4147 static const wxEventType eventsMouse
[] =
4161 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4162 InitMouseEvent(event
, x
, y
, flags
);
4164 return GetEventHandler()->ProcessEvent(event
);
4167 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4169 if ( !m_mouseInWindow
)
4171 // it would be wrong to assume that just because we get a mouse move
4172 // event that the mouse is inside the window: although this is usually
4173 // true, it is not if we had captured the mouse, so we need to check
4174 // the mouse coordinates here
4175 if ( !HasCapture() || IsMouseInWindow() )
4177 // Generate an ENTER event
4178 m_mouseInWindow
= TRUE
;
4180 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4181 InitMouseEvent(event
, x
, y
, flags
);
4183 (void)GetEventHandler()->ProcessEvent(event
);
4187 #if wxUSE_MOUSEEVENT_HACK
4188 // Window gets a click down message followed by a mouse move message even
4189 // if position isn't changed! We want to discard the trailing move event
4190 // if x and y are the same.
4191 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4192 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4193 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4194 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4196 m_lastMouseEvent
= wxEVT_MOTION
;
4200 #endif // wxUSE_MOUSEEVENT_HACK
4202 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4206 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4208 #if wxUSE_MOUSEWHEEL
4209 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4210 InitMouseEvent(event
,
4211 GET_X_LPARAM(lParam
),
4212 GET_Y_LPARAM(lParam
),
4214 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4215 event
.m_wheelDelta
= WHEEL_DELTA
;
4218 static int s_linesPerRotation
= -1;
4219 if ( s_linesPerRotation
== -1 )
4221 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4222 &s_linesPerRotation
, 0))
4224 // this is not supposed to happen
4225 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4227 // the default is 3, so use it if SystemParametersInfo() failed
4228 s_linesPerRotation
= 3;
4232 // no SystemParametersInfo() under Win16
4233 static const int s_linesPerRotation
= 3;
4236 event
.m_linesPerAction
= s_linesPerRotation
;
4237 return GetEventHandler()->ProcessEvent(event
);
4248 // ---------------------------------------------------------------------------
4249 // keyboard handling
4250 // ---------------------------------------------------------------------------
4252 // create the key event of the given type for the given key - used by
4253 // HandleChar and HandleKeyDown/Up
4254 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4257 WXWPARAM wParam
) const
4259 wxKeyEvent
event(evType
);
4260 event
.SetId(GetId());
4261 event
.m_shiftDown
= wxIsShiftDown();
4262 event
.m_controlDown
= wxIsCtrlDown();
4263 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4265 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4266 event
.m_keyCode
= id
;
4267 event
.m_rawCode
= (wxUint32
) wParam
;
4268 event
.m_rawFlags
= (wxUint32
) lParam
;
4269 event
.SetTimestamp(s_currentMsg
.time
);
4271 // translate the position to client coords
4275 GetWindowRect(GetHwnd(),&rect
);
4285 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4287 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4289 bool ctrlDown
= FALSE
;
4294 // If 1 -> 26, translate to CTRL plus a letter.
4296 if ( (id
> 0) && (id
< 27) )
4318 else // we're called from WM_KEYDOWN
4320 id
= wxCharCodeMSWToWX(wParam
);
4323 // it's ASCII and will be processed here only when called from
4324 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4329 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4332 event
.m_controlDown
= TRUE
;
4335 return GetEventHandler()->ProcessEvent(event
);
4338 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4340 int id
= wxCharCodeMSWToWX(wParam
);
4344 // normal ASCII char
4348 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4350 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4351 if ( GetEventHandler()->ProcessEvent(event
) )
4360 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4362 int id
= wxCharCodeMSWToWX(wParam
);
4366 // normal ASCII char
4370 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4372 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4373 if ( GetEventHandler()->ProcessEvent(event
) )
4380 // ---------------------------------------------------------------------------
4382 // ---------------------------------------------------------------------------
4384 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4388 if ( flags
& JOY_BUTTON1CHG
)
4389 change
= wxJOY_BUTTON1
;
4390 if ( flags
& JOY_BUTTON2CHG
)
4391 change
= wxJOY_BUTTON2
;
4392 if ( flags
& JOY_BUTTON3CHG
)
4393 change
= wxJOY_BUTTON3
;
4394 if ( flags
& JOY_BUTTON4CHG
)
4395 change
= wxJOY_BUTTON4
;
4398 if ( flags
& JOY_BUTTON1
)
4399 buttons
|= wxJOY_BUTTON1
;
4400 if ( flags
& JOY_BUTTON2
)
4401 buttons
|= wxJOY_BUTTON2
;
4402 if ( flags
& JOY_BUTTON3
)
4403 buttons
|= wxJOY_BUTTON3
;
4404 if ( flags
& JOY_BUTTON4
)
4405 buttons
|= wxJOY_BUTTON4
;
4407 // the event ids aren't consecutive so we can't use table based lookup
4409 wxEventType eventType
;
4414 eventType
= wxEVT_JOY_MOVE
;
4419 eventType
= wxEVT_JOY_MOVE
;
4424 eventType
= wxEVT_JOY_ZMOVE
;
4429 eventType
= wxEVT_JOY_ZMOVE
;
4432 case MM_JOY1BUTTONDOWN
:
4434 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4437 case MM_JOY2BUTTONDOWN
:
4439 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4442 case MM_JOY1BUTTONUP
:
4444 eventType
= wxEVT_JOY_BUTTON_UP
;
4447 case MM_JOY2BUTTONUP
:
4449 eventType
= wxEVT_JOY_BUTTON_UP
;
4453 wxFAIL_MSG(wxT("no such joystick event"));
4458 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4459 event
.SetPosition(wxPoint(x
, y
));
4460 event
.SetEventObject(this);
4462 return GetEventHandler()->ProcessEvent(event
);
4468 // ---------------------------------------------------------------------------
4470 // ---------------------------------------------------------------------------
4472 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4473 WXWORD pos
, WXHWND control
)
4477 wxWindow
*child
= wxFindWinFromHandle(control
);
4479 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4482 wxScrollWinEvent event
;
4483 event
.SetPosition(pos
);
4484 event
.SetOrientation(orientation
);
4485 event
.m_eventObject
= this;
4490 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4494 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4498 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4502 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4506 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4510 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4513 case SB_THUMBPOSITION
:
4516 // under Win32, the scrollbar range and position are 32 bit integers,
4517 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4518 // explicitly query the scrollbar for the correct position (this must
4519 // be done only for these two SB_ events as they are the only one
4520 // carrying the scrollbar position)
4522 SCROLLINFO scrollInfo
;
4523 wxZeroMemory(scrollInfo
);
4524 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
4525 scrollInfo
.fMask
= SIF_TRACKPOS
;
4527 if ( !::GetScrollInfo(GetHwnd(),
4528 orientation
== wxHORIZONTAL
? SB_HORZ
4532 wxLogLastError(_T("GetScrollInfo"));
4535 event
.SetPosition(scrollInfo
.nTrackPos
);
4539 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4540 ? wxEVT_SCROLLWIN_THUMBRELEASE
4541 : wxEVT_SCROLLWIN_THUMBTRACK
;
4548 return GetEventHandler()->ProcessEvent(event
);
4551 // ===========================================================================
4553 // ===========================================================================
4555 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4558 HDC dc
= ::GetDC((HWND
) wnd
);
4563 // the_font->UseResource();
4564 // the_font->RealizeResource();
4565 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4567 was
= (HFONT
) SelectObject(dc
,fnt
);
4569 GetTextMetrics(dc
, &tm
);
4570 if ( the_font
&& fnt
&& was
)
4572 SelectObject(dc
,was
);
4574 ReleaseDC((HWND
)wnd
, dc
);
4577 *x
= tm
.tmAveCharWidth
;
4579 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4582 // the_font->ReleaseResource();
4585 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4586 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4587 int wxCharCodeMSWToWX(int keySym
)
4592 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4593 case VK_BACK
: id
= WXK_BACK
; break;
4594 case VK_TAB
: id
= WXK_TAB
; break;
4595 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4596 case VK_RETURN
: id
= WXK_RETURN
; break;
4597 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4598 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4599 case VK_MENU
: id
= WXK_MENU
; break;
4600 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4601 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4602 case VK_SPACE
: id
= WXK_SPACE
; break;
4603 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4604 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4605 case VK_NEXT
: id
= WXK_NEXT
; break;
4606 case VK_END
: id
= WXK_END
; break;
4607 case VK_HOME
: id
= WXK_HOME
; break;
4608 case VK_LEFT
: id
= WXK_LEFT
; break;
4609 case VK_UP
: id
= WXK_UP
; break;
4610 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4611 case VK_DOWN
: id
= WXK_DOWN
; break;
4612 case VK_SELECT
: id
= WXK_SELECT
; break;
4613 case VK_PRINT
: id
= WXK_PRINT
; break;
4614 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4615 case VK_INSERT
: id
= WXK_INSERT
; break;
4616 case VK_DELETE
: id
= WXK_DELETE
; break;
4617 case VK_HELP
: id
= WXK_HELP
; break;
4618 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4619 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4620 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4621 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4622 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4623 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4624 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4625 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4626 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4627 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4628 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4629 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4630 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4631 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4632 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4633 case VK_F1
: id
= WXK_F1
; break;
4634 case VK_F2
: id
= WXK_F2
; break;
4635 case VK_F3
: id
= WXK_F3
; break;
4636 case VK_F4
: id
= WXK_F4
; break;
4637 case VK_F5
: id
= WXK_F5
; break;
4638 case VK_F6
: id
= WXK_F6
; break;
4639 case VK_F7
: id
= WXK_F7
; break;
4640 case VK_F8
: id
= WXK_F8
; break;
4641 case VK_F9
: id
= WXK_F9
; break;
4642 case VK_F10
: id
= WXK_F10
; break;
4643 case VK_F11
: id
= WXK_F11
; break;
4644 case VK_F12
: id
= WXK_F12
; break;
4645 case VK_F13
: id
= WXK_F13
; break;
4646 case VK_F14
: id
= WXK_F14
; break;
4647 case VK_F15
: id
= WXK_F15
; break;
4648 case VK_F16
: id
= WXK_F16
; break;
4649 case VK_F17
: id
= WXK_F17
; break;
4650 case VK_F18
: id
= WXK_F18
; break;
4651 case VK_F19
: id
= WXK_F19
; break;
4652 case VK_F20
: id
= WXK_F20
; break;
4653 case VK_F21
: id
= WXK_F21
; break;
4654 case VK_F22
: id
= WXK_F22
; break;
4655 case VK_F23
: id
= WXK_F23
; break;
4656 case VK_F24
: id
= WXK_F24
; break;
4657 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4658 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4660 case VK_OEM_1
: id
= ';'; break;
4661 case VK_OEM_PLUS
: id
= '+'; break;
4662 case VK_OEM_COMMA
: id
= ','; break;
4663 case VK_OEM_MINUS
: id
= '-'; break;
4664 case VK_OEM_PERIOD
: id
= '.'; break;
4665 case VK_OEM_2
: id
= '/'; break;
4666 case VK_OEM_3
: id
= '~'; break;
4667 case VK_OEM_4
: id
= '['; break;
4668 case VK_OEM_5
: id
= '\\'; break;
4669 case VK_OEM_6
: id
= ']'; break;
4670 case VK_OEM_7
: id
= '\''; break;
4679 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4685 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4686 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4687 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4688 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4689 case WXK_MENU
: keySym
= VK_MENU
; break;
4690 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4691 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4692 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4693 case WXK_END
: keySym
= VK_END
; break;
4694 case WXK_HOME
: keySym
= VK_HOME
; break;
4695 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4696 case WXK_UP
: keySym
= VK_UP
; break;
4697 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4698 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4699 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4700 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4701 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4702 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4703 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4704 case WXK_HELP
: keySym
= VK_HELP
; break;
4705 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4706 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4707 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4708 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4709 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4710 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4711 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4712 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4713 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4714 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4715 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4716 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4717 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4718 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4719 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4720 case WXK_F1
: keySym
= VK_F1
; break;
4721 case WXK_F2
: keySym
= VK_F2
; break;
4722 case WXK_F3
: keySym
= VK_F3
; break;
4723 case WXK_F4
: keySym
= VK_F4
; break;
4724 case WXK_F5
: keySym
= VK_F5
; break;
4725 case WXK_F6
: keySym
= VK_F6
; break;
4726 case WXK_F7
: keySym
= VK_F7
; break;
4727 case WXK_F8
: keySym
= VK_F8
; break;
4728 case WXK_F9
: keySym
= VK_F9
; break;
4729 case WXK_F10
: keySym
= VK_F10
; break;
4730 case WXK_F11
: keySym
= VK_F11
; break;
4731 case WXK_F12
: keySym
= VK_F12
; break;
4732 case WXK_F13
: keySym
= VK_F13
; break;
4733 case WXK_F14
: keySym
= VK_F14
; break;
4734 case WXK_F15
: keySym
= VK_F15
; break;
4735 case WXK_F16
: keySym
= VK_F16
; break;
4736 case WXK_F17
: keySym
= VK_F17
; break;
4737 case WXK_F18
: keySym
= VK_F18
; break;
4738 case WXK_F19
: keySym
= VK_F19
; break;
4739 case WXK_F20
: keySym
= VK_F20
; break;
4740 case WXK_F21
: keySym
= VK_F21
; break;
4741 case WXK_F22
: keySym
= VK_F22
; break;
4742 case WXK_F23
: keySym
= VK_F23
; break;
4743 case WXK_F24
: keySym
= VK_F24
; break;
4744 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4745 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4756 wxWindow
*wxGetActiveWindow()
4758 HWND hWnd
= GetActiveWindow();
4761 return wxFindWinFromHandle((WXHWND
) hWnd
);
4766 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4768 HWND hwnd
= (HWND
)hWnd
;
4770 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4771 // by code in msw/radiobox.cpp), for all the others we just search up the
4773 wxWindow
*win
= (wxWindow
*)NULL
;
4776 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4779 // all these hacks only work under Win32 anyhow
4783 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4784 // wxWindow class which overrides WM_GETDLGCODE processing to
4785 // do it as well, win would be already non NULL
4786 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
4788 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
4790 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4791 #endif // wxUSE_RADIOBOX
4793 // spin control text buddy window should be mapped to spin ctrl
4794 // itself so try it too
4795 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4798 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
4800 #endif // wxUSE_SPINCTRL
4806 while ( hwnd
&& !win
)
4808 // this is a really ugly hack needed to avoid mistakenly returning the
4809 // parent frame wxWindow for the find/replace modeless dialog HWND -
4810 // this, in turn, is needed to call IsDialogMessage() from
4811 // wxApp::ProcessMessage() as for this we must return NULL from here
4813 // FIXME: this is clearly not the best way to do it but I think we'll
4814 // need to change HWND <-> wxWindow code more heavily than I can
4815 // do it now to fix it
4816 #ifndef __WXMICROWIN__
4817 if ( ::GetWindow(hwnd
, GW_OWNER
) )
4819 // it's a dialog box, don't go upwards
4824 hwnd
= ::GetParent(hwnd
);
4825 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4831 #ifndef __WXMICROWIN__
4833 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4834 // in active frames and dialogs, regardless of where the focus is.
4835 static HHOOK wxTheKeyboardHook
= 0;
4836 static FARPROC wxTheKeyboardHookProc
= 0;
4837 int APIENTRY _EXPORT
4838 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
4840 void wxSetKeyboardHook(bool doIt
)
4844 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
4845 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
4847 #if defined(__WIN32__) && !defined(__TWIN32__)
4848 GetCurrentThreadId()
4849 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4857 UnhookWindowsHookEx(wxTheKeyboardHook
);
4859 // avoids warning about statement with no effect (FreeProcInstance
4860 // doesn't do anything under Win32)
4861 #if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32__) && !defined(__NT__) && !defined(__GNUWIN32__)
4862 FreeProcInstance(wxTheKeyboardHookProc
);
4867 int APIENTRY _EXPORT
4868 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
4870 DWORD hiWord
= HIWORD(lParam
);
4871 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
4873 int id
= wxCharCodeMSWToWX(wParam
);
4876 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
4877 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
4878 event
.m_altDown
= TRUE
;
4880 event
.m_eventObject
= NULL
;
4881 event
.m_keyCode
= id
;
4882 event
.m_shiftDown
= wxIsShiftDown();
4883 event
.m_controlDown
= wxIsCtrlDown();
4884 event
.SetTimestamp(s_currentMsg
.time
);
4886 wxWindow
*win
= wxGetActiveWindow();
4887 wxEvtHandler
*handler
;
4890 handler
= win
->GetEventHandler();
4891 event
.SetId(win
->GetId());
4899 if ( handler
&& handler
->ProcessEvent(event
) )
4907 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
4910 #endif // !__WXMICROWIN__
4913 const char *wxGetMessageName(int message
)
4917 case 0x0000: return "WM_NULL";
4918 case 0x0001: return "WM_CREATE";
4919 case 0x0002: return "WM_DESTROY";
4920 case 0x0003: return "WM_MOVE";
4921 case 0x0005: return "WM_SIZE";
4922 case 0x0006: return "WM_ACTIVATE";
4923 case 0x0007: return "WM_SETFOCUS";
4924 case 0x0008: return "WM_KILLFOCUS";
4925 case 0x000A: return "WM_ENABLE";
4926 case 0x000B: return "WM_SETREDRAW";
4927 case 0x000C: return "WM_SETTEXT";
4928 case 0x000D: return "WM_GETTEXT";
4929 case 0x000E: return "WM_GETTEXTLENGTH";
4930 case 0x000F: return "WM_PAINT";
4931 case 0x0010: return "WM_CLOSE";
4932 case 0x0011: return "WM_QUERYENDSESSION";
4933 case 0x0012: return "WM_QUIT";
4934 case 0x0013: return "WM_QUERYOPEN";
4935 case 0x0014: return "WM_ERASEBKGND";
4936 case 0x0015: return "WM_SYSCOLORCHANGE";
4937 case 0x0016: return "WM_ENDSESSION";
4938 case 0x0017: return "WM_SYSTEMERROR";
4939 case 0x0018: return "WM_SHOWWINDOW";
4940 case 0x0019: return "WM_CTLCOLOR";
4941 case 0x001A: return "WM_WININICHANGE";
4942 case 0x001B: return "WM_DEVMODECHANGE";
4943 case 0x001C: return "WM_ACTIVATEAPP";
4944 case 0x001D: return "WM_FONTCHANGE";
4945 case 0x001E: return "WM_TIMECHANGE";
4946 case 0x001F: return "WM_CANCELMODE";
4947 case 0x0020: return "WM_SETCURSOR";
4948 case 0x0021: return "WM_MOUSEACTIVATE";
4949 case 0x0022: return "WM_CHILDACTIVATE";
4950 case 0x0023: return "WM_QUEUESYNC";
4951 case 0x0024: return "WM_GETMINMAXINFO";
4952 case 0x0026: return "WM_PAINTICON";
4953 case 0x0027: return "WM_ICONERASEBKGND";
4954 case 0x0028: return "WM_NEXTDLGCTL";
4955 case 0x002A: return "WM_SPOOLERSTATUS";
4956 case 0x002B: return "WM_DRAWITEM";
4957 case 0x002C: return "WM_MEASUREITEM";
4958 case 0x002D: return "WM_DELETEITEM";
4959 case 0x002E: return "WM_VKEYTOITEM";
4960 case 0x002F: return "WM_CHARTOITEM";
4961 case 0x0030: return "WM_SETFONT";
4962 case 0x0031: return "WM_GETFONT";
4963 case 0x0037: return "WM_QUERYDRAGICON";
4964 case 0x0039: return "WM_COMPAREITEM";
4965 case 0x0041: return "WM_COMPACTING";
4966 case 0x0044: return "WM_COMMNOTIFY";
4967 case 0x0046: return "WM_WINDOWPOSCHANGING";
4968 case 0x0047: return "WM_WINDOWPOSCHANGED";
4969 case 0x0048: return "WM_POWER";
4972 case 0x004A: return "WM_COPYDATA";
4973 case 0x004B: return "WM_CANCELJOURNAL";
4974 case 0x004E: return "WM_NOTIFY";
4975 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
4976 case 0x0051: return "WM_INPUTLANGCHANGE";
4977 case 0x0052: return "WM_TCARD";
4978 case 0x0053: return "WM_HELP";
4979 case 0x0054: return "WM_USERCHANGED";
4980 case 0x0055: return "WM_NOTIFYFORMAT";
4981 case 0x007B: return "WM_CONTEXTMENU";
4982 case 0x007C: return "WM_STYLECHANGING";
4983 case 0x007D: return "WM_STYLECHANGED";
4984 case 0x007E: return "WM_DISPLAYCHANGE";
4985 case 0x007F: return "WM_GETICON";
4986 case 0x0080: return "WM_SETICON";
4989 case 0x0081: return "WM_NCCREATE";
4990 case 0x0082: return "WM_NCDESTROY";
4991 case 0x0083: return "WM_NCCALCSIZE";
4992 case 0x0084: return "WM_NCHITTEST";
4993 case 0x0085: return "WM_NCPAINT";
4994 case 0x0086: return "WM_NCACTIVATE";
4995 case 0x0087: return "WM_GETDLGCODE";
4996 case 0x00A0: return "WM_NCMOUSEMOVE";
4997 case 0x00A1: return "WM_NCLBUTTONDOWN";
4998 case 0x00A2: return "WM_NCLBUTTONUP";
4999 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5000 case 0x00A4: return "WM_NCRBUTTONDOWN";
5001 case 0x00A5: return "WM_NCRBUTTONUP";
5002 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5003 case 0x00A7: return "WM_NCMBUTTONDOWN";
5004 case 0x00A8: return "WM_NCMBUTTONUP";
5005 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5006 case 0x0100: return "WM_KEYDOWN";
5007 case 0x0101: return "WM_KEYUP";
5008 case 0x0102: return "WM_CHAR";
5009 case 0x0103: return "WM_DEADCHAR";
5010 case 0x0104: return "WM_SYSKEYDOWN";
5011 case 0x0105: return "WM_SYSKEYUP";
5012 case 0x0106: return "WM_SYSCHAR";
5013 case 0x0107: return "WM_SYSDEADCHAR";
5014 case 0x0108: return "WM_KEYLAST";
5017 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5018 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5019 case 0x010F: return "WM_IME_COMPOSITION";
5022 case 0x0110: return "WM_INITDIALOG";
5023 case 0x0111: return "WM_COMMAND";
5024 case 0x0112: return "WM_SYSCOMMAND";
5025 case 0x0113: return "WM_TIMER";
5026 case 0x0114: return "WM_HSCROLL";
5027 case 0x0115: return "WM_VSCROLL";
5028 case 0x0116: return "WM_INITMENU";
5029 case 0x0117: return "WM_INITMENUPOPUP";
5030 case 0x011F: return "WM_MENUSELECT";
5031 case 0x0120: return "WM_MENUCHAR";
5032 case 0x0121: return "WM_ENTERIDLE";
5033 case 0x0200: return "WM_MOUSEMOVE";
5034 case 0x0201: return "WM_LBUTTONDOWN";
5035 case 0x0202: return "WM_LBUTTONUP";
5036 case 0x0203: return "WM_LBUTTONDBLCLK";
5037 case 0x0204: return "WM_RBUTTONDOWN";
5038 case 0x0205: return "WM_RBUTTONUP";
5039 case 0x0206: return "WM_RBUTTONDBLCLK";
5040 case 0x0207: return "WM_MBUTTONDOWN";
5041 case 0x0208: return "WM_MBUTTONUP";
5042 case 0x0209: return "WM_MBUTTONDBLCLK";
5043 case 0x020A: return "WM_MOUSEWHEEL";
5044 case 0x0210: return "WM_PARENTNOTIFY";
5045 case 0x0211: return "WM_ENTERMENULOOP";
5046 case 0x0212: return "WM_EXITMENULOOP";
5049 case 0x0213: return "WM_NEXTMENU";
5050 case 0x0214: return "WM_SIZING";
5051 case 0x0215: return "WM_CAPTURECHANGED";
5052 case 0x0216: return "WM_MOVING";
5053 case 0x0218: return "WM_POWERBROADCAST";
5054 case 0x0219: return "WM_DEVICECHANGE";
5057 case 0x0220: return "WM_MDICREATE";
5058 case 0x0221: return "WM_MDIDESTROY";
5059 case 0x0222: return "WM_MDIACTIVATE";
5060 case 0x0223: return "WM_MDIRESTORE";
5061 case 0x0224: return "WM_MDINEXT";
5062 case 0x0225: return "WM_MDIMAXIMIZE";
5063 case 0x0226: return "WM_MDITILE";
5064 case 0x0227: return "WM_MDICASCADE";
5065 case 0x0228: return "WM_MDIICONARRANGE";
5066 case 0x0229: return "WM_MDIGETACTIVE";
5067 case 0x0230: return "WM_MDISETMENU";
5068 case 0x0233: return "WM_DROPFILES";
5071 case 0x0281: return "WM_IME_SETCONTEXT";
5072 case 0x0282: return "WM_IME_NOTIFY";
5073 case 0x0283: return "WM_IME_CONTROL";
5074 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5075 case 0x0285: return "WM_IME_SELECT";
5076 case 0x0286: return "WM_IME_CHAR";
5077 case 0x0290: return "WM_IME_KEYDOWN";
5078 case 0x0291: return "WM_IME_KEYUP";
5081 case 0x0300: return "WM_CUT";
5082 case 0x0301: return "WM_COPY";
5083 case 0x0302: return "WM_PASTE";
5084 case 0x0303: return "WM_CLEAR";
5085 case 0x0304: return "WM_UNDO";
5086 case 0x0305: return "WM_RENDERFORMAT";
5087 case 0x0306: return "WM_RENDERALLFORMATS";
5088 case 0x0307: return "WM_DESTROYCLIPBOARD";
5089 case 0x0308: return "WM_DRAWCLIPBOARD";
5090 case 0x0309: return "WM_PAINTCLIPBOARD";
5091 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5092 case 0x030B: return "WM_SIZECLIPBOARD";
5093 case 0x030C: return "WM_ASKCBFORMATNAME";
5094 case 0x030D: return "WM_CHANGECBCHAIN";
5095 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5096 case 0x030F: return "WM_QUERYNEWPALETTE";
5097 case 0x0310: return "WM_PALETTEISCHANGING";
5098 case 0x0311: return "WM_PALETTECHANGED";
5101 // common controls messages - although they're not strictly speaking
5102 // standard, it's nice to decode them nevertheless
5105 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5106 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5107 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5108 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5109 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5110 case 0x1000 + 5: return "LVM_GETITEMA";
5111 case 0x1000 + 75: return "LVM_GETITEMW";
5112 case 0x1000 + 6: return "LVM_SETITEMA";
5113 case 0x1000 + 76: return "LVM_SETITEMW";
5114 case 0x1000 + 7: return "LVM_INSERTITEMA";
5115 case 0x1000 + 77: return "LVM_INSERTITEMW";
5116 case 0x1000 + 8: return "LVM_DELETEITEM";
5117 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5118 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5119 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5120 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5121 case 0x1000 + 13: return "LVM_FINDITEMA";
5122 case 0x1000 + 83: return "LVM_FINDITEMW";
5123 case 0x1000 + 14: return "LVM_GETITEMRECT";
5124 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5125 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5126 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5127 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5128 case 0x1000 + 18: return "LVM_HITTEST";
5129 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5130 case 0x1000 + 20: return "LVM_SCROLL";
5131 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5132 case 0x1000 + 22: return "LVM_ARRANGE";
5133 case 0x1000 + 23: return "LVM_EDITLABELA";
5134 case 0x1000 + 118: return "LVM_EDITLABELW";
5135 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5136 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5137 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5138 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5139 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5140 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5141 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5142 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5143 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5144 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5145 case 0x1000 + 31: return "LVM_GETHEADER";
5146 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5147 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5148 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5149 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5150 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5151 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5152 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5153 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5154 case 0x1000 + 41: return "LVM_GETORIGIN";
5155 case 0x1000 + 42: return "LVM_UPDATE";
5156 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5157 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5158 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5159 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5160 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5161 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5162 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5163 case 0x1000 + 48: return "LVM_SORTITEMS";
5164 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5165 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5166 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5167 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5168 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5169 case 0x1000 + 53: return "LVM_SETICONSPACING";
5170 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5171 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5172 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5173 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5174 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5175 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5176 case 0x1000 + 60: return "LVM_SETHOTITEM";
5177 case 0x1000 + 61: return "LVM_GETHOTITEM";
5178 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5179 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5180 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5181 case 0x1000 + 65: return "LVM_SETWORKAREA";
5184 case 0x1100 + 0: return "TVM_INSERTITEMA";
5185 case 0x1100 + 50: return "TVM_INSERTITEMW";
5186 case 0x1100 + 1: return "TVM_DELETEITEM";
5187 case 0x1100 + 2: return "TVM_EXPAND";
5188 case 0x1100 + 4: return "TVM_GETITEMRECT";
5189 case 0x1100 + 5: return "TVM_GETCOUNT";
5190 case 0x1100 + 6: return "TVM_GETINDENT";
5191 case 0x1100 + 7: return "TVM_SETINDENT";
5192 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5193 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5194 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5195 case 0x1100 + 11: return "TVM_SELECTITEM";
5196 case 0x1100 + 12: return "TVM_GETITEMA";
5197 case 0x1100 + 62: return "TVM_GETITEMW";
5198 case 0x1100 + 13: return "TVM_SETITEMA";
5199 case 0x1100 + 63: return "TVM_SETITEMW";
5200 case 0x1100 + 14: return "TVM_EDITLABELA";
5201 case 0x1100 + 65: return "TVM_EDITLABELW";
5202 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5203 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5204 case 0x1100 + 17: return "TVM_HITTEST";
5205 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5206 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5207 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5208 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5209 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5210 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5211 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5212 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5213 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5216 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5217 case 0x1200 + 1: return "HDM_INSERTITEMA";
5218 case 0x1200 + 10: return "HDM_INSERTITEMW";
5219 case 0x1200 + 2: return "HDM_DELETEITEM";
5220 case 0x1200 + 3: return "HDM_GETITEMA";
5221 case 0x1200 + 11: return "HDM_GETITEMW";
5222 case 0x1200 + 4: return "HDM_SETITEMA";
5223 case 0x1200 + 12: return "HDM_SETITEMW";
5224 case 0x1200 + 5: return "HDM_LAYOUT";
5225 case 0x1200 + 6: return "HDM_HITTEST";
5226 case 0x1200 + 7: return "HDM_GETITEMRECT";
5227 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5228 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5229 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5230 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5231 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5232 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5233 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5236 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5237 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5238 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5239 case 0x1300 + 5: return "TCM_GETITEMA";
5240 case 0x1300 + 60: return "TCM_GETITEMW";
5241 case 0x1300 + 6: return "TCM_SETITEMA";
5242 case 0x1300 + 61: return "TCM_SETITEMW";
5243 case 0x1300 + 7: return "TCM_INSERTITEMA";
5244 case 0x1300 + 62: return "TCM_INSERTITEMW";
5245 case 0x1300 + 8: return "TCM_DELETEITEM";
5246 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5247 case 0x1300 + 10: return "TCM_GETITEMRECT";
5248 case 0x1300 + 11: return "TCM_GETCURSEL";
5249 case 0x1300 + 12: return "TCM_SETCURSEL";
5250 case 0x1300 + 13: return "TCM_HITTEST";
5251 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5252 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5253 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5254 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5255 case 0x1300 + 43: return "TCM_SETPADDING";
5256 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5257 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5258 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5259 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5260 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5261 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5262 case 0x1300 + 50: return "TCM_DESELECTALL";
5265 case WM_USER
+1: return "TB_ENABLEBUTTON";
5266 case WM_USER
+2: return "TB_CHECKBUTTON";
5267 case WM_USER
+3: return "TB_PRESSBUTTON";
5268 case WM_USER
+4: return "TB_HIDEBUTTON";
5269 case WM_USER
+5: return "TB_INDETERMINATE";
5270 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5271 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5272 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5273 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5274 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5275 case WM_USER
+17: return "TB_SETSTATE";
5276 case WM_USER
+18: return "TB_GETSTATE";
5277 case WM_USER
+19: return "TB_ADDBITMAP";
5278 case WM_USER
+20: return "TB_ADDBUTTONS";
5279 case WM_USER
+21: return "TB_INSERTBUTTON";
5280 case WM_USER
+22: return "TB_DELETEBUTTON";
5281 case WM_USER
+23: return "TB_GETBUTTON";
5282 case WM_USER
+24: return "TB_BUTTONCOUNT";
5283 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5284 case WM_USER
+26: return "TB_SAVERESTOREA";
5285 case WM_USER
+76: return "TB_SAVERESTOREW";
5286 case WM_USER
+27: return "TB_CUSTOMIZE";
5287 case WM_USER
+28: return "TB_ADDSTRINGA";
5288 case WM_USER
+77: return "TB_ADDSTRINGW";
5289 case WM_USER
+29: return "TB_GETITEMRECT";
5290 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5291 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5292 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5293 case WM_USER
+33: return "TB_AUTOSIZE";
5294 case WM_USER
+35: return "TB_GETTOOLTIPS";
5295 case WM_USER
+36: return "TB_SETTOOLTIPS";
5296 case WM_USER
+37: return "TB_SETPARENT";
5297 case WM_USER
+39: return "TB_SETROWS";
5298 case WM_USER
+40: return "TB_GETROWS";
5299 case WM_USER
+42: return "TB_SETCMDID";
5300 case WM_USER
+43: return "TB_CHANGEBITMAP";
5301 case WM_USER
+44: return "TB_GETBITMAP";
5302 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5303 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5304 case WM_USER
+46: return "TB_REPLACEBITMAP";
5305 case WM_USER
+47: return "TB_SETINDENT";
5306 case WM_USER
+48: return "TB_SETIMAGELIST";
5307 case WM_USER
+49: return "TB_GETIMAGELIST";
5308 case WM_USER
+50: return "TB_LOADIMAGES";
5309 case WM_USER
+51: return "TB_GETRECT";
5310 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5311 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5312 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5313 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5314 case WM_USER
+56: return "TB_SETSTYLE";
5315 case WM_USER
+57: return "TB_GETSTYLE";
5316 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5317 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5318 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5319 case WM_USER
+61: return "TB_GETTEXTROWS";
5320 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5325 static char s_szBuf
[128];
5326 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5330 #endif //__WXDEBUG__
5332 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5333 int *x
, int *y
, WPARAM
*flags
)
5335 // construct the key mask
5336 WPARAM
& fwKeys
= *flags
;
5338 fwKeys
= MK_RBUTTON
;
5339 if ( wxIsCtrlDown() )
5340 fwKeys
|= MK_CONTROL
;
5341 if ( wxIsShiftDown() )
5344 // simulate right mouse button click
5345 DWORD dwPos
= ::GetMessagePos();
5346 *x
= GET_X_LPARAM(dwPos
);
5347 *y
= GET_Y_LPARAM(dwPos
);
5349 win
->ScreenToClient(x
, y
);
5352 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5356 HWND hwnd
= GetHwndOf(win
);
5357 HDC hdc
= ::GetDC(hwnd
);
5359 #if !wxDIALOG_UNIT_COMPATIBILITY
5360 // and select the current font into it
5361 HFONT hfont
= GetHfontOf(win
->GetFont());
5364 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5368 // finally retrieve the text metrics from it
5369 GetTextMetrics(hdc
, &tm
);
5371 #if !wxDIALOG_UNIT_COMPATIBILITY
5375 (void)::SelectObject(hdc
, hfont
);
5379 ::ReleaseDC(hwnd
, hdc
);
5384 // Find the wxWindow at the current mouse position, returning the mouse
5386 wxWindow
* wxFindWindowAtPointer(wxPoint
& WXUNUSED(pt
))
5388 return wxFindWindowAtPoint(wxGetMousePosition());
5391 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5396 HWND hWndHit
= ::WindowFromPoint(pt2
);
5398 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5399 HWND hWnd
= hWndHit
;
5401 // Try to find a window with a wxWindow associated with it
5402 while (!win
&& (hWnd
!= 0))
5404 hWnd
= ::GetParent(hWnd
);
5405 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5410 // Get the current mouse position.
5411 wxPoint
wxGetMousePosition()
5414 GetCursorPos( & pt
);
5416 return wxPoint(pt
.x
, pt
.y
);