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
;
321 m_childrenDisabled
= NULL
;
330 m_backgroundTransparent
= FALSE
;
332 // as all windows are created with WS_VISIBLE style...
335 #if wxUSE_MOUSEEVENT_HACK
338 m_lastMouseEvent
= -1;
339 #endif // wxUSE_MOUSEEVENT_HACK
343 wxWindowMSW::~wxWindowMSW()
345 m_isBeingDeleted
= TRUE
;
347 #ifndef __WXUNIVERSAL__
348 // VS: make sure there's no wxFrame with last focus set to us:
349 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
351 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
354 if ( frame
->GetLastFocus() == this )
356 frame
->SetLastFocus(NULL
);
361 #endif // __WXUNIVERSAL__
363 // VS: destroy children first and _then_ detach *this from its parent.
364 // If we'd do it the other way around, children wouldn't be able
365 // find their parent frame (see above).
369 m_parent
->RemoveChild(this);
373 // VZ: test temp removed to understand what really happens here
374 //if (::IsWindow(GetHwnd()))
376 if ( !::DestroyWindow(GetHwnd()) )
377 wxLogLastError(wxT("DestroyWindow"));
380 // remove hWnd <-> wxWindow association
381 wxRemoveHandleAssociation(this);
384 delete m_childrenDisabled
;
387 // real construction (Init() must have been called before!)
388 bool wxWindowMSW::Create(wxWindow
*parent
,
393 const wxString
& name
)
395 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
398 // wxGTK doesn't allow to create controls with static box as the parent so
399 // this will result in a crash when the program is ported to wxGTK - warn
402 // the correct solution is to create the controls as siblings of the
404 wxASSERT_MSG( !wxDynamicCast(parent
, wxStaticBox
),
405 _T("wxStaticBox can't be used as a window parent!") );
406 #endif // wxUSE_STATBOX
408 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
411 parent
->AddChild(this);
414 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
416 #ifdef __WXUNIVERSAL__
417 // no borders, we draw them ourselves
418 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
422 msflags
&= ~WS_BORDER
;
423 #endif // wxUniversal
425 // all windows are created visible by default except popup ones (which are
426 // like the wxTopLevelWindows in this aspect)
427 if ( style
& wxPOPUP_WINDOW
)
429 msflags
&= ~WS_VISIBLE
;
434 msflags
|= WS_VISIBLE
;
437 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
440 // ---------------------------------------------------------------------------
442 // ---------------------------------------------------------------------------
444 void wxWindowMSW::SetFocus()
446 HWND hWnd
= GetHwnd();
447 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
449 #ifndef __WXMICROWIN__
453 if ( !::SetFocus(hWnd
) )
455 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
456 // was there really an error?
457 DWORD dwRes
= ::GetLastError();
460 HWND hwndFocus
= ::GetFocus();
461 if ( hwndFocus
!= hWnd
)
463 wxLogApiError(_T("SetFocus"), dwRes
);
470 void wxWindowMSW::SetFocusFromKbd()
472 wxWindowBase::SetFocusFromKbd();
474 // when the focus is given to the control with DLGC_HASSETSEL style from
475 // keyboard its contents should be entirely selected: this is what
476 // ::IsDialogMessage() does and so we should do it as well to provide the
477 // same LNF as the native programs
478 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
480 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
484 // Get the window with the focus
485 wxWindow
*wxWindowBase::FindFocus()
487 HWND hWnd
= ::GetFocus();
490 return wxGetWindowFromHWND((WXHWND
)hWnd
);
496 bool wxWindowMSW::Enable(bool enable
)
498 if ( !wxWindowBase::Enable(enable
) )
501 HWND hWnd
= GetHwnd();
503 ::EnableWindow(hWnd
, (BOOL
)enable
);
505 // when the parent is disabled, all of its children should be disabled as
506 // well but when it is enabled back, only those of the children which
507 // hadn't been already disabled in the beginning should be enabled again,
508 // so we have to keep the list of those children
509 for ( wxWindowList::Node
*node
= GetChildren().GetFirst();
511 node
= node
->GetNext() )
513 wxWindow
*child
= node
->GetData();
514 if ( child
->IsTopLevel() )
516 // the logic below doesn't apply to top level children
522 // enable the child back unless it had been disabled before us
523 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
526 else // we're being disabled
528 if ( child
->IsEnabled() )
530 // disable it as children shouldn't stay enabled while the
534 else // child already disabled, remember it
536 // have we created the list of disabled children already?
537 if ( !m_childrenDisabled
)
538 m_childrenDisabled
= new wxWindowList
;
540 m_childrenDisabled
->Append(child
);
545 if ( enable
&& m_childrenDisabled
)
547 // we don't need this list any more, don't keep unused memory
548 delete m_childrenDisabled
;
549 m_childrenDisabled
= NULL
;
555 bool wxWindowMSW::Show(bool show
)
557 if ( !wxWindowBase::Show(show
) )
560 HWND hWnd
= GetHwnd();
561 int cshow
= show
? SW_SHOW
: SW_HIDE
;
562 ::ShowWindow(hWnd
, cshow
);
566 wxBringWindowToTop(hWnd
);
572 // Raise the window to the top of the Z order
573 void wxWindowMSW::Raise()
575 wxBringWindowToTop(GetHwnd());
578 // Lower the window to the bottom of the Z order
579 void wxWindowMSW::Lower()
581 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
582 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
585 void wxWindowMSW::SetTitle( const wxString
& title
)
587 SetWindowText(GetHwnd(), title
.c_str());
590 wxString
wxWindowMSW::GetTitle() const
592 return wxGetWindowText(GetHWND());
595 void wxWindowMSW::DoCaptureMouse()
597 HWND hWnd
= GetHwnd();
604 void wxWindowMSW::DoReleaseMouse()
606 if ( !::ReleaseCapture() )
608 wxLogLastError(_T("ReleaseCapture"));
612 /* static */ wxWindow
*wxWindowBase::GetCapture()
614 HWND hwnd
= ::GetCapture();
615 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
618 bool wxWindowMSW::SetFont(const wxFont
& font
)
620 if ( !wxWindowBase::SetFont(font
) )
626 HWND hWnd
= GetHwnd();
629 WXHANDLE hFont
= m_font
.GetResourceHandle();
631 wxASSERT_MSG( hFont
, wxT("should have valid font") );
633 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
638 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
640 if ( !wxWindowBase::SetCursor(cursor
) )
648 HWND hWnd
= GetHwnd();
650 // Change the cursor NOW if we're within the correct window
652 ::GetCursorPos(&point
);
654 RECT rect
= wxGetWindowRect(hWnd
);
656 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
657 ::SetCursor(GetHcursorOf(m_cursor
));
663 void wxWindowMSW::WarpPointer (int x
, int y
)
665 ClientToScreen(&x
, &y
);
667 if ( !::SetCursorPos(x
, y
) )
669 wxLogLastError(_T("SetCursorPos"));
673 #if WXWIN_COMPATIBILITY
674 void wxWindowMSW::MSWDeviceToLogical (float *x
, float *y
) const
677 #endif // WXWIN_COMPATIBILITY
679 // ---------------------------------------------------------------------------
681 // ---------------------------------------------------------------------------
683 #if WXWIN_COMPATIBILITY
684 void wxWindowMSW::SetScrollRange(int orient
, int range
, bool refresh
)
686 #if defined(__WIN95__)
690 // Try to adjust the range to cope with page size > 1
691 // - a Windows API quirk
692 int pageSize
= GetScrollPage(orient
);
693 if ( pageSize
> 1 && range
> 0)
695 range1
+= (pageSize
- 1);
701 if ( orient
== wxHORIZONTAL
) {
707 info
.cbSize
= sizeof(SCROLLINFO
);
708 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
712 info
.fMask
= SIF_RANGE
| SIF_PAGE
;
714 HWND hWnd
= GetHwnd();
716 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
719 if ( orient
== wxHORIZONTAL
)
724 HWND hWnd
= GetHwnd();
726 ::SetScrollRange(hWnd
, wOrient
, 0, range
, refresh
);
730 void wxWindowMSW::SetScrollPage(int orient
, int page
, bool refresh
)
732 #if defined(__WIN95__)
736 if ( orient
== wxHORIZONTAL
) {
744 info
.cbSize
= sizeof(SCROLLINFO
);
747 info
.fMask
= SIF_PAGE
;
749 HWND hWnd
= GetHwnd();
751 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
753 if ( orient
== wxHORIZONTAL
)
760 int wxWindowMSW::OldGetScrollRange(int orient
) const
763 if ( orient
== wxHORIZONTAL
)
768 #if __WATCOMC__ && defined(__WINDOWS_386__)
769 short minPos
, maxPos
;
773 HWND hWnd
= GetHwnd();
776 ::GetScrollRange(hWnd
, wOrient
, &minPos
, &maxPos
);
777 #if defined(__WIN95__)
778 // Try to adjust the range to cope with page size > 1
779 // - a Windows API quirk
780 int pageSize
= GetScrollPage(orient
);
783 maxPos
-= (pageSize
- 1);
792 int wxWindowMSW::GetScrollPage(int orient
) const
794 if ( orient
== wxHORIZONTAL
)
800 #endif // WXWIN_COMPATIBILITY
802 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
804 #ifdef __WXMICROWIN__
805 return ::GetScrollPosWX(hWnd
, wOrient
);
807 return ::GetScrollPos(hWnd
, wOrient
);
811 int wxWindowMSW::GetScrollPos(int orient
) const
814 if ( orient
== wxHORIZONTAL
)
819 HWND hWnd
= GetHwnd();
820 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
822 return GetScrollPosition(hWnd
, wOrient
);
825 // This now returns the whole range, not just the number
826 // of positions that we can scroll.
827 int wxWindowMSW::GetScrollRange(int orient
) const
830 if ( orient
== wxHORIZONTAL
)
835 #if __WATCOMC__ && defined(__WINDOWS_386__)
836 short minPos
, maxPos
;
840 HWND hWnd
= GetHwnd();
843 ::GetScrollRange(hWnd
, wOrient
, &minPos
, &maxPos
);
844 #if defined(__WIN95__)
845 // Try to adjust the range to cope with page size > 1
846 // - a Windows API quirk
847 int pageSize
= GetScrollThumb(orient
);
850 maxPos
-= (pageSize
- 1);
852 // October 10th: new range concept.
862 int wxWindowMSW::GetScrollThumb(int orient
) const
864 if ( orient
== wxHORIZONTAL
)
870 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
872 HWND hWnd
= GetHwnd();
873 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
875 int dir
= orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
877 #if defined(__WIN95__)
879 info
.cbSize
= sizeof(SCROLLINFO
);
883 info
.fMask
= SIF_POS
;
885 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
887 ::SetScrollPos(hWnd
, dir
, pos
, refresh
);
888 #endif // __WIN95__/!__WIN95__
891 // New function that will replace some of the above.
892 void wxWindowMSW::SetScrollbar(int orient
, int pos
, int thumbVisible
,
893 int range
, bool refresh
)
895 #if defined(__WIN95__)
896 int oldRange
= range
- thumbVisible
;
898 int range1
= oldRange
;
900 // Try to adjust the range to cope with page size > 1
901 // - a Windows API quirk
902 int pageSize
= thumbVisible
;
903 if ( pageSize
> 1 && range
> 0)
905 range1
+= (pageSize
- 1);
911 if ( orient
== wxHORIZONTAL
) {
917 info
.cbSize
= sizeof(SCROLLINFO
);
918 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
922 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
924 HWND hWnd
= GetHwnd();
926 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
929 if ( orient
== wxHORIZONTAL
)
934 HWND hWnd
= GetHwnd();
937 ::SetScrollRange(hWnd
, wOrient
, 0, range
, FALSE
);
938 ::SetScrollPos(hWnd
, wOrient
, pos
, refresh
);
941 if ( orient
== wxHORIZONTAL
) {
942 m_xThumbSize
= thumbVisible
;
944 m_yThumbSize
= thumbVisible
;
948 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
954 rect
.left
= prect
->x
;
956 rect
.right
= prect
->x
+ prect
->width
;
957 rect
.bottom
= prect
->y
+ prect
->height
;
965 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
968 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
970 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
973 for ( int n
= 0; n
< count
; n
++ )
975 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
977 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
980 // don't bother to continue, we're already at top/bottom
987 return pos
!= posStart
;
990 bool wxWindowMSW::ScrollLines(int lines
)
992 bool down
= lines
> 0;
994 return ScrollVertically(GetHwnd(),
995 down
? SB_LINEDOWN
: SB_LINEUP
,
996 down
? lines
: -lines
);
999 bool wxWindowMSW::ScrollPages(int pages
)
1001 bool down
= pages
> 0;
1003 return ScrollVertically(GetHwnd(),
1004 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1005 down
? pages
: -pages
);
1008 // ---------------------------------------------------------------------------
1010 // ---------------------------------------------------------------------------
1012 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1014 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1016 HWND hwnd
= (HWND
)hWnd
;
1017 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1019 wxAssociateWinWithHandle(hwnd
, this);
1021 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
1023 // we don't need to subclass the window of our own class (in the Windows
1024 // sense of the word)
1025 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1027 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
1031 // don't bother restoring it neither: this also makes it easy to
1032 // implement IsOfStandardClass() method which returns TRUE for the
1033 // standard controls and FALSE for the wxWindows own windows as it can
1034 // simply check m_oldWndProc
1035 m_oldWndProc
= NULL
;
1039 void wxWindowMSW::UnsubclassWin()
1041 wxRemoveHandleAssociation(this);
1043 // Restore old Window proc
1044 HWND hwnd
= GetHwnd();
1049 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1053 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1055 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
1058 m_oldWndProc
= NULL
;
1063 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1065 // Unicows note: the code below works, but only because WNDCLASS contains
1066 // original window handler rather that the unicows fake one. This may not
1067 // be on purpose, though; if it stops working with future versions of
1068 // unicows.dll, we can override unicows hooks by setting
1069 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1070 // versions that keep track of fake<->real wnd proc mapping.
1072 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1074 wxLogLastError(_T("GetClassInfo"));
1079 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1082 // ----------------------------------------------------------------------------
1084 // ----------------------------------------------------------------------------
1086 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1088 long flagsOld
= GetWindowStyleFlag();
1089 if ( flags
== flagsOld
)
1092 // update the internal variable
1093 wxWindowBase::SetWindowStyleFlag(flags
);
1095 // now update the Windows style as well if needed - and if the window had
1096 // been already created
1100 WXDWORD exstyle
, exstyleOld
;
1101 long style
= MSWGetStyle(flags
, &exstyle
),
1102 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1104 if ( style
!= styleOld
)
1106 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1107 // this function so instead of simply setting the style to the new
1108 // value we clear the bits which were set in styleOld but are set in
1109 // the new one and set the ones which were not set before
1110 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1111 styleReal
&= ~styleOld
;
1114 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1117 // and the extended style
1118 if ( exstyle
!= exstyleOld
)
1120 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1121 exstyleReal
&= ~exstyleOld
;
1122 exstyleReal
|= exstyle
;
1124 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1126 // we must call SetWindowPos() to flash the cached extended style and
1127 // also to make the change to wxSTAY_ON_TOP style take effect: just
1128 // setting the style simply doesn't work
1129 if ( !::SetWindowPos(GetHwnd(),
1130 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1133 SWP_NOMOVE
| SWP_NOSIZE
) )
1135 wxLogLastError(_T("SetWindowPos"));
1140 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1142 // translate the style
1143 WXDWORD style
= WS_CHILD
;
1145 if ( flags
& wxCLIP_CHILDREN
)
1146 style
|= WS_CLIPCHILDREN
;
1148 if ( flags
& wxCLIP_SIBLINGS
)
1149 style
|= WS_CLIPSIBLINGS
;
1151 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
1152 if ( border
!= wxBORDER_NONE
&& border
!= wxBORDER_DEFAULT
)
1155 // now deal with ext style if the caller wants it
1160 if ( flags
& wxTRANSPARENT_WINDOW
)
1161 *exstyle
|= WS_EX_TRANSPARENT
;
1163 switch ( flags
& wxBORDER_MASK
)
1166 wxFAIL_MSG( _T("unknown border style") );
1170 case wxBORDER_SIMPLE
:
1171 case wxBORDER_DEFAULT
:
1174 case wxBORDER_STATIC
:
1175 *exstyle
|= WS_EX_STATICEDGE
;
1178 case wxBORDER_RAISED
:
1179 *exstyle
|= WS_EX_WINDOWEDGE
;
1182 case wxBORDER_SUNKEN
:
1183 *exstyle
|= WS_EX_CLIENTEDGE
;
1186 case wxBORDER_DOUBLE
:
1187 *exstyle
|= WS_EX_DLGMODALFRAME
;
1191 // wxUniv doesn't use Windows dialog navigation functions at all
1192 #ifndef __WXUNIVERSAL__
1193 // to make the dialog navigation work with the nested panels we must
1194 // use this style (top level windows such as dialogs don't need it)
1195 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1197 *exstyle
|= WS_EX_CONTROLPARENT
;
1199 #endif // __WXUNIVERSAL__
1205 // Make a Windows extended style from the given wxWindows window style
1206 WXDWORD
wxWindowMSW::MakeExtendedStyle(long style
, bool eliminateBorders
)
1208 WXDWORD exStyle
= 0;
1209 if ( style
& wxTRANSPARENT_WINDOW
)
1210 exStyle
|= WS_EX_TRANSPARENT
;
1212 if ( !eliminateBorders
)
1214 if ( style
& wxSUNKEN_BORDER
)
1215 exStyle
|= WS_EX_CLIENTEDGE
;
1216 if ( style
& wxDOUBLE_BORDER
)
1217 exStyle
|= WS_EX_DLGMODALFRAME
;
1218 #if defined(__WIN95__)
1219 if ( style
& wxRAISED_BORDER
)
1220 // It seems that WS_EX_WINDOWEDGE doesn't work, but WS_EX_DLGMODALFRAME does
1221 exStyle
|= WS_EX_DLGMODALFRAME
; /* WS_EX_WINDOWEDGE */;
1222 if ( style
& wxSTATIC_BORDER
)
1223 exStyle
|= WS_EX_STATICEDGE
;
1230 // Determines whether native 3D effects or CTL3D should be used,
1231 // applying a default border style if required, and returning an extended
1232 // style to pass to CreateWindowEx.
1233 WXDWORD
wxWindowMSW::Determine3DEffects(WXDWORD defaultBorderStyle
,
1236 // If matches certain criteria, then assume no 3D effects
1237 // unless specifically requested (dealt with in MakeExtendedStyle)
1240 || !IsKindOf(CLASSINFO(wxControl
))
1241 #endif // wxUSE_CONTROLS
1242 || (m_windowStyle
& wxNO_BORDER
) )
1245 return MakeExtendedStyle(m_windowStyle
);
1248 // Determine whether we should be using 3D effects or not.
1249 bool nativeBorder
= FALSE
; // by default, we don't want a Win95 effect
1251 // 1) App can specify global 3D effects
1252 *want3D
= wxTheApp
->GetAuto3D();
1254 // 2) If the parent is being drawn with user colours, or simple border specified,
1255 // switch effects off. TODO: replace wxUSER_COLOURS with wxNO_3D
1256 if ( GetParent() && (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS
) || (m_windowStyle
& wxSIMPLE_BORDER
) )
1259 // 3) Control can override this global setting by defining
1260 // a border style, e.g. wxSUNKEN_BORDER
1261 if ( m_windowStyle
& wxSUNKEN_BORDER
)
1264 // 4) If it's a special border, CTL3D can't cope so we want a native border
1265 if ( (m_windowStyle
& wxDOUBLE_BORDER
) || (m_windowStyle
& wxRAISED_BORDER
) ||
1266 (m_windowStyle
& wxSTATIC_BORDER
) )
1269 nativeBorder
= TRUE
;
1272 // 5) If this isn't a Win95 app, and we are using CTL3D, remove border
1273 // effects from extended style
1276 nativeBorder
= FALSE
;
1279 DWORD exStyle
= MakeExtendedStyle(m_windowStyle
, !nativeBorder
);
1281 // If we want 3D, but haven't specified a border here,
1282 // apply the default border style specified.
1283 // TODO what about non-Win95 WIN32? Does it have borders?
1284 #if defined(__WIN95__) && !wxUSE_CTL3D
1285 if ( defaultBorderStyle
&& (*want3D
) && ! ((m_windowStyle
& wxDOUBLE_BORDER
) || (m_windowStyle
& wxRAISED_BORDER
) ||
1286 (m_windowStyle
& wxSTATIC_BORDER
) || (m_windowStyle
& wxSIMPLE_BORDER
) ))
1287 exStyle
|= defaultBorderStyle
; // WS_EX_CLIENTEDGE;
1293 #if WXWIN_COMPATIBILITY
1294 // If nothing defined for this, try the parent.
1295 // E.g. we may be a button loaded from a resource, with no callback function
1297 void wxWindowMSW::OnCommand(wxWindow
& win
, wxCommandEvent
& event
)
1299 if ( GetEventHandler()->ProcessEvent(event
) )
1302 m_parent
->GetEventHandler()->OnCommand(win
, event
);
1304 #endif // WXWIN_COMPATIBILITY_2
1306 #if WXWIN_COMPATIBILITY
1307 wxObject
* wxWindowMSW::GetChild(int number
) const
1309 // Return a pointer to the Nth object in the Panel
1310 wxNode
*node
= GetChildren().First();
1313 node
= node
->Next();
1316 wxObject
*obj
= (wxObject
*)node
->Data();
1322 #endif // WXWIN_COMPATIBILITY
1324 // Setup background and foreground colours correctly
1325 void wxWindowMSW::SetupColours()
1328 SetBackgroundColour(GetParent()->GetBackgroundColour());
1331 bool wxWindowMSW::IsMouseInWindow() const
1333 // get the mouse position
1335 ::GetCursorPos(&pt
);
1337 // find the window which currently has the cursor and go up the window
1338 // chain until we find this window - or exhaust it
1339 HWND hwnd
= ::WindowFromPoint(pt
);
1340 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1341 hwnd
= ::GetParent(hwnd
);
1343 return hwnd
!= NULL
;
1346 void wxWindowMSW::OnIdle(wxIdleEvent
& WXUNUSED(event
))
1348 // Check if we need to send a LEAVE event
1349 if ( m_mouseInWindow
)
1351 // note that we should generate the leave event whether the window has
1352 // or doesn't have mouse capture
1353 if ( !IsMouseInWindow() )
1355 // Generate a LEAVE event
1356 m_mouseInWindow
= FALSE
;
1358 // Unfortunately the mouse button and keyboard state may have
1359 // changed by the time the OnIdle function is called, so 'state'
1360 // may be meaningless.
1362 if ( wxIsShiftDown() )
1364 if ( wxIsCtrlDown() )
1365 state
|= MK_CONTROL
;
1366 if ( GetKeyState( VK_LBUTTON
) )
1367 state
|= MK_LBUTTON
;
1368 if ( GetKeyState( VK_MBUTTON
) )
1369 state
|= MK_MBUTTON
;
1370 if ( GetKeyState( VK_RBUTTON
) )
1371 state
|= MK_RBUTTON
;
1374 if ( !::GetCursorPos(&pt
) )
1376 wxLogLastError(_T("GetCursorPos"));
1379 // we need to have client coordinates here for symmetry with
1380 // wxEVT_ENTER_WINDOW
1381 RECT rect
= wxGetWindowRect(GetHwnd());
1385 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1386 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1388 (void)GetEventHandler()->ProcessEvent(event2
);
1395 // Set this window to be the child of 'parent'.
1396 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1398 if ( !wxWindowBase::Reparent(parent
) )
1401 HWND hWndChild
= GetHwnd();
1402 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1404 ::SetParent(hWndChild
, hWndParent
);
1409 void wxWindowMSW::Clear()
1411 wxClientDC
dc((wxWindow
*)this);
1412 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1413 dc
.SetBackground(brush
);
1417 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1419 #ifndef __WXMICROWIN__
1420 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1424 void wxWindowMSW::Freeze()
1426 SendSetRedraw(GetHwnd(), FALSE
);
1429 void wxWindowMSW::Thaw()
1431 SendSetRedraw(GetHwnd(), TRUE
);
1433 // we need to refresh everything or otherwise he invalidated area is not
1438 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1440 HWND hWnd
= GetHwnd();
1446 mswRect
.left
= rect
->x
;
1447 mswRect
.top
= rect
->y
;
1448 mswRect
.right
= rect
->x
+ rect
->width
;
1449 mswRect
.bottom
= rect
->y
+ rect
->height
;
1451 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1454 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1458 void wxWindowMSW::Update()
1461 ::UpdateWindow(GetHwnd());
1463 if ( !::UpdateWindow(GetHwnd()) )
1465 wxLogLastError(_T("UpdateWindow"));
1469 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1470 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1471 // handler needs to be really drawn right now
1476 // ---------------------------------------------------------------------------
1478 // ---------------------------------------------------------------------------
1480 #if wxUSE_DRAG_AND_DROP
1482 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1484 if ( m_dropTarget
!= 0 ) {
1485 m_dropTarget
->Revoke(m_hWnd
);
1486 delete m_dropTarget
;
1489 m_dropTarget
= pDropTarget
;
1490 if ( m_dropTarget
!= 0 )
1491 m_dropTarget
->Register(m_hWnd
);
1494 #endif // wxUSE_DRAG_AND_DROP
1496 // old style file-manager drag&drop support: we retain the old-style
1497 // DragAcceptFiles in parallel with SetDropTarget.
1498 void wxWindowMSW::DragAcceptFiles(bool accept
)
1500 HWND hWnd
= GetHwnd();
1502 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1505 // ----------------------------------------------------------------------------
1507 // ----------------------------------------------------------------------------
1511 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1513 wxWindowBase::DoSetToolTip(tooltip
);
1516 m_tooltip
->SetWindow(this);
1519 #endif // wxUSE_TOOLTIPS
1521 // ---------------------------------------------------------------------------
1522 // moving and resizing
1523 // ---------------------------------------------------------------------------
1526 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1528 RECT rect
= wxGetWindowRect(GetHwnd());
1531 *x
= rect
.right
- rect
.left
;
1533 *y
= rect
.bottom
- rect
.top
;
1536 // Get size *available for subwindows* i.e. excluding menu bar etc.
1537 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1539 RECT rect
= wxGetClientRect(GetHwnd());
1547 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1549 RECT rect
= wxGetWindowRect(GetHwnd());
1552 point
.x
= rect
.left
;
1555 // we do the adjustments with respect to the parent only for the "real"
1556 // children, not for the dialogs/frames
1557 if ( !IsTopLevel() )
1559 HWND hParentWnd
= 0;
1560 wxWindow
*parent
= GetParent();
1562 hParentWnd
= GetWinHwnd(parent
);
1564 // Since we now have the absolute screen coords, if there's a parent we
1565 // must subtract its top left corner
1568 ::ScreenToClient(hParentWnd
, &point
);
1573 // We may be faking the client origin. So a window that's really at (0,
1574 // 30) may appear (to wxWin apps) to be at (0, 0).
1575 wxPoint
pt(parent
->GetClientAreaOrigin());
1587 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1595 ::ScreenToClient(GetHwnd(), &pt
);
1603 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1611 ::ClientToScreen(GetHwnd(), &pt
);
1619 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1621 // TODO: is this consistent with other platforms?
1622 // Still, negative width or height shouldn't be allowed
1627 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1629 wxLogLastError(wxT("MoveWindow"));
1633 // set the size of the window: if the dimensions are positive, just use them,
1634 // but if any of them is equal to -1, it means that we must find the value for
1635 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1636 // which case -1 is a valid value for x and y)
1638 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1639 // the width/height to best suit our contents, otherwise we reuse the current
1641 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1643 // get the current size and position...
1644 int currentX
, currentY
;
1645 GetPosition(¤tX
, ¤tY
);
1646 int currentW
,currentH
;
1647 GetSize(¤tW
, ¤tH
);
1649 // ... and don't do anything (avoiding flicker) if it's already ok
1650 if ( x
== currentX
&& y
== currentY
&&
1651 width
== currentW
&& height
== currentH
)
1656 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1658 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1661 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1663 wxSize
size(-1, -1);
1666 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1668 size
= DoGetBestSize();
1673 // just take the current one
1680 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1684 size
= DoGetBestSize();
1686 //else: already called DoGetBestSize() above
1692 // just take the current one
1697 DoMoveWindow(x
, y
, width
, height
);
1700 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1702 // setting the client size is less obvious than it it could have been
1703 // because in the result of changing the total size the window scrollbar
1704 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1705 // will not be correct as the difference between the total and client size
1706 // changes - so we keep changing it until we get it right
1708 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1709 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1710 // may become 3 if the window had 0 size originally and so we didn't
1711 // calculate the scrollbar correction correctly during the first iteration)
1712 // but just to be on the safe side we check for it instead of making it an
1713 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1714 for ( int i
= 0; i
< 4; i
++ )
1717 ::GetClientRect(GetHwnd(), &rectClient
);
1719 // if the size is already ok, stop here (rectClient.left = top = 0)
1720 if ( (rectClient
.right
== width
|| width
== -1) &&
1721 (rectClient
.bottom
== height
|| height
== -1) )
1726 int widthClient
= width
,
1727 heightClient
= height
;
1729 // Find the difference between the entire window (title bar and all)
1730 // and the client area; add this to the new client size to move the
1733 ::GetWindowRect(GetHwnd(), &rectWin
);
1735 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1736 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1739 point
.x
= rectWin
.left
;
1740 point
.y
= rectWin
.top
;
1742 // MoveWindow positions the child windows relative to the parent, so
1743 // adjust if necessary
1744 if ( !IsTopLevel() )
1746 wxWindow
*parent
= GetParent();
1749 ::ScreenToClient(GetHwndOf(parent
), &point
);
1753 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1757 // For implementation purposes - sometimes decorations make the client area
1759 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1761 return wxPoint(0, 0);
1764 // ---------------------------------------------------------------------------
1766 // ---------------------------------------------------------------------------
1768 int wxWindowMSW::GetCharHeight() const
1770 return wxGetTextMetrics(this).tmHeight
;
1773 int wxWindowMSW::GetCharWidth() const
1775 // +1 is needed because Windows apparently adds it when calculating the
1776 // dialog units size in pixels
1777 #if wxDIALOG_UNIT_COMPATIBILITY
1778 return wxGetTextMetrics(this).tmAveCharWidth
;
1780 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1784 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1786 int *descent
, int *externalLeading
,
1787 const wxFont
*theFont
) const
1789 const wxFont
*fontToUse
= theFont
;
1791 fontToUse
= &m_font
;
1793 HWND hWnd
= GetHwnd();
1794 HDC dc
= ::GetDC(hWnd
);
1798 if ( fontToUse
&& fontToUse
->Ok() )
1800 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1802 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1807 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1808 GetTextMetrics(dc
, &tm
);
1810 if ( fontToUse
&& fnt
&& hfontOld
)
1811 SelectObject(dc
, hfontOld
);
1813 ReleaseDC(hWnd
, dc
);
1820 *descent
= tm
.tmDescent
;
1821 if ( externalLeading
)
1822 *externalLeading
= tm
.tmExternalLeading
;
1825 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1826 // ---------------------------------------------------------------------------
1827 // Caret manipulation
1828 // ---------------------------------------------------------------------------
1830 void wxWindowMSW::CreateCaret(int w
, int h
)
1832 SetCaret(new wxCaret(this, w
, h
));
1835 void wxWindowMSW::CreateCaret(const wxBitmap
*WXUNUSED(bitmap
))
1837 wxFAIL_MSG("not implemented");
1840 void wxWindowMSW::ShowCaret(bool show
)
1842 wxCHECK_RET( m_caret
, "no caret to show" );
1844 m_caret
->Show(show
);
1847 void wxWindowMSW::DestroyCaret()
1852 void wxWindowMSW::SetCaretPos(int x
, int y
)
1854 wxCHECK_RET( m_caret
, "no caret to move" );
1856 m_caret
->Move(x
, y
);
1859 void wxWindowMSW::GetCaretPos(int *x
, int *y
) const
1861 wxCHECK_RET( m_caret
, "no caret to get position of" );
1863 m_caret
->GetPosition(x
, y
);
1865 #endif // wxUSE_CARET
1867 // ---------------------------------------------------------------------------
1869 // ---------------------------------------------------------------------------
1871 #if wxUSE_MENUS_NATIVE
1873 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1874 // immediately, without waiting for the next event loop iteration
1876 // NB: this function should probably be made public later as it can almost
1877 // surely replace wxYield() elsewhere as well
1878 static void wxYieldForCommandsOnly()
1880 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1881 // want to process it here)
1883 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1884 && msg
.message
!= WM_QUIT
)
1886 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1890 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1892 menu
->SetInvokingWindow(this);
1895 HWND hWnd
= GetHwnd();
1896 HMENU hMenu
= GetHmenuOf(menu
);
1900 ::ClientToScreen(hWnd
, &point
);
1901 wxCurrentPopupMenu
= menu
;
1902 ::TrackPopupMenu(hMenu
, TPM_RIGHTBUTTON
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1904 // we need to do it righ now as otherwise the events are never going to be
1905 // sent to wxCurrentPopupMenu from HandleCommand()
1907 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1908 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1909 // destroyed as soon as we return (it can be a local variable in the caller
1910 // for example) and so we do need to process the event immediately
1911 wxYieldForCommandsOnly();
1913 wxCurrentPopupMenu
= NULL
;
1915 menu
->SetInvokingWindow(NULL
);
1920 #endif // wxUSE_MENUS_NATIVE
1922 // ===========================================================================
1923 // pre/post message processing
1924 // ===========================================================================
1926 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1929 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1931 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1934 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1936 // wxUniversal implements tab traversal itself
1937 #ifndef __WXUNIVERSAL__
1938 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1940 // intercept dialog navigation keys
1941 MSG
*msg
= (MSG
*)pMsg
;
1943 // here we try to do all the job which ::IsDialogMessage() usually does
1946 if ( msg
->message
== WM_KEYDOWN
)
1948 bool bCtrlDown
= wxIsCtrlDown();
1949 bool bShiftDown
= wxIsShiftDown();
1951 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1952 // don't process it if it's the case (except for Ctrl-Tab/Enter
1953 // combinations which are always processed)
1957 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1960 bool bForward
= TRUE
,
1961 bWindowChange
= FALSE
;
1963 // should we process this message specially?
1964 bool bProcess
= TRUE
;
1965 switch ( msg
->wParam
)
1968 // assume that nobody wants Shift-TAB for himself - if we
1969 // don't do it there is no easy way for a control to grab
1970 // TABs but still let Shift-TAB work as navugation key
1971 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1975 // Ctrl-Tab cycles thru notebook pages
1976 bWindowChange
= bCtrlDown
;
1977 bForward
= !bShiftDown
;
1983 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1991 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1997 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1999 // control wants to process Enter itself, don't
2000 // call IsDialogMessage() which would interpret
2004 else if ( lDlgCode
& DLGC_BUTTON
)
2006 // let IsDialogMessage() handle this for all
2007 // buttons except the owner-drawn ones which it
2008 // just seems to ignore
2009 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2010 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2012 // emulate the button click
2013 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2015 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2020 // FIXME: this should be handled by
2021 // wxNavigationKeyEvent handler and not here!!
2025 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
2027 if ( btn
&& btn
->IsEnabled() )
2029 // if we do have a default button, do press it
2030 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2034 else // no default button
2036 #endif // wxUSE_BUTTON
2037 // this is a quick and dirty test for a text
2039 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
2041 // don't process Enter, the control might
2042 // need it for itself and don't let
2043 // ::IsDialogMessage() have it as it can
2044 // eat the Enter events sometimes
2047 //else: treat Enter as TAB: pass to the next
2048 // control as this is the best thing to do
2049 // if the text doesn't handle Enter itself
2061 wxNavigationKeyEvent event
;
2062 event
.SetDirection(bForward
);
2063 event
.SetWindowChange(bWindowChange
);
2064 event
.SetEventObject(this);
2066 if ( GetEventHandler()->ProcessEvent(event
) )
2073 // let ::IsDialogMessage() do almost everything and handle just the
2074 // things it doesn't here: Ctrl-TAB for switching notebook pages
2075 if ( msg
->message
== WM_KEYDOWN
)
2077 // don't process system keys here
2078 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
2080 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
2082 // find the first notebook parent and change its page
2083 wxWindow
*win
= this;
2084 wxNotebook
*nbook
= NULL
;
2085 while ( win
&& !nbook
)
2087 nbook
= wxDynamicCast(win
, wxNotebook
);
2088 win
= win
->GetParent();
2093 bool forward
= !wxIsShiftDown();
2095 nbook
->AdvanceSelection(forward
);
2102 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
2103 // shouldn't let IsDialogMessage() get it as it _always_ eats the
2104 // message even when there is no cancel button and when the message is
2105 // needed by the control itself: in particular, it prevents the tree in
2106 // place edit control from being closed with Escape in a dialog
2107 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2109 // ::IsDialogMessage() can enter in an infinite loop when the
2110 // currently focused window is disabled or hidden and its parent
2111 // has WS_EX_CONTROLPARENT style, so don't call it in this case
2112 bool canSafelyCallIsDlgMsg
= TRUE
;
2114 HWND hwndFocus
= ::GetFocus();
2117 if ( !::IsWindowEnabled(hwndFocus
) ||
2118 !::IsWindowVisible(hwndFocus
) )
2120 // it would enter an infinite loop if we do this!
2121 canSafelyCallIsDlgMsg
= FALSE
;
2126 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2128 // it's a top level window, don't go further -- e.g. even
2129 // if the parent of a dialog is disabled, this doesn't
2130 // break navigation inside the dialog
2134 hwndFocus
= ::GetParent(hwndFocus
);
2137 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2139 // IsDialogMessage() did something...
2144 #endif // __WXUNIVERSAL__
2149 // relay mouse move events to the tooltip control
2150 MSG
*msg
= (MSG
*)pMsg
;
2151 if ( msg
->message
== WM_MOUSEMOVE
)
2152 m_tooltip
->RelayEvent(pMsg
);
2154 #endif // wxUSE_TOOLTIPS
2159 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2161 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2162 return m_acceleratorTable
.Translate(this, pMsg
);
2166 #endif // wxUSE_ACCEL
2169 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2171 // preprocess all messages by default
2175 // ---------------------------------------------------------------------------
2176 // message params unpackers (different for Win16 and Win32)
2177 // ---------------------------------------------------------------------------
2181 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2182 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2184 *id
= LOWORD(wParam
);
2185 *hwnd
= (WXHWND
)lParam
;
2186 *cmd
= HIWORD(wParam
);
2189 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2190 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2192 *state
= LOWORD(wParam
);
2193 *minimized
= HIWORD(wParam
);
2194 *hwnd
= (WXHWND
)lParam
;
2197 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2198 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2200 *code
= LOWORD(wParam
);
2201 *pos
= HIWORD(wParam
);
2202 *hwnd
= (WXHWND
)lParam
;
2205 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2206 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2208 #ifndef __WXMICROWIN__
2209 *nCtlColor
= CTLCOLOR_BTN
;
2210 *hwnd
= (WXHWND
)lParam
;
2211 *hdc
= (WXHDC
)wParam
;
2215 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2216 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2218 *item
= (WXWORD
)wParam
;
2219 *flags
= HIWORD(wParam
);
2220 *hmenu
= (WXHMENU
)lParam
;
2225 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2226 WXWORD
*id
, WXHWND
*hwnd
, WXWORD
*cmd
)
2228 *id
= (WXWORD
)wParam
;
2229 *hwnd
= (WXHWND
)LOWORD(lParam
);
2230 *cmd
= HIWORD(lParam
);
2233 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2234 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2236 *state
= (WXWORD
)wParam
;
2237 *minimized
= LOWORD(lParam
);
2238 *hwnd
= (WXHWND
)HIWORD(lParam
);
2241 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2242 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2244 *code
= (WXWORD
)wParam
;
2245 *pos
= LOWORD(lParam
);
2246 *hwnd
= (WXHWND
)HIWORD(lParam
);
2249 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2250 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2252 *hwnd
= (WXHWND
)LOWORD(lParam
);
2253 *nCtlColor
= (int)HIWORD(lParam
);
2254 *hdc
= (WXHDC
)wParam
;
2257 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2258 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2260 *item
= (WXWORD
)wParam
;
2261 *flags
= LOWORD(lParam
);
2262 *hmenu
= (WXHMENU
)HIWORD(lParam
);
2267 // ---------------------------------------------------------------------------
2268 // Main wxWindows window proc and the window proc for wxWindow
2269 // ---------------------------------------------------------------------------
2271 // Hook for new window just as it's being created, when the window isn't yet
2272 // associated with the handle
2273 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2275 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2276 // window being created and insures that it's always unset back later
2277 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2279 gs_winBeingCreated
= winBeingCreated
;
2282 wxWindowCreationHook::~wxWindowCreationHook()
2284 gs_winBeingCreated
= NULL
;
2288 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2290 // trace all messages - useful for the debugging
2292 wxLogTrace(wxTraceMessages
, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
2293 wxGetMessageName(message
), (long) wParam
, lParam
);
2294 #endif // __WXDEBUG__
2296 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2298 // when we get the first message for the HWND we just created, we associate
2299 // it with wxWindow stored in gs_winBeingCreated
2300 if ( !wnd
&& gs_winBeingCreated
)
2302 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2303 wnd
= gs_winBeingCreated
;
2304 gs_winBeingCreated
= NULL
;
2305 wnd
->SetHWND((WXHWND
)hWnd
);
2311 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2313 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2318 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2320 // did we process the message?
2321 bool processed
= FALSE
;
2332 // for most messages we should return 0 when we do process the message
2340 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2343 // return 0 to allow window creation
2344 rc
.result
= mayCreate
? 0 : -1;
2350 // never set processed to TRUE and *always* pass WM_DESTROY to
2351 // DefWindowProc() as Windows may do some internal cleanup when
2352 // processing it and failing to pass the message along may cause
2353 // memory and resource leaks!
2354 (void)HandleDestroy();
2358 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2366 // we're not interested in these messages at all
2369 case SIZE_MINIMIZED
:
2370 // we shouldn't send sizev events for these messages as the
2371 // client size may be negative which breaks existing code
2373 // OTOH we might send another (wxMinimizedEvent?) one or
2374 // add an additional parameter to wxSizeEvent if this is
2375 // useful to anybody
2379 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2380 // fall through nevertheless
2382 case SIZE_MAXIMIZED
:
2384 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2389 #ifndef __WXMICROWIN__
2390 case WM_ACTIVATEAPP
:
2391 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2397 WXWORD state
, minimized
;
2399 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2401 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2406 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2410 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2414 processed
= HandlePaint();
2418 #ifdef __WXUNIVERSAL__
2419 // Universal uses its own wxFrame/wxDialog, so we don't receive
2420 // close events unless we have this.
2425 // don't let the DefWindowProc() destroy our window - we'll do it
2426 // ourselves in ~wxWindow
2433 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2437 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2438 GET_Y_LPARAM(lParam
),
2442 #if wxUSE_MOUSEWHEEL
2444 processed
= HandleMouseWheel(wParam
, lParam
);
2448 case WM_LBUTTONDOWN
:
2450 case WM_LBUTTONDBLCLK
:
2451 case WM_RBUTTONDOWN
:
2453 case WM_RBUTTONDBLCLK
:
2454 case WM_MBUTTONDOWN
:
2456 case WM_MBUTTONDBLCLK
:
2458 #ifdef __WXMICROWIN__
2459 // MicroWindows seems to ignore the fact that a window is
2460 // disabled. So catch mouse events and throw them away if
2462 wxWindowMSW
* win
= this;
2465 if (!win
->IsEnabled())
2471 win
= win
->GetParent();
2472 if ( !win
|| win
->IsTopLevel() )
2479 #endif // __WXMICROWIN__
2480 // VZ: if you find a situation when this is needed, tell
2481 // me about it, do *not* uncomment this code as it
2482 // causes other strange problems
2484 if ( message
== WM_LBUTTONDOWN
&& AcceptsFocus() )
2488 int x
= GET_X_LPARAM(lParam
),
2489 y
= GET_Y_LPARAM(lParam
);
2491 // redirect the event to a static control if necessary by
2492 // finding one under mouse
2494 if ( GetCapture() == this )
2496 // but don't do it if the mouse is captured by this window
2497 // because then it should really get this event itself
2502 win
= FindWindowForMouseEvent(this, &x
, &y
);
2505 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2514 case MM_JOY1BUTTONDOWN
:
2515 case MM_JOY2BUTTONDOWN
:
2516 case MM_JOY1BUTTONUP
:
2517 case MM_JOY2BUTTONUP
:
2518 processed
= HandleJoystickEvent(message
,
2519 GET_X_LPARAM(lParam
),
2520 GET_Y_LPARAM(lParam
),
2523 #endif // __WXMICROWIN__
2526 processed
= HandleSysCommand(wParam
, lParam
);
2533 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2535 processed
= HandleCommand(id
, cmd
, hwnd
);
2541 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2545 // for these messages we must return TRUE if process the message
2548 case WM_MEASUREITEM
:
2550 int idCtrl
= (UINT
)wParam
;
2551 if ( message
== WM_DRAWITEM
)
2553 processed
= MSWOnDrawItem(idCtrl
,
2554 (WXDRAWITEMSTRUCT
*)lParam
);
2558 processed
= MSWOnMeasureItem(idCtrl
,
2559 (WXMEASUREITEMSTRUCT
*)lParam
);
2566 #endif // defined(WM_DRAWITEM)
2569 if ( !IsOfStandardClass() )
2571 // we always want to get the char events
2572 rc
.result
= DLGC_WANTCHARS
;
2574 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2576 // in fact, we want everything
2577 rc
.result
|= DLGC_WANTARROWS
|
2584 //else: get the dlg code from the DefWindowProc()
2589 // If this has been processed by an event handler, return 0 now
2590 // (we've handled it).
2591 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2592 if ( m_lastKeydownProcessed
)
2600 // we consider these message "not interesting" to OnChar, so
2601 // just don't do anything more with them
2611 // avoid duplicate messages to OnChar for these ASCII keys:
2612 // they will be translated by TranslateMessage() and received
2634 // but set processed to FALSE, not TRUE to still pass them
2635 // to the control's default window proc - otherwise
2636 // built-in keyboard handling won't work
2642 // special case of VK_APPS: treat it the same as right mouse
2643 // click because both usually pop up a context menu
2649 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2650 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2656 // do generate a CHAR event
2657 processed
= HandleChar((WORD
)wParam
, lParam
);
2665 // special case of VK_APPS: treat it the same as right mouse button
2666 if ( wParam
== VK_APPS
)
2671 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2672 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2677 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2682 case WM_CHAR
: // Always an ASCII character
2683 if ( m_lastKeydownProcessed
)
2685 // The key was handled in the EVT_KEY_DOWN and handling
2686 // a key in an EVT_KEY_DOWN handler is meant, by
2687 // design, to prevent EVT_CHARs from happening
2688 m_lastKeydownProcessed
= FALSE
;
2693 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2702 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2704 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2710 // CTLCOLOR messages are sent by children to query the parent for their
2711 // colors#ifndef __WXMICROWIN__
2712 #ifndef __WXMICROWIN__
2714 case WM_CTLCOLORMSGBOX
:
2715 case WM_CTLCOLOREDIT
:
2716 case WM_CTLCOLORLISTBOX
:
2717 case WM_CTLCOLORBTN
:
2718 case WM_CTLCOLORDLG
:
2719 case WM_CTLCOLORSCROLLBAR
:
2720 case WM_CTLCOLORSTATIC
:
2728 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2730 processed
= HandleCtlColor(&rc
.hBrush
,
2739 #endif // !__WXMICROWIN__
2741 case WM_SYSCOLORCHANGE
:
2742 // the return value for this message is ignored
2743 processed
= HandleSysColorChange();
2746 case WM_DISPLAYCHANGE
:
2747 processed
= HandleDisplayChange();
2750 case WM_PALETTECHANGED
:
2751 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2754 case WM_CAPTURECHANGED
:
2755 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2758 case WM_QUERYNEWPALETTE
:
2759 processed
= HandleQueryNewPalette();
2763 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2766 // we processed the message, i.e. erased the background
2772 processed
= HandleDropFiles(wParam
);
2776 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2780 // we never set focus from here
2785 case WM_QUERYENDSESSION
:
2786 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2790 processed
= HandleEndSession(wParam
!= 0, lParam
);
2793 case WM_GETMINMAXINFO
:
2794 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2798 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2799 LOWORD(lParam
), // hit test
2800 HIWORD(lParam
)); // mouse msg
2804 // returning TRUE stops the DefWindowProc() from further
2805 // processing this message - exactly what we need because we've
2806 // just set the cursor.
2811 #if defined(__WIN32__) && defined(WM_HELP)
2814 HELPINFO
* info
= (HELPINFO
*) lParam
;
2815 // Don't yet process menu help events, just windows
2816 if (info
->iContextType
== HELPINFO_WINDOW
)
2818 wxWindowMSW
* subjectOfHelp
= this;
2819 bool eventProcessed
= FALSE
;
2820 while (subjectOfHelp
&& !eventProcessed
)
2822 wxHelpEvent
helpEvent(wxEVT_HELP
,
2823 subjectOfHelp
->GetId(),
2824 wxPoint(info
->MousePos
.x
,
2825 info
->MousePos
.y
) );
2826 helpEvent
.SetEventObject(this);
2828 GetEventHandler()->ProcessEvent(helpEvent
);
2830 // Go up the window hierarchy until the event is
2832 subjectOfHelp
= subjectOfHelp
->GetParent();
2835 processed
= eventProcessed
;
2837 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2839 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2840 helpEvent
.SetEventObject(this);
2841 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2844 //else: processed is already FALSE
2848 case WM_CONTEXTMENU
:
2850 // we don't convert from screen to client coordinates as
2851 // the event may be handled by a parent window
2852 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2854 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2855 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2864 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2865 wxGetMessageName(message
));
2866 #endif // __WXDEBUG__
2867 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2873 // ----------------------------------------------------------------------------
2874 // wxWindow <-> HWND map
2875 // ----------------------------------------------------------------------------
2877 wxWinHashTable
*wxWinHandleHash
= NULL
;
2879 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2881 return wxWinHandleHash
->Get((long)hWnd
);
2884 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2886 // adding NULL hWnd is (first) surely a result of an error and
2887 // (secondly) breaks menu command processing
2888 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2889 wxT("attempt to add a NULL hWnd to window list ignored") );
2891 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2893 if ( oldWin
&& (oldWin
!= win
) )
2895 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2896 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2899 #endif // __WXDEBUG__
2902 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2906 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2908 wxWinHandleHash
->Delete((long)win
->GetHWND());
2911 // ----------------------------------------------------------------------------
2912 // various MSW speciic class dependent functions
2913 // ----------------------------------------------------------------------------
2915 // Default destroyer - override if you destroy it in some other way
2916 // (e.g. with MDI child windows)
2917 void wxWindowMSW::MSWDestroyWindow()
2921 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2924 int& w
, int& h
) const
2926 static const int DEFAULT_Y
= 200;
2927 static const int DEFAULT_H
= 250;
2929 bool nonDefault
= FALSE
;
2933 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2934 // just as well set it to CW_USEDEFAULT as well
2940 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2941 // neither because it is not handled as a special value by Windows then
2942 // and so we have to choose some default value for it
2944 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2950 NB: there used to be some code here which set the initial size of the
2951 window to the client size of the parent if no explicit size was
2952 specified. This was wrong because wxWindows programs often assume
2953 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2954 it. To see why, you should understand that Windows sends WM_SIZE from
2955 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2956 from some base class ctor and so this WM_SIZE is not processed in the
2957 real class' OnSize() (because it's not fully constructed yet and the
2958 event goes to some base class OnSize() instead). So the WM_SIZE we
2959 rely on is the one sent when the parent frame resizes its children
2960 but here is the problem: if the child already has just the right
2961 size, nothing will happen as both wxWindows and Windows check for
2962 this and ignore any attempts to change the window size to the size it
2963 already has - so no WM_SIZE would be sent.
2967 // as above, h is not used at all in this case anyhow
2973 // and, again as above, we can't set the height to CW_USEDEFAULT here
2975 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2983 WXHWND
wxWindowMSW::MSWGetParent() const
2985 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
2988 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
2989 const wxChar
*title
,
2993 WXDWORD extendedStyle
)
2995 // choose the position/size for the new window
2997 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
2999 // controlId is menu handle for the top level windows, so set it to 0
3000 // unless we're creating a child window
3001 int controlId
= style
& WS_CHILD
? GetId() : 0;
3003 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3004 // which is the same but without CS_[HV]REDRAW class styles so using it
3005 // ensures that the window is not fully repainted on each resize
3006 wxString
className(wclass
);
3007 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
3009 className
+= wxT("NR");
3012 // do create the window
3013 wxWindowCreationHook
hook(this);
3015 m_hWnd
= (WXHWND
)::CreateWindowEx
3019 title
? title
: wxT(""),
3022 (HWND
)MSWGetParent(),
3025 NULL
// no extra data
3030 wxLogSysError(_("Can't create window of class %s"), wclass
);
3035 SubclassWin(m_hWnd
);
3037 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
3042 // ===========================================================================
3043 // MSW message handlers
3044 // ===========================================================================
3046 // ---------------------------------------------------------------------------
3048 // ---------------------------------------------------------------------------
3052 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3054 #ifndef __WXMICROWIN__
3055 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3056 HWND hWnd
= hdr
->hwndFrom
;
3057 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3059 // if the control is one of our windows, let it handle the message itself
3062 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3065 // VZ: why did we do it? normally this is unnecessary and, besides, it
3066 // breaks the message processing for the toolbars because the tooltip
3067 // notifications were being forwarded to the toolbar child controls
3068 // (if it had any) before being passed to the toolbar itself, so in my
3069 // example the tooltip for the combobox was always shown instead of the
3070 // correct button tooltips
3072 // try all our children
3073 wxWindowList::Node
*node
= GetChildren().GetFirst();
3076 wxWindow
*child
= node
->GetData();
3077 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3082 node
= node
->GetNext();
3086 // by default, handle it ourselves
3087 return MSWOnNotify(idCtrl
, lParam
, result
);
3088 #else // __WXMICROWIN__
3095 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3097 const wxString
& ttip
)
3099 // I don't know why it happens, but the versions of comctl32.dll starting
3100 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3101 // this message is supposed to be sent to Unicode programs only) -- hence
3102 // we need to handle it as well, otherwise no tooltips will be shown in
3105 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
3107 // not a tooltip message or no tooltip to show anyhow
3111 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3113 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
3115 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3120 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3122 size_t lenAnsi
= ttip
.length();
3124 // some compilers (MetroWerks and Cygwin) don't like calling mbstowcs
3125 // with NULL argument
3126 #if defined( __MWERKS__ ) || defined( __CYGWIN__ )
3127 size_t lenUnicode
= 2*lenAnsi
;
3129 size_t lenUnicode
= mbstowcs(NULL
, ttip
, lenAnsi
);
3132 // using the pointer of right type avoids us doing all sorts of
3133 // pointer arithmetics ourselves
3134 wchar_t *dst
= (wchar_t *)ttText
->szText
,
3135 *pwz
= new wchar_t[lenUnicode
+ 1];
3136 mbstowcs(pwz
, ttip
, lenAnsi
+ 1);
3137 memcpy(dst
, pwz
, lenUnicode
*sizeof(wchar_t));
3139 // put the terminating wide NUL
3140 dst
[lenUnicode
] = L
'\0';
3143 #endif // Unicode/!Unicode
3149 #endif // wxUSE_TOOLTIPS
3151 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3153 WXLPARAM
* WXUNUSED(result
))
3158 NMHDR
* hdr
= (NMHDR
*)lParam
;
3159 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3165 #endif // wxUSE_TOOLTIPS
3172 // ---------------------------------------------------------------------------
3173 // end session messages
3174 // ---------------------------------------------------------------------------
3176 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3178 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3179 event
.SetEventObject(wxTheApp
);
3180 event
.SetCanVeto(TRUE
);
3181 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3183 bool rc
= wxTheApp
->ProcessEvent(event
);
3187 // we may end only if the app didn't veto session closing (double
3189 *mayEnd
= !event
.GetVeto();
3195 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3197 // do nothing if the session isn't ending
3202 if ( (this != wxTheApp
->GetTopWindow()) )
3205 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3206 event
.SetEventObject(wxTheApp
);
3207 event
.SetCanVeto(FALSE
);
3208 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3210 return wxTheApp
->ProcessEvent(event
);
3213 // ---------------------------------------------------------------------------
3214 // window creation/destruction
3215 // ---------------------------------------------------------------------------
3217 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3219 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3220 // parent as well as otherwise several Win32 functions using
3221 // GetNextDlgTabItem() to iterate over all controls such as
3222 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3223 // all of them iterate over all the controls starting from the focus and
3224 // stop iterating when they get back to the focus but unless all parents
3225 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3226 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3228 // there is no need to do anything for the top level windows
3229 const wxWindow
*parent
= GetParent();
3230 while ( parent
&& !parent
->IsTopLevel() )
3232 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
3233 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
3235 // force the parent to have this style
3236 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
3237 exStyle
| WS_EX_CONTROLPARENT
);
3240 parent
= parent
->GetParent();
3244 // TODO: should generate this event from WM_NCCREATE
3245 wxWindowCreateEvent
event((wxWindow
*)this);
3246 (void)GetEventHandler()->ProcessEvent(event
);
3253 bool wxWindowMSW::HandleDestroy()
3255 wxWindowDestroyEvent
event((wxWindow
*)this);
3256 (void)GetEventHandler()->ProcessEvent(event
);
3258 // delete our drop target if we've got one
3259 #if wxUSE_DRAG_AND_DROP
3260 if ( m_dropTarget
!= NULL
)
3262 m_dropTarget
->Revoke(m_hWnd
);
3264 delete m_dropTarget
;
3265 m_dropTarget
= NULL
;
3267 #endif // wxUSE_DRAG_AND_DROP
3269 // WM_DESTROY handled
3273 // ---------------------------------------------------------------------------
3275 // ---------------------------------------------------------------------------
3277 bool wxWindowMSW::HandleActivate(int state
,
3278 bool WXUNUSED(minimized
),
3279 WXHWND
WXUNUSED(activate
))
3281 wxActivateEvent
event(wxEVT_ACTIVATE
,
3282 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3284 event
.SetEventObject(this);
3286 return GetEventHandler()->ProcessEvent(event
);
3289 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3291 // notify the parent keeping track of focus for the kbd navigation
3292 // purposes that we got it
3293 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3294 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3300 m_caret
->OnSetFocus();
3302 #endif // wxUSE_CARET
3305 // If it's a wxTextCtrl don't send the event as it will be done
3306 // after the control gets to process it from EN_FOCUS handler
3307 if ( wxDynamicCastThis(wxTextCtrl
) )
3311 #endif // wxUSE_TEXTCTRL
3313 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3314 event
.SetEventObject(this);
3316 // wxFindWinFromHandle() may return NULL, it is ok
3317 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3319 return GetEventHandler()->ProcessEvent(event
);
3322 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3328 m_caret
->OnKillFocus();
3330 #endif // wxUSE_CARET
3333 // If it's a wxTextCtrl don't send the event as it will be done
3334 // after the control gets to process it.
3335 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3342 // Don't send the event when in the process of being deleted. This can
3343 // only cause problems if the event handler tries to access the object.
3344 if ( m_isBeingDeleted
)
3349 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3350 event
.SetEventObject(this);
3352 // wxFindWinFromHandle() may return NULL, it is ok
3353 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3355 return GetEventHandler()->ProcessEvent(event
);
3358 // ---------------------------------------------------------------------------
3360 // ---------------------------------------------------------------------------
3362 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3364 wxShowEvent
event(GetId(), show
);
3365 event
.m_eventObject
= this;
3367 return GetEventHandler()->ProcessEvent(event
);
3370 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3372 wxInitDialogEvent
event(GetId());
3373 event
.m_eventObject
= this;
3375 return GetEventHandler()->ProcessEvent(event
);
3378 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3380 #ifndef __WXMICROWIN__
3381 HDROP hFilesInfo
= (HDROP
) wParam
;
3383 // Get the total number of files dropped
3384 UINT gwFilesDropped
= ::DragQueryFile
3392 wxString
*files
= new wxString
[gwFilesDropped
];
3393 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3395 // first get the needed buffer length (+1 for terminating NUL)
3396 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3398 // and now get the file name
3399 ::DragQueryFile(hFilesInfo
, wIndex
,
3400 files
[wIndex
].GetWriteBuf(len
), len
);
3402 files
[wIndex
].UngetWriteBuf();
3404 DragFinish (hFilesInfo
);
3406 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3407 event
.m_eventObject
= this;
3410 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3411 event
.m_pos
.x
= dropPoint
.x
;
3412 event
.m_pos
.y
= dropPoint
.y
;
3414 return GetEventHandler()->ProcessEvent(event
);
3415 #else // __WXMICROWIN__
3420 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3422 int WXUNUSED(mouseMsg
))
3424 #ifndef __WXMICROWIN__
3425 // the logic is as follows:
3426 // -1. don't set cursor for non client area, including but not limited to
3427 // the title bar, scrollbars, &c
3428 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3429 // 1. if we have the cursor set it unless wxIsBusy()
3430 // 2. if we're a top level window, set some cursor anyhow
3431 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3433 if ( nHitTest
!= HTCLIENT
)
3438 HCURSOR hcursor
= 0;
3440 // first ask the user code - it may wish to set the cursor in some very
3441 // specific way (for example, depending on the current position)
3444 if ( !::GetCursorPos(&pt
) )
3446 wxLogLastError(wxT("GetCursorPos"));
3449 // In WIN16 it doesn't return a value.
3450 ::GetCursorPos(&pt
);
3455 ScreenToClient(&x
, &y
);
3456 wxSetCursorEvent
event(x
, y
);
3458 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3459 if ( processedEvtSetCursor
&& event
.HasCursor() )
3461 hcursor
= GetHcursorOf(event
.GetCursor());
3466 bool isBusy
= wxIsBusy();
3468 // the test for processedEvtSetCursor is here to prevent using m_cursor
3469 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3470 // it - this is a way to say that our cursor shouldn't be used for this
3472 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3474 hcursor
= GetHcursorOf(m_cursor
);
3481 hcursor
= wxGetCurrentBusyCursor();
3483 else if ( !hcursor
)
3485 const wxCursor
*cursor
= wxGetGlobalCursor();
3486 if ( cursor
&& cursor
->Ok() )
3488 hcursor
= GetHcursorOf(*cursor
);
3496 ::SetCursor(hcursor
);
3498 // cursor set, stop here
3501 #endif // __WXMICROWIN__
3503 // pass up the window chain
3507 // ---------------------------------------------------------------------------
3508 // owner drawn stuff
3509 // ---------------------------------------------------------------------------
3511 bool wxWindowMSW::MSWOnDrawItem(int id
, WXDRAWITEMSTRUCT
*itemStruct
)
3513 #if wxUSE_OWNER_DRAWN
3515 #if wxUSE_MENUS_NATIVE
3516 // is it a menu item?
3517 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3518 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3520 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3522 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3524 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3525 // the DC from being released
3526 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3527 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3528 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3529 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3531 return pMenuItem
->OnDrawItem
3535 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3536 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3539 #endif // wxUSE_MENUS_NATIVE
3542 wxWindow
*item
= FindItem(id
);
3543 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3545 return ((wxControl
*)item
)->MSWOnDraw(itemStruct
);
3547 #endif // wxUSE_CONTROLS
3549 #endif // USE_OWNER_DRAWN
3554 bool wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3556 #if wxUSE_OWNER_DRAWN
3557 // is it a menu item?
3558 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3559 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3561 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3563 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3565 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3566 &pMeasureStruct
->itemHeight
);
3569 wxWindow
*item
= FindItem(id
);
3570 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3572 return ((wxControl
*)item
)->MSWOnMeasure(itemStruct
);
3574 #endif // owner-drawn menus
3578 // ---------------------------------------------------------------------------
3579 // colours and palettes
3580 // ---------------------------------------------------------------------------
3582 bool wxWindowMSW::HandleSysColorChange()
3584 wxSysColourChangedEvent event
;
3585 event
.SetEventObject(this);
3587 (void)GetEventHandler()->ProcessEvent(event
);
3589 // always let the system carry on the default processing to allow the
3590 // native controls to react to the colours update
3594 bool wxWindowMSW::HandleDisplayChange()
3596 wxDisplayChangedEvent event
;
3597 event
.SetEventObject(this);
3599 return GetEventHandler()->ProcessEvent(event
);
3602 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3610 #ifndef __WXMICROWIN__
3611 WXHBRUSH hBrush
= 0;
3613 if ( nCtlColor
== CTLCOLOR_DLG
)
3615 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3620 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3622 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3624 #endif // wxUSE_CONTROLS
3630 #else // __WXMICROWIN__
3635 // Define for each class of dialog and control
3636 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3637 WXHWND
WXUNUSED(hWnd
),
3638 WXUINT
WXUNUSED(nCtlColor
),
3639 WXUINT
WXUNUSED(message
),
3640 WXWPARAM
WXUNUSED(wParam
),
3641 WXLPARAM
WXUNUSED(lParam
))
3646 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3649 // same as below except we don't respond to our own messages
3650 if ( hWndPalChange
!= GetHWND() )
3652 // check to see if we our our parents have a custom palette
3653 wxWindowMSW
*win
= this;
3654 while ( win
&& !win
->HasCustomPalette() )
3656 win
= win
->GetParent();
3659 if ( win
&& win
->HasCustomPalette() )
3661 // realize the palette to see whether redrawing is needed
3662 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3663 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3664 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3666 int result
= ::RealizePalette(hdc
);
3668 // restore the palette (before releasing the DC)
3669 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3670 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3671 ::RealizePalette(hdc
);
3672 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3674 // now check for the need to redraw
3676 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3680 #endif // wxUSE_PALETTE
3682 wxPaletteChangedEvent
event(GetId());
3683 event
.SetEventObject(this);
3684 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3686 return GetEventHandler()->ProcessEvent(event
);
3689 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3691 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3692 event
.SetEventObject(this);
3694 return GetEventHandler()->ProcessEvent(event
);
3697 bool wxWindowMSW::HandleQueryNewPalette()
3701 // check to see if we our our parents have a custom palette
3702 wxWindowMSW
*win
= this;
3703 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3704 if (win
->HasCustomPalette()) {
3705 /* realize the palette to see whether redrawing is needed */
3706 HDC hdc
= GetDC((HWND
) GetHWND());
3707 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3708 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3710 int result
= ::RealizePalette(hdc
);
3711 /* restore the palette (before releasing the DC) */
3712 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3713 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3714 ::RealizePalette(hdc
);
3715 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3716 /* now check for the need to redraw */
3718 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3720 #endif // wxUSE_PALETTE
3722 wxQueryNewPaletteEvent
event(GetId());
3723 event
.SetEventObject(this);
3725 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3728 // Responds to colour changes: passes event on to children.
3729 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3731 // the top level window also reset the standard colour map as it might have
3732 // changed (there is no need to do it for the non top level windows as we
3733 // only have to do it once)
3737 gs_hasStdCmap
= FALSE
;
3739 wxWindowList::Node
*node
= GetChildren().GetFirst();
3742 // Only propagate to non-top-level windows because Windows already
3743 // sends this event to all top-level ones
3744 wxWindow
*win
= node
->GetData();
3745 if ( !win
->IsTopLevel() )
3747 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3748 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3749 // the standard controls
3750 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3753 node
= node
->GetNext();
3756 // update the colours we use if they were not set explicitly by the user:
3757 // this must be done or OnCtlColor() would continue to use the old colours
3760 m_foregroundColour
= wxSystemSettings::
3761 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3766 m_backgroundColour
= wxSystemSettings::
3767 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3771 extern wxCOLORMAP
*wxGetStdColourMap()
3773 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3774 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3776 if ( !gs_hasStdCmap
)
3778 static bool s_coloursInit
= FALSE
;
3780 if ( !s_coloursInit
)
3782 // When a bitmap is loaded, the RGB values can change (apparently
3783 // because Windows adjusts them to care for the old programs always
3784 // using 0xc0c0c0 while the transparent colour for the new Windows
3785 // versions is different). But we do this adjustment ourselves so
3786 // we want to avoid Windows' "help" and for this we need to have a
3787 // reference bitmap which can tell us what the RGB values change
3789 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3790 if ( stdColourBitmap
.Ok() )
3792 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3793 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3794 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3797 memDC
.SelectObject(stdColourBitmap
);
3800 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3802 memDC
.GetPixel(i
, 0, &colour
);
3803 s_stdColours
[i
] = wxColourToRGB(colour
);
3806 else // wxBITMAP_STD_COLOURS couldn't be loaded
3808 s_stdColours
[0] = RGB(000,000,000); // black
3809 s_stdColours
[1] = RGB(128,128,128); // dark grey
3810 s_stdColours
[2] = RGB(192,192,192); // light grey
3811 s_stdColours
[3] = RGB(255,255,255); // white
3812 //s_stdColours[4] = RGB(000,000,255); // blue
3813 //s_stdColours[5] = RGB(255,000,255); // magenta
3816 s_coloursInit
= TRUE
;
3819 gs_hasStdCmap
= TRUE
;
3821 // create the colour map
3822 #define INIT_CMAP_ENTRY(col) \
3823 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3824 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3826 INIT_CMAP_ENTRY(BTNTEXT
);
3827 INIT_CMAP_ENTRY(BTNSHADOW
);
3828 INIT_CMAP_ENTRY(BTNFACE
);
3829 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3831 #undef INIT_CMAP_ENTRY
3837 // ---------------------------------------------------------------------------
3839 // ---------------------------------------------------------------------------
3841 bool wxWindowMSW::HandlePaint()
3844 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3846 wxLogLastError(wxT("CreateRectRgn"));
3847 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3848 wxLogLastError(wxT("GetUpdateRgn"));
3850 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3853 ::GetUpdateRect(GetHwnd(), &updateRect
, FALSE
);
3855 m_updateRegion
= wxRegion(updateRect
.left
, updateRect
.top
,
3856 updateRect
.right
- updateRect
.left
,
3857 updateRect
.bottom
- updateRect
.top
);
3860 wxPaintEvent
event(m_windowId
);
3861 event
.SetEventObject(this);
3863 bool processed
= GetEventHandler()->ProcessEvent(event
);
3865 // note that we must generate NC event after the normal one as otherwise
3866 // BeginPaint() will happily overwrite our decorations with the background
3868 wxNcPaintEvent
eventNc(m_windowId
);
3869 eventNc
.SetEventObject(this);
3870 GetEventHandler()->ProcessEvent(eventNc
);
3875 // Can be called from an application's OnPaint handler
3876 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3878 #ifdef __WXUNIVERSAL__
3881 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3884 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3889 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3891 // Prevents flicker when dragging
3892 if ( ::IsIconic(GetHwnd()) )
3898 dc
.SetWindow((wxWindow
*)this);
3901 wxEraseEvent
event(m_windowId
, &dc
);
3902 event
.SetEventObject(this);
3903 bool rc
= GetEventHandler()->ProcessEvent(event
);
3907 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3908 dc
.SelectOldObjects(hdc
);
3913 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3916 ::GetClientRect(GetHwnd(), &rect
);
3918 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3919 m_backgroundColour
.Green(),
3920 m_backgroundColour
.Blue());
3921 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3923 wxLogLastError(wxT("CreateSolidBrush"));
3925 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
3927 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
3929 ::FillRect(hdc
, &rect
, hBrush
);
3930 ::DeleteObject(hBrush
);
3931 ::SetMapMode(hdc
, mode
);
3934 // ---------------------------------------------------------------------------
3935 // moving and resizing
3936 // ---------------------------------------------------------------------------
3938 bool wxWindowMSW::HandleMinimize()
3940 wxIconizeEvent
event(m_windowId
);
3941 event
.SetEventObject(this);
3943 return GetEventHandler()->ProcessEvent(event
);
3946 bool wxWindowMSW::HandleMaximize()
3948 wxMaximizeEvent
event(m_windowId
);
3949 event
.SetEventObject(this);
3951 return GetEventHandler()->ProcessEvent(event
);
3954 bool wxWindowMSW::HandleMove(int x
, int y
)
3956 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
3957 event
.SetEventObject(this);
3959 return GetEventHandler()->ProcessEvent(event
);
3962 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
3963 WXUINT
WXUNUSED(flag
))
3965 // don't use w and h parameters as they specify the client size while
3966 // according to the docs EVT_SIZE handler is supposed to receive the total
3968 wxSizeEvent
event(GetSize(), m_windowId
);
3969 event
.SetEventObject(this);
3971 return GetEventHandler()->ProcessEvent(event
);
3974 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
3976 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
3980 int minWidth
= GetMinWidth(),
3981 minHeight
= GetMinHeight(),
3982 maxWidth
= GetMaxWidth(),
3983 maxHeight
= GetMaxHeight();
3985 if ( minWidth
!= -1 )
3987 info
->ptMinTrackSize
.x
= minWidth
;
3991 if ( minHeight
!= -1 )
3993 info
->ptMinTrackSize
.y
= minHeight
;
3997 if ( maxWidth
!= -1 )
3999 info
->ptMaxTrackSize
.x
= maxWidth
;
4003 if ( maxHeight
!= -1 )
4005 info
->ptMaxTrackSize
.y
= maxHeight
;
4012 // ---------------------------------------------------------------------------
4014 // ---------------------------------------------------------------------------
4016 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4018 #if wxUSE_MENUS_NATIVE
4019 if ( !cmd
&& wxCurrentPopupMenu
)
4021 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4022 wxCurrentPopupMenu
= NULL
;
4024 return popupMenu
->MSWCommand(cmd
, id
);
4026 #endif // wxUSE_MENUS_NATIVE
4028 wxWindow
*win
= NULL
;
4030 // first try to find it from HWND - this works even with the broken
4031 // programs using the same ids for different controls
4034 win
= wxFindWinFromHandle(control
);
4040 // must cast to a signed type before comparing with other ids!
4041 win
= FindItem((signed short)id
);
4046 return win
->MSWCommand(cmd
, id
);
4049 // the messages sent from the in-place edit control used by the treectrl
4050 // for label editing have id == 0, but they should _not_ be treated as menu
4051 // messages (they are EN_XXX ones, in fact) so don't translate anything
4052 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4055 // If no child window, it may be an accelerator, e.g. for a popup menu
4058 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4059 event
.SetEventObject(this);
4063 return GetEventHandler()->ProcessEvent(event
);
4065 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4068 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4069 // notifications to its parent which we want to reflect back to
4071 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4072 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4075 #endif // wxUSE_SPINCTRL
4080 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4082 // 4 bits are reserved
4083 switch ( wParam
& 0xFFFFFFF0 )
4086 return HandleMaximize();
4089 return HandleMinimize();
4095 // ---------------------------------------------------------------------------
4097 // ---------------------------------------------------------------------------
4099 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4103 // our client coords are not quite the same as Windows ones
4104 wxPoint pt
= GetClientAreaOrigin();
4105 event
.m_x
= x
- pt
.x
;
4106 event
.m_y
= y
- pt
.y
;
4108 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4109 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4110 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4111 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4112 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4113 event
.m_altDown
= (::GetKeyState(VK_MENU
) & 0x80000000) != 0;
4115 event
.SetTimestamp(s_currentMsg
.time
);
4116 event
.m_eventObject
= this;
4117 event
.SetId(GetId());
4119 #if wxUSE_MOUSEEVENT_HACK
4122 m_lastMouseEvent
= event
.GetEventType();
4123 #endif // wxUSE_MOUSEEVENT_HACK
4126 // Windows doesn't send the mouse events to the static controls (which are
4127 // transparent in the sense that their WM_NCHITTEST handler returns
4128 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4129 // and so we manually check if we don't have a child window under mouse and if
4130 // we do, send the event to it instead of the window Windows had sent WM_XXX
4133 // Notice that this is not done for the mouse move events because this could
4134 // (would?) be too slow, but only for clicks which means that the static texts
4135 // still don't get move, enter nor leave events.
4136 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4138 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4140 // first try to find a non transparent child: this allows us to send events
4141 // to a static text which is inside a static box, for example
4142 POINT pt
= { *x
, *y
};
4143 HWND hwnd
= GetHwndOf(win
),
4147 hwndUnderMouse
= ::ChildWindowFromPointEx
4156 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4159 // now try any child window at all
4160 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4163 // check that we have a child window which is susceptible to receive mouse
4164 // events: for this it must be shown and enabled
4165 if ( hwndUnderMouse
&&
4166 hwndUnderMouse
!= hwnd
&&
4167 ::IsWindowVisible(hwndUnderMouse
) &&
4168 ::IsWindowEnabled(hwndUnderMouse
) )
4170 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4171 if ( winUnderMouse
)
4173 // translate the mouse coords to the other window coords
4174 win
->ClientToScreen(x
, y
);
4175 winUnderMouse
->ScreenToClient(x
, y
);
4177 win
= winUnderMouse
;
4184 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4186 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4187 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4188 // from the message id and take the value in the table to get wxWin event
4190 static const wxEventType eventsMouse
[] =
4204 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4205 InitMouseEvent(event
, x
, y
, flags
);
4207 return GetEventHandler()->ProcessEvent(event
);
4210 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4212 if ( !m_mouseInWindow
)
4214 // it would be wrong to assume that just because we get a mouse move
4215 // event that the mouse is inside the window: although this is usually
4216 // true, it is not if we had captured the mouse, so we need to check
4217 // the mouse coordinates here
4218 if ( !HasCapture() || IsMouseInWindow() )
4220 // Generate an ENTER event
4221 m_mouseInWindow
= TRUE
;
4223 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4224 InitMouseEvent(event
, x
, y
, flags
);
4226 (void)GetEventHandler()->ProcessEvent(event
);
4230 #if wxUSE_MOUSEEVENT_HACK
4231 // Window gets a click down message followed by a mouse move message even
4232 // if position isn't changed! We want to discard the trailing move event
4233 // if x and y are the same.
4234 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4235 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4236 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4237 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4239 m_lastMouseEvent
= wxEVT_MOTION
;
4243 #endif // wxUSE_MOUSEEVENT_HACK
4245 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4249 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4251 #if wxUSE_MOUSEWHEEL
4252 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4253 InitMouseEvent(event
,
4254 GET_X_LPARAM(lParam
),
4255 GET_Y_LPARAM(lParam
),
4257 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4258 event
.m_wheelDelta
= WHEEL_DELTA
;
4261 static int s_linesPerRotation
= -1;
4262 if ( s_linesPerRotation
== -1 )
4264 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4265 &s_linesPerRotation
, 0))
4267 // this is not supposed to happen
4268 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4270 // the default is 3, so use it if SystemParametersInfo() failed
4271 s_linesPerRotation
= 3;
4275 // no SystemParametersInfo() under Win16
4276 static const int s_linesPerRotation
= 3;
4279 event
.m_linesPerAction
= s_linesPerRotation
;
4280 return GetEventHandler()->ProcessEvent(event
);
4291 // ---------------------------------------------------------------------------
4292 // keyboard handling
4293 // ---------------------------------------------------------------------------
4295 // create the key event of the given type for the given key - used by
4296 // HandleChar and HandleKeyDown/Up
4297 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4300 WXWPARAM wParam
) const
4302 wxKeyEvent
event(evType
);
4303 event
.SetId(GetId());
4304 event
.m_shiftDown
= wxIsShiftDown();
4305 event
.m_controlDown
= wxIsCtrlDown();
4306 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4308 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4309 event
.m_keyCode
= id
;
4310 event
.m_rawCode
= (wxUint32
) wParam
;
4311 event
.m_rawFlags
= (wxUint32
) lParam
;
4312 event
.SetTimestamp(s_currentMsg
.time
);
4314 // translate the position to client coords
4318 GetWindowRect(GetHwnd(),&rect
);
4328 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4330 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4332 bool ctrlDown
= FALSE
;
4337 // If 1 -> 26, translate to either special keycode or just set
4338 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4339 // ControlDown() == TRUE.
4341 if ( (id
> 0) && (id
< 27) )
4363 else // we're called from WM_KEYDOWN
4365 id
= wxCharCodeMSWToWX(wParam
);
4368 // it's ASCII and will be processed here only when called from
4369 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4374 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4377 event
.m_controlDown
= TRUE
;
4380 return GetEventHandler()->ProcessEvent(event
);
4383 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4385 int id
= wxCharCodeMSWToWX(wParam
);
4389 // normal ASCII char
4393 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4395 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4396 if ( GetEventHandler()->ProcessEvent(event
) )
4405 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4407 int id
= wxCharCodeMSWToWX(wParam
);
4411 // normal ASCII char
4415 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4417 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4418 if ( GetEventHandler()->ProcessEvent(event
) )
4425 // ---------------------------------------------------------------------------
4427 // ---------------------------------------------------------------------------
4429 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4433 if ( flags
& JOY_BUTTON1CHG
)
4434 change
= wxJOY_BUTTON1
;
4435 if ( flags
& JOY_BUTTON2CHG
)
4436 change
= wxJOY_BUTTON2
;
4437 if ( flags
& JOY_BUTTON3CHG
)
4438 change
= wxJOY_BUTTON3
;
4439 if ( flags
& JOY_BUTTON4CHG
)
4440 change
= wxJOY_BUTTON4
;
4443 if ( flags
& JOY_BUTTON1
)
4444 buttons
|= wxJOY_BUTTON1
;
4445 if ( flags
& JOY_BUTTON2
)
4446 buttons
|= wxJOY_BUTTON2
;
4447 if ( flags
& JOY_BUTTON3
)
4448 buttons
|= wxJOY_BUTTON3
;
4449 if ( flags
& JOY_BUTTON4
)
4450 buttons
|= wxJOY_BUTTON4
;
4452 // the event ids aren't consecutive so we can't use table based lookup
4454 wxEventType eventType
;
4459 eventType
= wxEVT_JOY_MOVE
;
4464 eventType
= wxEVT_JOY_MOVE
;
4469 eventType
= wxEVT_JOY_ZMOVE
;
4474 eventType
= wxEVT_JOY_ZMOVE
;
4477 case MM_JOY1BUTTONDOWN
:
4479 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4482 case MM_JOY2BUTTONDOWN
:
4484 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4487 case MM_JOY1BUTTONUP
:
4489 eventType
= wxEVT_JOY_BUTTON_UP
;
4492 case MM_JOY2BUTTONUP
:
4494 eventType
= wxEVT_JOY_BUTTON_UP
;
4498 wxFAIL_MSG(wxT("no such joystick event"));
4503 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4504 event
.SetPosition(wxPoint(x
, y
));
4505 event
.SetEventObject(this);
4507 return GetEventHandler()->ProcessEvent(event
);
4513 // ---------------------------------------------------------------------------
4515 // ---------------------------------------------------------------------------
4517 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4518 WXWORD pos
, WXHWND control
)
4522 wxWindow
*child
= wxFindWinFromHandle(control
);
4524 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4527 wxScrollWinEvent event
;
4528 event
.SetPosition(pos
);
4529 event
.SetOrientation(orientation
);
4530 event
.m_eventObject
= this;
4535 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4539 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4543 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4547 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4551 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4555 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4558 case SB_THUMBPOSITION
:
4561 // under Win32, the scrollbar range and position are 32 bit integers,
4562 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4563 // explicitly query the scrollbar for the correct position (this must
4564 // be done only for these two SB_ events as they are the only one
4565 // carrying the scrollbar position)
4567 SCROLLINFO scrollInfo
;
4568 wxZeroMemory(scrollInfo
);
4569 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
4570 scrollInfo
.fMask
= SIF_TRACKPOS
;
4572 if ( !::GetScrollInfo(GetHwnd(),
4573 orientation
== wxHORIZONTAL
? SB_HORZ
4577 wxLogLastError(_T("GetScrollInfo"));
4580 event
.SetPosition(scrollInfo
.nTrackPos
);
4584 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4585 ? wxEVT_SCROLLWIN_THUMBRELEASE
4586 : wxEVT_SCROLLWIN_THUMBTRACK
;
4593 return GetEventHandler()->ProcessEvent(event
);
4596 // ===========================================================================
4598 // ===========================================================================
4600 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4603 HDC dc
= ::GetDC((HWND
) wnd
);
4608 // the_font->UseResource();
4609 // the_font->RealizeResource();
4610 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4612 was
= (HFONT
) SelectObject(dc
,fnt
);
4614 GetTextMetrics(dc
, &tm
);
4615 if ( the_font
&& fnt
&& was
)
4617 SelectObject(dc
,was
);
4619 ReleaseDC((HWND
)wnd
, dc
);
4622 *x
= tm
.tmAveCharWidth
;
4624 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4627 // the_font->ReleaseResource();
4630 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4631 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4632 int wxCharCodeMSWToWX(int keySym
)
4637 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4638 case VK_BACK
: id
= WXK_BACK
; break;
4639 case VK_TAB
: id
= WXK_TAB
; break;
4640 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4641 case VK_RETURN
: id
= WXK_RETURN
; break;
4642 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4643 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4644 case VK_MENU
: id
= WXK_MENU
; break;
4645 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4646 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4647 case VK_SPACE
: id
= WXK_SPACE
; break;
4648 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4649 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4650 case VK_NEXT
: id
= WXK_NEXT
; break;
4651 case VK_END
: id
= WXK_END
; break;
4652 case VK_HOME
: id
= WXK_HOME
; break;
4653 case VK_LEFT
: id
= WXK_LEFT
; break;
4654 case VK_UP
: id
= WXK_UP
; break;
4655 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4656 case VK_DOWN
: id
= WXK_DOWN
; break;
4657 case VK_SELECT
: id
= WXK_SELECT
; break;
4658 case VK_PRINT
: id
= WXK_PRINT
; break;
4659 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4660 case VK_INSERT
: id
= WXK_INSERT
; break;
4661 case VK_DELETE
: id
= WXK_DELETE
; break;
4662 case VK_HELP
: id
= WXK_HELP
; break;
4663 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4664 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4665 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4666 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4667 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4668 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4669 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4670 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4671 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4672 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4673 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4674 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4675 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4676 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4677 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4678 case VK_F1
: id
= WXK_F1
; break;
4679 case VK_F2
: id
= WXK_F2
; break;
4680 case VK_F3
: id
= WXK_F3
; break;
4681 case VK_F4
: id
= WXK_F4
; break;
4682 case VK_F5
: id
= WXK_F5
; break;
4683 case VK_F6
: id
= WXK_F6
; break;
4684 case VK_F7
: id
= WXK_F7
; break;
4685 case VK_F8
: id
= WXK_F8
; break;
4686 case VK_F9
: id
= WXK_F9
; break;
4687 case VK_F10
: id
= WXK_F10
; break;
4688 case VK_F11
: id
= WXK_F11
; break;
4689 case VK_F12
: id
= WXK_F12
; break;
4690 case VK_F13
: id
= WXK_F13
; break;
4691 case VK_F14
: id
= WXK_F14
; break;
4692 case VK_F15
: id
= WXK_F15
; break;
4693 case VK_F16
: id
= WXK_F16
; break;
4694 case VK_F17
: id
= WXK_F17
; break;
4695 case VK_F18
: id
= WXK_F18
; break;
4696 case VK_F19
: id
= WXK_F19
; break;
4697 case VK_F20
: id
= WXK_F20
; break;
4698 case VK_F21
: id
= WXK_F21
; break;
4699 case VK_F22
: id
= WXK_F22
; break;
4700 case VK_F23
: id
= WXK_F23
; break;
4701 case VK_F24
: id
= WXK_F24
; break;
4702 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4703 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4705 case VK_OEM_1
: id
= ';'; break;
4706 case VK_OEM_PLUS
: id
= '+'; break;
4707 case VK_OEM_COMMA
: id
= ','; break;
4708 case VK_OEM_MINUS
: id
= '-'; break;
4709 case VK_OEM_PERIOD
: id
= '.'; break;
4710 case VK_OEM_2
: id
= '/'; break;
4711 case VK_OEM_3
: id
= '~'; break;
4712 case VK_OEM_4
: id
= '['; break;
4713 case VK_OEM_5
: id
= '\\'; break;
4714 case VK_OEM_6
: id
= ']'; break;
4715 case VK_OEM_7
: id
= '\''; break;
4724 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4730 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4731 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4732 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4733 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4734 case WXK_MENU
: keySym
= VK_MENU
; break;
4735 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4736 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4737 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4738 case WXK_END
: keySym
= VK_END
; break;
4739 case WXK_HOME
: keySym
= VK_HOME
; break;
4740 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4741 case WXK_UP
: keySym
= VK_UP
; break;
4742 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4743 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4744 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4745 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4746 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4747 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4748 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4749 case WXK_HELP
: keySym
= VK_HELP
; break;
4750 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4751 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4752 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4753 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4754 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4755 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4756 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4757 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4758 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4759 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4760 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4761 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4762 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4763 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4764 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4765 case WXK_F1
: keySym
= VK_F1
; break;
4766 case WXK_F2
: keySym
= VK_F2
; break;
4767 case WXK_F3
: keySym
= VK_F3
; break;
4768 case WXK_F4
: keySym
= VK_F4
; break;
4769 case WXK_F5
: keySym
= VK_F5
; break;
4770 case WXK_F6
: keySym
= VK_F6
; break;
4771 case WXK_F7
: keySym
= VK_F7
; break;
4772 case WXK_F8
: keySym
= VK_F8
; break;
4773 case WXK_F9
: keySym
= VK_F9
; break;
4774 case WXK_F10
: keySym
= VK_F10
; break;
4775 case WXK_F11
: keySym
= VK_F11
; break;
4776 case WXK_F12
: keySym
= VK_F12
; break;
4777 case WXK_F13
: keySym
= VK_F13
; break;
4778 case WXK_F14
: keySym
= VK_F14
; break;
4779 case WXK_F15
: keySym
= VK_F15
; break;
4780 case WXK_F16
: keySym
= VK_F16
; break;
4781 case WXK_F17
: keySym
= VK_F17
; break;
4782 case WXK_F18
: keySym
= VK_F18
; break;
4783 case WXK_F19
: keySym
= VK_F19
; break;
4784 case WXK_F20
: keySym
= VK_F20
; break;
4785 case WXK_F21
: keySym
= VK_F21
; break;
4786 case WXK_F22
: keySym
= VK_F22
; break;
4787 case WXK_F23
: keySym
= VK_F23
; break;
4788 case WXK_F24
: keySym
= VK_F24
; break;
4789 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4790 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4801 wxWindow
*wxGetActiveWindow()
4803 HWND hWnd
= GetActiveWindow();
4806 return wxFindWinFromHandle((WXHWND
) hWnd
);
4811 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4813 HWND hwnd
= (HWND
)hWnd
;
4815 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4816 // by code in msw/radiobox.cpp), for all the others we just search up the
4818 wxWindow
*win
= (wxWindow
*)NULL
;
4821 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4824 // all these hacks only work under Win32 anyhow
4828 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4829 // wxWindow class which overrides WM_GETDLGCODE processing to
4830 // do it as well, win would be already non NULL
4831 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
4833 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
4835 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4836 #endif // wxUSE_RADIOBOX
4838 // spin control text buddy window should be mapped to spin ctrl
4839 // itself so try it too
4840 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4843 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
4845 #endif // wxUSE_SPINCTRL
4851 while ( hwnd
&& !win
)
4853 // this is a really ugly hack needed to avoid mistakenly returning the
4854 // parent frame wxWindow for the find/replace modeless dialog HWND -
4855 // this, in turn, is needed to call IsDialogMessage() from
4856 // wxApp::ProcessMessage() as for this we must return NULL from here
4858 // FIXME: this is clearly not the best way to do it but I think we'll
4859 // need to change HWND <-> wxWindow code more heavily than I can
4860 // do it now to fix it
4861 #ifndef __WXMICROWIN__
4862 if ( ::GetWindow(hwnd
, GW_OWNER
) )
4864 // it's a dialog box, don't go upwards
4869 hwnd
= ::GetParent(hwnd
);
4870 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4876 #ifndef __WXMICROWIN__
4878 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4879 // in active frames and dialogs, regardless of where the focus is.
4880 static HHOOK wxTheKeyboardHook
= 0;
4881 static FARPROC wxTheKeyboardHookProc
= 0;
4882 int APIENTRY _EXPORT
4883 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
4885 void wxSetKeyboardHook(bool doIt
)
4889 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
4890 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
4892 #if defined(__WIN32__) && !defined(__TWIN32__)
4893 GetCurrentThreadId()
4894 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4902 UnhookWindowsHookEx(wxTheKeyboardHook
);
4904 // avoids warning about statement with no effect (FreeProcInstance
4905 // doesn't do anything under Win32)
4906 #if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32__) && !defined(__NT__) && !defined(__GNUWIN32__)
4907 FreeProcInstance(wxTheKeyboardHookProc
);
4912 int APIENTRY _EXPORT
4913 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
4915 DWORD hiWord
= HIWORD(lParam
);
4916 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
4918 int id
= wxCharCodeMSWToWX(wParam
);
4921 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
4922 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
4923 event
.m_altDown
= TRUE
;
4925 event
.m_eventObject
= NULL
;
4926 event
.m_keyCode
= id
;
4927 event
.m_shiftDown
= wxIsShiftDown();
4928 event
.m_controlDown
= wxIsCtrlDown();
4929 event
.SetTimestamp(s_currentMsg
.time
);
4931 wxWindow
*win
= wxGetActiveWindow();
4932 wxEvtHandler
*handler
;
4935 handler
= win
->GetEventHandler();
4936 event
.SetId(win
->GetId());
4944 if ( handler
&& handler
->ProcessEvent(event
) )
4952 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
4955 #endif // !__WXMICROWIN__
4958 const char *wxGetMessageName(int message
)
4962 case 0x0000: return "WM_NULL";
4963 case 0x0001: return "WM_CREATE";
4964 case 0x0002: return "WM_DESTROY";
4965 case 0x0003: return "WM_MOVE";
4966 case 0x0005: return "WM_SIZE";
4967 case 0x0006: return "WM_ACTIVATE";
4968 case 0x0007: return "WM_SETFOCUS";
4969 case 0x0008: return "WM_KILLFOCUS";
4970 case 0x000A: return "WM_ENABLE";
4971 case 0x000B: return "WM_SETREDRAW";
4972 case 0x000C: return "WM_SETTEXT";
4973 case 0x000D: return "WM_GETTEXT";
4974 case 0x000E: return "WM_GETTEXTLENGTH";
4975 case 0x000F: return "WM_PAINT";
4976 case 0x0010: return "WM_CLOSE";
4977 case 0x0011: return "WM_QUERYENDSESSION";
4978 case 0x0012: return "WM_QUIT";
4979 case 0x0013: return "WM_QUERYOPEN";
4980 case 0x0014: return "WM_ERASEBKGND";
4981 case 0x0015: return "WM_SYSCOLORCHANGE";
4982 case 0x0016: return "WM_ENDSESSION";
4983 case 0x0017: return "WM_SYSTEMERROR";
4984 case 0x0018: return "WM_SHOWWINDOW";
4985 case 0x0019: return "WM_CTLCOLOR";
4986 case 0x001A: return "WM_WININICHANGE";
4987 case 0x001B: return "WM_DEVMODECHANGE";
4988 case 0x001C: return "WM_ACTIVATEAPP";
4989 case 0x001D: return "WM_FONTCHANGE";
4990 case 0x001E: return "WM_TIMECHANGE";
4991 case 0x001F: return "WM_CANCELMODE";
4992 case 0x0020: return "WM_SETCURSOR";
4993 case 0x0021: return "WM_MOUSEACTIVATE";
4994 case 0x0022: return "WM_CHILDACTIVATE";
4995 case 0x0023: return "WM_QUEUESYNC";
4996 case 0x0024: return "WM_GETMINMAXINFO";
4997 case 0x0026: return "WM_PAINTICON";
4998 case 0x0027: return "WM_ICONERASEBKGND";
4999 case 0x0028: return "WM_NEXTDLGCTL";
5000 case 0x002A: return "WM_SPOOLERSTATUS";
5001 case 0x002B: return "WM_DRAWITEM";
5002 case 0x002C: return "WM_MEASUREITEM";
5003 case 0x002D: return "WM_DELETEITEM";
5004 case 0x002E: return "WM_VKEYTOITEM";
5005 case 0x002F: return "WM_CHARTOITEM";
5006 case 0x0030: return "WM_SETFONT";
5007 case 0x0031: return "WM_GETFONT";
5008 case 0x0037: return "WM_QUERYDRAGICON";
5009 case 0x0039: return "WM_COMPAREITEM";
5010 case 0x0041: return "WM_COMPACTING";
5011 case 0x0044: return "WM_COMMNOTIFY";
5012 case 0x0046: return "WM_WINDOWPOSCHANGING";
5013 case 0x0047: return "WM_WINDOWPOSCHANGED";
5014 case 0x0048: return "WM_POWER";
5017 case 0x004A: return "WM_COPYDATA";
5018 case 0x004B: return "WM_CANCELJOURNAL";
5019 case 0x004E: return "WM_NOTIFY";
5020 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5021 case 0x0051: return "WM_INPUTLANGCHANGE";
5022 case 0x0052: return "WM_TCARD";
5023 case 0x0053: return "WM_HELP";
5024 case 0x0054: return "WM_USERCHANGED";
5025 case 0x0055: return "WM_NOTIFYFORMAT";
5026 case 0x007B: return "WM_CONTEXTMENU";
5027 case 0x007C: return "WM_STYLECHANGING";
5028 case 0x007D: return "WM_STYLECHANGED";
5029 case 0x007E: return "WM_DISPLAYCHANGE";
5030 case 0x007F: return "WM_GETICON";
5031 case 0x0080: return "WM_SETICON";
5034 case 0x0081: return "WM_NCCREATE";
5035 case 0x0082: return "WM_NCDESTROY";
5036 case 0x0083: return "WM_NCCALCSIZE";
5037 case 0x0084: return "WM_NCHITTEST";
5038 case 0x0085: return "WM_NCPAINT";
5039 case 0x0086: return "WM_NCACTIVATE";
5040 case 0x0087: return "WM_GETDLGCODE";
5041 case 0x00A0: return "WM_NCMOUSEMOVE";
5042 case 0x00A1: return "WM_NCLBUTTONDOWN";
5043 case 0x00A2: return "WM_NCLBUTTONUP";
5044 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5045 case 0x00A4: return "WM_NCRBUTTONDOWN";
5046 case 0x00A5: return "WM_NCRBUTTONUP";
5047 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5048 case 0x00A7: return "WM_NCMBUTTONDOWN";
5049 case 0x00A8: return "WM_NCMBUTTONUP";
5050 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5051 case 0x0100: return "WM_KEYDOWN";
5052 case 0x0101: return "WM_KEYUP";
5053 case 0x0102: return "WM_CHAR";
5054 case 0x0103: return "WM_DEADCHAR";
5055 case 0x0104: return "WM_SYSKEYDOWN";
5056 case 0x0105: return "WM_SYSKEYUP";
5057 case 0x0106: return "WM_SYSCHAR";
5058 case 0x0107: return "WM_SYSDEADCHAR";
5059 case 0x0108: return "WM_KEYLAST";
5062 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5063 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5064 case 0x010F: return "WM_IME_COMPOSITION";
5067 case 0x0110: return "WM_INITDIALOG";
5068 case 0x0111: return "WM_COMMAND";
5069 case 0x0112: return "WM_SYSCOMMAND";
5070 case 0x0113: return "WM_TIMER";
5071 case 0x0114: return "WM_HSCROLL";
5072 case 0x0115: return "WM_VSCROLL";
5073 case 0x0116: return "WM_INITMENU";
5074 case 0x0117: return "WM_INITMENUPOPUP";
5075 case 0x011F: return "WM_MENUSELECT";
5076 case 0x0120: return "WM_MENUCHAR";
5077 case 0x0121: return "WM_ENTERIDLE";
5078 case 0x0200: return "WM_MOUSEMOVE";
5079 case 0x0201: return "WM_LBUTTONDOWN";
5080 case 0x0202: return "WM_LBUTTONUP";
5081 case 0x0203: return "WM_LBUTTONDBLCLK";
5082 case 0x0204: return "WM_RBUTTONDOWN";
5083 case 0x0205: return "WM_RBUTTONUP";
5084 case 0x0206: return "WM_RBUTTONDBLCLK";
5085 case 0x0207: return "WM_MBUTTONDOWN";
5086 case 0x0208: return "WM_MBUTTONUP";
5087 case 0x0209: return "WM_MBUTTONDBLCLK";
5088 case 0x020A: return "WM_MOUSEWHEEL";
5089 case 0x0210: return "WM_PARENTNOTIFY";
5090 case 0x0211: return "WM_ENTERMENULOOP";
5091 case 0x0212: return "WM_EXITMENULOOP";
5094 case 0x0213: return "WM_NEXTMENU";
5095 case 0x0214: return "WM_SIZING";
5096 case 0x0215: return "WM_CAPTURECHANGED";
5097 case 0x0216: return "WM_MOVING";
5098 case 0x0218: return "WM_POWERBROADCAST";
5099 case 0x0219: return "WM_DEVICECHANGE";
5102 case 0x0220: return "WM_MDICREATE";
5103 case 0x0221: return "WM_MDIDESTROY";
5104 case 0x0222: return "WM_MDIACTIVATE";
5105 case 0x0223: return "WM_MDIRESTORE";
5106 case 0x0224: return "WM_MDINEXT";
5107 case 0x0225: return "WM_MDIMAXIMIZE";
5108 case 0x0226: return "WM_MDITILE";
5109 case 0x0227: return "WM_MDICASCADE";
5110 case 0x0228: return "WM_MDIICONARRANGE";
5111 case 0x0229: return "WM_MDIGETACTIVE";
5112 case 0x0230: return "WM_MDISETMENU";
5113 case 0x0233: return "WM_DROPFILES";
5116 case 0x0281: return "WM_IME_SETCONTEXT";
5117 case 0x0282: return "WM_IME_NOTIFY";
5118 case 0x0283: return "WM_IME_CONTROL";
5119 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5120 case 0x0285: return "WM_IME_SELECT";
5121 case 0x0286: return "WM_IME_CHAR";
5122 case 0x0290: return "WM_IME_KEYDOWN";
5123 case 0x0291: return "WM_IME_KEYUP";
5126 case 0x0300: return "WM_CUT";
5127 case 0x0301: return "WM_COPY";
5128 case 0x0302: return "WM_PASTE";
5129 case 0x0303: return "WM_CLEAR";
5130 case 0x0304: return "WM_UNDO";
5131 case 0x0305: return "WM_RENDERFORMAT";
5132 case 0x0306: return "WM_RENDERALLFORMATS";
5133 case 0x0307: return "WM_DESTROYCLIPBOARD";
5134 case 0x0308: return "WM_DRAWCLIPBOARD";
5135 case 0x0309: return "WM_PAINTCLIPBOARD";
5136 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5137 case 0x030B: return "WM_SIZECLIPBOARD";
5138 case 0x030C: return "WM_ASKCBFORMATNAME";
5139 case 0x030D: return "WM_CHANGECBCHAIN";
5140 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5141 case 0x030F: return "WM_QUERYNEWPALETTE";
5142 case 0x0310: return "WM_PALETTEISCHANGING";
5143 case 0x0311: return "WM_PALETTECHANGED";
5146 // common controls messages - although they're not strictly speaking
5147 // standard, it's nice to decode them nevertheless
5150 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5151 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5152 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5153 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5154 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5155 case 0x1000 + 5: return "LVM_GETITEMA";
5156 case 0x1000 + 75: return "LVM_GETITEMW";
5157 case 0x1000 + 6: return "LVM_SETITEMA";
5158 case 0x1000 + 76: return "LVM_SETITEMW";
5159 case 0x1000 + 7: return "LVM_INSERTITEMA";
5160 case 0x1000 + 77: return "LVM_INSERTITEMW";
5161 case 0x1000 + 8: return "LVM_DELETEITEM";
5162 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5163 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5164 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5165 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5166 case 0x1000 + 13: return "LVM_FINDITEMA";
5167 case 0x1000 + 83: return "LVM_FINDITEMW";
5168 case 0x1000 + 14: return "LVM_GETITEMRECT";
5169 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5170 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5171 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5172 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5173 case 0x1000 + 18: return "LVM_HITTEST";
5174 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5175 case 0x1000 + 20: return "LVM_SCROLL";
5176 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5177 case 0x1000 + 22: return "LVM_ARRANGE";
5178 case 0x1000 + 23: return "LVM_EDITLABELA";
5179 case 0x1000 + 118: return "LVM_EDITLABELW";
5180 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5181 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5182 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5183 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5184 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5185 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5186 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5187 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5188 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5189 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5190 case 0x1000 + 31: return "LVM_GETHEADER";
5191 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5192 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5193 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5194 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5195 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5196 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5197 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5198 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5199 case 0x1000 + 41: return "LVM_GETORIGIN";
5200 case 0x1000 + 42: return "LVM_UPDATE";
5201 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5202 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5203 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5204 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5205 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5206 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5207 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5208 case 0x1000 + 48: return "LVM_SORTITEMS";
5209 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5210 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5211 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5212 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5213 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5214 case 0x1000 + 53: return "LVM_SETICONSPACING";
5215 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5216 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5217 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5218 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5219 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5220 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5221 case 0x1000 + 60: return "LVM_SETHOTITEM";
5222 case 0x1000 + 61: return "LVM_GETHOTITEM";
5223 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5224 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5225 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5226 case 0x1000 + 65: return "LVM_SETWORKAREA";
5229 case 0x1100 + 0: return "TVM_INSERTITEMA";
5230 case 0x1100 + 50: return "TVM_INSERTITEMW";
5231 case 0x1100 + 1: return "TVM_DELETEITEM";
5232 case 0x1100 + 2: return "TVM_EXPAND";
5233 case 0x1100 + 4: return "TVM_GETITEMRECT";
5234 case 0x1100 + 5: return "TVM_GETCOUNT";
5235 case 0x1100 + 6: return "TVM_GETINDENT";
5236 case 0x1100 + 7: return "TVM_SETINDENT";
5237 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5238 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5239 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5240 case 0x1100 + 11: return "TVM_SELECTITEM";
5241 case 0x1100 + 12: return "TVM_GETITEMA";
5242 case 0x1100 + 62: return "TVM_GETITEMW";
5243 case 0x1100 + 13: return "TVM_SETITEMA";
5244 case 0x1100 + 63: return "TVM_SETITEMW";
5245 case 0x1100 + 14: return "TVM_EDITLABELA";
5246 case 0x1100 + 65: return "TVM_EDITLABELW";
5247 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5248 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5249 case 0x1100 + 17: return "TVM_HITTEST";
5250 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5251 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5252 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5253 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5254 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5255 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5256 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5257 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5258 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5261 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5262 case 0x1200 + 1: return "HDM_INSERTITEMA";
5263 case 0x1200 + 10: return "HDM_INSERTITEMW";
5264 case 0x1200 + 2: return "HDM_DELETEITEM";
5265 case 0x1200 + 3: return "HDM_GETITEMA";
5266 case 0x1200 + 11: return "HDM_GETITEMW";
5267 case 0x1200 + 4: return "HDM_SETITEMA";
5268 case 0x1200 + 12: return "HDM_SETITEMW";
5269 case 0x1200 + 5: return "HDM_LAYOUT";
5270 case 0x1200 + 6: return "HDM_HITTEST";
5271 case 0x1200 + 7: return "HDM_GETITEMRECT";
5272 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5273 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5274 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5275 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5276 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5277 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5278 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5281 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5282 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5283 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5284 case 0x1300 + 5: return "TCM_GETITEMA";
5285 case 0x1300 + 60: return "TCM_GETITEMW";
5286 case 0x1300 + 6: return "TCM_SETITEMA";
5287 case 0x1300 + 61: return "TCM_SETITEMW";
5288 case 0x1300 + 7: return "TCM_INSERTITEMA";
5289 case 0x1300 + 62: return "TCM_INSERTITEMW";
5290 case 0x1300 + 8: return "TCM_DELETEITEM";
5291 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5292 case 0x1300 + 10: return "TCM_GETITEMRECT";
5293 case 0x1300 + 11: return "TCM_GETCURSEL";
5294 case 0x1300 + 12: return "TCM_SETCURSEL";
5295 case 0x1300 + 13: return "TCM_HITTEST";
5296 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5297 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5298 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5299 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5300 case 0x1300 + 43: return "TCM_SETPADDING";
5301 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5302 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5303 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5304 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5305 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5306 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5307 case 0x1300 + 50: return "TCM_DESELECTALL";
5310 case WM_USER
+1: return "TB_ENABLEBUTTON";
5311 case WM_USER
+2: return "TB_CHECKBUTTON";
5312 case WM_USER
+3: return "TB_PRESSBUTTON";
5313 case WM_USER
+4: return "TB_HIDEBUTTON";
5314 case WM_USER
+5: return "TB_INDETERMINATE";
5315 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5316 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5317 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5318 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5319 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5320 case WM_USER
+17: return "TB_SETSTATE";
5321 case WM_USER
+18: return "TB_GETSTATE";
5322 case WM_USER
+19: return "TB_ADDBITMAP";
5323 case WM_USER
+20: return "TB_ADDBUTTONS";
5324 case WM_USER
+21: return "TB_INSERTBUTTON";
5325 case WM_USER
+22: return "TB_DELETEBUTTON";
5326 case WM_USER
+23: return "TB_GETBUTTON";
5327 case WM_USER
+24: return "TB_BUTTONCOUNT";
5328 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5329 case WM_USER
+26: return "TB_SAVERESTOREA";
5330 case WM_USER
+76: return "TB_SAVERESTOREW";
5331 case WM_USER
+27: return "TB_CUSTOMIZE";
5332 case WM_USER
+28: return "TB_ADDSTRINGA";
5333 case WM_USER
+77: return "TB_ADDSTRINGW";
5334 case WM_USER
+29: return "TB_GETITEMRECT";
5335 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5336 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5337 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5338 case WM_USER
+33: return "TB_AUTOSIZE";
5339 case WM_USER
+35: return "TB_GETTOOLTIPS";
5340 case WM_USER
+36: return "TB_SETTOOLTIPS";
5341 case WM_USER
+37: return "TB_SETPARENT";
5342 case WM_USER
+39: return "TB_SETROWS";
5343 case WM_USER
+40: return "TB_GETROWS";
5344 case WM_USER
+42: return "TB_SETCMDID";
5345 case WM_USER
+43: return "TB_CHANGEBITMAP";
5346 case WM_USER
+44: return "TB_GETBITMAP";
5347 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5348 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5349 case WM_USER
+46: return "TB_REPLACEBITMAP";
5350 case WM_USER
+47: return "TB_SETINDENT";
5351 case WM_USER
+48: return "TB_SETIMAGELIST";
5352 case WM_USER
+49: return "TB_GETIMAGELIST";
5353 case WM_USER
+50: return "TB_LOADIMAGES";
5354 case WM_USER
+51: return "TB_GETRECT";
5355 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5356 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5357 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5358 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5359 case WM_USER
+56: return "TB_SETSTYLE";
5360 case WM_USER
+57: return "TB_GETSTYLE";
5361 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5362 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5363 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5364 case WM_USER
+61: return "TB_GETTEXTROWS";
5365 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5370 static char s_szBuf
[128];
5371 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5375 #endif //__WXDEBUG__
5377 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5378 int *x
, int *y
, WPARAM
*flags
)
5380 // construct the key mask
5381 WPARAM
& fwKeys
= *flags
;
5383 fwKeys
= MK_RBUTTON
;
5384 if ( wxIsCtrlDown() )
5385 fwKeys
|= MK_CONTROL
;
5386 if ( wxIsShiftDown() )
5389 // simulate right mouse button click
5390 DWORD dwPos
= ::GetMessagePos();
5391 *x
= GET_X_LPARAM(dwPos
);
5392 *y
= GET_Y_LPARAM(dwPos
);
5394 win
->ScreenToClient(x
, y
);
5397 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5401 HWND hwnd
= GetHwndOf(win
);
5402 HDC hdc
= ::GetDC(hwnd
);
5404 #if !wxDIALOG_UNIT_COMPATIBILITY
5405 // and select the current font into it
5406 HFONT hfont
= GetHfontOf(win
->GetFont());
5409 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5413 // finally retrieve the text metrics from it
5414 GetTextMetrics(hdc
, &tm
);
5416 #if !wxDIALOG_UNIT_COMPATIBILITY
5420 (void)::SelectObject(hdc
, hfont
);
5424 ::ReleaseDC(hwnd
, hdc
);
5429 // Find the wxWindow at the current mouse position, returning the mouse
5431 wxWindow
* wxFindWindowAtPointer(wxPoint
& WXUNUSED(pt
))
5433 return wxFindWindowAtPoint(wxGetMousePosition());
5436 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5441 HWND hWndHit
= ::WindowFromPoint(pt2
);
5443 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5444 HWND hWnd
= hWndHit
;
5446 // Try to find a window with a wxWindow associated with it
5447 while (!win
&& (hWnd
!= 0))
5449 hWnd
= ::GetParent(hWnd
);
5450 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5455 // Get the current mouse position.
5456 wxPoint
wxGetMousePosition()
5459 GetCursorPos( & pt
);
5461 return wxPoint(pt
.x
, pt
.y
);