1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/msw/winundef.h"
34 #include "wx/window.h"
39 #include "wx/dcclient.h"
40 #include "wx/dcmemory.h"
43 #include "wx/layout.h"
44 #include "wx/dialog.h"
46 #include "wx/listbox.h"
47 #include "wx/button.h"
48 #include "wx/msgdlg.h"
49 #include "wx/settings.h"
50 #include "wx/statbox.h"
54 #include "wx/ownerdrw.h"
57 #if wxUSE_DRAG_AND_DROP
61 #include "wx/menuitem.h"
64 #include "wx/msw/private.h"
67 #include "wx/tooltip.h"
75 #include "wx/spinctrl.h"
76 #endif // wxUSE_SPINCTRL
81 #include "wx/textctrl.h"
82 #include "wx/notebook.h"
86 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
95 #if (!defined(__GNUWIN32_OLD__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
99 #elif !defined(__WXMICROWIN__) // broken compiler
101 #include "wx/msw/gnuwin32/extra.h"
105 // ----------------------------------------------------------------------------
106 // standard constants not available with all compilers/headers
107 // ----------------------------------------------------------------------------
109 // This didn't appear in mingw until 2.95.2
111 #define SIF_TRACKPOS 16
115 #ifndef WM_MOUSEWHEEL
116 #define WM_MOUSEWHEEL 0x020A
119 #define WHEEL_DELTA 120
121 #ifndef SPI_GETWHEELSCROLLLINES
122 #define SPI_GETWHEELSCROLLLINES 104
124 #endif // wxUSE_MOUSEWHEEL
127 #define VK_OEM_1 0xBA
128 #define VK_OEM_PLUS 0xBB
129 #define VK_OEM_COMMA 0xBC
130 #define VK_OEM_MINUS 0xBD
131 #define VK_OEM_PERIOD 0xBE
132 #define VK_OEM_2 0xBF
133 #define VK_OEM_3 0xC0
134 #define VK_OEM_4 0xDB
135 #define VK_OEM_5 0xDC
136 #define VK_OEM_6 0xDD
137 #define VK_OEM_7 0xDE
140 // ---------------------------------------------------------------------------
142 // ---------------------------------------------------------------------------
144 // the last Windows message we got (FIXME-MT)
145 extern MSG s_currentMsg
;
147 #if wxUSE_MENUS_NATIVE
148 wxMenu
*wxCurrentPopupMenu
= NULL
;
149 #endif // wxUSE_MENUS_NATIVE
151 extern const wxChar
*wxCanvasClassName
;
153 // true if we had already created the std colour map, used by
154 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
155 static bool gs_hasStdCmap
= FALSE
;
157 // ---------------------------------------------------------------------------
159 // ---------------------------------------------------------------------------
161 // the window proc for all our windows
162 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
163 WPARAM wParam
, LPARAM lParam
);
166 const char *wxGetMessageName(int message
);
169 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
170 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
171 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
173 // this magical function is used to translate VK_APPS key presses to right
175 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
176 int *x
, int *y
, WPARAM
*flags
);
178 // get the text metrics for the current font
179 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
181 // find the window for the mouse event at the specified position
182 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
184 // wrapper around BringWindowToTop() API
185 static inline void wxBringWindowToTop(HWND hwnd
)
187 #ifdef __WXMICROWIN__
188 // It seems that MicroWindows brings the _parent_ of the window to the top,
189 // which can be the wrong one.
191 // activate (set focus to) specified window
194 // raise top level parent to top of z order
195 ::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
);
196 #else // !__WXMICROWIN__
197 if ( !::BringWindowToTop(hwnd
) )
199 wxLogLastError(_T("BringWindowToTop"));
201 #endif // __WXMICROWIN__/!__WXMICROWIN__
204 // ---------------------------------------------------------------------------
206 // ---------------------------------------------------------------------------
208 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
210 #ifdef __WXUNIVERSAL__
211 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
213 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
214 #endif // __WXUNIVERSAL__/__WXMSW__
216 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
217 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
218 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
219 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
220 EVT_IDLE(wxWindowMSW::OnIdle
)
223 // ===========================================================================
225 // ===========================================================================
227 // ---------------------------------------------------------------------------
228 // wxWindow utility functions
229 // ---------------------------------------------------------------------------
231 // Find an item given the MS Windows id
232 wxWindow
*wxWindowMSW::FindItem(long id
) const
235 wxControl
*item
= wxDynamicCastThis(wxControl
);
238 // is it we or one of our "internal" children?
239 if ( item
->GetId() == id
240 #ifndef __WXUNIVERSAL__
241 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
242 #endif // __WXUNIVERSAL__
248 #endif // wxUSE_CONTROLS
250 wxWindowList::Node
*current
= GetChildren().GetFirst();
253 wxWindow
*childWin
= current
->GetData();
255 wxWindow
*wnd
= childWin
->FindItem(id
);
259 current
= current
->GetNext();
265 // Find an item given the MS Windows handle
266 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
268 wxWindowList::Node
*current
= GetChildren().GetFirst();
271 wxWindow
*parent
= current
->GetData();
273 // Do a recursive search.
274 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
280 || parent
->IsKindOf(CLASSINFO(wxControl
))
281 #endif // wxUSE_CONTROLS
284 wxWindow
*item
= current
->GetData();
285 if ( item
->GetHWND() == hWnd
)
289 if ( item
->ContainsHWND(hWnd
) )
294 current
= current
->GetNext();
299 // Default command handler
300 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
305 // ----------------------------------------------------------------------------
306 // constructors and such
307 // ----------------------------------------------------------------------------
309 void wxWindowMSW::Init()
315 m_isBeingDeleted
= FALSE
;
318 m_mouseInWindow
= FALSE
;
319 m_lastKeydownProcessed
= FALSE
;
328 m_backgroundTransparent
= FALSE
;
330 // as all windows are created with WS_VISIBLE style...
333 #if wxUSE_MOUSEEVENT_HACK
336 m_lastMouseEvent
= -1;
337 #endif // wxUSE_MOUSEEVENT_HACK
341 wxWindowMSW::~wxWindowMSW()
343 m_isBeingDeleted
= TRUE
;
345 #ifndef __WXUNIVERSAL__
346 // VS: make sure there's no wxFrame with last focus set to us:
347 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
349 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
352 if ( frame
->GetLastFocus() == this )
354 frame
->SetLastFocus(NULL
);
359 #endif // __WXUNIVERSAL__
361 // VS: destroy children first and _then_ detach *this from its parent.
362 // If we'd do it the other way around, children wouldn't be able
363 // find their parent frame (see above).
367 m_parent
->RemoveChild(this);
371 // VZ: test temp removed to understand what really happens here
372 //if (::IsWindow(GetHwnd()))
374 if ( !::DestroyWindow(GetHwnd()) )
375 wxLogLastError(wxT("DestroyWindow"));
378 // remove hWnd <-> wxWindow association
379 wxRemoveHandleAssociation(this);
383 // real construction (Init() must have been called before!)
384 bool wxWindowMSW::Create(wxWindow
*parent
,
389 const wxString
& name
)
391 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
394 // wxGTK doesn't allow to create controls with static box as the parent so
395 // this will result in a crash when the program is ported to wxGTK - warn
398 // the correct solution is to create the controls as siblings of the
400 wxASSERT_MSG( !wxDynamicCast(parent
, wxStaticBox
),
401 _T("wxStaticBox can't be used as a window parent!") );
402 #endif // wxUSE_STATBOX
404 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
407 parent
->AddChild(this);
410 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
412 #ifdef __WXUNIVERSAL__
413 // no borders, we draw them ourselves
414 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
418 msflags
&= ~WS_BORDER
;
419 #endif // wxUniversal
421 // all windows are created visible by default except popup ones (which are
422 // like the wxTopLevelWindows in this aspect)
423 if ( style
& wxPOPUP_WINDOW
)
425 msflags
&= ~WS_VISIBLE
;
430 msflags
|= WS_VISIBLE
;
433 bool retValue
= MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
435 SetWindowLong( (HWND
)m_hWnd
, GWL_WNDPROC
, (LONG
)wxWndProc
);
439 // ---------------------------------------------------------------------------
441 // ---------------------------------------------------------------------------
443 void wxWindowMSW::SetFocus()
445 HWND hWnd
= GetHwnd();
446 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
448 #ifndef __WXMICROWIN__
452 if ( !::SetFocus(hWnd
) )
454 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
455 // was there really an error?
456 DWORD dwRes
= ::GetLastError();
459 HWND hwndFocus
= ::GetFocus();
460 if ( hwndFocus
!= hWnd
)
462 wxLogApiError(_T("SetFocus"), dwRes
);
469 void wxWindowMSW::SetFocusFromKbd()
471 wxWindowBase::SetFocusFromKbd();
473 // when the focus is given to the control with DLGC_HASSETSEL style from
474 // keyboard its contents should be entirely selected: this is what
475 // ::IsDialogMessage() does and so we should do it as well to provide the
476 // same LNF as the native programs
477 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
479 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
483 // Get the window with the focus
484 wxWindow
*wxWindowBase::FindFocus()
486 HWND hWnd
= ::GetFocus();
489 return wxGetWindowFromHWND((WXHWND
)hWnd
);
495 bool wxWindowMSW::Enable(bool enable
)
497 if ( !wxWindowBase::Enable(enable
) )
500 HWND hWnd
= GetHwnd();
502 ::EnableWindow(hWnd
, (BOOL
)enable
);
504 // VZ: no, this is a bad idea: imagine that you have a dialog with some
505 // disabled controls and disable it - you really wouldn't like the
506 // disabled controls be reenabled too when you reenable the dialog!
508 wxWindowList::Node
*node
= GetChildren().GetFirst();
511 wxWindow
*child
= node
->GetData();
512 child
->Enable(enable
);
514 node
= node
->GetNext();
521 bool wxWindowMSW::Show(bool show
)
523 if ( !wxWindowBase::Show(show
) )
526 HWND hWnd
= GetHwnd();
527 int cshow
= show
? SW_SHOW
: SW_HIDE
;
528 ::ShowWindow(hWnd
, cshow
);
532 wxBringWindowToTop(hWnd
);
538 // Raise the window to the top of the Z order
539 void wxWindowMSW::Raise()
541 wxBringWindowToTop(GetHwnd());
544 // Lower the window to the bottom of the Z order
545 void wxWindowMSW::Lower()
547 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
548 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
551 void wxWindowMSW::SetTitle( const wxString
& title
)
553 SetWindowText(GetHwnd(), title
.c_str());
556 wxString
wxWindowMSW::GetTitle() const
558 return wxGetWindowText(GetHWND());
561 void wxWindowMSW::DoCaptureMouse()
563 HWND hWnd
= GetHwnd();
570 void wxWindowMSW::DoReleaseMouse()
572 if ( !::ReleaseCapture() )
574 wxLogLastError(_T("ReleaseCapture"));
578 /* static */ wxWindow
*wxWindowBase::GetCapture()
580 HWND hwnd
= ::GetCapture();
581 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
584 bool wxWindowMSW::SetFont(const wxFont
& font
)
586 if ( !wxWindowBase::SetFont(font
) )
592 HWND hWnd
= GetHwnd();
595 WXHANDLE hFont
= m_font
.GetResourceHandle();
597 wxASSERT_MSG( hFont
, wxT("should have valid font") );
599 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
604 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
606 if ( !wxWindowBase::SetCursor(cursor
) )
614 HWND hWnd
= GetHwnd();
616 // Change the cursor NOW if we're within the correct window
618 ::GetCursorPos(&point
);
620 RECT rect
= wxGetWindowRect(hWnd
);
622 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
623 ::SetCursor(GetHcursorOf(m_cursor
));
629 void wxWindowMSW::WarpPointer (int x
, int y
)
631 ClientToScreen(&x
, &y
);
633 if ( !::SetCursorPos(x
, y
) )
635 wxLogLastError(_T("SetCursorPos"));
639 #if WXWIN_COMPATIBILITY
640 void wxWindowMSW::MSWDeviceToLogical (float *x
, float *y
) const
643 #endif // WXWIN_COMPATIBILITY
645 // ---------------------------------------------------------------------------
647 // ---------------------------------------------------------------------------
649 #if WXWIN_COMPATIBILITY
650 void wxWindowMSW::SetScrollRange(int orient
, int range
, bool refresh
)
652 #if defined(__WIN95__)
656 // Try to adjust the range to cope with page size > 1
657 // - a Windows API quirk
658 int pageSize
= GetScrollPage(orient
);
659 if ( pageSize
> 1 && range
> 0)
661 range1
+= (pageSize
- 1);
667 if ( orient
== wxHORIZONTAL
) {
673 info
.cbSize
= sizeof(SCROLLINFO
);
674 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
678 info
.fMask
= SIF_RANGE
| SIF_PAGE
;
680 HWND hWnd
= GetHwnd();
682 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
685 if ( orient
== wxHORIZONTAL
)
690 HWND hWnd
= GetHwnd();
692 ::SetScrollRange(hWnd
, wOrient
, 0, range
, refresh
);
696 void wxWindowMSW::SetScrollPage(int orient
, int page
, bool refresh
)
698 #if defined(__WIN95__)
702 if ( orient
== wxHORIZONTAL
) {
710 info
.cbSize
= sizeof(SCROLLINFO
);
713 info
.fMask
= SIF_PAGE
;
715 HWND hWnd
= GetHwnd();
717 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
719 if ( orient
== wxHORIZONTAL
)
726 int wxWindowMSW::OldGetScrollRange(int orient
) const
729 if ( orient
== wxHORIZONTAL
)
734 #if __WATCOMC__ && defined(__WINDOWS_386__)
735 short minPos
, maxPos
;
739 HWND hWnd
= GetHwnd();
742 ::GetScrollRange(hWnd
, wOrient
, &minPos
, &maxPos
);
743 #if defined(__WIN95__)
744 // Try to adjust the range to cope with page size > 1
745 // - a Windows API quirk
746 int pageSize
= GetScrollPage(orient
);
749 maxPos
-= (pageSize
- 1);
758 int wxWindowMSW::GetScrollPage(int orient
) const
760 if ( orient
== wxHORIZONTAL
)
766 #endif // WXWIN_COMPATIBILITY
768 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
770 #ifdef __WXMICROWIN__
771 return ::GetScrollPosWX(hWnd
, wOrient
);
773 return ::GetScrollPos(hWnd
, wOrient
);
777 int wxWindowMSW::GetScrollPos(int orient
) const
780 if ( orient
== wxHORIZONTAL
)
785 HWND hWnd
= GetHwnd();
786 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
788 return GetScrollPosition(hWnd
, wOrient
);
791 // This now returns the whole range, not just the number
792 // of positions that we can scroll.
793 int wxWindowMSW::GetScrollRange(int orient
) const
796 if ( orient
== wxHORIZONTAL
)
801 #if __WATCOMC__ && defined(__WINDOWS_386__)
802 short minPos
, maxPos
;
806 HWND hWnd
= GetHwnd();
809 ::GetScrollRange(hWnd
, wOrient
, &minPos
, &maxPos
);
810 #if defined(__WIN95__)
811 // Try to adjust the range to cope with page size > 1
812 // - a Windows API quirk
813 int pageSize
= GetScrollThumb(orient
);
816 maxPos
-= (pageSize
- 1);
818 // October 10th: new range concept.
828 int wxWindowMSW::GetScrollThumb(int orient
) const
830 if ( orient
== wxHORIZONTAL
)
836 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
838 HWND hWnd
= GetHwnd();
839 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
841 int dir
= orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
843 #if defined(__WIN95__)
845 info
.cbSize
= sizeof(SCROLLINFO
);
849 info
.fMask
= SIF_POS
;
851 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
853 ::SetScrollPos(hWnd
, dir
, pos
, refresh
);
854 #endif // __WIN95__/!__WIN95__
857 // New function that will replace some of the above.
858 void wxWindowMSW::SetScrollbar(int orient
, int pos
, int thumbVisible
,
859 int range
, bool refresh
)
861 #if defined(__WIN95__)
862 int oldRange
= range
- thumbVisible
;
864 int range1
= oldRange
;
866 // Try to adjust the range to cope with page size > 1
867 // - a Windows API quirk
868 int pageSize
= thumbVisible
;
869 if ( pageSize
> 1 && range
> 0)
871 range1
+= (pageSize
- 1);
877 if ( orient
== wxHORIZONTAL
) {
883 info
.cbSize
= sizeof(SCROLLINFO
);
884 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
888 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
890 HWND hWnd
= GetHwnd();
892 ::SetScrollInfo(hWnd
, dir
, &info
, refresh
);
895 if ( orient
== wxHORIZONTAL
)
900 HWND hWnd
= GetHwnd();
903 ::SetScrollRange(hWnd
, wOrient
, 0, range
, FALSE
);
904 ::SetScrollPos(hWnd
, wOrient
, pos
, refresh
);
907 if ( orient
== wxHORIZONTAL
) {
908 m_xThumbSize
= thumbVisible
;
910 m_yThumbSize
= thumbVisible
;
914 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
920 rect
.left
= prect
->x
;
922 rect
.right
= prect
->x
+ prect
->width
;
923 rect
.bottom
= prect
->y
+ prect
->height
;
931 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
934 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
936 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
939 for ( int n
= 0; n
< count
; n
++ )
941 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
943 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
946 // don't bother to continue, we're already at top/bottom
953 return pos
!= posStart
;
956 bool wxWindowMSW::ScrollLines(int lines
)
958 bool down
= lines
> 0;
960 return ScrollVertically(GetHwnd(),
961 down
? SB_LINEDOWN
: SB_LINEUP
,
962 down
? lines
: -lines
);
965 bool wxWindowMSW::ScrollPages(int pages
)
967 bool down
= pages
> 0;
969 return ScrollVertically(GetHwnd(),
970 down
? SB_PAGEDOWN
: SB_PAGEUP
,
971 down
? pages
: -pages
);
974 // ---------------------------------------------------------------------------
976 // ---------------------------------------------------------------------------
978 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
980 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
982 HWND hwnd
= (HWND
)hWnd
;
983 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
985 wxAssociateWinWithHandle(hwnd
, this);
987 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
989 // we don't need to subclass the window of our own class (in the Windows
990 // sense of the word)
991 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
993 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
997 // don't bother restoring it neither: this also makes it easy to
998 // implement IsOfStandardClass() method which returns TRUE for the
999 // standard controls and FALSE for the wxWindows own windows as it can
1000 // simply check m_oldWndProc
1001 m_oldWndProc
= NULL
;
1005 void wxWindowMSW::UnsubclassWin()
1007 wxRemoveHandleAssociation(this);
1009 // Restore old Window proc
1010 HWND hwnd
= GetHwnd();
1015 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1019 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1021 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
1024 m_oldWndProc
= NULL
;
1029 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1031 #if wxUSE_UNICODE_MSLU
1032 // VS: We can't use GetWindowLong(hwnd, GWL_WNDPROC) together with unicows.dll
1033 // because it doesn't return pointer to the real wnd proc but rather a handle
1034 // of a fake proc that does Unicode<->ANSI translation.
1036 // The hack bellow works, because WNDCLASS contains original window handler
1037 // rather that the unicows fake one. This may not be on purpose, though; if
1038 // it stops working with future versions of unicows.dll, we can override
1039 // unicows hooks by setting Unicows_{Set,Get}WindowLong and
1040 // Unicows_RegisterClass to our own versions that keep track of
1041 // fake<->real wnd proc mapping.
1043 // FIXME: Doesn't handle wnd procs set by SetWindowLong, only these set
1044 // with RegisterClass!!
1046 if ( wxUsingUnicowsDll() )
1048 static wxChar buffer
[512];
1051 ::GetClassName((HWND
)hWnd
, buffer
, 512);
1052 ::GetClassInfo(wxGetInstance(), buffer
, &cls
);
1053 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1058 return wndProc
== (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
1062 // ----------------------------------------------------------------------------
1064 // ----------------------------------------------------------------------------
1066 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1068 long flagsOld
= GetWindowStyleFlag();
1069 if ( flags
== flagsOld
)
1072 // update the internal variable
1073 wxWindowBase::SetWindowStyleFlag(flags
);
1075 // now update the Windows style as well if needed - and if the window had
1076 // been already created
1080 WXDWORD exstyle
, exstyleOld
;
1081 long style
= MSWGetStyle(flags
, &exstyle
),
1082 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1084 if ( style
!= styleOld
)
1086 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1087 // this function so instead of simply setting the style to the new
1088 // value we clear the bits which were set in styleOld but are set in
1089 // the new one and set the ones which were not set before
1090 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1091 styleReal
&= ~styleOld
;
1094 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1097 // and the extended style
1098 if ( exstyle
!= exstyleOld
)
1100 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1101 exstyleReal
&= ~exstyleOld
;
1102 exstyleReal
|= exstyle
;
1104 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1106 // we must call SetWindowPos() to flash the cached extended style and
1107 // also to make the change to wxSTAY_ON_TOP style take effect: just
1108 // setting the style simply doesn't work
1109 if ( !::SetWindowPos(GetHwnd(),
1110 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1113 SWP_NOMOVE
| SWP_NOSIZE
) )
1115 wxLogLastError(_T("SetWindowPos"));
1120 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1122 // translate the style
1123 WXDWORD style
= WS_CHILD
;
1125 if ( flags
& wxCLIP_CHILDREN
)
1126 style
|= WS_CLIPCHILDREN
;
1128 if ( flags
& wxCLIP_SIBLINGS
)
1129 style
|= WS_CLIPSIBLINGS
;
1131 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
1132 if ( border
!= wxBORDER_NONE
&& border
!= wxBORDER_DEFAULT
)
1135 // now deal with ext style if the caller wants it
1140 if ( flags
& wxTRANSPARENT_WINDOW
)
1141 *exstyle
|= WS_EX_TRANSPARENT
;
1143 switch ( flags
& wxBORDER_MASK
)
1146 wxFAIL_MSG( _T("unknown border style") );
1150 case wxBORDER_SIMPLE
:
1151 case wxBORDER_DEFAULT
:
1154 case wxBORDER_STATIC
:
1155 *exstyle
|= WS_EX_STATICEDGE
;
1158 case wxBORDER_RAISED
:
1159 *exstyle
|= WS_EX_WINDOWEDGE
;
1162 case wxBORDER_SUNKEN
:
1163 *exstyle
|= WS_EX_CLIENTEDGE
;
1166 case wxBORDER_DOUBLE
:
1167 *exstyle
|= WS_EX_DLGMODALFRAME
;
1171 // wxUniv doesn't use Windows dialog navigation functions at all
1172 #ifndef __WXUNIVERSAL__
1173 // to make the dialog navigation work with the nested panels we must
1174 // use this style (top level windows such as dialogs don't need it)
1175 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1177 *exstyle
|= WS_EX_CONTROLPARENT
;
1179 #endif // __WXUNIVERSAL__
1185 // Make a Windows extended style from the given wxWindows window style
1186 WXDWORD
wxWindowMSW::MakeExtendedStyle(long style
, bool eliminateBorders
)
1188 WXDWORD exStyle
= 0;
1189 if ( style
& wxTRANSPARENT_WINDOW
)
1190 exStyle
|= WS_EX_TRANSPARENT
;
1192 if ( !eliminateBorders
)
1194 if ( style
& wxSUNKEN_BORDER
)
1195 exStyle
|= WS_EX_CLIENTEDGE
;
1196 if ( style
& wxDOUBLE_BORDER
)
1197 exStyle
|= WS_EX_DLGMODALFRAME
;
1198 #if defined(__WIN95__)
1199 if ( style
& wxRAISED_BORDER
)
1200 // It seems that WS_EX_WINDOWEDGE doesn't work, but WS_EX_DLGMODALFRAME does
1201 exStyle
|= WS_EX_DLGMODALFRAME
; /* WS_EX_WINDOWEDGE */;
1202 if ( style
& wxSTATIC_BORDER
)
1203 exStyle
|= WS_EX_STATICEDGE
;
1210 // Determines whether native 3D effects or CTL3D should be used,
1211 // applying a default border style if required, and returning an extended
1212 // style to pass to CreateWindowEx.
1213 WXDWORD
wxWindowMSW::Determine3DEffects(WXDWORD defaultBorderStyle
,
1216 // If matches certain criteria, then assume no 3D effects
1217 // unless specifically requested (dealt with in MakeExtendedStyle)
1220 || !IsKindOf(CLASSINFO(wxControl
))
1221 #endif // wxUSE_CONTROLS
1222 || (m_windowStyle
& wxNO_BORDER
) )
1225 return MakeExtendedStyle(m_windowStyle
);
1228 // Determine whether we should be using 3D effects or not.
1229 bool nativeBorder
= FALSE
; // by default, we don't want a Win95 effect
1231 // 1) App can specify global 3D effects
1232 *want3D
= wxTheApp
->GetAuto3D();
1234 // 2) If the parent is being drawn with user colours, or simple border specified,
1235 // switch effects off. TODO: replace wxUSER_COLOURS with wxNO_3D
1236 if ( GetParent() && (GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS
) || (m_windowStyle
& wxSIMPLE_BORDER
) )
1239 // 3) Control can override this global setting by defining
1240 // a border style, e.g. wxSUNKEN_BORDER
1241 if ( m_windowStyle
& wxSUNKEN_BORDER
)
1244 // 4) If it's a special border, CTL3D can't cope so we want a native border
1245 if ( (m_windowStyle
& wxDOUBLE_BORDER
) || (m_windowStyle
& wxRAISED_BORDER
) ||
1246 (m_windowStyle
& wxSTATIC_BORDER
) )
1249 nativeBorder
= TRUE
;
1252 // 5) If this isn't a Win95 app, and we are using CTL3D, remove border
1253 // effects from extended style
1256 nativeBorder
= FALSE
;
1259 DWORD exStyle
= MakeExtendedStyle(m_windowStyle
, !nativeBorder
);
1261 // If we want 3D, but haven't specified a border here,
1262 // apply the default border style specified.
1263 // TODO what about non-Win95 WIN32? Does it have borders?
1264 #if defined(__WIN95__) && !wxUSE_CTL3D
1265 if ( defaultBorderStyle
&& (*want3D
) && ! ((m_windowStyle
& wxDOUBLE_BORDER
) || (m_windowStyle
& wxRAISED_BORDER
) ||
1266 (m_windowStyle
& wxSTATIC_BORDER
) || (m_windowStyle
& wxSIMPLE_BORDER
) ))
1267 exStyle
|= defaultBorderStyle
; // WS_EX_CLIENTEDGE;
1273 #if WXWIN_COMPATIBILITY
1274 // If nothing defined for this, try the parent.
1275 // E.g. we may be a button loaded from a resource, with no callback function
1277 void wxWindowMSW::OnCommand(wxWindow
& win
, wxCommandEvent
& event
)
1279 if ( GetEventHandler()->ProcessEvent(event
) )
1282 m_parent
->GetEventHandler()->OnCommand(win
, event
);
1284 #endif // WXWIN_COMPATIBILITY_2
1286 #if WXWIN_COMPATIBILITY
1287 wxObject
* wxWindowMSW::GetChild(int number
) const
1289 // Return a pointer to the Nth object in the Panel
1290 wxNode
*node
= GetChildren().First();
1293 node
= node
->Next();
1296 wxObject
*obj
= (wxObject
*)node
->Data();
1302 #endif // WXWIN_COMPATIBILITY
1304 // Setup background and foreground colours correctly
1305 void wxWindowMSW::SetupColours()
1308 SetBackgroundColour(GetParent()->GetBackgroundColour());
1311 bool wxWindowMSW::IsMouseInWindow() const
1313 // get the mouse position
1315 ::GetCursorPos(&pt
);
1317 // find the window which currently has the cursor and go up the window
1318 // chain until we find this window - or exhaust it
1319 HWND hwnd
= ::WindowFromPoint(pt
);
1320 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1321 hwnd
= ::GetParent(hwnd
);
1323 return hwnd
!= NULL
;
1326 void wxWindowMSW::OnIdle(wxIdleEvent
& WXUNUSED(event
))
1328 // Check if we need to send a LEAVE event
1329 if ( m_mouseInWindow
)
1331 // note that we should generate the leave event whether the window has
1332 // or doesn't have mouse capture
1333 if ( !IsMouseInWindow() )
1335 // Generate a LEAVE event
1336 m_mouseInWindow
= FALSE
;
1338 // Unfortunately the mouse button and keyboard state may have
1339 // changed by the time the OnIdle function is called, so 'state'
1340 // may be meaningless.
1342 if ( wxIsShiftDown() )
1344 if ( wxIsCtrlDown() )
1345 state
|= MK_CONTROL
;
1346 if ( GetKeyState( VK_LBUTTON
) )
1347 state
|= MK_LBUTTON
;
1348 if ( GetKeyState( VK_MBUTTON
) )
1349 state
|= MK_MBUTTON
;
1350 if ( GetKeyState( VK_RBUTTON
) )
1351 state
|= MK_RBUTTON
;
1354 if ( !::GetCursorPos(&pt
) )
1356 wxLogLastError(_T("GetCursorPos"));
1359 // we need to have client coordinates here for symmetry with
1360 // wxEVT_ENTER_WINDOW
1361 RECT rect
= wxGetWindowRect(GetHwnd());
1365 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1366 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1368 (void)GetEventHandler()->ProcessEvent(event2
);
1375 // Set this window to be the child of 'parent'.
1376 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1378 if ( !wxWindowBase::Reparent(parent
) )
1381 HWND hWndChild
= GetHwnd();
1382 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1384 ::SetParent(hWndChild
, hWndParent
);
1389 void wxWindowMSW::Clear()
1391 wxClientDC
dc((wxWindow
*)this);
1392 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1393 dc
.SetBackground(brush
);
1397 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1399 #ifndef __WXMICROWIN__
1400 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1404 void wxWindowMSW::Freeze()
1406 SendSetRedraw(GetHwnd(), FALSE
);
1409 void wxWindowMSW::Thaw()
1411 SendSetRedraw(GetHwnd(), TRUE
);
1413 // we need to refresh everything or otherwise he invalidated area is not
1418 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1420 HWND hWnd
= GetHwnd();
1426 mswRect
.left
= rect
->x
;
1427 mswRect
.top
= rect
->y
;
1428 mswRect
.right
= rect
->x
+ rect
->width
;
1429 mswRect
.bottom
= rect
->y
+ rect
->height
;
1431 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1434 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1438 void wxWindowMSW::Update()
1440 if ( !::UpdateWindow(GetHwnd()) )
1442 wxLogLastError(_T("UpdateWindow"));
1445 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1446 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1447 // handler needs to be really drawn right now
1452 // ---------------------------------------------------------------------------
1454 // ---------------------------------------------------------------------------
1456 #if wxUSE_DRAG_AND_DROP
1458 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1460 if ( m_dropTarget
!= 0 ) {
1461 m_dropTarget
->Revoke(m_hWnd
);
1462 delete m_dropTarget
;
1465 m_dropTarget
= pDropTarget
;
1466 if ( m_dropTarget
!= 0 )
1467 m_dropTarget
->Register(m_hWnd
);
1470 #endif // wxUSE_DRAG_AND_DROP
1472 // old style file-manager drag&drop support: we retain the old-style
1473 // DragAcceptFiles in parallel with SetDropTarget.
1474 void wxWindowMSW::DragAcceptFiles(bool accept
)
1476 HWND hWnd
= GetHwnd();
1478 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1481 // ----------------------------------------------------------------------------
1483 // ----------------------------------------------------------------------------
1487 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1489 wxWindowBase::DoSetToolTip(tooltip
);
1492 m_tooltip
->SetWindow(this);
1495 #endif // wxUSE_TOOLTIPS
1497 // ---------------------------------------------------------------------------
1498 // moving and resizing
1499 // ---------------------------------------------------------------------------
1502 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1504 RECT rect
= wxGetWindowRect(GetHwnd());
1507 *x
= rect
.right
- rect
.left
;
1509 *y
= rect
.bottom
- rect
.top
;
1512 // Get size *available for subwindows* i.e. excluding menu bar etc.
1513 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1515 RECT rect
= wxGetClientRect(GetHwnd());
1523 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1525 RECT rect
= wxGetWindowRect(GetHwnd());
1528 point
.x
= rect
.left
;
1531 // we do the adjustments with respect to the parent only for the "real"
1532 // children, not for the dialogs/frames
1533 if ( !IsTopLevel() )
1535 HWND hParentWnd
= 0;
1536 wxWindow
*parent
= GetParent();
1538 hParentWnd
= GetWinHwnd(parent
);
1540 // Since we now have the absolute screen coords, if there's a parent we
1541 // must subtract its top left corner
1544 ::ScreenToClient(hParentWnd
, &point
);
1549 // We may be faking the client origin. So a window that's really at (0,
1550 // 30) may appear (to wxWin apps) to be at (0, 0).
1551 wxPoint
pt(parent
->GetClientAreaOrigin());
1563 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1571 ::ScreenToClient(GetHwnd(), &pt
);
1579 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1587 ::ClientToScreen(GetHwnd(), &pt
);
1595 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1597 // TODO: is this consistent with other platforms?
1598 // Still, negative width or height shouldn't be allowed
1603 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1605 wxLogLastError(wxT("MoveWindow"));
1609 // set the size of the window: if the dimensions are positive, just use them,
1610 // but if any of them is equal to -1, it means that we must find the value for
1611 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1612 // which case -1 is a valid value for x and y)
1614 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1615 // the width/height to best suit our contents, otherwise we reuse the current
1617 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1619 // get the current size and position...
1620 int currentX
, currentY
;
1621 GetPosition(¤tX
, ¤tY
);
1622 int currentW
,currentH
;
1623 GetSize(¤tW
, ¤tH
);
1625 // ... and don't do anything (avoiding flicker) if it's already ok
1626 if ( x
== currentX
&& y
== currentY
&&
1627 width
== currentW
&& height
== currentH
)
1632 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1634 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1637 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1639 wxSize
size(-1, -1);
1642 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1644 size
= DoGetBestSize();
1649 // just take the current one
1656 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1660 size
= DoGetBestSize();
1662 //else: already called DoGetBestSize() above
1668 // just take the current one
1673 DoMoveWindow(x
, y
, width
, height
);
1676 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1678 // setting the client size is less obvious than it it could have been
1679 // because in the result of changing the total size the window scrollbar
1680 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1681 // will not be correct as the difference between the total and client size
1682 // changes - so we keep changing it until we get it right
1684 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1685 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1686 // may become 3 if the window had 0 size originally and so we didn't
1687 // calculate the scrollbar correction correctly during the first iteration)
1688 // but just to be on the safe side we check for it instead of making it an
1689 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1690 for ( int i
= 0; i
< 4; i
++ )
1693 ::GetClientRect(GetHwnd(), &rectClient
);
1695 // if the size is already ok, stop here (rectClient.left = top = 0)
1696 if ( (rectClient
.right
== width
|| width
== -1) &&
1697 (rectClient
.bottom
== height
|| height
== -1) )
1702 int widthClient
= width
,
1703 heightClient
= height
;
1705 // Find the difference between the entire window (title bar and all)
1706 // and the client area; add this to the new client size to move the
1709 ::GetWindowRect(GetHwnd(), &rectWin
);
1711 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1712 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1715 point
.x
= rectWin
.left
;
1716 point
.y
= rectWin
.top
;
1718 // MoveWindow positions the child windows relative to the parent, so
1719 // adjust if necessary
1720 if ( !IsTopLevel() )
1722 wxWindow
*parent
= GetParent();
1725 ::ScreenToClient(GetHwndOf(parent
), &point
);
1729 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1733 // For implementation purposes - sometimes decorations make the client area
1735 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1737 return wxPoint(0, 0);
1740 // ---------------------------------------------------------------------------
1742 // ---------------------------------------------------------------------------
1744 int wxWindowMSW::GetCharHeight() const
1746 return wxGetTextMetrics(this).tmHeight
;
1749 int wxWindowMSW::GetCharWidth() const
1751 // +1 is needed because Windows apparently adds it when calculating the
1752 // dialog units size in pixels
1753 #if wxDIALOG_UNIT_COMPATIBILITY
1754 return wxGetTextMetrics(this).tmAveCharWidth
;
1756 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1760 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1762 int *descent
, int *externalLeading
,
1763 const wxFont
*theFont
) const
1765 const wxFont
*fontToUse
= theFont
;
1767 fontToUse
= &m_font
;
1769 HWND hWnd
= GetHwnd();
1770 HDC dc
= ::GetDC(hWnd
);
1774 if ( fontToUse
&& fontToUse
->Ok() )
1776 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1778 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1783 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1784 GetTextMetrics(dc
, &tm
);
1786 if ( fontToUse
&& fnt
&& hfontOld
)
1787 SelectObject(dc
, hfontOld
);
1789 ReleaseDC(hWnd
, dc
);
1796 *descent
= tm
.tmDescent
;
1797 if ( externalLeading
)
1798 *externalLeading
= tm
.tmExternalLeading
;
1801 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1802 // ---------------------------------------------------------------------------
1803 // Caret manipulation
1804 // ---------------------------------------------------------------------------
1806 void wxWindowMSW::CreateCaret(int w
, int h
)
1808 SetCaret(new wxCaret(this, w
, h
));
1811 void wxWindowMSW::CreateCaret(const wxBitmap
*WXUNUSED(bitmap
))
1813 wxFAIL_MSG("not implemented");
1816 void wxWindowMSW::ShowCaret(bool show
)
1818 wxCHECK_RET( m_caret
, "no caret to show" );
1820 m_caret
->Show(show
);
1823 void wxWindowMSW::DestroyCaret()
1828 void wxWindowMSW::SetCaretPos(int x
, int y
)
1830 wxCHECK_RET( m_caret
, "no caret to move" );
1832 m_caret
->Move(x
, y
);
1835 void wxWindowMSW::GetCaretPos(int *x
, int *y
) const
1837 wxCHECK_RET( m_caret
, "no caret to get position of" );
1839 m_caret
->GetPosition(x
, y
);
1841 #endif // wxUSE_CARET
1843 // ---------------------------------------------------------------------------
1845 // ---------------------------------------------------------------------------
1847 #if wxUSE_MENUS_NATIVE
1849 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1850 // immediately, without waiting for the next event loop iteration
1852 // NB: this function should probably be made public later as it can almost
1853 // surely replace wxYield() elsewhere as well
1854 static void wxYieldForCommandsOnly()
1856 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1857 // want to process it here)
1859 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1860 && msg
.message
!= WM_QUIT
)
1862 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1866 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1868 menu
->SetInvokingWindow(this);
1871 HWND hWnd
= GetHwnd();
1872 HMENU hMenu
= GetHmenuOf(menu
);
1876 ::ClientToScreen(hWnd
, &point
);
1877 wxCurrentPopupMenu
= menu
;
1878 ::TrackPopupMenu(hMenu
, TPM_RIGHTBUTTON
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1880 // we need to do it righ now as otherwise the events are never going to be
1881 // sent to wxCurrentPopupMenu from HandleCommand()
1883 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1884 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1885 // destroyed as soon as we return (it can be a local variable in the caller
1886 // for example) and so we do need to process the event immediately
1887 wxYieldForCommandsOnly();
1889 wxCurrentPopupMenu
= NULL
;
1891 menu
->SetInvokingWindow(NULL
);
1896 #endif // wxUSE_MENUS_NATIVE
1898 // ===========================================================================
1899 // pre/post message processing
1900 // ===========================================================================
1902 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1905 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1907 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1910 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1912 // wxUniversal implements tab traversal itself
1913 #ifndef __WXUNIVERSAL__
1914 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1916 // intercept dialog navigation keys
1917 MSG
*msg
= (MSG
*)pMsg
;
1919 // here we try to do all the job which ::IsDialogMessage() usually does
1922 if ( msg
->message
== WM_KEYDOWN
)
1924 bool bCtrlDown
= wxIsCtrlDown();
1925 bool bShiftDown
= wxIsShiftDown();
1927 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1928 // don't process it if it's the case (except for Ctrl-Tab/Enter
1929 // combinations which are always processed)
1933 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1936 bool bForward
= TRUE
,
1937 bWindowChange
= FALSE
;
1939 // should we process this message specially?
1940 bool bProcess
= TRUE
;
1941 switch ( msg
->wParam
)
1944 // assume that nobody wants Shift-TAB for himself - if we
1945 // don't do it there is no easy way for a control to grab
1946 // TABs but still let Shift-TAB work as navugation key
1947 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1951 // Ctrl-Tab cycles thru notebook pages
1952 bWindowChange
= bCtrlDown
;
1953 bForward
= !bShiftDown
;
1959 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1967 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1973 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1975 // control wants to process Enter itself, don't
1976 // call IsDialogMessage() which would interpret
1980 else if ( lDlgCode
& DLGC_BUTTON
)
1982 // let IsDialogMessage() handle this for all
1983 // buttons except the owner-drawn ones which it
1984 // just seems to ignore
1985 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1986 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1988 // emulate the button click
1989 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1991 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1996 // FIXME: this should be handled by
1997 // wxNavigationKeyEvent handler and not here!!
2001 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
2003 if ( btn
&& btn
->IsEnabled() )
2005 // if we do have a default button, do press it
2006 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2010 else // no default button
2012 #endif // wxUSE_BUTTON
2013 // this is a quick and dirty test for a text
2015 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
2017 // don't process Enter, the control might
2018 // need it for itself and don't let
2019 // ::IsDialogMessage() have it as it can
2020 // eat the Enter events sometimes
2023 //else: treat Enter as TAB: pass to the next
2024 // control as this is the best thing to do
2025 // if the text doesn't handle Enter itself
2037 wxNavigationKeyEvent event
;
2038 event
.SetDirection(bForward
);
2039 event
.SetWindowChange(bWindowChange
);
2040 event
.SetEventObject(this);
2042 if ( GetEventHandler()->ProcessEvent(event
) )
2049 // let ::IsDialogMessage() do almost everything and handle just the
2050 // things it doesn't here: Ctrl-TAB for switching notebook pages
2051 if ( msg
->message
== WM_KEYDOWN
)
2053 // don't process system keys here
2054 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
2056 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
2058 // find the first notebook parent and change its page
2059 wxWindow
*win
= this;
2060 wxNotebook
*nbook
= NULL
;
2061 while ( win
&& !nbook
)
2063 nbook
= wxDynamicCast(win
, wxNotebook
);
2064 win
= win
->GetParent();
2069 bool forward
= !wxIsShiftDown();
2071 nbook
->AdvanceSelection(forward
);
2078 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
2079 // shouldn't let IsDialogMessage() get it as it _always_ eats the
2080 // message even when there is no cancel button and when the message is
2081 // needed by the control itself: in particular, it prevents the tree in
2082 // place edit control from being closed with Escape in a dialog
2083 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2085 // ::IsDialogMessage() can enter in an infinite loop when the
2086 // currently focused window is disabled or hidden and its parent
2087 // has WS_EX_CONTROLPARENT style, so don't call it in this case
2088 bool canSafelyCallIsDlgMsg
= TRUE
;
2090 HWND hwndFocus
= ::GetFocus();
2093 if ( !::IsWindowEnabled(hwndFocus
) ||
2094 !::IsWindowVisible(hwndFocus
) )
2096 // it would enter an infinite loop if we do this!
2097 canSafelyCallIsDlgMsg
= FALSE
;
2102 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2104 // it's a top level window, don't go further -- e.g. even
2105 // if the parent of a dialog is disabled, this doesn't
2106 // break navigation inside the dialog
2110 hwndFocus
= ::GetParent(hwndFocus
);
2113 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2115 // IsDialogMessage() did something...
2120 #endif // __WXUNIVERSAL__
2125 // relay mouse move events to the tooltip control
2126 MSG
*msg
= (MSG
*)pMsg
;
2127 if ( msg
->message
== WM_MOUSEMOVE
)
2128 m_tooltip
->RelayEvent(pMsg
);
2130 #endif // wxUSE_TOOLTIPS
2135 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2137 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2138 return m_acceleratorTable
.Translate(this, pMsg
);
2142 #endif // wxUSE_ACCEL
2145 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2147 // preprocess all messages by default
2151 // ---------------------------------------------------------------------------
2152 // message params unpackers (different for Win16 and Win32)
2153 // ---------------------------------------------------------------------------
2157 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2158 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2160 *id
= LOWORD(wParam
);
2161 *hwnd
= (WXHWND
)lParam
;
2162 *cmd
= HIWORD(wParam
);
2165 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2166 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2168 *state
= LOWORD(wParam
);
2169 *minimized
= HIWORD(wParam
);
2170 *hwnd
= (WXHWND
)lParam
;
2173 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2174 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2176 *code
= LOWORD(wParam
);
2177 *pos
= HIWORD(wParam
);
2178 *hwnd
= (WXHWND
)lParam
;
2181 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2182 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2184 #ifndef __WXMICROWIN__
2185 *nCtlColor
= CTLCOLOR_BTN
;
2186 *hwnd
= (WXHWND
)lParam
;
2187 *hdc
= (WXHDC
)wParam
;
2191 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2192 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2194 *item
= (WXWORD
)wParam
;
2195 *flags
= HIWORD(wParam
);
2196 *hmenu
= (WXHMENU
)lParam
;
2201 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2202 WXWORD
*id
, WXHWND
*hwnd
, WXWORD
*cmd
)
2204 *id
= (WXWORD
)wParam
;
2205 *hwnd
= (WXHWND
)LOWORD(lParam
);
2206 *cmd
= HIWORD(lParam
);
2209 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2210 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2212 *state
= (WXWORD
)wParam
;
2213 *minimized
= LOWORD(lParam
);
2214 *hwnd
= (WXHWND
)HIWORD(lParam
);
2217 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2218 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2220 *code
= (WXWORD
)wParam
;
2221 *pos
= LOWORD(lParam
);
2222 *hwnd
= (WXHWND
)HIWORD(lParam
);
2225 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2226 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2228 *hwnd
= (WXHWND
)LOWORD(lParam
);
2229 *nCtlColor
= (int)HIWORD(lParam
);
2230 *hdc
= (WXHDC
)wParam
;
2233 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2234 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2236 *item
= (WXWORD
)wParam
;
2237 *flags
= LOWORD(lParam
);
2238 *hmenu
= (WXHMENU
)HIWORD(lParam
);
2243 // ---------------------------------------------------------------------------
2244 // Main wxWindows window proc and the window proc for wxWindow
2245 // ---------------------------------------------------------------------------
2247 // Hook for new window just as it's being created, when the window isn't yet
2248 // associated with the handle
2249 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2251 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2252 // window being created and insures that it's always unset back later
2253 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2255 gs_winBeingCreated
= winBeingCreated
;
2258 wxWindowCreationHook::~wxWindowCreationHook()
2260 gs_winBeingCreated
= NULL
;
2264 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2266 // trace all messages - useful for the debugging
2268 wxLogTrace(wxTraceMessages
, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
2269 wxGetMessageName(message
), wParam
, lParam
);
2270 #endif // __WXDEBUG__
2272 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2274 // when we get the first message for the HWND we just created, we associate
2275 // it with wxWindow stored in gs_winBeingCreated
2276 if ( !wnd
&& gs_winBeingCreated
)
2278 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2279 wnd
= gs_winBeingCreated
;
2280 gs_winBeingCreated
= NULL
;
2281 wnd
->SetHWND((WXHWND
)hWnd
);
2287 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2289 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2294 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2296 // did we process the message?
2297 bool processed
= FALSE
;
2308 // for most messages we should return 0 when we do process the message
2316 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2319 // return 0 to allow window creation
2320 rc
.result
= mayCreate
? 0 : -1;
2326 // never set processed to TRUE and *always* pass WM_DESTROY to
2327 // DefWindowProc() as Windows may do some internal cleanup when
2328 // processing it and failing to pass the message along may cause
2329 // memory and resource leaks!
2330 (void)HandleDestroy();
2334 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2342 // we're not interested in these messages at all
2345 case SIZE_MINIMIZED
:
2346 // we shouldn't send sizev events for these messages as the
2347 // client size may be negative which breaks existing code
2349 // OTOH we might send another (wxMinimizedEvent?) one or
2350 // add an additional parameter to wxSizeEvent if this is
2351 // useful to anybody
2355 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2356 // fall through nevertheless
2358 case SIZE_MAXIMIZED
:
2360 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2365 #ifndef __WXMICROWIN__
2366 case WM_ACTIVATEAPP
:
2367 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2373 WXWORD state
, minimized
;
2375 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2377 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2382 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2386 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2390 processed
= HandlePaint();
2394 #ifdef __WXUNIVERSAL__
2395 // Universal uses its own wxFrame/wxDialog, so we don't receive
2396 // close events unless we have this.
2401 // don't let the DefWindowProc() destroy our window - we'll do it
2402 // ourselves in ~wxWindow
2409 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2413 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2414 GET_Y_LPARAM(lParam
),
2418 #if wxUSE_MOUSEWHEEL
2420 processed
= HandleMouseWheel(wParam
, lParam
);
2424 case WM_LBUTTONDOWN
:
2426 case WM_LBUTTONDBLCLK
:
2427 case WM_RBUTTONDOWN
:
2429 case WM_RBUTTONDBLCLK
:
2430 case WM_MBUTTONDOWN
:
2432 case WM_MBUTTONDBLCLK
:
2434 #ifdef __WXMICROWIN__
2435 // MicroWindows seems to ignore the fact that a window is
2436 // disabled. So catch mouse events and throw them away if
2438 wxWindowMSW
* win
= this;
2441 if (!win
->IsEnabled())
2447 win
= win
->GetParent();
2448 if ( !win
|| win
->IsTopLevel() )
2455 #endif // __WXMICROWIN__
2456 // VZ: if you find a situation when this is needed, tell
2457 // me about it, do *not* uncomment this code as it
2458 // causes other strange problems
2460 if ( message
== WM_LBUTTONDOWN
&& AcceptsFocus() )
2464 int x
= GET_X_LPARAM(lParam
),
2465 y
= GET_Y_LPARAM(lParam
);
2467 // redirect the event to a static control if necessary by
2468 // finding one under mouse
2470 if ( GetCapture() == this )
2472 // but don't do it if the mouse is captured by this window
2473 // because then it should really get this event itself
2478 win
= FindWindowForMouseEvent(this, &x
, &y
);
2481 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2490 case MM_JOY1BUTTONDOWN
:
2491 case MM_JOY2BUTTONDOWN
:
2492 case MM_JOY1BUTTONUP
:
2493 case MM_JOY2BUTTONUP
:
2494 processed
= HandleJoystickEvent(message
,
2495 GET_X_LPARAM(lParam
),
2496 GET_Y_LPARAM(lParam
),
2499 #endif // __WXMICROWIN__
2502 processed
= HandleSysCommand(wParam
, lParam
);
2509 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2511 processed
= HandleCommand(id
, cmd
, hwnd
);
2517 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2521 // for these messages we must return TRUE if process the message
2524 case WM_MEASUREITEM
:
2526 int idCtrl
= (UINT
)wParam
;
2527 if ( message
== WM_DRAWITEM
)
2529 processed
= MSWOnDrawItem(idCtrl
,
2530 (WXDRAWITEMSTRUCT
*)lParam
);
2534 processed
= MSWOnMeasureItem(idCtrl
,
2535 (WXMEASUREITEMSTRUCT
*)lParam
);
2542 #endif // defined(WM_DRAWITEM)
2545 if ( !IsOfStandardClass() )
2547 // we always want to get the char events
2548 rc
.result
= DLGC_WANTCHARS
;
2550 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2552 // in fact, we want everything
2553 rc
.result
|= DLGC_WANTARROWS
|
2560 //else: get the dlg code from the DefWindowProc()
2565 // If this has been processed by an event handler, return 0 now
2566 // (we've handled it).
2567 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2568 if ( m_lastKeydownProcessed
)
2576 // we consider these message "not interesting" to OnChar, so
2577 // just don't do anything more with them
2587 // avoid duplicate messages to OnChar for these ASCII keys:
2588 // they will be translated by TranslateMessage() and received
2610 // but set processed to FALSE, not TRUE to still pass them
2611 // to the control's default window proc - otherwise
2612 // built-in keyboard handling won't work
2618 // special case of VK_APPS: treat it the same as right mouse
2619 // click because both usually pop up a context menu
2625 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2626 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2632 // do generate a CHAR event
2633 processed
= HandleChar((WORD
)wParam
, lParam
);
2641 // special case of VK_APPS: treat it the same as right mouse button
2642 if ( wParam
== VK_APPS
)
2647 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2648 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2653 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2658 case WM_CHAR
: // Always an ASCII character
2659 if ( m_lastKeydownProcessed
)
2661 // The key was handled in the EVT_KEY_DOWN and handling
2662 // a key in an EVT_KEY_DOWN handler is meant, by
2663 // design, to prevent EVT_CHARs from happening
2664 m_lastKeydownProcessed
= FALSE
;
2669 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2678 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2680 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2686 // CTLCOLOR messages are sent by children to query the parent for their
2687 // colors#ifndef __WXMICROWIN__
2688 #ifndef __WXMICROWIN__
2690 case WM_CTLCOLORMSGBOX
:
2691 case WM_CTLCOLOREDIT
:
2692 case WM_CTLCOLORLISTBOX
:
2693 case WM_CTLCOLORBTN
:
2694 case WM_CTLCOLORDLG
:
2695 case WM_CTLCOLORSCROLLBAR
:
2696 case WM_CTLCOLORSTATIC
:
2704 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2706 processed
= HandleCtlColor(&rc
.hBrush
,
2715 #endif // !__WXMICROWIN__
2717 case WM_SYSCOLORCHANGE
:
2718 // the return value for this message is ignored
2719 processed
= HandleSysColorChange();
2722 case WM_DISPLAYCHANGE
:
2723 processed
= HandleDisplayChange();
2726 case WM_PALETTECHANGED
:
2727 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2730 case WM_CAPTURECHANGED
:
2731 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2734 case WM_QUERYNEWPALETTE
:
2735 processed
= HandleQueryNewPalette();
2739 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2742 // we processed the message, i.e. erased the background
2748 processed
= HandleDropFiles(wParam
);
2752 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2756 // we never set focus from here
2761 case WM_QUERYENDSESSION
:
2762 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2766 processed
= HandleEndSession(wParam
!= 0, lParam
);
2769 case WM_GETMINMAXINFO
:
2770 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2774 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2775 LOWORD(lParam
), // hit test
2776 HIWORD(lParam
)); // mouse msg
2780 // returning TRUE stops the DefWindowProc() from further
2781 // processing this message - exactly what we need because we've
2782 // just set the cursor.
2787 #if defined(__WIN32__) && defined(WM_HELP)
2790 HELPINFO
* info
= (HELPINFO
*) lParam
;
2791 // Don't yet process menu help events, just windows
2792 if (info
->iContextType
== HELPINFO_WINDOW
)
2794 wxWindowMSW
* subjectOfHelp
= this;
2795 bool eventProcessed
= FALSE
;
2796 while (subjectOfHelp
&& !eventProcessed
)
2798 wxHelpEvent
helpEvent(wxEVT_HELP
,
2799 subjectOfHelp
->GetId(),
2800 wxPoint(info
->MousePos
.x
,
2801 info
->MousePos
.y
) );
2802 helpEvent
.SetEventObject(this);
2804 GetEventHandler()->ProcessEvent(helpEvent
);
2806 // Go up the window hierarchy until the event is
2808 subjectOfHelp
= subjectOfHelp
->GetParent();
2811 processed
= eventProcessed
;
2813 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2815 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2816 helpEvent
.SetEventObject(this);
2817 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2820 //else: processed is already FALSE
2824 case WM_CONTEXTMENU
:
2826 // we don't convert from screen to client coordinates as
2827 // the event may be handled by a parent window
2828 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2830 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2831 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2840 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2841 wxGetMessageName(message
));
2842 #endif // __WXDEBUG__
2843 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2849 // ----------------------------------------------------------------------------
2850 // wxWindow <-> HWND map
2851 // ----------------------------------------------------------------------------
2853 wxWinHashTable
*wxWinHandleHash
= NULL
;
2855 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2857 return wxWinHandleHash
->Get((long)hWnd
);
2860 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2862 // adding NULL hWnd is (first) surely a result of an error and
2863 // (secondly) breaks menu command processing
2864 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2865 wxT("attempt to add a NULL hWnd to window list ignored") );
2867 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2869 if ( oldWin
&& (oldWin
!= win
) )
2871 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2872 hWnd
, win
->GetClassInfo()->GetClassName());
2875 #endif // __WXDEBUG__
2878 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2882 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2884 wxWinHandleHash
->Delete((long)win
->GetHWND());
2887 // ----------------------------------------------------------------------------
2888 // various MSW speciic class dependent functions
2889 // ----------------------------------------------------------------------------
2891 // Default destroyer - override if you destroy it in some other way
2892 // (e.g. with MDI child windows)
2893 void wxWindowMSW::MSWDestroyWindow()
2897 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2900 int& w
, int& h
) const
2902 static const int DEFAULT_Y
= 200;
2903 static const int DEFAULT_H
= 250;
2905 bool nonDefault
= FALSE
;
2909 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2910 // just as well set it to CW_USEDEFAULT as well
2916 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2917 // neither because it is not handled as a special value by Windows then
2918 // and so we have to choose some default value for it
2920 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2926 NB: there used to be some code here which set the initial size of the
2927 window to the client size of the parent if no explicit size was
2928 specified. This was wrong because wxWindows programs often assume
2929 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2930 it. To see why, you should understand that Windows sends WM_SIZE from
2931 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2932 from some base class ctor and so this WM_SIZE is not processed in the
2933 real class' OnSize() (because it's not fully constructed yet and the
2934 event goes to some base class OnSize() instead). So the WM_SIZE we
2935 rely on is the one sent when the parent frame resizes its children
2936 but here is the problem: if the child already has just the right
2937 size, nothing will happen as both wxWindows and Windows check for
2938 this and ignore any attempts to change the window size to the size it
2939 already has - so no WM_SIZE would be sent.
2943 // as above, h is not used at all in this case anyhow
2949 // and, again as above, we can't set the height to CW_USEDEFAULT here
2951 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2959 WXHWND
wxWindowMSW::MSWGetParent() const
2961 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
2964 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
2965 const wxChar
*title
,
2969 WXDWORD extendedStyle
)
2971 // choose the position/size for the new window
2973 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
2975 // controlId is menu handle for the top level windows, so set it to 0
2976 // unless we're creating a child window
2977 int controlId
= style
& WS_CHILD
? GetId() : 0;
2979 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2980 // which is the same but without CS_[HV]REDRAW class styles so using it
2981 // ensures that the window is not fully repainted on each resize
2982 wxString
className(wclass
);
2983 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
2985 className
+= wxT("NR");
2988 // do create the window
2989 wxWindowCreationHook
hook(this);
2991 m_hWnd
= (WXHWND
)::CreateWindowEx
2995 title
? title
: wxT(""),
2998 (HWND
)MSWGetParent(),
3001 NULL
// no extra data
3006 wxLogSysError(_("Can't create window of class %s"), wclass
);
3011 SubclassWin(m_hWnd
);
3013 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
3018 // ===========================================================================
3019 // MSW message handlers
3020 // ===========================================================================
3022 // ---------------------------------------------------------------------------
3024 // ---------------------------------------------------------------------------
3028 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3030 #ifndef __WXMICROWIN__
3031 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3032 HWND hWnd
= hdr
->hwndFrom
;
3033 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3035 // if the control is one of our windows, let it handle the message itself
3038 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3041 // VZ: why did we do it? normally this is unnecessary and, besides, it
3042 // breaks the message processing for the toolbars because the tooltip
3043 // notifications were being forwarded to the toolbar child controls
3044 // (if it had any) before being passed to the toolbar itself, so in my
3045 // example the tooltip for the combobox was always shown instead of the
3046 // correct button tooltips
3048 // try all our children
3049 wxWindowList::Node
*node
= GetChildren().GetFirst();
3052 wxWindow
*child
= node
->GetData();
3053 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3058 node
= node
->GetNext();
3062 // by default, handle it ourselves
3063 return MSWOnNotify(idCtrl
, lParam
, result
);
3064 #else // __WXMICROWIN__
3071 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3073 const wxString
& ttip
)
3075 // I don't know why it happens, but the versions of comctl32.dll starting
3076 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3077 // this message is supposed to be sent to Unicode programs only) -- hence
3078 // we need to handle it as well, otherwise no tooltips will be shown in
3081 if ( !(code
== TTN_NEEDTEXTA
|| code
== TTN_NEEDTEXTW
) || ttip
.empty() )
3083 // not a tooltip message or no tooltip to show anyhow
3087 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3089 if ( code
== TTN_NEEDTEXTA
)
3091 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3096 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3098 size_t lenAnsi
= ttip
.length();
3100 // some compilers (MetroWerks and Cygwin) don't like calling mbstowcs
3101 // with NULL argument
3102 #if defined( __MWERKS__ ) || defined( __CYGWIN__ )
3103 size_t lenUnicode
= 2*lenAnsi
;
3105 size_t lenUnicode
= mbstowcs(NULL
, ttip
, lenAnsi
);
3108 // using the pointer of right type avoids us doing all sorts of
3109 // pointer arithmetics ourselves
3110 wchar_t *dst
= (wchar_t *)ttText
->szText
,
3111 *pwz
= new wchar_t[lenUnicode
+ 1];
3112 mbstowcs(pwz
, ttip
, lenAnsi
+ 1);
3113 memcpy(dst
, pwz
, lenUnicode
*sizeof(wchar_t));
3115 // put the terminating wide NUL
3116 dst
[lenUnicode
] = L
'\0';
3119 #endif // Unicode/!Unicode
3125 #endif // wxUSE_TOOLTIPS
3127 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3129 WXLPARAM
* WXUNUSED(result
))
3134 NMHDR
* hdr
= (NMHDR
*)lParam
;
3135 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3141 #endif // wxUSE_TOOLTIPS
3148 // ---------------------------------------------------------------------------
3149 // end session messages
3150 // ---------------------------------------------------------------------------
3152 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3154 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3155 event
.SetEventObject(wxTheApp
);
3156 event
.SetCanVeto(TRUE
);
3157 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3159 bool rc
= wxTheApp
->ProcessEvent(event
);
3163 // we may end only if the app didn't veto session closing (double
3165 *mayEnd
= !event
.GetVeto();
3171 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3173 // do nothing if the session isn't ending
3178 if ( (this != wxTheApp
->GetTopWindow()) )
3181 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3182 event
.SetEventObject(wxTheApp
);
3183 event
.SetCanVeto(FALSE
);
3184 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3186 return wxTheApp
->ProcessEvent(event
);
3189 // ---------------------------------------------------------------------------
3190 // window creation/destruction
3191 // ---------------------------------------------------------------------------
3193 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3195 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3196 // parent as well as otherwise several Win32 functions using
3197 // GetNextDlgTabItem() to iterate over all controls such as
3198 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3199 // all of them iterate over all the controls starting from the focus and
3200 // stop iterating when they get back to the focus but unless all parents
3201 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3202 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3204 // there is no need to do anything for the top level windows
3205 const wxWindow
*parent
= GetParent();
3206 while ( parent
&& !parent
->IsTopLevel() )
3208 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
3209 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
3211 // force the parent to have this style
3212 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
3213 exStyle
| WS_EX_CONTROLPARENT
);
3216 parent
= parent
->GetParent();
3220 // TODO: should generate this event from WM_NCCREATE
3221 wxWindowCreateEvent
event((wxWindow
*)this);
3222 (void)GetEventHandler()->ProcessEvent(event
);
3229 bool wxWindowMSW::HandleDestroy()
3231 wxWindowDestroyEvent
event((wxWindow
*)this);
3232 (void)GetEventHandler()->ProcessEvent(event
);
3234 // delete our drop target if we've got one
3235 #if wxUSE_DRAG_AND_DROP
3236 if ( m_dropTarget
!= NULL
)
3238 m_dropTarget
->Revoke(m_hWnd
);
3240 delete m_dropTarget
;
3241 m_dropTarget
= NULL
;
3243 #endif // wxUSE_DRAG_AND_DROP
3245 // WM_DESTROY handled
3249 // ---------------------------------------------------------------------------
3251 // ---------------------------------------------------------------------------
3253 bool wxWindowMSW::HandleActivate(int state
,
3254 bool WXUNUSED(minimized
),
3255 WXHWND
WXUNUSED(activate
))
3257 wxActivateEvent
event(wxEVT_ACTIVATE
,
3258 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3260 event
.SetEventObject(this);
3262 return GetEventHandler()->ProcessEvent(event
);
3265 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3267 // notify the parent keeping track of focus for the kbd navigation
3268 // purposes that we got it
3269 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3270 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3276 m_caret
->OnSetFocus();
3278 #endif // wxUSE_CARET
3281 // If it's a wxTextCtrl don't send the event as it will be done
3282 // after the control gets to process it from EN_FOCUS handler
3283 if ( wxDynamicCastThis(wxTextCtrl
) )
3287 #endif // wxUSE_TEXTCTRL
3289 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3290 event
.SetEventObject(this);
3292 // wxFindWinFromHandle() may return NULL, it is ok
3293 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3295 return GetEventHandler()->ProcessEvent(event
);
3298 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3304 m_caret
->OnKillFocus();
3306 #endif // wxUSE_CARET
3309 // If it's a wxTextCtrl don't send the event as it will be done
3310 // after the control gets to process it.
3311 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3318 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3319 event
.SetEventObject(this);
3321 // wxFindWinFromHandle() may return NULL, it is ok
3322 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3324 return GetEventHandler()->ProcessEvent(event
);
3327 // ---------------------------------------------------------------------------
3329 // ---------------------------------------------------------------------------
3331 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3333 wxShowEvent
event(GetId(), show
);
3334 event
.m_eventObject
= this;
3336 return GetEventHandler()->ProcessEvent(event
);
3339 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3341 wxInitDialogEvent
event(GetId());
3342 event
.m_eventObject
= this;
3344 return GetEventHandler()->ProcessEvent(event
);
3347 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3349 #ifndef __WXMICROWIN__
3350 HDROP hFilesInfo
= (HDROP
) wParam
;
3352 // Get the total number of files dropped
3353 UINT gwFilesDropped
= ::DragQueryFile
3361 wxString
*files
= new wxString
[gwFilesDropped
];
3362 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3364 // first get the needed buffer length (+1 for terminating NUL)
3365 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3367 // and now get the file name
3368 ::DragQueryFile(hFilesInfo
, wIndex
,
3369 files
[wIndex
].GetWriteBuf(len
), len
);
3371 files
[wIndex
].UngetWriteBuf();
3373 DragFinish (hFilesInfo
);
3375 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3376 event
.m_eventObject
= this;
3379 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3380 event
.m_pos
.x
= dropPoint
.x
;
3381 event
.m_pos
.y
= dropPoint
.y
;
3383 return GetEventHandler()->ProcessEvent(event
);
3384 #else // __WXMICROWIN__
3389 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3391 int WXUNUSED(mouseMsg
))
3393 #ifndef __WXMICROWIN__
3394 // the logic is as follows:
3395 // -1. don't set cursor for non client area, including but not limited to
3396 // the title bar, scrollbars, &c
3397 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3398 // 1. if we have the cursor set it unless wxIsBusy()
3399 // 2. if we're a top level window, set some cursor anyhow
3400 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3402 if ( nHitTest
!= HTCLIENT
)
3407 HCURSOR hcursor
= 0;
3409 // first ask the user code - it may wish to set the cursor in some very
3410 // specific way (for example, depending on the current position)
3413 if ( !::GetCursorPos(&pt
) )
3415 wxLogLastError(wxT("GetCursorPos"));
3418 // In WIN16 it doesn't return a value.
3419 ::GetCursorPos(&pt
);
3424 ScreenToClient(&x
, &y
);
3425 wxSetCursorEvent
event(x
, y
);
3427 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3428 if ( processedEvtSetCursor
&& event
.HasCursor() )
3430 hcursor
= GetHcursorOf(event
.GetCursor());
3435 bool isBusy
= wxIsBusy();
3437 // the test for processedEvtSetCursor is here to prevent using m_cursor
3438 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3439 // it - this is a way to say that our cursor shouldn't be used for this
3441 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3443 hcursor
= GetHcursorOf(m_cursor
);
3450 hcursor
= wxGetCurrentBusyCursor();
3452 else if ( !hcursor
)
3454 const wxCursor
*cursor
= wxGetGlobalCursor();
3455 if ( cursor
&& cursor
->Ok() )
3457 hcursor
= GetHcursorOf(*cursor
);
3465 ::SetCursor(hcursor
);
3467 // cursor set, stop here
3470 #endif // __WXMICROWIN__
3472 // pass up the window chain
3476 // ---------------------------------------------------------------------------
3477 // owner drawn stuff
3478 // ---------------------------------------------------------------------------
3480 bool wxWindowMSW::MSWOnDrawItem(int id
, WXDRAWITEMSTRUCT
*itemStruct
)
3482 #if wxUSE_OWNER_DRAWN
3484 #if wxUSE_MENUS_NATIVE
3485 // is it a menu item?
3486 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3487 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3489 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3491 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3493 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3494 // the DC from being released
3495 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3496 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3497 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3498 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3500 return pMenuItem
->OnDrawItem
3504 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3505 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3508 #endif // wxUSE_MENUS_NATIVE
3511 wxWindow
*item
= FindItem(id
);
3512 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3514 return ((wxControl
*)item
)->MSWOnDraw(itemStruct
);
3516 #endif // wxUSE_CONTROLS
3518 #endif // USE_OWNER_DRAWN
3523 bool wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3525 #if wxUSE_OWNER_DRAWN
3526 // is it a menu item?
3527 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3528 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3530 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3532 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3534 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3535 &pMeasureStruct
->itemHeight
);
3538 wxWindow
*item
= FindItem(id
);
3539 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3541 return ((wxControl
*)item
)->MSWOnMeasure(itemStruct
);
3543 #endif // owner-drawn menus
3547 // ---------------------------------------------------------------------------
3548 // colours and palettes
3549 // ---------------------------------------------------------------------------
3551 bool wxWindowMSW::HandleSysColorChange()
3553 wxSysColourChangedEvent event
;
3554 event
.SetEventObject(this);
3556 (void)GetEventHandler()->ProcessEvent(event
);
3558 // always let the system carry on the default processing to allow the
3559 // native controls to react to the colours update
3563 bool wxWindowMSW::HandleDisplayChange()
3565 wxDisplayChangedEvent event
;
3566 event
.SetEventObject(this);
3568 return GetEventHandler()->ProcessEvent(event
);
3571 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3579 #ifndef __WXMICROWIN__
3580 WXHBRUSH hBrush
= 0;
3582 if ( nCtlColor
== CTLCOLOR_DLG
)
3584 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3589 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3591 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3593 #endif // wxUSE_CONTROLS
3599 #else // __WXMICROWIN__
3604 // Define for each class of dialog and control
3605 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3606 WXHWND
WXUNUSED(hWnd
),
3607 WXUINT
WXUNUSED(nCtlColor
),
3608 WXUINT
WXUNUSED(message
),
3609 WXWPARAM
WXUNUSED(wParam
),
3610 WXLPARAM
WXUNUSED(lParam
))
3615 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3618 // same as below except we don't respond to our own messages
3619 if ( hWndPalChange
!= GetHWND() )
3621 // check to see if we our our parents have a custom palette
3622 wxWindowMSW
*win
= this;
3623 while ( win
&& !win
->HasCustomPalette() )
3625 win
= win
->GetParent();
3628 if ( win
&& win
->HasCustomPalette() )
3630 // realize the palette to see whether redrawing is needed
3631 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3632 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3633 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3635 int result
= ::RealizePalette(hdc
);
3637 // restore the palette (before releasing the DC)
3638 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3639 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3640 ::RealizePalette(hdc
);
3641 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3643 // now check for the need to redraw
3645 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3649 #endif // wxUSE_PALETTE
3651 wxPaletteChangedEvent
event(GetId());
3652 event
.SetEventObject(this);
3653 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3655 return GetEventHandler()->ProcessEvent(event
);
3658 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3660 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3661 event
.SetEventObject(this);
3663 return GetEventHandler()->ProcessEvent(event
);
3666 bool wxWindowMSW::HandleQueryNewPalette()
3670 // check to see if we our our parents have a custom palette
3671 wxWindowMSW
*win
= this;
3672 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3673 if (win
->HasCustomPalette()) {
3674 /* realize the palette to see whether redrawing is needed */
3675 HDC hdc
= GetDC((HWND
) GetHWND());
3676 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3677 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3679 int result
= ::RealizePalette(hdc
);
3680 /* restore the palette (before releasing the DC) */
3681 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3682 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3683 ::RealizePalette(hdc
);
3684 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3685 /* now check for the need to redraw */
3687 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3689 #endif // wxUSE_PALETTE
3691 wxQueryNewPaletteEvent
event(GetId());
3692 event
.SetEventObject(this);
3694 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3697 // Responds to colour changes: passes event on to children.
3698 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3700 // the top level window also reset the standard colour map as it might have
3701 // changed (there is no need to do it for the non top level windows as we
3702 // only have to do it once)
3706 gs_hasStdCmap
= FALSE
;
3708 wxWindowList::Node
*node
= GetChildren().GetFirst();
3711 // Only propagate to non-top-level windows because Windows already
3712 // sends this event to all top-level ones
3713 wxWindow
*win
= node
->GetData();
3714 if ( !win
->IsTopLevel() )
3716 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3717 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3718 // the standard controls
3719 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3722 node
= node
->GetNext();
3725 // update the colours we use if they were not set explicitly by the user:
3726 // this must be done or OnCtlColor() would continue to use the old colours
3729 m_foregroundColour
= wxSystemSettings::
3730 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3735 m_backgroundColour
= wxSystemSettings::
3736 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3740 extern wxCOLORMAP
*wxGetStdColourMap()
3742 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3743 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3745 if ( !gs_hasStdCmap
)
3747 static bool s_coloursInit
= FALSE
;
3749 if ( !s_coloursInit
)
3751 // When a bitmap is loaded, the RGB values can change (apparently
3752 // because Windows adjusts them to care for the old programs always
3753 // using 0xc0c0c0 while the transparent colour for the new Windows
3754 // versions is different). But we do this adjustment ourselves so
3755 // we want to avoid Windows' "help" and for this we need to have a
3756 // reference bitmap which can tell us what the RGB values change
3758 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3759 if ( stdColourBitmap
.Ok() )
3761 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3762 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3763 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3766 memDC
.SelectObject(stdColourBitmap
);
3769 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3771 memDC
.GetPixel(i
, 0, &colour
);
3772 s_stdColours
[i
] = wxColourToRGB(colour
);
3775 else // wxBITMAP_STD_COLOURS couldn't be loaded
3777 s_stdColours
[0] = RGB(000,000,000); // black
3778 s_stdColours
[1] = RGB(128,128,128); // dark grey
3779 s_stdColours
[2] = RGB(192,192,192); // light grey
3780 s_stdColours
[3] = RGB(255,255,255); // white
3781 //s_stdColours[4] = RGB(000,000,255); // blue
3782 //s_stdColours[5] = RGB(255,000,255); // magenta
3785 s_coloursInit
= TRUE
;
3788 gs_hasStdCmap
= TRUE
;
3790 // create the colour map
3791 #define INIT_CMAP_ENTRY(col) \
3792 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3793 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3795 INIT_CMAP_ENTRY(BTNTEXT
);
3796 INIT_CMAP_ENTRY(BTNSHADOW
);
3797 INIT_CMAP_ENTRY(BTNFACE
);
3798 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3800 #undef INIT_CMAP_ENTRY
3806 // ---------------------------------------------------------------------------
3808 // ---------------------------------------------------------------------------
3810 bool wxWindowMSW::HandlePaint()
3813 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3815 wxLogLastError(wxT("CreateRectRgn"));
3816 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3817 wxLogLastError(wxT("GetUpdateRgn"));
3819 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3822 ::GetUpdateRect(GetHwnd(), &updateRect
, FALSE
);
3824 m_updateRegion
= wxRegion(updateRect
.left
, updateRect
.top
,
3825 updateRect
.right
- updateRect
.left
,
3826 updateRect
.bottom
- updateRect
.top
);
3829 wxPaintEvent
event(m_windowId
);
3830 event
.SetEventObject(this);
3832 bool processed
= GetEventHandler()->ProcessEvent(event
);
3834 // note that we must generate NC event after the normal one as otherwise
3835 // BeginPaint() will happily overwrite our decorations with the background
3837 wxNcPaintEvent
eventNc(m_windowId
);
3838 eventNc
.SetEventObject(this);
3839 GetEventHandler()->ProcessEvent(eventNc
);
3844 // Can be called from an application's OnPaint handler
3845 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3847 #ifdef __WXUNIVERSAL__
3850 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3853 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3858 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3860 // Prevents flicker when dragging
3861 if ( ::IsIconic(GetHwnd()) )
3867 dc
.SetWindow((wxWindow
*)this);
3870 wxEraseEvent
event(m_windowId
, &dc
);
3871 event
.SetEventObject(this);
3872 bool rc
= GetEventHandler()->ProcessEvent(event
);
3876 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3877 dc
.SelectOldObjects(hdc
);
3882 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3885 ::GetClientRect(GetHwnd(), &rect
);
3887 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3888 m_backgroundColour
.Green(),
3889 m_backgroundColour
.Blue());
3890 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3892 wxLogLastError(wxT("CreateSolidBrush"));
3894 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
3896 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
3898 ::FillRect(hdc
, &rect
, hBrush
);
3899 ::DeleteObject(hBrush
);
3900 ::SetMapMode(hdc
, mode
);
3903 // ---------------------------------------------------------------------------
3904 // moving and resizing
3905 // ---------------------------------------------------------------------------
3907 bool wxWindowMSW::HandleMinimize()
3909 wxIconizeEvent
event(m_windowId
);
3910 event
.SetEventObject(this);
3912 return GetEventHandler()->ProcessEvent(event
);
3915 bool wxWindowMSW::HandleMaximize()
3917 wxMaximizeEvent
event(m_windowId
);
3918 event
.SetEventObject(this);
3920 return GetEventHandler()->ProcessEvent(event
);
3923 bool wxWindowMSW::HandleMove(int x
, int y
)
3925 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
3926 event
.SetEventObject(this);
3928 return GetEventHandler()->ProcessEvent(event
);
3931 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
3932 WXUINT
WXUNUSED(flag
))
3934 // don't use w and h parameters as they specify the client size while
3935 // according to the docs EVT_SIZE handler is supposed to receive the total
3937 wxSizeEvent
event(GetSize(), m_windowId
);
3938 event
.SetEventObject(this);
3940 return GetEventHandler()->ProcessEvent(event
);
3943 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
3945 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
3949 int minWidth
= GetMinWidth(),
3950 minHeight
= GetMinHeight(),
3951 maxWidth
= GetMaxWidth(),
3952 maxHeight
= GetMaxHeight();
3954 if ( minWidth
!= -1 )
3956 info
->ptMinTrackSize
.x
= minWidth
;
3960 if ( minHeight
!= -1 )
3962 info
->ptMinTrackSize
.y
= minHeight
;
3966 if ( maxWidth
!= -1 )
3968 info
->ptMaxTrackSize
.x
= maxWidth
;
3972 if ( maxHeight
!= -1 )
3974 info
->ptMaxTrackSize
.y
= maxHeight
;
3981 // ---------------------------------------------------------------------------
3983 // ---------------------------------------------------------------------------
3985 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
3987 #if wxUSE_MENUS_NATIVE
3988 if ( !cmd
&& wxCurrentPopupMenu
)
3990 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
3991 wxCurrentPopupMenu
= NULL
;
3993 return popupMenu
->MSWCommand(cmd
, id
);
3995 #endif // wxUSE_MENUS_NATIVE
3997 wxWindow
*win
= NULL
;
3999 // first try to find it from HWND - this works even with the broken
4000 // programs using the same ids for different controls
4003 win
= wxFindWinFromHandle(control
);
4009 // must cast to a signed type before comparing with other ids!
4010 win
= FindItem((signed short)id
);
4015 return win
->MSWCommand(cmd
, id
);
4018 // the messages sent from the in-place edit control used by the treectrl
4019 // for label editing have id == 0, but they should _not_ be treated as menu
4020 // messages (they are EN_XXX ones, in fact) so don't translate anything
4021 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4024 // If no child window, it may be an accelerator, e.g. for a popup menu
4027 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4028 event
.SetEventObject(this);
4032 return GetEventHandler()->ProcessEvent(event
);
4034 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4037 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4038 // notifications to its parent which we want to reflect back to
4040 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4041 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4044 #endif // wxUSE_SPINCTRL
4049 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4051 // 4 bits are reserved
4052 switch ( wParam
& 0xFFFFFFF0 )
4055 return HandleMaximize();
4058 return HandleMinimize();
4064 // ---------------------------------------------------------------------------
4066 // ---------------------------------------------------------------------------
4068 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4072 // our client coords are not quite the same as Windows ones
4073 wxPoint pt
= GetClientAreaOrigin();
4074 event
.m_x
= x
- pt
.x
;
4075 event
.m_y
= y
- pt
.y
;
4077 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4078 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4079 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4080 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4081 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4082 event
.m_altDown
= (::GetKeyState(VK_MENU
) & 0x80000000) != 0;
4084 event
.SetTimestamp(s_currentMsg
.time
);
4085 event
.m_eventObject
= this;
4086 event
.SetId(GetId());
4088 #if wxUSE_MOUSEEVENT_HACK
4091 m_lastMouseEvent
= event
.GetEventType();
4092 #endif // wxUSE_MOUSEEVENT_HACK
4095 // Windows doesn't send the mouse events to the static controls (which are
4096 // transparent in the sense that their WM_NCHITTEST handler returns
4097 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4098 // and so we manually check if we don't have a child window under mouse and if
4099 // we do, send the event to it instead of the window Windows had sent WM_XXX
4102 // Notice that this is not done for the mouse move events because this could
4103 // (would?) be too slow, but only for clicks which means that the static texts
4104 // still don't get move, enter nor leave events.
4105 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4107 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4109 // first try to find a non transparent child: this allows us to send events
4110 // to a static text which is inside a static box, for example
4111 POINT pt
= { *x
, *y
};
4112 HWND hwnd
= GetHwndOf(win
),
4116 hwndUnderMouse
= ::ChildWindowFromPointEx
4125 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4128 // now try any child window at all
4129 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4132 // check that we have a child window which is susceptible to receive mouse
4133 // events: for this it must be shown and enabled
4134 if ( hwndUnderMouse
&&
4135 hwndUnderMouse
!= hwnd
&&
4136 ::IsWindowVisible(hwndUnderMouse
) &&
4137 ::IsWindowEnabled(hwndUnderMouse
) )
4139 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4140 if ( winUnderMouse
)
4142 // translate the mouse coords to the other window coords
4143 win
->ClientToScreen(x
, y
);
4144 winUnderMouse
->ScreenToClient(x
, y
);
4146 win
= winUnderMouse
;
4153 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4155 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4156 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4157 // from the message id and take the value in the table to get wxWin event
4159 static const wxEventType eventsMouse
[] =
4173 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4174 InitMouseEvent(event
, x
, y
, flags
);
4176 return GetEventHandler()->ProcessEvent(event
);
4179 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4181 if ( !m_mouseInWindow
)
4183 // it would be wrong to assume that just because we get a mouse move
4184 // event that the mouse is inside the window: although this is usually
4185 // true, it is not if we had captured the mouse, so we need to check
4186 // the mouse coordinates here
4187 if ( !HasCapture() || IsMouseInWindow() )
4189 // Generate an ENTER event
4190 m_mouseInWindow
= TRUE
;
4192 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4193 InitMouseEvent(event
, x
, y
, flags
);
4195 (void)GetEventHandler()->ProcessEvent(event
);
4199 #if wxUSE_MOUSEEVENT_HACK
4200 // Window gets a click down message followed by a mouse move message even
4201 // if position isn't changed! We want to discard the trailing move event
4202 // if x and y are the same.
4203 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4204 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4205 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4206 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4208 m_lastMouseEvent
= wxEVT_MOTION
;
4212 #endif // wxUSE_MOUSEEVENT_HACK
4214 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4218 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4220 #if wxUSE_MOUSEWHEEL
4221 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4222 InitMouseEvent(event
,
4223 GET_X_LPARAM(lParam
),
4224 GET_Y_LPARAM(lParam
),
4226 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4227 event
.m_wheelDelta
= WHEEL_DELTA
;
4230 static int s_linesPerRotation
= -1;
4231 if ( s_linesPerRotation
== -1 )
4233 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4234 &s_linesPerRotation
, 0))
4236 // this is not supposed to happen
4237 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4239 // the default is 3, so use it if SystemParametersInfo() failed
4240 s_linesPerRotation
= 3;
4244 // no SystemParametersInfo() under Win16
4245 static const int s_linesPerRotation
= 3;
4248 event
.m_linesPerAction
= s_linesPerRotation
;
4249 return GetEventHandler()->ProcessEvent(event
);
4260 // ---------------------------------------------------------------------------
4261 // keyboard handling
4262 // ---------------------------------------------------------------------------
4264 // create the key event of the given type for the given key - used by
4265 // HandleChar and HandleKeyDown/Up
4266 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4269 WXWPARAM wParam
) const
4271 wxKeyEvent
event(evType
);
4272 event
.SetId(GetId());
4273 event
.m_shiftDown
= wxIsShiftDown();
4274 event
.m_controlDown
= wxIsCtrlDown();
4275 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4277 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4278 event
.m_keyCode
= id
;
4279 event
.m_rawCode
= (wxUint32
) wParam
;
4280 event
.m_rawFlags
= (wxUint32
) lParam
;
4281 event
.SetTimestamp(s_currentMsg
.time
);
4283 // translate the position to client coords
4287 GetWindowRect(GetHwnd(),&rect
);
4297 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4299 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4301 bool ctrlDown
= FALSE
;
4306 // If 1 -> 26, translate to CTRL plus a letter.
4308 if ( (id
> 0) && (id
< 27) )
4330 else // we're called from WM_KEYDOWN
4332 id
= wxCharCodeMSWToWX(wParam
);
4335 // it's ASCII and will be processed here only when called from
4336 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4341 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4344 event
.m_controlDown
= TRUE
;
4347 return GetEventHandler()->ProcessEvent(event
);
4350 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4352 int id
= wxCharCodeMSWToWX(wParam
);
4356 // normal ASCII char
4360 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4362 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4363 if ( GetEventHandler()->ProcessEvent(event
) )
4372 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4374 int id
= wxCharCodeMSWToWX(wParam
);
4378 // normal ASCII char
4382 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4384 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4385 if ( GetEventHandler()->ProcessEvent(event
) )
4392 // ---------------------------------------------------------------------------
4394 // ---------------------------------------------------------------------------
4396 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4400 if ( flags
& JOY_BUTTON1CHG
)
4401 change
= wxJOY_BUTTON1
;
4402 if ( flags
& JOY_BUTTON2CHG
)
4403 change
= wxJOY_BUTTON2
;
4404 if ( flags
& JOY_BUTTON3CHG
)
4405 change
= wxJOY_BUTTON3
;
4406 if ( flags
& JOY_BUTTON4CHG
)
4407 change
= wxJOY_BUTTON4
;
4410 if ( flags
& JOY_BUTTON1
)
4411 buttons
|= wxJOY_BUTTON1
;
4412 if ( flags
& JOY_BUTTON2
)
4413 buttons
|= wxJOY_BUTTON2
;
4414 if ( flags
& JOY_BUTTON3
)
4415 buttons
|= wxJOY_BUTTON3
;
4416 if ( flags
& JOY_BUTTON4
)
4417 buttons
|= wxJOY_BUTTON4
;
4419 // the event ids aren't consecutive so we can't use table based lookup
4421 wxEventType eventType
;
4426 eventType
= wxEVT_JOY_MOVE
;
4431 eventType
= wxEVT_JOY_MOVE
;
4436 eventType
= wxEVT_JOY_ZMOVE
;
4441 eventType
= wxEVT_JOY_ZMOVE
;
4444 case MM_JOY1BUTTONDOWN
:
4446 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4449 case MM_JOY2BUTTONDOWN
:
4451 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4454 case MM_JOY1BUTTONUP
:
4456 eventType
= wxEVT_JOY_BUTTON_UP
;
4459 case MM_JOY2BUTTONUP
:
4461 eventType
= wxEVT_JOY_BUTTON_UP
;
4465 wxFAIL_MSG(wxT("no such joystick event"));
4470 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4471 event
.SetPosition(wxPoint(x
, y
));
4472 event
.SetEventObject(this);
4474 return GetEventHandler()->ProcessEvent(event
);
4480 // ---------------------------------------------------------------------------
4482 // ---------------------------------------------------------------------------
4484 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4485 WXWORD pos
, WXHWND control
)
4489 wxWindow
*child
= wxFindWinFromHandle(control
);
4491 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4494 wxScrollWinEvent event
;
4495 event
.SetPosition(pos
);
4496 event
.SetOrientation(orientation
);
4497 event
.m_eventObject
= this;
4502 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4506 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4510 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4514 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4518 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4522 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4525 case SB_THUMBPOSITION
:
4528 // under Win32, the scrollbar range and position are 32 bit integers,
4529 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4530 // explicitly query the scrollbar for the correct position (this must
4531 // be done only for these two SB_ events as they are the only one
4532 // carrying the scrollbar position)
4534 SCROLLINFO scrollInfo
;
4535 wxZeroMemory(scrollInfo
);
4536 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
4537 scrollInfo
.fMask
= SIF_TRACKPOS
;
4539 if ( !::GetScrollInfo(GetHwnd(),
4540 orientation
== wxHORIZONTAL
? SB_HORZ
4544 wxLogLastError(_T("GetScrollInfo"));
4547 event
.SetPosition(scrollInfo
.nTrackPos
);
4551 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4552 ? wxEVT_SCROLLWIN_THUMBRELEASE
4553 : wxEVT_SCROLLWIN_THUMBTRACK
;
4560 return GetEventHandler()->ProcessEvent(event
);
4563 // ===========================================================================
4565 // ===========================================================================
4567 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4570 HDC dc
= ::GetDC((HWND
) wnd
);
4575 // the_font->UseResource();
4576 // the_font->RealizeResource();
4577 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4579 was
= (HFONT
) SelectObject(dc
,fnt
);
4581 GetTextMetrics(dc
, &tm
);
4582 if ( the_font
&& fnt
&& was
)
4584 SelectObject(dc
,was
);
4586 ReleaseDC((HWND
)wnd
, dc
);
4589 *x
= tm
.tmAveCharWidth
;
4591 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4594 // the_font->ReleaseResource();
4597 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4598 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4599 int wxCharCodeMSWToWX(int keySym
)
4604 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4605 case VK_BACK
: id
= WXK_BACK
; break;
4606 case VK_TAB
: id
= WXK_TAB
; break;
4607 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4608 case VK_RETURN
: id
= WXK_RETURN
; break;
4609 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4610 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4611 case VK_MENU
: id
= WXK_MENU
; break;
4612 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4613 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4614 case VK_SPACE
: id
= WXK_SPACE
; break;
4615 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4616 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4617 case VK_NEXT
: id
= WXK_NEXT
; break;
4618 case VK_END
: id
= WXK_END
; break;
4619 case VK_HOME
: id
= WXK_HOME
; break;
4620 case VK_LEFT
: id
= WXK_LEFT
; break;
4621 case VK_UP
: id
= WXK_UP
; break;
4622 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4623 case VK_DOWN
: id
= WXK_DOWN
; break;
4624 case VK_SELECT
: id
= WXK_SELECT
; break;
4625 case VK_PRINT
: id
= WXK_PRINT
; break;
4626 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4627 case VK_INSERT
: id
= WXK_INSERT
; break;
4628 case VK_DELETE
: id
= WXK_DELETE
; break;
4629 case VK_HELP
: id
= WXK_HELP
; break;
4630 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4631 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4632 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4633 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4634 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4635 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4636 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4637 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4638 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4639 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4640 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4641 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4642 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4643 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4644 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4645 case VK_F1
: id
= WXK_F1
; break;
4646 case VK_F2
: id
= WXK_F2
; break;
4647 case VK_F3
: id
= WXK_F3
; break;
4648 case VK_F4
: id
= WXK_F4
; break;
4649 case VK_F5
: id
= WXK_F5
; break;
4650 case VK_F6
: id
= WXK_F6
; break;
4651 case VK_F7
: id
= WXK_F7
; break;
4652 case VK_F8
: id
= WXK_F8
; break;
4653 case VK_F9
: id
= WXK_F9
; break;
4654 case VK_F10
: id
= WXK_F10
; break;
4655 case VK_F11
: id
= WXK_F11
; break;
4656 case VK_F12
: id
= WXK_F12
; break;
4657 case VK_F13
: id
= WXK_F13
; break;
4658 case VK_F14
: id
= WXK_F14
; break;
4659 case VK_F15
: id
= WXK_F15
; break;
4660 case VK_F16
: id
= WXK_F16
; break;
4661 case VK_F17
: id
= WXK_F17
; break;
4662 case VK_F18
: id
= WXK_F18
; break;
4663 case VK_F19
: id
= WXK_F19
; break;
4664 case VK_F20
: id
= WXK_F20
; break;
4665 case VK_F21
: id
= WXK_F21
; break;
4666 case VK_F22
: id
= WXK_F22
; break;
4667 case VK_F23
: id
= WXK_F23
; break;
4668 case VK_F24
: id
= WXK_F24
; break;
4669 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4670 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4672 case VK_OEM_1
: id
= ';'; break;
4673 case VK_OEM_PLUS
: id
= '+'; break;
4674 case VK_OEM_COMMA
: id
= ','; break;
4675 case VK_OEM_MINUS
: id
= '-'; break;
4676 case VK_OEM_PERIOD
: id
= '.'; break;
4677 case VK_OEM_2
: id
= '/'; break;
4678 case VK_OEM_3
: id
= '~'; break;
4679 case VK_OEM_4
: id
= '['; break;
4680 case VK_OEM_5
: id
= '\\'; break;
4681 case VK_OEM_6
: id
= ']'; break;
4682 case VK_OEM_7
: id
= '\''; break;
4691 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4697 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4698 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4699 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4700 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4701 case WXK_MENU
: keySym
= VK_MENU
; break;
4702 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4703 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4704 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4705 case WXK_END
: keySym
= VK_END
; break;
4706 case WXK_HOME
: keySym
= VK_HOME
; break;
4707 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4708 case WXK_UP
: keySym
= VK_UP
; break;
4709 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4710 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4711 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4712 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4713 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4714 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4715 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4716 case WXK_HELP
: keySym
= VK_HELP
; break;
4717 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4718 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4719 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4720 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4721 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4722 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4723 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4724 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4725 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4726 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4727 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4728 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4729 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4730 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4731 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4732 case WXK_F1
: keySym
= VK_F1
; break;
4733 case WXK_F2
: keySym
= VK_F2
; break;
4734 case WXK_F3
: keySym
= VK_F3
; break;
4735 case WXK_F4
: keySym
= VK_F4
; break;
4736 case WXK_F5
: keySym
= VK_F5
; break;
4737 case WXK_F6
: keySym
= VK_F6
; break;
4738 case WXK_F7
: keySym
= VK_F7
; break;
4739 case WXK_F8
: keySym
= VK_F8
; break;
4740 case WXK_F9
: keySym
= VK_F9
; break;
4741 case WXK_F10
: keySym
= VK_F10
; break;
4742 case WXK_F11
: keySym
= VK_F11
; break;
4743 case WXK_F12
: keySym
= VK_F12
; break;
4744 case WXK_F13
: keySym
= VK_F13
; break;
4745 case WXK_F14
: keySym
= VK_F14
; break;
4746 case WXK_F15
: keySym
= VK_F15
; break;
4747 case WXK_F16
: keySym
= VK_F16
; break;
4748 case WXK_F17
: keySym
= VK_F17
; break;
4749 case WXK_F18
: keySym
= VK_F18
; break;
4750 case WXK_F19
: keySym
= VK_F19
; break;
4751 case WXK_F20
: keySym
= VK_F20
; break;
4752 case WXK_F21
: keySym
= VK_F21
; break;
4753 case WXK_F22
: keySym
= VK_F22
; break;
4754 case WXK_F23
: keySym
= VK_F23
; break;
4755 case WXK_F24
: keySym
= VK_F24
; break;
4756 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4757 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4768 wxWindow
*wxGetActiveWindow()
4770 HWND hWnd
= GetActiveWindow();
4773 return wxFindWinFromHandle((WXHWND
) hWnd
);
4778 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4780 HWND hwnd
= (HWND
)hWnd
;
4782 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4783 // by code in msw/radiobox.cpp), for all the others we just search up the
4785 wxWindow
*win
= (wxWindow
*)NULL
;
4788 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4791 // all these hacks only work under Win32 anyhow
4795 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4796 // wxWindow class which overrides WM_GETDLGCODE processing to
4797 // do it as well, win would be already non NULL
4798 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
4800 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
4802 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4803 #endif // wxUSE_RADIOBOX
4805 // spin control text buddy window should be mapped to spin ctrl
4806 // itself so try it too
4807 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4810 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
4812 #endif // wxUSE_SPINCTRL
4818 while ( hwnd
&& !win
)
4820 // this is a really ugly hack needed to avoid mistakenly returning the
4821 // parent frame wxWindow for the find/replace modeless dialog HWND -
4822 // this, in turn, is needed to call IsDialogMessage() from
4823 // wxApp::ProcessMessage() as for this we must return NULL from here
4825 // FIXME: this is clearly not the best way to do it but I think we'll
4826 // need to change HWND <-> wxWindow code more heavily than I can
4827 // do it now to fix it
4828 #ifndef __WXMICROWIN__
4829 if ( ::GetWindow(hwnd
, GW_OWNER
) )
4831 // it's a dialog box, don't go upwards
4836 hwnd
= ::GetParent(hwnd
);
4837 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4843 #ifndef __WXMICROWIN__
4845 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4846 // in active frames and dialogs, regardless of where the focus is.
4847 static HHOOK wxTheKeyboardHook
= 0;
4848 static FARPROC wxTheKeyboardHookProc
= 0;
4849 int APIENTRY _EXPORT
4850 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
4852 void wxSetKeyboardHook(bool doIt
)
4856 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
4857 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
4859 #if defined(__WIN32__) && !defined(__TWIN32__)
4860 GetCurrentThreadId()
4861 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4869 UnhookWindowsHookEx(wxTheKeyboardHook
);
4871 // avoids warning about statement with no effect (FreeProcInstance
4872 // doesn't do anything under Win32)
4873 #if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32__) && !defined(__NT__) && !defined(__GNUWIN32__)
4874 FreeProcInstance(wxTheKeyboardHookProc
);
4879 int APIENTRY _EXPORT
4880 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
4882 DWORD hiWord
= HIWORD(lParam
);
4883 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
4885 int id
= wxCharCodeMSWToWX(wParam
);
4888 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
4889 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
4890 event
.m_altDown
= TRUE
;
4892 event
.m_eventObject
= NULL
;
4893 event
.m_keyCode
= id
;
4894 event
.m_shiftDown
= wxIsShiftDown();
4895 event
.m_controlDown
= wxIsCtrlDown();
4896 event
.SetTimestamp(s_currentMsg
.time
);
4898 wxWindow
*win
= wxGetActiveWindow();
4899 wxEvtHandler
*handler
;
4902 handler
= win
->GetEventHandler();
4903 event
.SetId(win
->GetId());
4911 if ( handler
&& handler
->ProcessEvent(event
) )
4919 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
4922 #endif // !__WXMICROWIN__
4925 const char *wxGetMessageName(int message
)
4929 case 0x0000: return "WM_NULL";
4930 case 0x0001: return "WM_CREATE";
4931 case 0x0002: return "WM_DESTROY";
4932 case 0x0003: return "WM_MOVE";
4933 case 0x0005: return "WM_SIZE";
4934 case 0x0006: return "WM_ACTIVATE";
4935 case 0x0007: return "WM_SETFOCUS";
4936 case 0x0008: return "WM_KILLFOCUS";
4937 case 0x000A: return "WM_ENABLE";
4938 case 0x000B: return "WM_SETREDRAW";
4939 case 0x000C: return "WM_SETTEXT";
4940 case 0x000D: return "WM_GETTEXT";
4941 case 0x000E: return "WM_GETTEXTLENGTH";
4942 case 0x000F: return "WM_PAINT";
4943 case 0x0010: return "WM_CLOSE";
4944 case 0x0011: return "WM_QUERYENDSESSION";
4945 case 0x0012: return "WM_QUIT";
4946 case 0x0013: return "WM_QUERYOPEN";
4947 case 0x0014: return "WM_ERASEBKGND";
4948 case 0x0015: return "WM_SYSCOLORCHANGE";
4949 case 0x0016: return "WM_ENDSESSION";
4950 case 0x0017: return "WM_SYSTEMERROR";
4951 case 0x0018: return "WM_SHOWWINDOW";
4952 case 0x0019: return "WM_CTLCOLOR";
4953 case 0x001A: return "WM_WININICHANGE";
4954 case 0x001B: return "WM_DEVMODECHANGE";
4955 case 0x001C: return "WM_ACTIVATEAPP";
4956 case 0x001D: return "WM_FONTCHANGE";
4957 case 0x001E: return "WM_TIMECHANGE";
4958 case 0x001F: return "WM_CANCELMODE";
4959 case 0x0020: return "WM_SETCURSOR";
4960 case 0x0021: return "WM_MOUSEACTIVATE";
4961 case 0x0022: return "WM_CHILDACTIVATE";
4962 case 0x0023: return "WM_QUEUESYNC";
4963 case 0x0024: return "WM_GETMINMAXINFO";
4964 case 0x0026: return "WM_PAINTICON";
4965 case 0x0027: return "WM_ICONERASEBKGND";
4966 case 0x0028: return "WM_NEXTDLGCTL";
4967 case 0x002A: return "WM_SPOOLERSTATUS";
4968 case 0x002B: return "WM_DRAWITEM";
4969 case 0x002C: return "WM_MEASUREITEM";
4970 case 0x002D: return "WM_DELETEITEM";
4971 case 0x002E: return "WM_VKEYTOITEM";
4972 case 0x002F: return "WM_CHARTOITEM";
4973 case 0x0030: return "WM_SETFONT";
4974 case 0x0031: return "WM_GETFONT";
4975 case 0x0037: return "WM_QUERYDRAGICON";
4976 case 0x0039: return "WM_COMPAREITEM";
4977 case 0x0041: return "WM_COMPACTING";
4978 case 0x0044: return "WM_COMMNOTIFY";
4979 case 0x0046: return "WM_WINDOWPOSCHANGING";
4980 case 0x0047: return "WM_WINDOWPOSCHANGED";
4981 case 0x0048: return "WM_POWER";
4984 case 0x004A: return "WM_COPYDATA";
4985 case 0x004B: return "WM_CANCELJOURNAL";
4986 case 0x004E: return "WM_NOTIFY";
4987 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
4988 case 0x0051: return "WM_INPUTLANGCHANGE";
4989 case 0x0052: return "WM_TCARD";
4990 case 0x0053: return "WM_HELP";
4991 case 0x0054: return "WM_USERCHANGED";
4992 case 0x0055: return "WM_NOTIFYFORMAT";
4993 case 0x007B: return "WM_CONTEXTMENU";
4994 case 0x007C: return "WM_STYLECHANGING";
4995 case 0x007D: return "WM_STYLECHANGED";
4996 case 0x007E: return "WM_DISPLAYCHANGE";
4997 case 0x007F: return "WM_GETICON";
4998 case 0x0080: return "WM_SETICON";
5001 case 0x0081: return "WM_NCCREATE";
5002 case 0x0082: return "WM_NCDESTROY";
5003 case 0x0083: return "WM_NCCALCSIZE";
5004 case 0x0084: return "WM_NCHITTEST";
5005 case 0x0085: return "WM_NCPAINT";
5006 case 0x0086: return "WM_NCACTIVATE";
5007 case 0x0087: return "WM_GETDLGCODE";
5008 case 0x00A0: return "WM_NCMOUSEMOVE";
5009 case 0x00A1: return "WM_NCLBUTTONDOWN";
5010 case 0x00A2: return "WM_NCLBUTTONUP";
5011 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5012 case 0x00A4: return "WM_NCRBUTTONDOWN";
5013 case 0x00A5: return "WM_NCRBUTTONUP";
5014 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5015 case 0x00A7: return "WM_NCMBUTTONDOWN";
5016 case 0x00A8: return "WM_NCMBUTTONUP";
5017 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5018 case 0x0100: return "WM_KEYDOWN";
5019 case 0x0101: return "WM_KEYUP";
5020 case 0x0102: return "WM_CHAR";
5021 case 0x0103: return "WM_DEADCHAR";
5022 case 0x0104: return "WM_SYSKEYDOWN";
5023 case 0x0105: return "WM_SYSKEYUP";
5024 case 0x0106: return "WM_SYSCHAR";
5025 case 0x0107: return "WM_SYSDEADCHAR";
5026 case 0x0108: return "WM_KEYLAST";
5029 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5030 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5031 case 0x010F: return "WM_IME_COMPOSITION";
5034 case 0x0110: return "WM_INITDIALOG";
5035 case 0x0111: return "WM_COMMAND";
5036 case 0x0112: return "WM_SYSCOMMAND";
5037 case 0x0113: return "WM_TIMER";
5038 case 0x0114: return "WM_HSCROLL";
5039 case 0x0115: return "WM_VSCROLL";
5040 case 0x0116: return "WM_INITMENU";
5041 case 0x0117: return "WM_INITMENUPOPUP";
5042 case 0x011F: return "WM_MENUSELECT";
5043 case 0x0120: return "WM_MENUCHAR";
5044 case 0x0121: return "WM_ENTERIDLE";
5045 case 0x0200: return "WM_MOUSEMOVE";
5046 case 0x0201: return "WM_LBUTTONDOWN";
5047 case 0x0202: return "WM_LBUTTONUP";
5048 case 0x0203: return "WM_LBUTTONDBLCLK";
5049 case 0x0204: return "WM_RBUTTONDOWN";
5050 case 0x0205: return "WM_RBUTTONUP";
5051 case 0x0206: return "WM_RBUTTONDBLCLK";
5052 case 0x0207: return "WM_MBUTTONDOWN";
5053 case 0x0208: return "WM_MBUTTONUP";
5054 case 0x0209: return "WM_MBUTTONDBLCLK";
5055 case 0x020A: return "WM_MOUSEWHEEL";
5056 case 0x0210: return "WM_PARENTNOTIFY";
5057 case 0x0211: return "WM_ENTERMENULOOP";
5058 case 0x0212: return "WM_EXITMENULOOP";
5061 case 0x0213: return "WM_NEXTMENU";
5062 case 0x0214: return "WM_SIZING";
5063 case 0x0215: return "WM_CAPTURECHANGED";
5064 case 0x0216: return "WM_MOVING";
5065 case 0x0218: return "WM_POWERBROADCAST";
5066 case 0x0219: return "WM_DEVICECHANGE";
5069 case 0x0220: return "WM_MDICREATE";
5070 case 0x0221: return "WM_MDIDESTROY";
5071 case 0x0222: return "WM_MDIACTIVATE";
5072 case 0x0223: return "WM_MDIRESTORE";
5073 case 0x0224: return "WM_MDINEXT";
5074 case 0x0225: return "WM_MDIMAXIMIZE";
5075 case 0x0226: return "WM_MDITILE";
5076 case 0x0227: return "WM_MDICASCADE";
5077 case 0x0228: return "WM_MDIICONARRANGE";
5078 case 0x0229: return "WM_MDIGETACTIVE";
5079 case 0x0230: return "WM_MDISETMENU";
5080 case 0x0233: return "WM_DROPFILES";
5083 case 0x0281: return "WM_IME_SETCONTEXT";
5084 case 0x0282: return "WM_IME_NOTIFY";
5085 case 0x0283: return "WM_IME_CONTROL";
5086 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5087 case 0x0285: return "WM_IME_SELECT";
5088 case 0x0286: return "WM_IME_CHAR";
5089 case 0x0290: return "WM_IME_KEYDOWN";
5090 case 0x0291: return "WM_IME_KEYUP";
5093 case 0x0300: return "WM_CUT";
5094 case 0x0301: return "WM_COPY";
5095 case 0x0302: return "WM_PASTE";
5096 case 0x0303: return "WM_CLEAR";
5097 case 0x0304: return "WM_UNDO";
5098 case 0x0305: return "WM_RENDERFORMAT";
5099 case 0x0306: return "WM_RENDERALLFORMATS";
5100 case 0x0307: return "WM_DESTROYCLIPBOARD";
5101 case 0x0308: return "WM_DRAWCLIPBOARD";
5102 case 0x0309: return "WM_PAINTCLIPBOARD";
5103 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5104 case 0x030B: return "WM_SIZECLIPBOARD";
5105 case 0x030C: return "WM_ASKCBFORMATNAME";
5106 case 0x030D: return "WM_CHANGECBCHAIN";
5107 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5108 case 0x030F: return "WM_QUERYNEWPALETTE";
5109 case 0x0310: return "WM_PALETTEISCHANGING";
5110 case 0x0311: return "WM_PALETTECHANGED";
5113 // common controls messages - although they're not strictly speaking
5114 // standard, it's nice to decode them nevertheless
5117 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5118 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5119 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5120 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5121 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5122 case 0x1000 + 5: return "LVM_GETITEMA";
5123 case 0x1000 + 75: return "LVM_GETITEMW";
5124 case 0x1000 + 6: return "LVM_SETITEMA";
5125 case 0x1000 + 76: return "LVM_SETITEMW";
5126 case 0x1000 + 7: return "LVM_INSERTITEMA";
5127 case 0x1000 + 77: return "LVM_INSERTITEMW";
5128 case 0x1000 + 8: return "LVM_DELETEITEM";
5129 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5130 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5131 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5132 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5133 case 0x1000 + 13: return "LVM_FINDITEMA";
5134 case 0x1000 + 83: return "LVM_FINDITEMW";
5135 case 0x1000 + 14: return "LVM_GETITEMRECT";
5136 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5137 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5138 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5139 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5140 case 0x1000 + 18: return "LVM_HITTEST";
5141 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5142 case 0x1000 + 20: return "LVM_SCROLL";
5143 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5144 case 0x1000 + 22: return "LVM_ARRANGE";
5145 case 0x1000 + 23: return "LVM_EDITLABELA";
5146 case 0x1000 + 118: return "LVM_EDITLABELW";
5147 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5148 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5149 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5150 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5151 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5152 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5153 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5154 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5155 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5156 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5157 case 0x1000 + 31: return "LVM_GETHEADER";
5158 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5159 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5160 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5161 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5162 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5163 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5164 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5165 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5166 case 0x1000 + 41: return "LVM_GETORIGIN";
5167 case 0x1000 + 42: return "LVM_UPDATE";
5168 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5169 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5170 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5171 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5172 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5173 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5174 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5175 case 0x1000 + 48: return "LVM_SORTITEMS";
5176 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5177 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5178 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5179 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5180 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5181 case 0x1000 + 53: return "LVM_SETICONSPACING";
5182 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5183 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5184 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5185 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5186 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5187 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5188 case 0x1000 + 60: return "LVM_SETHOTITEM";
5189 case 0x1000 + 61: return "LVM_GETHOTITEM";
5190 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5191 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5192 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5193 case 0x1000 + 65: return "LVM_SETWORKAREA";
5196 case 0x1100 + 0: return "TVM_INSERTITEMA";
5197 case 0x1100 + 50: return "TVM_INSERTITEMW";
5198 case 0x1100 + 1: return "TVM_DELETEITEM";
5199 case 0x1100 + 2: return "TVM_EXPAND";
5200 case 0x1100 + 4: return "TVM_GETITEMRECT";
5201 case 0x1100 + 5: return "TVM_GETCOUNT";
5202 case 0x1100 + 6: return "TVM_GETINDENT";
5203 case 0x1100 + 7: return "TVM_SETINDENT";
5204 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5205 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5206 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5207 case 0x1100 + 11: return "TVM_SELECTITEM";
5208 case 0x1100 + 12: return "TVM_GETITEMA";
5209 case 0x1100 + 62: return "TVM_GETITEMW";
5210 case 0x1100 + 13: return "TVM_SETITEMA";
5211 case 0x1100 + 63: return "TVM_SETITEMW";
5212 case 0x1100 + 14: return "TVM_EDITLABELA";
5213 case 0x1100 + 65: return "TVM_EDITLABELW";
5214 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5215 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5216 case 0x1100 + 17: return "TVM_HITTEST";
5217 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5218 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5219 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5220 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5221 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5222 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5223 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5224 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5225 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5228 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5229 case 0x1200 + 1: return "HDM_INSERTITEMA";
5230 case 0x1200 + 10: return "HDM_INSERTITEMW";
5231 case 0x1200 + 2: return "HDM_DELETEITEM";
5232 case 0x1200 + 3: return "HDM_GETITEMA";
5233 case 0x1200 + 11: return "HDM_GETITEMW";
5234 case 0x1200 + 4: return "HDM_SETITEMA";
5235 case 0x1200 + 12: return "HDM_SETITEMW";
5236 case 0x1200 + 5: return "HDM_LAYOUT";
5237 case 0x1200 + 6: return "HDM_HITTEST";
5238 case 0x1200 + 7: return "HDM_GETITEMRECT";
5239 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5240 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5241 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5242 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5243 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5244 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5245 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5248 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5249 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5250 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5251 case 0x1300 + 5: return "TCM_GETITEMA";
5252 case 0x1300 + 60: return "TCM_GETITEMW";
5253 case 0x1300 + 6: return "TCM_SETITEMA";
5254 case 0x1300 + 61: return "TCM_SETITEMW";
5255 case 0x1300 + 7: return "TCM_INSERTITEMA";
5256 case 0x1300 + 62: return "TCM_INSERTITEMW";
5257 case 0x1300 + 8: return "TCM_DELETEITEM";
5258 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5259 case 0x1300 + 10: return "TCM_GETITEMRECT";
5260 case 0x1300 + 11: return "TCM_GETCURSEL";
5261 case 0x1300 + 12: return "TCM_SETCURSEL";
5262 case 0x1300 + 13: return "TCM_HITTEST";
5263 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5264 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5265 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5266 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5267 case 0x1300 + 43: return "TCM_SETPADDING";
5268 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5269 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5270 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5271 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5272 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5273 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5274 case 0x1300 + 50: return "TCM_DESELECTALL";
5277 case WM_USER
+1: return "TB_ENABLEBUTTON";
5278 case WM_USER
+2: return "TB_CHECKBUTTON";
5279 case WM_USER
+3: return "TB_PRESSBUTTON";
5280 case WM_USER
+4: return "TB_HIDEBUTTON";
5281 case WM_USER
+5: return "TB_INDETERMINATE";
5282 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5283 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5284 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5285 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5286 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5287 case WM_USER
+17: return "TB_SETSTATE";
5288 case WM_USER
+18: return "TB_GETSTATE";
5289 case WM_USER
+19: return "TB_ADDBITMAP";
5290 case WM_USER
+20: return "TB_ADDBUTTONS";
5291 case WM_USER
+21: return "TB_INSERTBUTTON";
5292 case WM_USER
+22: return "TB_DELETEBUTTON";
5293 case WM_USER
+23: return "TB_GETBUTTON";
5294 case WM_USER
+24: return "TB_BUTTONCOUNT";
5295 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5296 case WM_USER
+26: return "TB_SAVERESTOREA";
5297 case WM_USER
+76: return "TB_SAVERESTOREW";
5298 case WM_USER
+27: return "TB_CUSTOMIZE";
5299 case WM_USER
+28: return "TB_ADDSTRINGA";
5300 case WM_USER
+77: return "TB_ADDSTRINGW";
5301 case WM_USER
+29: return "TB_GETITEMRECT";
5302 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5303 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5304 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5305 case WM_USER
+33: return "TB_AUTOSIZE";
5306 case WM_USER
+35: return "TB_GETTOOLTIPS";
5307 case WM_USER
+36: return "TB_SETTOOLTIPS";
5308 case WM_USER
+37: return "TB_SETPARENT";
5309 case WM_USER
+39: return "TB_SETROWS";
5310 case WM_USER
+40: return "TB_GETROWS";
5311 case WM_USER
+42: return "TB_SETCMDID";
5312 case WM_USER
+43: return "TB_CHANGEBITMAP";
5313 case WM_USER
+44: return "TB_GETBITMAP";
5314 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5315 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5316 case WM_USER
+46: return "TB_REPLACEBITMAP";
5317 case WM_USER
+47: return "TB_SETINDENT";
5318 case WM_USER
+48: return "TB_SETIMAGELIST";
5319 case WM_USER
+49: return "TB_GETIMAGELIST";
5320 case WM_USER
+50: return "TB_LOADIMAGES";
5321 case WM_USER
+51: return "TB_GETRECT";
5322 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5323 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5324 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5325 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5326 case WM_USER
+56: return "TB_SETSTYLE";
5327 case WM_USER
+57: return "TB_GETSTYLE";
5328 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5329 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5330 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5331 case WM_USER
+61: return "TB_GETTEXTROWS";
5332 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5337 static char s_szBuf
[128];
5338 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5342 #endif //__WXDEBUG__
5344 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5345 int *x
, int *y
, WPARAM
*flags
)
5347 // construct the key mask
5348 WPARAM
& fwKeys
= *flags
;
5350 fwKeys
= MK_RBUTTON
;
5351 if ( wxIsCtrlDown() )
5352 fwKeys
|= MK_CONTROL
;
5353 if ( wxIsShiftDown() )
5356 // simulate right mouse button click
5357 DWORD dwPos
= ::GetMessagePos();
5358 *x
= GET_X_LPARAM(dwPos
);
5359 *y
= GET_Y_LPARAM(dwPos
);
5361 win
->ScreenToClient(x
, y
);
5364 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5368 HWND hwnd
= GetHwndOf(win
);
5369 HDC hdc
= ::GetDC(hwnd
);
5371 #if !wxDIALOG_UNIT_COMPATIBILITY
5372 // and select the current font into it
5373 HFONT hfont
= GetHfontOf(win
->GetFont());
5376 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5380 // finally retrieve the text metrics from it
5381 GetTextMetrics(hdc
, &tm
);
5383 #if !wxDIALOG_UNIT_COMPATIBILITY
5387 (void)::SelectObject(hdc
, hfont
);
5391 ::ReleaseDC(hwnd
, hdc
);
5396 // Find the wxWindow at the current mouse position, returning the mouse
5398 wxWindow
* wxFindWindowAtPointer(wxPoint
& WXUNUSED(pt
))
5400 return wxFindWindowAtPoint(wxGetMousePosition());
5403 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5408 HWND hWndHit
= ::WindowFromPoint(pt2
);
5410 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5411 HWND hWnd
= hWndHit
;
5413 // Try to find a window with a wxWindow associated with it
5414 while (!win
&& (hWnd
!= 0))
5416 hWnd
= ::GetParent(hWnd
);
5417 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5422 // Get the current mouse position.
5423 wxPoint
wxGetMousePosition()
5426 GetCursorPos( & pt
);
5428 return wxPoint(pt
.x
, pt
.y
);