1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/msw/winundef.h"
34 #include "wx/window.h"
39 #include "wx/dcclient.h"
40 #include "wx/dcmemory.h"
43 #include "wx/layout.h"
44 #include "wx/dialog.h"
46 #include "wx/listbox.h"
47 #include "wx/button.h"
48 #include "wx/msgdlg.h"
49 #include "wx/settings.h"
50 #include "wx/statbox.h"
54 #include "wx/ownerdrw.h"
57 #if wxUSE_DRAG_AND_DROP
61 #if wxUSE_ACCESSIBILITY
62 #include "wx/access.h"
65 #define WM_GETOBJECT 0x003D
68 #define OBJID_CLIENT 0xFFFFFFFC
72 #include "wx/menuitem.h"
75 #include "wx/msw/private.h"
78 #include "wx/tooltip.h"
86 #include "wx/spinctrl.h"
87 #endif // wxUSE_SPINCTRL
92 #include "wx/textctrl.h"
93 #include "wx/notebook.h"
97 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
103 #include <windowsx.h>
106 #if (!defined(__GNUWIN32_OLD__) && !defined(__TWIN32__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
108 #include <commctrl.h>
110 #elif !defined(__WXMICROWIN__) // broken compiler
112 #include "wx/msw/gnuwin32/extra.h"
116 // ----------------------------------------------------------------------------
117 // standard constants not available with all compilers/headers
118 // ----------------------------------------------------------------------------
120 // This didn't appear in mingw until 2.95.2
122 #define SIF_TRACKPOS 16
126 #ifndef WM_MOUSEWHEEL
127 #define WM_MOUSEWHEEL 0x020A
130 #define WHEEL_DELTA 120
132 #ifndef SPI_GETWHEELSCROLLLINES
133 #define SPI_GETWHEELSCROLLLINES 104
135 #endif // wxUSE_MOUSEWHEEL
138 #define VK_OEM_1 0xBA
139 #define VK_OEM_PLUS 0xBB
140 #define VK_OEM_COMMA 0xBC
141 #define VK_OEM_MINUS 0xBD
142 #define VK_OEM_PERIOD 0xBE
143 #define VK_OEM_2 0xBF
144 #define VK_OEM_3 0xC0
145 #define VK_OEM_4 0xDB
146 #define VK_OEM_5 0xDC
147 #define VK_OEM_6 0xDD
148 #define VK_OEM_7 0xDE
151 // ---------------------------------------------------------------------------
153 // ---------------------------------------------------------------------------
155 // the last Windows message we got (FIXME-MT)
156 extern MSG s_currentMsg
;
158 #if wxUSE_MENUS_NATIVE
159 wxMenu
*wxCurrentPopupMenu
= NULL
;
160 #endif // wxUSE_MENUS_NATIVE
162 extern const wxChar
*wxCanvasClassName
;
164 // true if we had already created the std colour map, used by
165 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
166 static bool gs_hasStdCmap
= FALSE
;
168 // ---------------------------------------------------------------------------
170 // ---------------------------------------------------------------------------
172 // the window proc for all our windows
173 #ifdef __DIGITALMARS__
174 extern "C" LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
175 WPARAM wParam
, LPARAM lParam
);
177 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
178 WPARAM wParam
, LPARAM lParam
);
183 const char *wxGetMessageName(int message
);
186 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
187 #ifdef __DIGITALMARS__
188 extern "C" void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
190 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
192 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
194 // this magical function is used to translate VK_APPS key presses to right
196 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
197 int *x
, int *y
, WPARAM
*flags
);
199 // get the text metrics for the current font
200 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
202 // find the window for the mouse event at the specified position
203 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
205 // wrapper around BringWindowToTop() API
206 static inline void wxBringWindowToTop(HWND hwnd
)
208 #ifdef __WXMICROWIN__
209 // It seems that MicroWindows brings the _parent_ of the window to the top,
210 // which can be the wrong one.
212 // activate (set focus to) specified window
215 // raise top level parent to top of z order
216 ::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
);
217 #else // !__WXMICROWIN__
218 if ( !::BringWindowToTop(hwnd
) )
220 wxLogLastError(_T("BringWindowToTop"));
222 #endif // __WXMICROWIN__/!__WXMICROWIN__
225 // ---------------------------------------------------------------------------
227 // ---------------------------------------------------------------------------
229 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
231 #ifdef __WXUNIVERSAL__
232 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
234 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
235 #endif // __WXUNIVERSAL__/__WXMSW__
237 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
238 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
239 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
240 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
241 EVT_IDLE(wxWindowMSW::OnIdle
)
244 // ===========================================================================
246 // ===========================================================================
248 // ---------------------------------------------------------------------------
249 // wxWindow utility functions
250 // ---------------------------------------------------------------------------
252 // Find an item given the MS Windows id
253 wxWindow
*wxWindowMSW::FindItem(long id
) const
256 wxControl
*item
= wxDynamicCastThis(wxControl
);
259 // is it we or one of our "internal" children?
260 if ( item
->GetId() == id
261 #ifndef __WXUNIVERSAL__
262 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
263 #endif // __WXUNIVERSAL__
269 #endif // wxUSE_CONTROLS
271 wxWindowList::Node
*current
= GetChildren().GetFirst();
274 wxWindow
*childWin
= current
->GetData();
276 wxWindow
*wnd
= childWin
->FindItem(id
);
280 current
= current
->GetNext();
286 // Find an item given the MS Windows handle
287 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
289 wxWindowList::Node
*current
= GetChildren().GetFirst();
292 wxWindow
*parent
= current
->GetData();
294 // Do a recursive search.
295 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
301 || parent
->IsKindOf(CLASSINFO(wxControl
))
302 #endif // wxUSE_CONTROLS
305 wxWindow
*item
= current
->GetData();
306 if ( item
->GetHWND() == hWnd
)
310 if ( item
->ContainsHWND(hWnd
) )
315 current
= current
->GetNext();
320 // Default command handler
321 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
326 // ----------------------------------------------------------------------------
327 // constructors and such
328 // ----------------------------------------------------------------------------
330 void wxWindowMSW::Init()
336 m_isBeingDeleted
= FALSE
;
339 m_mouseInWindow
= FALSE
;
340 m_lastKeydownProcessed
= FALSE
;
342 m_childrenDisabled
= NULL
;
351 m_backgroundTransparent
= FALSE
;
353 // as all windows are created with WS_VISIBLE style...
356 #if wxUSE_MOUSEEVENT_HACK
359 m_lastMouseEvent
= -1;
360 #endif // wxUSE_MOUSEEVENT_HACK
364 wxWindowMSW::~wxWindowMSW()
366 m_isBeingDeleted
= TRUE
;
368 #ifndef __WXUNIVERSAL__
369 // VS: make sure there's no wxFrame with last focus set to us:
370 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
372 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
375 if ( frame
->GetLastFocus() == this )
377 frame
->SetLastFocus(NULL
);
382 #endif // __WXUNIVERSAL__
384 // VS: destroy children first and _then_ detach *this from its parent.
385 // If we'd do it the other way around, children wouldn't be able
386 // find their parent frame (see above).
390 m_parent
->RemoveChild(this);
394 // VZ: test temp removed to understand what really happens here
395 //if (::IsWindow(GetHwnd()))
397 if ( !::DestroyWindow(GetHwnd()) )
398 wxLogLastError(wxT("DestroyWindow"));
401 // remove hWnd <-> wxWindow association
402 wxRemoveHandleAssociation(this);
405 delete m_childrenDisabled
;
408 // real construction (Init() must have been called before!)
409 bool wxWindowMSW::Create(wxWindow
*parent
,
414 const wxString
& name
)
416 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
418 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
421 parent
->AddChild(this);
424 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
426 #ifdef __WXUNIVERSAL__
427 // no borders, we draw them ourselves
428 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
432 msflags
&= ~WS_BORDER
;
433 #endif // wxUniversal
435 // all windows are created visible by default except popup ones (which are
436 // like the wxTopLevelWindows in this aspect)
437 if ( style
& wxPOPUP_WINDOW
)
439 msflags
&= ~WS_VISIBLE
;
444 msflags
|= WS_VISIBLE
;
447 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
450 // ---------------------------------------------------------------------------
452 // ---------------------------------------------------------------------------
454 void wxWindowMSW::SetFocus()
456 HWND hWnd
= GetHwnd();
457 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
459 #ifndef __WXMICROWIN__
463 if ( !::SetFocus(hWnd
) )
465 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
466 // was there really an error?
467 DWORD dwRes
= ::GetLastError();
470 HWND hwndFocus
= ::GetFocus();
471 if ( hwndFocus
!= hWnd
)
473 wxLogApiError(_T("SetFocus"), dwRes
);
480 void wxWindowMSW::SetFocusFromKbd()
482 wxWindowBase::SetFocusFromKbd();
484 // when the focus is given to the control with DLGC_HASSETSEL style from
485 // keyboard its contents should be entirely selected: this is what
486 // ::IsDialogMessage() does and so we should do it as well to provide the
487 // same LNF as the native programs
488 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
490 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
494 // Get the window with the focus
495 wxWindow
*wxWindowBase::FindFocus()
497 HWND hWnd
= ::GetFocus();
500 return wxGetWindowFromHWND((WXHWND
)hWnd
);
506 bool wxWindowMSW::Enable(bool enable
)
508 if ( !wxWindowBase::Enable(enable
) )
511 HWND hWnd
= GetHwnd();
513 ::EnableWindow(hWnd
, (BOOL
)enable
);
515 // the logic below doesn't apply to the top level windows -- otherwise
516 // showing a modal dialog would result in total greying out (and ungreying
517 // out later) of everything which would be really ugly
521 // when the parent is disabled, all of its children should be disabled as
522 // well but when it is enabled back, only those of the children which
523 // hadn't been already disabled in the beginning should be enabled again,
524 // so we have to keep the list of those children
525 for ( wxWindowList::Node
*node
= GetChildren().GetFirst();
527 node
= node
->GetNext() )
529 wxWindow
*child
= node
->GetData();
530 if ( child
->IsTopLevel() )
532 // the logic below doesn't apply to top level children
538 // enable the child back unless it had been disabled before us
539 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
542 else // we're being disabled
544 if ( child
->IsEnabled() )
546 // disable it as children shouldn't stay enabled while the
550 else // child already disabled, remember it
552 // have we created the list of disabled children already?
553 if ( !m_childrenDisabled
)
554 m_childrenDisabled
= new wxWindowList
;
556 m_childrenDisabled
->Append(child
);
561 if ( enable
&& m_childrenDisabled
)
563 // we don't need this list any more, don't keep unused memory
564 delete m_childrenDisabled
;
565 m_childrenDisabled
= NULL
;
571 bool wxWindowMSW::Show(bool show
)
573 if ( !wxWindowBase::Show(show
) )
576 HWND hWnd
= GetHwnd();
577 int cshow
= show
? SW_SHOW
: SW_HIDE
;
578 ::ShowWindow(hWnd
, cshow
);
582 wxBringWindowToTop(hWnd
);
588 // Raise the window to the top of the Z order
589 void wxWindowMSW::Raise()
591 wxBringWindowToTop(GetHwnd());
594 // Lower the window to the bottom of the Z order
595 void wxWindowMSW::Lower()
597 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
598 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
601 void wxWindowMSW::SetTitle( const wxString
& title
)
603 SetWindowText(GetHwnd(), title
.c_str());
606 wxString
wxWindowMSW::GetTitle() const
608 return wxGetWindowText(GetHWND());
611 void wxWindowMSW::DoCaptureMouse()
613 HWND hWnd
= GetHwnd();
620 void wxWindowMSW::DoReleaseMouse()
622 if ( !::ReleaseCapture() )
624 wxLogLastError(_T("ReleaseCapture"));
628 /* static */ wxWindow
*wxWindowBase::GetCapture()
630 HWND hwnd
= ::GetCapture();
631 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
634 bool wxWindowMSW::SetFont(const wxFont
& font
)
636 if ( !wxWindowBase::SetFont(font
) )
642 HWND hWnd
= GetHwnd();
645 WXHANDLE hFont
= m_font
.GetResourceHandle();
647 wxASSERT_MSG( hFont
, wxT("should have valid font") );
649 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
654 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
656 if ( !wxWindowBase::SetCursor(cursor
) )
664 HWND hWnd
= GetHwnd();
666 // Change the cursor NOW if we're within the correct window
668 ::GetCursorPos(&point
);
670 RECT rect
= wxGetWindowRect(hWnd
);
672 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
673 ::SetCursor(GetHcursorOf(m_cursor
));
679 void wxWindowMSW::WarpPointer (int x
, int y
)
681 ClientToScreen(&x
, &y
);
683 if ( !::SetCursorPos(x
, y
) )
685 wxLogLastError(_T("SetCursorPos"));
689 #if WXWIN_COMPATIBILITY
690 void wxWindowMSW::MSWDeviceToLogical (float *x
, float *y
) const
693 #endif // WXWIN_COMPATIBILITY
695 // ---------------------------------------------------------------------------
697 // ---------------------------------------------------------------------------
699 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
700 static inline wxDirToWinStyle(int orient
)
702 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
705 #if WXWIN_COMPATIBILITY
706 void wxWindowMSW::SetScrollRange(int orient
, int range
, bool refresh
)
710 // Try to adjust the range to cope with page size > 1
711 // - a Windows API quirk
712 int pageSize
= GetScrollPage(orient
);
713 if ( pageSize
> 1 && range
> 0)
715 range1
+= (pageSize
- 1);
718 WinStruct
<SCROLLINFO
> info
;
719 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
722 info
.fMask
= SIF_RANGE
| SIF_PAGE
;
724 HWND hWnd
= GetHwnd();
726 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
729 void wxWindowMSW::SetScrollPage(int orient
, int page
, bool refresh
)
731 WinStruct
<SCROLLINFO
> info
;
733 info
.fMask
= SIF_PAGE
;
735 HWND hWnd
= GetHwnd();
737 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
740 int wxWindowMSW::GetScrollPage(int orient
) const
742 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
745 #endif // WXWIN_COMPATIBILITY
747 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
749 #ifdef __WXMICROWIN__
750 return ::GetScrollPosWX(hWnd
, wOrient
);
752 return ::GetScrollPos(hWnd
, wOrient
);
756 int wxWindowMSW::GetScrollPos(int orient
) const
758 HWND hWnd
= GetHwnd();
759 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
761 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
764 // This now returns the whole range, not just the number
765 // of positions that we can scroll.
766 int wxWindowMSW::GetScrollRange(int orient
) const
769 HWND hWnd
= GetHwnd();
773 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
776 // undo "range - 1" done in SetScrollbar()
780 int wxWindowMSW::GetScrollThumb(int orient
) const
782 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
785 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
787 HWND hWnd
= GetHwnd();
788 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
790 WinStruct
<SCROLLINFO
> info
;
794 info
.fMask
= SIF_POS
;
796 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
800 // New function that will replace some of the above.
801 void wxWindowMSW::SetScrollbar(int orient
,
807 WinStruct
<SCROLLINFO
> info
;
808 info
.nPage
= pageSize
;
809 info
.nMin
= 0; // range is nMax - nMin + 1
810 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
812 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
814 HWND hWnd
= GetHwnd();
817 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
821 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
824 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
830 rect
.left
= prect
->x
;
832 rect
.right
= prect
->x
+ prect
->width
;
833 rect
.bottom
= prect
->y
+ prect
->height
;
841 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
844 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
846 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
849 for ( int n
= 0; n
< count
; n
++ )
851 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
853 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
856 // don't bother to continue, we're already at top/bottom
863 return pos
!= posStart
;
866 bool wxWindowMSW::ScrollLines(int lines
)
868 bool down
= lines
> 0;
870 return ScrollVertically(GetHwnd(),
871 down
? SB_LINEDOWN
: SB_LINEUP
,
872 down
? lines
: -lines
);
875 bool wxWindowMSW::ScrollPages(int pages
)
877 bool down
= pages
> 0;
879 return ScrollVertically(GetHwnd(),
880 down
? SB_PAGEDOWN
: SB_PAGEUP
,
881 down
? pages
: -pages
);
884 // ---------------------------------------------------------------------------
886 // ---------------------------------------------------------------------------
888 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
890 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
892 HWND hwnd
= (HWND
)hWnd
;
893 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
895 wxAssociateWinWithHandle(hwnd
, this);
897 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
899 // we don't need to subclass the window of our own class (in the Windows
900 // sense of the word)
901 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
903 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
907 // don't bother restoring it neither: this also makes it easy to
908 // implement IsOfStandardClass() method which returns TRUE for the
909 // standard controls and FALSE for the wxWindows own windows as it can
910 // simply check m_oldWndProc
915 void wxWindowMSW::UnsubclassWin()
917 wxRemoveHandleAssociation(this);
919 // Restore old Window proc
920 HWND hwnd
= GetHwnd();
925 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
929 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
931 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
939 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
941 // Unicows note: the code below works, but only because WNDCLASS contains
942 // original window handler rather that the unicows fake one. This may not
943 // be on purpose, though; if it stops working with future versions of
944 // unicows.dll, we can override unicows hooks by setting
945 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
946 // versions that keep track of fake<->real wnd proc mapping.
948 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
950 wxLogLastError(_T("GetClassInfo"));
955 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
958 // ----------------------------------------------------------------------------
960 // ----------------------------------------------------------------------------
962 void wxWindowMSW::SetWindowStyleFlag(long flags
)
964 long flagsOld
= GetWindowStyleFlag();
965 if ( flags
== flagsOld
)
968 // update the internal variable
969 wxWindowBase::SetWindowStyleFlag(flags
);
971 // now update the Windows style as well if needed - and if the window had
972 // been already created
976 WXDWORD exstyle
, exstyleOld
;
977 long style
= MSWGetStyle(flags
, &exstyle
),
978 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
980 if ( style
!= styleOld
)
982 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
983 // this function so instead of simply setting the style to the new
984 // value we clear the bits which were set in styleOld but are set in
985 // the new one and set the ones which were not set before
986 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
987 styleReal
&= ~styleOld
;
990 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
993 // and the extended style
994 if ( exstyle
!= exstyleOld
)
996 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
997 exstyleReal
&= ~exstyleOld
;
998 exstyleReal
|= exstyle
;
1000 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1002 // we must call SetWindowPos() to flash the cached extended style and
1003 // also to make the change to wxSTAY_ON_TOP style take effect: just
1004 // setting the style simply doesn't work
1005 if ( !::SetWindowPos(GetHwnd(),
1006 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1009 SWP_NOMOVE
| SWP_NOSIZE
) )
1011 wxLogLastError(_T("SetWindowPos"));
1016 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1018 // translate the style
1019 WXDWORD style
= WS_CHILD
| WS_VISIBLE
;
1021 if ( flags
& wxCLIP_CHILDREN
)
1022 style
|= WS_CLIPCHILDREN
;
1024 if ( flags
& wxCLIP_SIBLINGS
)
1025 style
|= WS_CLIPSIBLINGS
;
1027 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
1029 // Check if we want to automatically give it a sunken style.
1030 // Note than because 'sunken' actually maps to WS_EX_CLIENTEDGE, which
1031 // is a more neutral term, we don't necessarily get a sunken effect in
1032 // Windows XP. Instead we get the appropriate style for the theme.
1034 if (border
== wxBORDER_DEFAULT
&& wxTheApp
->GetAuto3D() &&
1035 GetParent() && (GetParent()->IsKindOf(CLASSINFO(wxPanel
)) ||
1036 GetParent()->IsKindOf(CLASSINFO(wxDialog
))) &&
1037 ((GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS
) != wxUSER_COLOURS
))
1039 border
= (wxBorder
)((flags
& wxBORDER_MASK
) | wxBORDER_SUNKEN
);
1042 // Only give it WS_BORDER for wxBORDER_SIMPLE
1043 if (border
& wxBORDER_SIMPLE
)
1046 // now deal with ext style if the caller wants it
1051 if ( flags
& wxTRANSPARENT_WINDOW
)
1052 *exstyle
|= WS_EX_TRANSPARENT
;
1057 wxFAIL_MSG( _T("unknown border style") );
1061 case wxBORDER_SIMPLE
:
1062 case wxBORDER_DEFAULT
:
1065 case wxBORDER_STATIC
:
1066 *exstyle
|= WS_EX_STATICEDGE
;
1069 case wxBORDER_RAISED
:
1070 *exstyle
|= WS_EX_DLGMODALFRAME
;
1073 case wxBORDER_SUNKEN
:
1074 *exstyle
|= WS_EX_CLIENTEDGE
;
1075 style
&= ~WS_BORDER
;
1078 case wxBORDER_DOUBLE
:
1079 *exstyle
|= WS_EX_DLGMODALFRAME
;
1083 // wxUniv doesn't use Windows dialog navigation functions at all
1084 #ifndef __WXUNIVERSAL__
1085 // to make the dialog navigation work with the nested panels we must
1086 // use this style (top level windows such as dialogs don't need it)
1087 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1089 *exstyle
|= WS_EX_CONTROLPARENT
;
1091 #endif // __WXUNIVERSAL__
1097 #if WXWIN_COMPATIBILITY
1098 // If nothing defined for this, try the parent.
1099 // E.g. we may be a button loaded from a resource, with no callback function
1101 void wxWindowMSW::OnCommand(wxWindow
& win
, wxCommandEvent
& event
)
1103 if ( GetEventHandler()->ProcessEvent(event
) )
1106 m_parent
->GetEventHandler()->OnCommand(win
, event
);
1108 #endif // WXWIN_COMPATIBILITY_2
1110 #if WXWIN_COMPATIBILITY
1111 wxObject
* wxWindowMSW::GetChild(int number
) const
1113 // Return a pointer to the Nth object in the Panel
1114 wxNode
*node
= GetChildren().First();
1117 node
= node
->Next();
1120 wxObject
*obj
= (wxObject
*)node
->Data();
1126 #endif // WXWIN_COMPATIBILITY
1128 // Setup background and foreground colours correctly
1129 void wxWindowMSW::SetupColours()
1132 SetBackgroundColour(GetParent()->GetBackgroundColour());
1135 bool wxWindowMSW::IsMouseInWindow() const
1137 // get the mouse position
1139 ::GetCursorPos(&pt
);
1141 // find the window which currently has the cursor and go up the window
1142 // chain until we find this window - or exhaust it
1143 HWND hwnd
= ::WindowFromPoint(pt
);
1144 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1145 hwnd
= ::GetParent(hwnd
);
1147 return hwnd
!= NULL
;
1150 void wxWindowMSW::OnIdle(wxIdleEvent
& WXUNUSED(event
))
1152 // Check if we need to send a LEAVE event
1153 if ( m_mouseInWindow
)
1155 // note that we should generate the leave event whether the window has
1156 // or doesn't have mouse capture
1157 if ( !IsMouseInWindow() )
1159 // Generate a LEAVE event
1160 m_mouseInWindow
= FALSE
;
1162 // Unfortunately the mouse button and keyboard state may have
1163 // changed by the time the OnIdle function is called, so 'state'
1164 // may be meaningless.
1166 if ( wxIsShiftDown() )
1168 if ( wxIsCtrlDown() )
1169 state
|= MK_CONTROL
;
1170 if ( GetKeyState( VK_LBUTTON
) )
1171 state
|= MK_LBUTTON
;
1172 if ( GetKeyState( VK_MBUTTON
) )
1173 state
|= MK_MBUTTON
;
1174 if ( GetKeyState( VK_RBUTTON
) )
1175 state
|= MK_RBUTTON
;
1178 if ( !::GetCursorPos(&pt
) )
1180 wxLogLastError(_T("GetCursorPos"));
1183 // we need to have client coordinates here for symmetry with
1184 // wxEVT_ENTER_WINDOW
1185 RECT rect
= wxGetWindowRect(GetHwnd());
1189 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1190 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1192 (void)GetEventHandler()->ProcessEvent(event2
);
1199 // Set this window to be the child of 'parent'.
1200 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1202 if ( !wxWindowBase::Reparent(parent
) )
1205 HWND hWndChild
= GetHwnd();
1206 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1208 ::SetParent(hWndChild
, hWndParent
);
1213 void wxWindowMSW::Clear()
1215 wxClientDC
dc((wxWindow
*)this);
1216 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1217 dc
.SetBackground(brush
);
1221 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1223 #ifndef __WXMICROWIN__
1224 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1228 void wxWindowMSW::Freeze()
1230 SendSetRedraw(GetHwnd(), FALSE
);
1233 void wxWindowMSW::Thaw()
1235 SendSetRedraw(GetHwnd(), TRUE
);
1237 // we need to refresh everything or otherwise he invalidated area is not
1242 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1244 HWND hWnd
= GetHwnd();
1250 mswRect
.left
= rect
->x
;
1251 mswRect
.top
= rect
->y
;
1252 mswRect
.right
= rect
->x
+ rect
->width
;
1253 mswRect
.bottom
= rect
->y
+ rect
->height
;
1255 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1258 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1262 void wxWindowMSW::Update()
1264 if ( !::UpdateWindow(GetHwnd()) )
1266 wxLogLastError(_T("UpdateWindow"));
1269 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1270 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1271 // handler needs to be really drawn right now
1276 // ---------------------------------------------------------------------------
1278 // ---------------------------------------------------------------------------
1281 #if wxUSE_DRAG_AND_DROP
1282 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1284 if ( m_dropTarget
!= 0 ) {
1285 m_dropTarget
->Revoke(m_hWnd
);
1286 delete m_dropTarget
;
1289 m_dropTarget
= pDropTarget
;
1290 if ( m_dropTarget
!= 0 )
1291 m_dropTarget
->Register(m_hWnd
);
1293 #endif // wxUSE_DRAG_AND_DROP
1295 // old style file-manager drag&drop support: we retain the old-style
1296 // DragAcceptFiles in parallel with SetDropTarget.
1297 void wxWindowMSW::DragAcceptFiles(bool accept
)
1299 HWND hWnd
= GetHwnd();
1301 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1304 // ----------------------------------------------------------------------------
1306 // ----------------------------------------------------------------------------
1310 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1312 wxWindowBase::DoSetToolTip(tooltip
);
1315 m_tooltip
->SetWindow((wxWindow
*)this);
1318 #endif // wxUSE_TOOLTIPS
1320 // ---------------------------------------------------------------------------
1321 // moving and resizing
1322 // ---------------------------------------------------------------------------
1325 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1327 RECT rect
= wxGetWindowRect(GetHwnd());
1330 *x
= rect
.right
- rect
.left
;
1332 *y
= rect
.bottom
- rect
.top
;
1335 // Get size *available for subwindows* i.e. excluding menu bar etc.
1336 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1338 RECT rect
= wxGetClientRect(GetHwnd());
1346 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1348 RECT rect
= wxGetWindowRect(GetHwnd());
1351 point
.x
= rect
.left
;
1354 // we do the adjustments with respect to the parent only for the "real"
1355 // children, not for the dialogs/frames
1356 if ( !IsTopLevel() )
1358 HWND hParentWnd
= 0;
1359 wxWindow
*parent
= GetParent();
1361 hParentWnd
= GetWinHwnd(parent
);
1363 // Since we now have the absolute screen coords, if there's a parent we
1364 // must subtract its top left corner
1367 ::ScreenToClient(hParentWnd
, &point
);
1372 // We may be faking the client origin. So a window that's really at (0,
1373 // 30) may appear (to wxWin apps) to be at (0, 0).
1374 wxPoint
pt(parent
->GetClientAreaOrigin());
1386 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1394 ::ScreenToClient(GetHwnd(), &pt
);
1402 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1410 ::ClientToScreen(GetHwnd(), &pt
);
1418 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1420 // TODO: is this consistent with other platforms?
1421 // Still, negative width or height shouldn't be allowed
1426 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1428 wxLogLastError(wxT("MoveWindow"));
1432 // set the size of the window: if the dimensions are positive, just use them,
1433 // but if any of them is equal to -1, it means that we must find the value for
1434 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1435 // which case -1 is a valid value for x and y)
1437 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1438 // the width/height to best suit our contents, otherwise we reuse the current
1440 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1442 // get the current size and position...
1443 int currentX
, currentY
;
1444 GetPosition(¤tX
, ¤tY
);
1445 int currentW
,currentH
;
1446 GetSize(¤tW
, ¤tH
);
1448 // ... and don't do anything (avoiding flicker) if it's already ok
1449 if ( x
== currentX
&& y
== currentY
&&
1450 width
== currentW
&& height
== currentH
)
1455 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1457 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1460 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1462 wxSize
size(-1, -1);
1465 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1467 size
= DoGetBestSize();
1472 // just take the current one
1479 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1483 size
= DoGetBestSize();
1485 //else: already called DoGetBestSize() above
1491 // just take the current one
1496 DoMoveWindow(x
, y
, width
, height
);
1499 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1501 // setting the client size is less obvious than it it could have been
1502 // because in the result of changing the total size the window scrollbar
1503 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1504 // will not be correct as the difference between the total and client size
1505 // changes - so we keep changing it until we get it right
1507 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1508 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1509 // may become 3 if the window had 0 size originally and so we didn't
1510 // calculate the scrollbar correction correctly during the first iteration)
1511 // but just to be on the safe side we check for it instead of making it an
1512 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1513 for ( int i
= 0; i
< 4; i
++ )
1516 ::GetClientRect(GetHwnd(), &rectClient
);
1518 // if the size is already ok, stop here (rectClient.left = top = 0)
1519 if ( (rectClient
.right
== width
|| width
== -1) &&
1520 (rectClient
.bottom
== height
|| height
== -1) )
1525 int widthClient
= width
,
1526 heightClient
= height
;
1528 // Find the difference between the entire window (title bar and all)
1529 // and the client area; add this to the new client size to move the
1532 ::GetWindowRect(GetHwnd(), &rectWin
);
1534 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1535 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1538 point
.x
= rectWin
.left
;
1539 point
.y
= rectWin
.top
;
1541 // MoveWindow positions the child windows relative to the parent, so
1542 // adjust if necessary
1543 if ( !IsTopLevel() )
1545 wxWindow
*parent
= GetParent();
1548 ::ScreenToClient(GetHwndOf(parent
), &point
);
1552 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1556 // For implementation purposes - sometimes decorations make the client area
1558 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1560 return wxPoint(0, 0);
1563 // ---------------------------------------------------------------------------
1565 // ---------------------------------------------------------------------------
1567 int wxWindowMSW::GetCharHeight() const
1569 return wxGetTextMetrics(this).tmHeight
;
1572 int wxWindowMSW::GetCharWidth() const
1574 // +1 is needed because Windows apparently adds it when calculating the
1575 // dialog units size in pixels
1576 #if wxDIALOG_UNIT_COMPATIBILITY
1577 return wxGetTextMetrics(this).tmAveCharWidth
;
1579 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1583 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1585 int *descent
, int *externalLeading
,
1586 const wxFont
*theFont
) const
1588 const wxFont
*fontToUse
= theFont
;
1590 fontToUse
= &m_font
;
1592 HWND hWnd
= GetHwnd();
1593 HDC dc
= ::GetDC(hWnd
);
1597 if ( fontToUse
&& fontToUse
->Ok() )
1599 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1601 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1606 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1607 GetTextMetrics(dc
, &tm
);
1609 if ( fontToUse
&& fnt
&& hfontOld
)
1610 SelectObject(dc
, hfontOld
);
1612 ReleaseDC(hWnd
, dc
);
1619 *descent
= tm
.tmDescent
;
1620 if ( externalLeading
)
1621 *externalLeading
= tm
.tmExternalLeading
;
1624 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1625 // ---------------------------------------------------------------------------
1626 // Caret manipulation
1627 // ---------------------------------------------------------------------------
1629 void wxWindowMSW::CreateCaret(int w
, int h
)
1631 SetCaret(new wxCaret(this, w
, h
));
1634 void wxWindowMSW::CreateCaret(const wxBitmap
*WXUNUSED(bitmap
))
1636 wxFAIL_MSG("not implemented");
1639 void wxWindowMSW::ShowCaret(bool show
)
1641 wxCHECK_RET( m_caret
, "no caret to show" );
1643 m_caret
->Show(show
);
1646 void wxWindowMSW::DestroyCaret()
1651 void wxWindowMSW::SetCaretPos(int x
, int y
)
1653 wxCHECK_RET( m_caret
, "no caret to move" );
1655 m_caret
->Move(x
, y
);
1658 void wxWindowMSW::GetCaretPos(int *x
, int *y
) const
1660 wxCHECK_RET( m_caret
, "no caret to get position of" );
1662 m_caret
->GetPosition(x
, y
);
1664 #endif // wxUSE_CARET
1666 // ---------------------------------------------------------------------------
1668 // ---------------------------------------------------------------------------
1670 #if wxUSE_MENUS_NATIVE
1672 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1673 // immediately, without waiting for the next event loop iteration
1675 // NB: this function should probably be made public later as it can almost
1676 // surely replace wxYield() elsewhere as well
1677 static void wxYieldForCommandsOnly()
1679 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1680 // want to process it here)
1682 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1683 && msg
.message
!= WM_QUIT
)
1685 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1688 // If we retrieved a WM_QUIT, insert back into the message queue.
1689 if (msg
.message
== WM_QUIT
)
1690 ::PostQuitMessage(0);
1693 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1695 menu
->SetInvokingWindow(this);
1698 HWND hWnd
= GetHwnd();
1699 HMENU hMenu
= GetHmenuOf(menu
);
1703 ::ClientToScreen(hWnd
, &point
);
1704 wxCurrentPopupMenu
= menu
;
1705 ::TrackPopupMenu(hMenu
, TPM_RIGHTBUTTON
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1707 // we need to do it righ now as otherwise the events are never going to be
1708 // sent to wxCurrentPopupMenu from HandleCommand()
1710 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1711 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1712 // destroyed as soon as we return (it can be a local variable in the caller
1713 // for example) and so we do need to process the event immediately
1714 wxYieldForCommandsOnly();
1716 wxCurrentPopupMenu
= NULL
;
1718 menu
->SetInvokingWindow(NULL
);
1723 #endif // wxUSE_MENUS_NATIVE
1725 // ===========================================================================
1726 // pre/post message processing
1727 // ===========================================================================
1729 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1732 #ifdef __DIGITALMARS__
1733 return ::CallWindowProc( (FARPROC
) m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1735 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1738 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1741 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1743 // wxUniversal implements tab traversal itself
1744 #ifndef __WXUNIVERSAL__
1745 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1747 // intercept dialog navigation keys
1748 MSG
*msg
= (MSG
*)pMsg
;
1750 // here we try to do all the job which ::IsDialogMessage() usually does
1753 if ( msg
->message
== WM_KEYDOWN
)
1755 bool bCtrlDown
= wxIsCtrlDown();
1756 bool bShiftDown
= wxIsShiftDown();
1758 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1759 // don't process it if it's the case (except for Ctrl-Tab/Enter
1760 // combinations which are always processed)
1764 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1766 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1767 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1768 // it, of course, implies them
1769 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1771 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1775 bool bForward
= TRUE
,
1776 bWindowChange
= FALSE
;
1778 // should we process this message specially?
1779 bool bProcess
= TRUE
;
1780 switch ( msg
->wParam
)
1783 // assume that nobody wants Shift-TAB for himself - if we
1784 // don't do it there is no easy way for a control to grab
1785 // TABs but still let Shift-TAB work as navugation key
1786 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1790 // Ctrl-Tab cycles thru notebook pages
1791 bWindowChange
= bCtrlDown
;
1792 bForward
= !bShiftDown
;
1798 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1806 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1812 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1814 // control wants to process Enter itself, don't
1815 // call IsDialogMessage() which would interpret
1819 else if ( lDlgCode
& DLGC_BUTTON
)
1821 // let IsDialogMessage() handle this for all
1822 // buttons except the owner-drawn ones which it
1823 // just seems to ignore
1824 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1825 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1827 // emulate the button click
1828 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1830 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1835 // FIXME: this should be handled by
1836 // wxNavigationKeyEvent handler and not here!!
1840 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1842 if ( btn
&& btn
->IsEnabled() )
1844 // if we do have a default button, do press it
1845 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1849 else // no default button
1851 #endif // wxUSE_BUTTON
1852 // this is a quick and dirty test for a text
1854 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1856 // don't process Enter, the control might
1857 // need it for itself and don't let
1858 // ::IsDialogMessage() have it as it can
1859 // eat the Enter events sometimes
1862 else if (!IsTopLevel())
1864 // if not a top level window, let parent
1868 //else: treat Enter as TAB: pass to the next
1869 // control as this is the best thing to do
1870 // if the text doesn't handle Enter itself
1882 wxNavigationKeyEvent event
;
1883 event
.SetDirection(bForward
);
1884 event
.SetWindowChange(bWindowChange
);
1885 event
.SetEventObject(this);
1887 if ( GetEventHandler()->ProcessEvent(event
) )
1894 // let ::IsDialogMessage() do almost everything and handle just the
1895 // things it doesn't here: Ctrl-TAB for switching notebook pages
1896 if ( msg
->message
== WM_KEYDOWN
)
1898 // don't process system keys here
1899 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1901 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1903 // find the first notebook parent and change its page
1904 wxWindow
*win
= this;
1905 wxNotebook
*nbook
= NULL
;
1906 while ( win
&& !nbook
)
1908 nbook
= wxDynamicCast(win
, wxNotebook
);
1909 win
= win
->GetParent();
1914 bool forward
= !wxIsShiftDown();
1916 nbook
->AdvanceSelection(forward
);
1923 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1924 // shouldn't let IsDialogMessage() get it as it _always_ eats the
1925 // message even when there is no cancel button and when the message is
1926 // needed by the control itself: in particular, it prevents the tree in
1927 // place edit control from being closed with Escape in a dialog
1928 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
1930 // ::IsDialogMessage() can enter in an infinite loop when the
1931 // currently focused window is disabled or hidden and its parent
1932 // has WS_EX_CONTROLPARENT style, so don't call it in this case
1933 bool canSafelyCallIsDlgMsg
= TRUE
;
1935 HWND hwndFocus
= ::GetFocus();
1938 if ( !::IsWindowEnabled(hwndFocus
) ||
1939 !::IsWindowVisible(hwndFocus
) )
1941 // it would enter an infinite loop if we do this!
1942 canSafelyCallIsDlgMsg
= FALSE
;
1947 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
1949 // it's a top level window, don't go further -- e.g. even
1950 // if the parent of a dialog is disabled, this doesn't
1951 // break navigation inside the dialog
1955 hwndFocus
= ::GetParent(hwndFocus
);
1958 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
1960 // IsDialogMessage() did something...
1965 #endif // __WXUNIVERSAL__
1970 // relay mouse move events to the tooltip control
1971 MSG
*msg
= (MSG
*)pMsg
;
1972 if ( msg
->message
== WM_MOUSEMOVE
)
1973 m_tooltip
->RelayEvent(pMsg
);
1975 #endif // wxUSE_TOOLTIPS
1980 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
1982 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
1983 return m_acceleratorTable
.Translate(this, pMsg
);
1987 #endif // wxUSE_ACCEL
1990 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
1992 // preprocess all messages by default
1996 // ---------------------------------------------------------------------------
1997 // message params unpackers (different for Win16 and Win32)
1998 // ---------------------------------------------------------------------------
2002 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2003 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2005 *id
= LOWORD(wParam
);
2006 *hwnd
= (WXHWND
)lParam
;
2007 *cmd
= HIWORD(wParam
);
2010 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2011 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2013 *state
= LOWORD(wParam
);
2014 *minimized
= HIWORD(wParam
);
2015 *hwnd
= (WXHWND
)lParam
;
2018 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2019 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2021 *code
= LOWORD(wParam
);
2022 *pos
= HIWORD(wParam
);
2023 *hwnd
= (WXHWND
)lParam
;
2026 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2027 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2029 #ifndef __WXMICROWIN__
2030 *nCtlColor
= CTLCOLOR_BTN
;
2031 *hwnd
= (WXHWND
)lParam
;
2032 *hdc
= (WXHDC
)wParam
;
2036 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2037 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2039 *item
= (WXWORD
)wParam
;
2040 *flags
= HIWORD(wParam
);
2041 *hmenu
= (WXHMENU
)lParam
;
2046 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2047 WXWORD
*id
, WXHWND
*hwnd
, WXWORD
*cmd
)
2049 *id
= (WXWORD
)wParam
;
2050 *hwnd
= (WXHWND
)LOWORD(lParam
);
2051 *cmd
= HIWORD(lParam
);
2054 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2055 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2057 *state
= (WXWORD
)wParam
;
2058 *minimized
= LOWORD(lParam
);
2059 *hwnd
= (WXHWND
)HIWORD(lParam
);
2062 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2063 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2065 *code
= (WXWORD
)wParam
;
2066 *pos
= LOWORD(lParam
);
2067 *hwnd
= (WXHWND
)HIWORD(lParam
);
2070 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2071 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2073 *hwnd
= (WXHWND
)LOWORD(lParam
);
2074 *nCtlColor
= (int)HIWORD(lParam
);
2075 *hdc
= (WXHDC
)wParam
;
2078 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2079 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2081 *item
= (WXWORD
)wParam
;
2082 *flags
= LOWORD(lParam
);
2083 *hmenu
= (WXHMENU
)HIWORD(lParam
);
2088 // ---------------------------------------------------------------------------
2089 // Main wxWindows window proc and the window proc for wxWindow
2090 // ---------------------------------------------------------------------------
2092 // Hook for new window just as it's being created, when the window isn't yet
2093 // associated with the handle
2094 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2096 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2097 // window being created and insures that it's always unset back later
2098 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2100 gs_winBeingCreated
= winBeingCreated
;
2103 wxWindowCreationHook::~wxWindowCreationHook()
2105 gs_winBeingCreated
= NULL
;
2109 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2111 // trace all messages - useful for the debugging
2114 wxLogTrace(wxTraceMessages
, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
2115 wxGetMessageName(message
), (long) wParam
, lParam
);
2117 #endif // __WXDEBUG__
2119 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2121 // when we get the first message for the HWND we just created, we associate
2122 // it with wxWindow stored in gs_winBeingCreated
2123 if ( !wnd
&& gs_winBeingCreated
)
2125 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2126 wnd
= gs_winBeingCreated
;
2127 gs_winBeingCreated
= NULL
;
2128 wnd
->SetHWND((WXHWND
)hWnd
);
2134 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2136 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2141 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2143 // did we process the message?
2144 bool processed
= FALSE
;
2155 // for most messages we should return 0 when we do process the message
2163 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2166 // return 0 to allow window creation
2167 rc
.result
= mayCreate
? 0 : -1;
2173 // never set processed to TRUE and *always* pass WM_DESTROY to
2174 // DefWindowProc() as Windows may do some internal cleanup when
2175 // processing it and failing to pass the message along may cause
2176 // memory and resource leaks!
2177 (void)HandleDestroy();
2181 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2189 // we're not interested in these messages at all
2192 case SIZE_MINIMIZED
:
2193 // we shouldn't send sizev events for these messages as the
2194 // client size may be negative which breaks existing code
2196 // OTOH we might send another (wxMinimizedEvent?) one or
2197 // add an additional parameter to wxSizeEvent if this is
2198 // useful to anybody
2202 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2203 // fall through nevertheless
2205 case SIZE_MAXIMIZED
:
2207 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2212 #ifndef __WXMICROWIN__
2213 case WM_ACTIVATEAPP
:
2214 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2220 WXWORD state
, minimized
;
2222 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2224 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2229 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2233 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2237 processed
= HandlePaint();
2241 #ifdef __WXUNIVERSAL__
2242 // Universal uses its own wxFrame/wxDialog, so we don't receive
2243 // close events unless we have this.
2248 // don't let the DefWindowProc() destroy our window - we'll do it
2249 // ourselves in ~wxWindow
2256 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2260 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2261 GET_Y_LPARAM(lParam
),
2265 #if wxUSE_MOUSEWHEEL
2267 processed
= HandleMouseWheel(wParam
, lParam
);
2271 case WM_LBUTTONDOWN
:
2273 case WM_LBUTTONDBLCLK
:
2274 case WM_RBUTTONDOWN
:
2276 case WM_RBUTTONDBLCLK
:
2277 case WM_MBUTTONDOWN
:
2279 case WM_MBUTTONDBLCLK
:
2281 #ifdef __WXMICROWIN__
2282 // MicroWindows seems to ignore the fact that a window is
2283 // disabled. So catch mouse events and throw them away if
2285 wxWindowMSW
* win
= this;
2288 if (!win
->IsEnabled())
2294 win
= win
->GetParent();
2295 if ( !win
|| win
->IsTopLevel() )
2302 #endif // __WXMICROWIN__
2303 int x
= GET_X_LPARAM(lParam
),
2304 y
= GET_Y_LPARAM(lParam
);
2306 // redirect the event to a static control if necessary by
2307 // finding one under mouse
2309 if ( GetCapture() == this )
2311 // but don't do it if the mouse is captured by this window
2312 // because then it should really get this event itself
2317 win
= FindWindowForMouseEvent(this, &x
, &y
);
2319 // this should never happen
2320 wxCHECK_MSG( win
, 0,
2321 _T("FindWindowForMouseEvent() returned NULL") );
2323 // for the standard classes their WndProc sets the focus to
2324 // them anyhow and doing it from here results in some weird
2325 // problems, but for our windows we want them to acquire
2326 // focus when clicked
2327 if ( !win
->IsOfStandardClass() )
2329 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2334 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2343 case MM_JOY1BUTTONDOWN
:
2344 case MM_JOY2BUTTONDOWN
:
2345 case MM_JOY1BUTTONUP
:
2346 case MM_JOY2BUTTONUP
:
2347 processed
= HandleJoystickEvent(message
,
2348 GET_X_LPARAM(lParam
),
2349 GET_Y_LPARAM(lParam
),
2352 #endif // __WXMICROWIN__
2355 processed
= HandleSysCommand(wParam
, lParam
);
2362 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2364 processed
= HandleCommand(id
, cmd
, hwnd
);
2370 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2374 // for these messages we must return TRUE if process the message
2377 case WM_MEASUREITEM
:
2379 int idCtrl
= (UINT
)wParam
;
2380 if ( message
== WM_DRAWITEM
)
2382 processed
= MSWOnDrawItem(idCtrl
,
2383 (WXDRAWITEMSTRUCT
*)lParam
);
2387 processed
= MSWOnMeasureItem(idCtrl
,
2388 (WXMEASUREITEMSTRUCT
*)lParam
);
2395 #endif // defined(WM_DRAWITEM)
2398 if ( !IsOfStandardClass() )
2400 // we always want to get the char events
2401 rc
.result
= DLGC_WANTCHARS
;
2403 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2405 // in fact, we want everything
2406 rc
.result
|= DLGC_WANTARROWS
|
2413 //else: get the dlg code from the DefWindowProc()
2418 // If this has been processed by an event handler, return 0 now
2419 // (we've handled it).
2420 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2421 if ( m_lastKeydownProcessed
)
2430 // we consider these message "not interesting" to OnChar, so
2431 // just don't do anything more with them
2441 // avoid duplicate messages to OnChar for these ASCII keys:
2442 // they will be translated by TranslateMessage() and received
2464 // but set processed to FALSE, not TRUE to still pass them
2465 // to the control's default window proc - otherwise
2466 // built-in keyboard handling won't work
2471 // special case of VK_APPS: treat it the same as right mouse
2472 // click because both usually pop up a context menu
2478 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2479 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2485 // do generate a CHAR event
2486 processed
= HandleChar((WORD
)wParam
, lParam
);
2489 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2496 // special case of VK_APPS: treat it the same as right mouse button
2497 if ( wParam
== VK_APPS
)
2502 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2503 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2508 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2513 case WM_CHAR
: // Always an ASCII character
2514 if ( m_lastKeydownProcessed
)
2516 // The key was handled in the EVT_KEY_DOWN and handling
2517 // a key in an EVT_KEY_DOWN handler is meant, by
2518 // design, to prevent EVT_CHARs from happening
2519 m_lastKeydownProcessed
= FALSE
;
2524 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2533 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2535 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2541 // CTLCOLOR messages are sent by children to query the parent for their
2542 // colors#ifndef __WXMICROWIN__
2543 #ifndef __WXMICROWIN__
2545 case WM_CTLCOLORMSGBOX
:
2546 case WM_CTLCOLOREDIT
:
2547 case WM_CTLCOLORLISTBOX
:
2548 case WM_CTLCOLORBTN
:
2549 case WM_CTLCOLORDLG
:
2550 case WM_CTLCOLORSCROLLBAR
:
2551 case WM_CTLCOLORSTATIC
:
2559 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2561 processed
= HandleCtlColor(&rc
.hBrush
,
2570 #endif // !__WXMICROWIN__
2572 case WM_SYSCOLORCHANGE
:
2573 // the return value for this message is ignored
2574 processed
= HandleSysColorChange();
2577 case WM_DISPLAYCHANGE
:
2578 processed
= HandleDisplayChange();
2581 case WM_PALETTECHANGED
:
2582 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2585 case WM_CAPTURECHANGED
:
2586 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2589 case WM_QUERYNEWPALETTE
:
2590 processed
= HandleQueryNewPalette();
2594 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2597 // we processed the message, i.e. erased the background
2603 processed
= HandleDropFiles(wParam
);
2607 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2611 // we never set focus from here
2616 case WM_QUERYENDSESSION
:
2617 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2621 processed
= HandleEndSession(wParam
!= 0, lParam
);
2624 case WM_GETMINMAXINFO
:
2625 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2629 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2630 LOWORD(lParam
), // hit test
2631 HIWORD(lParam
)); // mouse msg
2635 // returning TRUE stops the DefWindowProc() from further
2636 // processing this message - exactly what we need because we've
2637 // just set the cursor.
2642 #if wxUSE_ACCESSIBILITY
2645 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2646 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2648 if (dwObjId
== OBJID_CLIENT
&& GetOrCreateAccessible())
2650 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2656 #if defined(__WIN32__) && defined(WM_HELP)
2659 HELPINFO
* info
= (HELPINFO
*) lParam
;
2660 // Don't yet process menu help events, just windows
2661 if (info
->iContextType
== HELPINFO_WINDOW
)
2663 wxWindowMSW
* subjectOfHelp
= this;
2664 bool eventProcessed
= FALSE
;
2665 while (subjectOfHelp
&& !eventProcessed
)
2667 wxHelpEvent
helpEvent(wxEVT_HELP
,
2668 subjectOfHelp
->GetId(),
2669 wxPoint(info
->MousePos
.x
,
2670 info
->MousePos
.y
) );
2671 helpEvent
.SetEventObject(this);
2673 GetEventHandler()->ProcessEvent(helpEvent
);
2675 // Go up the window hierarchy until the event is
2677 subjectOfHelp
= subjectOfHelp
->GetParent();
2680 processed
= eventProcessed
;
2682 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2684 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2685 helpEvent
.SetEventObject(this);
2686 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2689 //else: processed is already FALSE
2693 case WM_CONTEXTMENU
:
2695 // we don't convert from screen to client coordinates as
2696 // the event may be handled by a parent window
2697 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2699 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2700 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2705 // we're only interested in our own menus, not MF_SYSMENU
2706 if ( HIWORD(wParam
) == MF_POPUP
)
2708 // handle menu chars for ownerdrawn menu items
2709 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2710 if ( i
!= wxNOT_FOUND
)
2712 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2724 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2725 wxGetMessageName(message
));
2727 #endif // __WXDEBUG__
2728 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2734 // ----------------------------------------------------------------------------
2735 // wxWindow <-> HWND map
2736 // ----------------------------------------------------------------------------
2738 wxWinHashTable
*wxWinHandleHash
= NULL
;
2740 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2742 return wxWinHandleHash
->Get((long)hWnd
);
2745 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2747 // adding NULL hWnd is (first) surely a result of an error and
2748 // (secondly) breaks menu command processing
2749 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2750 wxT("attempt to add a NULL hWnd to window list ignored") );
2752 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2754 if ( oldWin
&& (oldWin
!= win
) )
2756 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2757 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2760 #endif // __WXDEBUG__
2763 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2767 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2769 wxWinHandleHash
->Delete((long)win
->GetHWND());
2772 // ----------------------------------------------------------------------------
2773 // various MSW speciic class dependent functions
2774 // ----------------------------------------------------------------------------
2776 // Default destroyer - override if you destroy it in some other way
2777 // (e.g. with MDI child windows)
2778 void wxWindowMSW::MSWDestroyWindow()
2782 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2785 int& w
, int& h
) const
2787 static const int DEFAULT_Y
= 200;
2788 static const int DEFAULT_H
= 250;
2790 bool nonDefault
= FALSE
;
2794 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2795 // just as well set it to CW_USEDEFAULT as well
2801 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2802 // neither because it is not handled as a special value by Windows then
2803 // and so we have to choose some default value for it
2805 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2811 NB: there used to be some code here which set the initial size of the
2812 window to the client size of the parent if no explicit size was
2813 specified. This was wrong because wxWindows programs often assume
2814 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2815 it. To see why, you should understand that Windows sends WM_SIZE from
2816 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2817 from some base class ctor and so this WM_SIZE is not processed in the
2818 real class' OnSize() (because it's not fully constructed yet and the
2819 event goes to some base class OnSize() instead). So the WM_SIZE we
2820 rely on is the one sent when the parent frame resizes its children
2821 but here is the problem: if the child already has just the right
2822 size, nothing will happen as both wxWindows and Windows check for
2823 this and ignore any attempts to change the window size to the size it
2824 already has - so no WM_SIZE would be sent.
2828 // as above, h is not used at all in this case anyhow
2834 // and, again as above, we can't set the height to CW_USEDEFAULT here
2836 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2844 WXHWND
wxWindowMSW::MSWGetParent() const
2846 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
2849 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
2850 const wxChar
*title
,
2854 WXDWORD extendedStyle
)
2856 // choose the position/size for the new window
2858 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
2860 // controlId is menu handle for the top level windows, so set it to 0
2861 // unless we're creating a child window
2862 int controlId
= style
& WS_CHILD
? GetId() : 0;
2864 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2865 // which is the same but without CS_[HV]REDRAW class styles so using it
2866 // ensures that the window is not fully repainted on each resize
2867 wxString
className(wclass
);
2868 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
2870 className
+= wxT("NR");
2873 // do create the window
2874 wxWindowCreationHook
hook(this);
2876 m_hWnd
= (WXHWND
)::CreateWindowEx
2880 title
? title
: wxT(""),
2883 (HWND
)MSWGetParent(),
2886 NULL
// no extra data
2891 wxLogSysError(_("Can't create window of class %s"), wclass
);
2896 SubclassWin(m_hWnd
);
2898 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
2903 // ===========================================================================
2904 // MSW message handlers
2905 // ===========================================================================
2907 // ---------------------------------------------------------------------------
2909 // ---------------------------------------------------------------------------
2913 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
2915 #ifndef __WXMICROWIN__
2916 LPNMHDR hdr
= (LPNMHDR
)lParam
;
2917 HWND hWnd
= hdr
->hwndFrom
;
2918 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
2920 // if the control is one of our windows, let it handle the message itself
2923 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
2926 // VZ: why did we do it? normally this is unnecessary and, besides, it
2927 // breaks the message processing for the toolbars because the tooltip
2928 // notifications were being forwarded to the toolbar child controls
2929 // (if it had any) before being passed to the toolbar itself, so in my
2930 // example the tooltip for the combobox was always shown instead of the
2931 // correct button tooltips
2933 // try all our children
2934 wxWindowList::Node
*node
= GetChildren().GetFirst();
2937 wxWindow
*child
= node
->GetData();
2938 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
2943 node
= node
->GetNext();
2947 // by default, handle it ourselves
2948 return MSWOnNotify(idCtrl
, lParam
, result
);
2949 #else // __WXMICROWIN__
2956 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
2958 const wxString
& ttip
)
2960 // I don't know why it happens, but the versions of comctl32.dll starting
2961 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
2962 // this message is supposed to be sent to Unicode programs only) -- hence
2963 // we need to handle it as well, otherwise no tooltips will be shown in
2966 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
2968 // not a tooltip message or no tooltip to show anyhow
2972 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
2975 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
2977 // we pass just the pointer as we store the string internally anyhow
2978 ttText
->lpszText
= (char *)ttip
.c_str();
2980 else // TTN_NEEDTEXTW
2984 // in Unicode mode this is just what we need
2985 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
2987 MultiByteToWideChar(CP_ACP
, 0, ttip
, ttip
.length()+1,
2988 (wchar_t *)ttText
->szText
,
2989 sizeof(ttText
->szText
) / sizeof(wchar_t));
2990 #endif // Unicode/!Unicode
2996 #endif // wxUSE_TOOLTIPS
2998 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3000 WXLPARAM
* WXUNUSED(result
))
3005 NMHDR
* hdr
= (NMHDR
*)lParam
;
3006 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3012 #endif // wxUSE_TOOLTIPS
3019 // ---------------------------------------------------------------------------
3020 // end session messages
3021 // ---------------------------------------------------------------------------
3023 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3025 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3026 event
.SetEventObject(wxTheApp
);
3027 event
.SetCanVeto(TRUE
);
3028 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3030 bool rc
= wxTheApp
->ProcessEvent(event
);
3034 // we may end only if the app didn't veto session closing (double
3036 *mayEnd
= !event
.GetVeto();
3042 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3044 // do nothing if the session isn't ending
3049 if ( (this != wxTheApp
->GetTopWindow()) )
3052 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3053 event
.SetEventObject(wxTheApp
);
3054 event
.SetCanVeto(FALSE
);
3055 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3057 return wxTheApp
->ProcessEvent(event
);
3060 // ---------------------------------------------------------------------------
3061 // window creation/destruction
3062 // ---------------------------------------------------------------------------
3064 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3066 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3067 // parent as well as otherwise several Win32 functions using
3068 // GetNextDlgTabItem() to iterate over all controls such as
3069 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3070 // all of them iterate over all the controls starting from the focus and
3071 // stop iterating when they get back to the focus but unless all parents
3072 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3073 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3075 // there is no need to do anything for the top level windows
3076 const wxWindow
*parent
= GetParent();
3077 while ( parent
&& !parent
->IsTopLevel() )
3079 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
3080 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
3082 // force the parent to have this style
3083 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
3084 exStyle
| WS_EX_CONTROLPARENT
);
3087 parent
= parent
->GetParent();
3091 // TODO: should generate this event from WM_NCCREATE
3092 wxWindowCreateEvent
event((wxWindow
*)this);
3093 (void)GetEventHandler()->ProcessEvent(event
);
3100 bool wxWindowMSW::HandleDestroy()
3104 // delete our drop target if we've got one
3105 #if wxUSE_DRAG_AND_DROP
3106 if ( m_dropTarget
!= NULL
)
3108 m_dropTarget
->Revoke(m_hWnd
);
3110 delete m_dropTarget
;
3111 m_dropTarget
= NULL
;
3113 #endif // wxUSE_DRAG_AND_DROP
3115 // WM_DESTROY handled
3119 // ---------------------------------------------------------------------------
3121 // ---------------------------------------------------------------------------
3123 bool wxWindowMSW::HandleActivate(int state
,
3124 bool WXUNUSED(minimized
),
3125 WXHWND
WXUNUSED(activate
))
3127 wxActivateEvent
event(wxEVT_ACTIVATE
,
3128 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3130 event
.SetEventObject(this);
3132 return GetEventHandler()->ProcessEvent(event
);
3135 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3137 // notify the parent keeping track of focus for the kbd navigation
3138 // purposes that we got it
3139 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3140 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3146 m_caret
->OnSetFocus();
3148 #endif // wxUSE_CARET
3151 // If it's a wxTextCtrl don't send the event as it will be done
3152 // after the control gets to process it from EN_FOCUS handler
3153 if ( wxDynamicCastThis(wxTextCtrl
) )
3157 #endif // wxUSE_TEXTCTRL
3159 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3160 event
.SetEventObject(this);
3162 // wxFindWinFromHandle() may return NULL, it is ok
3163 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3165 return GetEventHandler()->ProcessEvent(event
);
3168 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3174 m_caret
->OnKillFocus();
3176 #endif // wxUSE_CARET
3179 // If it's a wxTextCtrl don't send the event as it will be done
3180 // after the control gets to process it.
3181 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3188 // Don't send the event when in the process of being deleted. This can
3189 // only cause problems if the event handler tries to access the object.
3190 if ( m_isBeingDeleted
)
3195 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3196 event
.SetEventObject(this);
3198 // wxFindWinFromHandle() may return NULL, it is ok
3199 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3201 return GetEventHandler()->ProcessEvent(event
);
3204 // ---------------------------------------------------------------------------
3206 // ---------------------------------------------------------------------------
3208 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3210 wxShowEvent
event(GetId(), show
);
3211 event
.m_eventObject
= this;
3213 return GetEventHandler()->ProcessEvent(event
);
3216 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3218 wxInitDialogEvent
event(GetId());
3219 event
.m_eventObject
= this;
3221 return GetEventHandler()->ProcessEvent(event
);
3224 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3226 #if defined (__WXMICROWIN__)
3228 #else // __WXMICROWIN__
3229 HDROP hFilesInfo
= (HDROP
) wParam
;
3231 // Get the total number of files dropped
3232 UINT gwFilesDropped
= ::DragQueryFile
3240 wxString
*files
= new wxString
[gwFilesDropped
];
3241 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3243 // first get the needed buffer length (+1 for terminating NUL)
3244 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3246 // and now get the file name
3247 ::DragQueryFile(hFilesInfo
, wIndex
,
3248 files
[wIndex
].GetWriteBuf(len
), len
);
3250 files
[wIndex
].UngetWriteBuf();
3252 DragFinish (hFilesInfo
);
3254 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3255 event
.m_eventObject
= this;
3258 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3259 event
.m_pos
.x
= dropPoint
.x
;
3260 event
.m_pos
.y
= dropPoint
.y
;
3262 return GetEventHandler()->ProcessEvent(event
);
3266 #ifdef __DIGITALMARS__
3267 extern "C" HCURSOR
wxGetCurrentBusyCursor();
3270 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3272 int WXUNUSED(mouseMsg
))
3274 #ifndef __WXMICROWIN__
3275 // the logic is as follows:
3276 // -1. don't set cursor for non client area, including but not limited to
3277 // the title bar, scrollbars, &c
3278 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3279 // 1. if we have the cursor set it unless wxIsBusy()
3280 // 2. if we're a top level window, set some cursor anyhow
3281 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3283 if ( nHitTest
!= HTCLIENT
)
3288 HCURSOR hcursor
= 0;
3290 // first ask the user code - it may wish to set the cursor in some very
3291 // specific way (for example, depending on the current position)
3294 if ( !::GetCursorPos(&pt
) )
3296 wxLogLastError(wxT("GetCursorPos"));
3299 // In WIN16 it doesn't return a value.
3300 ::GetCursorPos(&pt
);
3305 ScreenToClient(&x
, &y
);
3306 wxSetCursorEvent
event(x
, y
);
3308 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3309 if ( processedEvtSetCursor
&& event
.HasCursor() )
3311 hcursor
= GetHcursorOf(event
.GetCursor());
3316 bool isBusy
= wxIsBusy();
3318 // the test for processedEvtSetCursor is here to prevent using m_cursor
3319 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3320 // it - this is a way to say that our cursor shouldn't be used for this
3322 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3324 hcursor
= GetHcursorOf(m_cursor
);
3331 hcursor
= wxGetCurrentBusyCursor();
3333 else if ( !hcursor
)
3335 const wxCursor
*cursor
= wxGetGlobalCursor();
3336 if ( cursor
&& cursor
->Ok() )
3338 hcursor
= GetHcursorOf(*cursor
);
3346 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3348 ::SetCursor(hcursor
);
3350 // cursor set, stop here
3353 #endif // __WXMICROWIN__
3355 // pass up the window chain
3359 // ---------------------------------------------------------------------------
3360 // owner drawn stuff
3361 // ---------------------------------------------------------------------------
3363 bool wxWindowMSW::MSWOnDrawItem(int id
, WXDRAWITEMSTRUCT
*itemStruct
)
3365 #if wxUSE_OWNER_DRAWN
3367 #if wxUSE_MENUS_NATIVE
3368 // is it a menu item?
3369 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3370 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3372 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3374 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3376 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3377 // the DC from being released
3378 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3379 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3380 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3381 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3383 return pMenuItem
->OnDrawItem
3387 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3388 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3391 #endif // wxUSE_MENUS_NATIVE
3394 wxWindow
*item
= FindItem(id
);
3395 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3397 return ((wxControl
*)item
)->MSWOnDraw(itemStruct
);
3399 #endif // wxUSE_CONTROLS
3401 #endif // USE_OWNER_DRAWN
3406 bool wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3408 #if wxUSE_OWNER_DRAWN
3409 // is it a menu item?
3410 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3411 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3413 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3415 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3417 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3418 &pMeasureStruct
->itemHeight
);
3421 wxWindow
*item
= FindItem(id
);
3422 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3424 return ((wxControl
*)item
)->MSWOnMeasure(itemStruct
);
3426 #endif // owner-drawn menus
3430 // ---------------------------------------------------------------------------
3431 // colours and palettes
3432 // ---------------------------------------------------------------------------
3434 bool wxWindowMSW::HandleSysColorChange()
3436 wxSysColourChangedEvent event
;
3437 event
.SetEventObject(this);
3439 (void)GetEventHandler()->ProcessEvent(event
);
3441 // always let the system carry on the default processing to allow the
3442 // native controls to react to the colours update
3446 bool wxWindowMSW::HandleDisplayChange()
3448 wxDisplayChangedEvent event
;
3449 event
.SetEventObject(this);
3451 return GetEventHandler()->ProcessEvent(event
);
3454 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3462 #ifndef __WXMICROWIN__
3463 WXHBRUSH hBrush
= 0;
3465 if ( nCtlColor
== CTLCOLOR_DLG
)
3467 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3472 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3474 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3476 #endif // wxUSE_CONTROLS
3482 #else // __WXMICROWIN__
3487 // Define for each class of dialog and control
3488 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3489 WXHWND
WXUNUSED(hWnd
),
3490 WXUINT
WXUNUSED(nCtlColor
),
3491 WXUINT
WXUNUSED(message
),
3492 WXWPARAM
WXUNUSED(wParam
),
3493 WXLPARAM
WXUNUSED(lParam
))
3498 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3501 // same as below except we don't respond to our own messages
3502 if ( hWndPalChange
!= GetHWND() )
3504 // check to see if we our our parents have a custom palette
3505 wxWindowMSW
*win
= this;
3506 while ( win
&& !win
->HasCustomPalette() )
3508 win
= win
->GetParent();
3511 if ( win
&& win
->HasCustomPalette() )
3513 // realize the palette to see whether redrawing is needed
3514 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3515 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3516 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3518 int result
= ::RealizePalette(hdc
);
3520 // restore the palette (before releasing the DC)
3521 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3522 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3523 ::RealizePalette(hdc
);
3524 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3526 // now check for the need to redraw
3528 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3532 #endif // wxUSE_PALETTE
3534 wxPaletteChangedEvent
event(GetId());
3535 event
.SetEventObject(this);
3536 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3538 return GetEventHandler()->ProcessEvent(event
);
3541 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3543 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3544 event
.SetEventObject(this);
3546 return GetEventHandler()->ProcessEvent(event
);
3549 bool wxWindowMSW::HandleQueryNewPalette()
3553 // check to see if we our our parents have a custom palette
3554 wxWindowMSW
*win
= this;
3555 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3556 if (win
->HasCustomPalette()) {
3557 /* realize the palette to see whether redrawing is needed */
3558 HDC hdc
= GetDC((HWND
) GetHWND());
3559 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3560 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3562 int result
= ::RealizePalette(hdc
);
3563 /* restore the palette (before releasing the DC) */
3564 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3565 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3566 ::RealizePalette(hdc
);
3567 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3568 /* now check for the need to redraw */
3570 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3572 #endif // wxUSE_PALETTE
3574 wxQueryNewPaletteEvent
event(GetId());
3575 event
.SetEventObject(this);
3577 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3580 // Responds to colour changes: passes event on to children.
3581 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3583 // the top level window also reset the standard colour map as it might have
3584 // changed (there is no need to do it for the non top level windows as we
3585 // only have to do it once)
3589 gs_hasStdCmap
= FALSE
;
3591 wxWindowList::Node
*node
= GetChildren().GetFirst();
3594 // Only propagate to non-top-level windows because Windows already
3595 // sends this event to all top-level ones
3596 wxWindow
*win
= node
->GetData();
3597 if ( !win
->IsTopLevel() )
3599 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3600 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3601 // the standard controls
3602 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3605 node
= node
->GetNext();
3608 // update the colours we use if they were not set explicitly by the user:
3609 // this must be done or OnCtlColor() would continue to use the old colours
3612 m_foregroundColour
= wxSystemSettings::
3613 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3618 m_backgroundColour
= wxSystemSettings::
3619 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3623 extern wxCOLORMAP
*wxGetStdColourMap()
3625 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3626 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3628 if ( !gs_hasStdCmap
)
3630 static bool s_coloursInit
= FALSE
;
3632 if ( !s_coloursInit
)
3634 // When a bitmap is loaded, the RGB values can change (apparently
3635 // because Windows adjusts them to care for the old programs always
3636 // using 0xc0c0c0 while the transparent colour for the new Windows
3637 // versions is different). But we do this adjustment ourselves so
3638 // we want to avoid Windows' "help" and for this we need to have a
3639 // reference bitmap which can tell us what the RGB values change
3641 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3642 if ( stdColourBitmap
.Ok() )
3644 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3645 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3646 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3649 memDC
.SelectObject(stdColourBitmap
);
3652 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3654 memDC
.GetPixel(i
, 0, &colour
);
3655 s_stdColours
[i
] = wxColourToRGB(colour
);
3658 else // wxBITMAP_STD_COLOURS couldn't be loaded
3660 s_stdColours
[0] = RGB(000,000,000); // black
3661 s_stdColours
[1] = RGB(128,128,128); // dark grey
3662 s_stdColours
[2] = RGB(192,192,192); // light grey
3663 s_stdColours
[3] = RGB(255,255,255); // white
3664 //s_stdColours[4] = RGB(000,000,255); // blue
3665 //s_stdColours[5] = RGB(255,000,255); // magenta
3668 s_coloursInit
= TRUE
;
3671 gs_hasStdCmap
= TRUE
;
3673 // create the colour map
3674 #define INIT_CMAP_ENTRY(col) \
3675 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3676 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3678 INIT_CMAP_ENTRY(BTNTEXT
);
3679 INIT_CMAP_ENTRY(BTNSHADOW
);
3680 INIT_CMAP_ENTRY(BTNFACE
);
3681 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3683 #undef INIT_CMAP_ENTRY
3689 // ---------------------------------------------------------------------------
3691 // ---------------------------------------------------------------------------
3693 bool wxWindowMSW::HandlePaint()
3696 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3698 wxLogLastError(wxT("CreateRectRgn"));
3699 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3700 wxLogLastError(wxT("GetUpdateRgn"));
3702 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3705 ::GetUpdateRect(GetHwnd(), &updateRect
, FALSE
);
3707 m_updateRegion
= wxRegion(updateRect
.left
, updateRect
.top
,
3708 updateRect
.right
- updateRect
.left
,
3709 updateRect
.bottom
- updateRect
.top
);
3712 wxPaintEvent
event(m_windowId
);
3713 event
.SetEventObject(this);
3715 bool processed
= GetEventHandler()->ProcessEvent(event
);
3717 // note that we must generate NC event after the normal one as otherwise
3718 // BeginPaint() will happily overwrite our decorations with the background
3720 wxNcPaintEvent
eventNc(m_windowId
);
3721 eventNc
.SetEventObject(this);
3722 GetEventHandler()->ProcessEvent(eventNc
);
3727 // Can be called from an application's OnPaint handler
3728 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3730 #ifdef __WXUNIVERSAL__
3733 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3736 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3741 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3743 // Prevents flicker when dragging
3744 if ( ::IsIconic(GetHwnd()) )
3750 dc
.SetWindow((wxWindow
*)this);
3753 wxEraseEvent
event(m_windowId
, &dc
);
3754 event
.SetEventObject(this);
3755 bool rc
= GetEventHandler()->ProcessEvent(event
);
3759 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3760 dc
.SelectOldObjects(hdc
);
3765 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3768 ::GetClientRect(GetHwnd(), &rect
);
3770 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3771 m_backgroundColour
.Green(),
3772 m_backgroundColour
.Blue());
3773 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3775 wxLogLastError(wxT("CreateSolidBrush"));
3777 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
3779 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
3781 ::FillRect(hdc
, &rect
, hBrush
);
3782 ::DeleteObject(hBrush
);
3783 ::SetMapMode(hdc
, mode
);
3786 // ---------------------------------------------------------------------------
3787 // moving and resizing
3788 // ---------------------------------------------------------------------------
3790 bool wxWindowMSW::HandleMinimize()
3792 wxIconizeEvent
event(m_windowId
);
3793 event
.SetEventObject(this);
3795 return GetEventHandler()->ProcessEvent(event
);
3798 bool wxWindowMSW::HandleMaximize()
3800 wxMaximizeEvent
event(m_windowId
);
3801 event
.SetEventObject(this);
3803 return GetEventHandler()->ProcessEvent(event
);
3806 bool wxWindowMSW::HandleMove(int x
, int y
)
3808 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
3809 event
.SetEventObject(this);
3811 return GetEventHandler()->ProcessEvent(event
);
3814 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
3815 WXUINT
WXUNUSED(flag
))
3817 // don't use w and h parameters as they specify the client size while
3818 // according to the docs EVT_SIZE handler is supposed to receive the total
3820 wxSizeEvent
event(GetSize(), m_windowId
);
3821 event
.SetEventObject(this);
3823 return GetEventHandler()->ProcessEvent(event
);
3826 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
3828 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
3832 int minWidth
= GetMinWidth(),
3833 minHeight
= GetMinHeight(),
3834 maxWidth
= GetMaxWidth(),
3835 maxHeight
= GetMaxHeight();
3837 if ( minWidth
!= -1 )
3839 info
->ptMinTrackSize
.x
= minWidth
;
3843 if ( minHeight
!= -1 )
3845 info
->ptMinTrackSize
.y
= minHeight
;
3849 if ( maxWidth
!= -1 )
3851 info
->ptMaxTrackSize
.x
= maxWidth
;
3855 if ( maxHeight
!= -1 )
3857 info
->ptMaxTrackSize
.y
= maxHeight
;
3864 // ---------------------------------------------------------------------------
3866 // ---------------------------------------------------------------------------
3868 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
3870 #if wxUSE_MENUS_NATIVE
3871 if ( !cmd
&& wxCurrentPopupMenu
)
3873 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
3874 wxCurrentPopupMenu
= NULL
;
3876 return popupMenu
->MSWCommand(cmd
, id
);
3878 #endif // wxUSE_MENUS_NATIVE
3880 wxWindow
*win
= NULL
;
3882 // first try to find it from HWND - this works even with the broken
3883 // programs using the same ids for different controls
3886 win
= wxFindWinFromHandle(control
);
3892 // must cast to a signed type before comparing with other ids!
3893 win
= FindItem((signed short)id
);
3898 return win
->MSWCommand(cmd
, id
);
3901 // the messages sent from the in-place edit control used by the treectrl
3902 // for label editing have id == 0, but they should _not_ be treated as menu
3903 // messages (they are EN_XXX ones, in fact) so don't translate anything
3904 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
3907 // If no child window, it may be an accelerator, e.g. for a popup menu
3910 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
3911 event
.SetEventObject(this);
3915 return GetEventHandler()->ProcessEvent(event
);
3917 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
3920 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
3921 // notifications to its parent which we want to reflect back to
3923 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
3924 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
3927 #endif // wxUSE_SPINCTRL
3932 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
3934 // 4 bits are reserved
3935 switch ( wParam
& 0xFFFFFFF0 )
3938 return HandleMaximize();
3941 return HandleMinimize();
3947 // ---------------------------------------------------------------------------
3949 // ---------------------------------------------------------------------------
3951 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
3955 // our client coords are not quite the same as Windows ones
3956 wxPoint pt
= GetClientAreaOrigin();
3957 event
.m_x
= x
- pt
.x
;
3958 event
.m_y
= y
- pt
.y
;
3960 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
3961 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
3962 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
3963 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
3964 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
3965 event
.m_altDown
= (::GetKeyState(VK_MENU
) & 0x80000000) != 0;
3967 event
.SetTimestamp(s_currentMsg
.time
);
3968 event
.m_eventObject
= this;
3969 event
.SetId(GetId());
3971 #if wxUSE_MOUSEEVENT_HACK
3974 m_lastMouseEvent
= event
.GetEventType();
3975 #endif // wxUSE_MOUSEEVENT_HACK
3978 // Windows doesn't send the mouse events to the static controls (which are
3979 // transparent in the sense that their WM_NCHITTEST handler returns
3980 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
3981 // and so we manually check if we don't have a child window under mouse and if
3982 // we do, send the event to it instead of the window Windows had sent WM_XXX
3985 // Notice that this is not done for the mouse move events because this could
3986 // (would?) be too slow, but only for clicks which means that the static texts
3987 // still don't get move, enter nor leave events.
3988 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
3990 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
3992 // first try to find a non transparent child: this allows us to send events
3993 // to a static text which is inside a static box, for example
3994 POINT pt
= { *x
, *y
};
3995 HWND hwnd
= GetHwndOf(win
),
3999 hwndUnderMouse
= ::ChildWindowFromPointEx
4008 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4011 // now try any child window at all
4012 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4015 // check that we have a child window which is susceptible to receive mouse
4016 // events: for this it must be shown and enabled
4017 if ( hwndUnderMouse
&&
4018 hwndUnderMouse
!= hwnd
&&
4019 ::IsWindowVisible(hwndUnderMouse
) &&
4020 ::IsWindowEnabled(hwndUnderMouse
) )
4022 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4023 if ( winUnderMouse
)
4025 // translate the mouse coords to the other window coords
4026 win
->ClientToScreen(x
, y
);
4027 winUnderMouse
->ScreenToClient(x
, y
);
4029 win
= winUnderMouse
;
4036 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4038 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4039 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4040 // from the message id and take the value in the table to get wxWin event
4042 static const wxEventType eventsMouse
[] =
4056 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4057 InitMouseEvent(event
, x
, y
, flags
);
4059 return GetEventHandler()->ProcessEvent(event
);
4062 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4064 if ( !m_mouseInWindow
)
4066 // it would be wrong to assume that just because we get a mouse move
4067 // event that the mouse is inside the window: although this is usually
4068 // true, it is not if we had captured the mouse, so we need to check
4069 // the mouse coordinates here
4070 if ( !HasCapture() || IsMouseInWindow() )
4072 // Generate an ENTER event
4073 m_mouseInWindow
= TRUE
;
4075 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4076 InitMouseEvent(event
, x
, y
, flags
);
4078 (void)GetEventHandler()->ProcessEvent(event
);
4082 #if wxUSE_MOUSEEVENT_HACK
4083 // Window gets a click down message followed by a mouse move message even
4084 // if position isn't changed! We want to discard the trailing move event
4085 // if x and y are the same.
4086 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4087 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4088 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4089 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4091 m_lastMouseEvent
= wxEVT_MOTION
;
4095 #endif // wxUSE_MOUSEEVENT_HACK
4097 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4101 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4103 #if wxUSE_MOUSEWHEEL
4104 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4105 InitMouseEvent(event
,
4106 GET_X_LPARAM(lParam
),
4107 GET_Y_LPARAM(lParam
),
4109 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4110 event
.m_wheelDelta
= WHEEL_DELTA
;
4113 static int s_linesPerRotation
= -1;
4114 if ( s_linesPerRotation
== -1 )
4116 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4117 &s_linesPerRotation
, 0))
4119 // this is not supposed to happen
4120 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4122 // the default is 3, so use it if SystemParametersInfo() failed
4123 s_linesPerRotation
= 3;
4127 // no SystemParametersInfo() under Win16
4128 static const int s_linesPerRotation
= 3;
4131 event
.m_linesPerAction
= s_linesPerRotation
;
4132 return GetEventHandler()->ProcessEvent(event
);
4143 // ---------------------------------------------------------------------------
4144 // keyboard handling
4145 // ---------------------------------------------------------------------------
4147 // create the key event of the given type for the given key - used by
4148 // HandleChar and HandleKeyDown/Up
4149 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4152 WXWPARAM wParam
) const
4154 wxKeyEvent
event(evType
);
4155 event
.SetId(GetId());
4156 event
.m_shiftDown
= wxIsShiftDown();
4157 event
.m_controlDown
= wxIsCtrlDown();
4158 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4160 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4161 event
.m_keyCode
= id
;
4162 event
.m_rawCode
= (wxUint32
) wParam
;
4163 event
.m_rawFlags
= (wxUint32
) lParam
;
4164 event
.SetTimestamp(s_currentMsg
.time
);
4166 // translate the position to client coords
4170 GetWindowRect(GetHwnd(),&rect
);
4180 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4182 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4184 bool ctrlDown
= FALSE
;
4189 // If 1 -> 26, translate to either special keycode or just set
4190 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4191 // ControlDown() == TRUE.
4193 if ( (id
> 0) && (id
< 27) )
4215 else // we're called from WM_KEYDOWN
4217 id
= wxCharCodeMSWToWX(wParam
);
4220 // it's ASCII and will be processed here only when called from
4221 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4226 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4228 // the alphanumeric keys produced by pressing AltGr+something on European
4229 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4230 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4231 // alphanumeric, so pretend that there are no modifiers at all (the
4232 // KEY_DOWN event would still have the correct modifiers if they're really
4234 if ( event
.m_controlDown
&& event
.m_altDown
&&
4235 (id
>= 32 && id
< 256) )
4237 event
.m_controlDown
=
4238 event
.m_altDown
= FALSE
;
4241 return GetEventHandler()->ProcessEvent(event
);
4244 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4246 int id
= wxCharCodeMSWToWX(wParam
);
4250 // normal ASCII char
4254 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4256 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4257 if ( GetEventHandler()->ProcessEvent(event
) )
4266 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4268 int id
= wxCharCodeMSWToWX(wParam
);
4272 // normal ASCII char
4276 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4278 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4279 if ( GetEventHandler()->ProcessEvent(event
) )
4288 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4290 const HMENU hmenu
= (HMENU
)lParam
;
4294 mii
.cbSize
= sizeof(MENUITEMINFO
);
4295 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4297 // find if we have this letter in any owner drawn item
4298 const int count
= ::GetMenuItemCount(hmenu
);
4299 for ( int i
= 0; i
< count
; i
++ )
4301 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4303 if ( mii
.fType
== MFT_OWNERDRAW
)
4305 // dwItemData member of the MENUITEMINFO is a
4306 // pointer to the associated wxMenuItem -- see the
4307 // menu creation code
4308 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4310 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4313 if ( *p
== _T('&') )
4315 // this is not the accel char, find the real one
4316 p
= wxStrchr(p
+ 1, _T('&'));
4318 else // got the accel char
4320 // FIXME-UNICODE: this comparison doesn't risk to work
4321 // for non ASCII accelerator characters I'm afraid, but
4323 if ( wxToupper(*p
) == chAccel
)
4329 // this one doesn't match
4336 else // failed ot get the menu text?
4338 // it's not fatal, so don't show error, but still log
4340 wxLogLastError(_T("GetMenuItemInfo"));
4349 // ---------------------------------------------------------------------------
4351 // ---------------------------------------------------------------------------
4353 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4357 if ( flags
& JOY_BUTTON1CHG
)
4358 change
= wxJOY_BUTTON1
;
4359 if ( flags
& JOY_BUTTON2CHG
)
4360 change
= wxJOY_BUTTON2
;
4361 if ( flags
& JOY_BUTTON3CHG
)
4362 change
= wxJOY_BUTTON3
;
4363 if ( flags
& JOY_BUTTON4CHG
)
4364 change
= wxJOY_BUTTON4
;
4367 if ( flags
& JOY_BUTTON1
)
4368 buttons
|= wxJOY_BUTTON1
;
4369 if ( flags
& JOY_BUTTON2
)
4370 buttons
|= wxJOY_BUTTON2
;
4371 if ( flags
& JOY_BUTTON3
)
4372 buttons
|= wxJOY_BUTTON3
;
4373 if ( flags
& JOY_BUTTON4
)
4374 buttons
|= wxJOY_BUTTON4
;
4376 // the event ids aren't consecutive so we can't use table based lookup
4378 wxEventType eventType
;
4383 eventType
= wxEVT_JOY_MOVE
;
4388 eventType
= wxEVT_JOY_MOVE
;
4393 eventType
= wxEVT_JOY_ZMOVE
;
4398 eventType
= wxEVT_JOY_ZMOVE
;
4401 case MM_JOY1BUTTONDOWN
:
4403 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4406 case MM_JOY2BUTTONDOWN
:
4408 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4411 case MM_JOY1BUTTONUP
:
4413 eventType
= wxEVT_JOY_BUTTON_UP
;
4416 case MM_JOY2BUTTONUP
:
4418 eventType
= wxEVT_JOY_BUTTON_UP
;
4422 wxFAIL_MSG(wxT("no such joystick event"));
4427 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4428 event
.SetPosition(wxPoint(x
, y
));
4429 event
.SetEventObject(this);
4431 return GetEventHandler()->ProcessEvent(event
);
4437 // ---------------------------------------------------------------------------
4439 // ---------------------------------------------------------------------------
4441 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4442 WXWORD pos
, WXHWND control
)
4446 wxWindow
*child
= wxFindWinFromHandle(control
);
4448 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4451 wxScrollWinEvent event
;
4452 event
.SetPosition(pos
);
4453 event
.SetOrientation(orientation
);
4454 event
.m_eventObject
= this;
4459 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4463 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4467 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4471 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4475 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4479 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4482 case SB_THUMBPOSITION
:
4485 // under Win32, the scrollbar range and position are 32 bit integers,
4486 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4487 // explicitly query the scrollbar for the correct position (this must
4488 // be done only for these two SB_ events as they are the only one
4489 // carrying the scrollbar position)
4491 WinStruct
<SCROLLINFO
> scrollInfo
;
4492 scrollInfo
.fMask
= SIF_TRACKPOS
;
4494 if ( !::GetScrollInfo(GetHwnd(),
4495 orientation
== wxHORIZONTAL
? SB_HORZ
4499 wxLogLastError(_T("GetScrollInfo"));
4502 event
.SetPosition(scrollInfo
.nTrackPos
);
4506 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4507 ? wxEVT_SCROLLWIN_THUMBRELEASE
4508 : wxEVT_SCROLLWIN_THUMBTRACK
;
4515 return GetEventHandler()->ProcessEvent(event
);
4518 // ===========================================================================
4520 // ===========================================================================
4522 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4525 HDC dc
= ::GetDC((HWND
) wnd
);
4530 // the_font->UseResource();
4531 // the_font->RealizeResource();
4532 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4534 was
= (HFONT
) SelectObject(dc
,fnt
);
4536 GetTextMetrics(dc
, &tm
);
4537 if ( the_font
&& fnt
&& was
)
4539 SelectObject(dc
,was
);
4541 ReleaseDC((HWND
)wnd
, dc
);
4544 *x
= tm
.tmAveCharWidth
;
4546 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4549 // the_font->ReleaseResource();
4552 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4553 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4554 int wxCharCodeMSWToWX(int keySym
)
4559 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4560 case VK_BACK
: id
= WXK_BACK
; break;
4561 case VK_TAB
: id
= WXK_TAB
; break;
4562 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4563 case VK_RETURN
: id
= WXK_RETURN
; break;
4564 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4565 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4566 case VK_MENU
: id
= WXK_MENU
; break;
4567 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4568 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4569 case VK_SPACE
: id
= WXK_SPACE
; break;
4570 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4571 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4572 case VK_NEXT
: id
= WXK_NEXT
; break;
4573 case VK_END
: id
= WXK_END
; break;
4574 case VK_HOME
: id
= WXK_HOME
; break;
4575 case VK_LEFT
: id
= WXK_LEFT
; break;
4576 case VK_UP
: id
= WXK_UP
; break;
4577 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4578 case VK_DOWN
: id
= WXK_DOWN
; break;
4579 case VK_SELECT
: id
= WXK_SELECT
; break;
4580 case VK_PRINT
: id
= WXK_PRINT
; break;
4581 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4582 case VK_INSERT
: id
= WXK_INSERT
; break;
4583 case VK_DELETE
: id
= WXK_DELETE
; break;
4584 case VK_HELP
: id
= WXK_HELP
; break;
4585 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4586 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4587 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4588 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4589 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4590 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4591 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4592 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4593 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4594 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4595 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4596 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4597 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4598 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4599 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4600 case VK_F1
: id
= WXK_F1
; break;
4601 case VK_F2
: id
= WXK_F2
; break;
4602 case VK_F3
: id
= WXK_F3
; break;
4603 case VK_F4
: id
= WXK_F4
; break;
4604 case VK_F5
: id
= WXK_F5
; break;
4605 case VK_F6
: id
= WXK_F6
; break;
4606 case VK_F7
: id
= WXK_F7
; break;
4607 case VK_F8
: id
= WXK_F8
; break;
4608 case VK_F9
: id
= WXK_F9
; break;
4609 case VK_F10
: id
= WXK_F10
; break;
4610 case VK_F11
: id
= WXK_F11
; break;
4611 case VK_F12
: id
= WXK_F12
; break;
4612 case VK_F13
: id
= WXK_F13
; break;
4613 case VK_F14
: id
= WXK_F14
; break;
4614 case VK_F15
: id
= WXK_F15
; break;
4615 case VK_F16
: id
= WXK_F16
; break;
4616 case VK_F17
: id
= WXK_F17
; break;
4617 case VK_F18
: id
= WXK_F18
; break;
4618 case VK_F19
: id
= WXK_F19
; break;
4619 case VK_F20
: id
= WXK_F20
; break;
4620 case VK_F21
: id
= WXK_F21
; break;
4621 case VK_F22
: id
= WXK_F22
; break;
4622 case VK_F23
: id
= WXK_F23
; break;
4623 case VK_F24
: id
= WXK_F24
; break;
4624 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4625 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4627 case VK_OEM_1
: id
= ';'; break;
4628 case VK_OEM_PLUS
: id
= '+'; break;
4629 case VK_OEM_COMMA
: id
= ','; break;
4630 case VK_OEM_MINUS
: id
= '-'; break;
4631 case VK_OEM_PERIOD
: id
= '.'; break;
4632 case VK_OEM_2
: id
= '/'; break;
4633 case VK_OEM_3
: id
= '~'; break;
4634 case VK_OEM_4
: id
= '['; break;
4635 case VK_OEM_5
: id
= '\\'; break;
4636 case VK_OEM_6
: id
= ']'; break;
4637 case VK_OEM_7
: id
= '\''; break;
4640 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4641 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4642 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4643 #endif // VK_APPS defined
4652 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4658 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4659 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4660 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4661 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4662 case WXK_MENU
: keySym
= VK_MENU
; break;
4663 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4664 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4665 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4666 case WXK_END
: keySym
= VK_END
; break;
4667 case WXK_HOME
: keySym
= VK_HOME
; break;
4668 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4669 case WXK_UP
: keySym
= VK_UP
; break;
4670 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4671 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4672 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4673 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4674 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4675 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4676 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4677 case WXK_HELP
: keySym
= VK_HELP
; break;
4678 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4679 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4680 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4681 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4682 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4683 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4684 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4685 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4686 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4687 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4688 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4689 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4690 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4691 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4692 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4693 case WXK_F1
: keySym
= VK_F1
; break;
4694 case WXK_F2
: keySym
= VK_F2
; break;
4695 case WXK_F3
: keySym
= VK_F3
; break;
4696 case WXK_F4
: keySym
= VK_F4
; break;
4697 case WXK_F5
: keySym
= VK_F5
; break;
4698 case WXK_F6
: keySym
= VK_F6
; break;
4699 case WXK_F7
: keySym
= VK_F7
; break;
4700 case WXK_F8
: keySym
= VK_F8
; break;
4701 case WXK_F9
: keySym
= VK_F9
; break;
4702 case WXK_F10
: keySym
= VK_F10
; break;
4703 case WXK_F11
: keySym
= VK_F11
; break;
4704 case WXK_F12
: keySym
= VK_F12
; break;
4705 case WXK_F13
: keySym
= VK_F13
; break;
4706 case WXK_F14
: keySym
= VK_F14
; break;
4707 case WXK_F15
: keySym
= VK_F15
; break;
4708 case WXK_F16
: keySym
= VK_F16
; break;
4709 case WXK_F17
: keySym
= VK_F17
; break;
4710 case WXK_F18
: keySym
= VK_F18
; break;
4711 case WXK_F19
: keySym
= VK_F19
; break;
4712 case WXK_F20
: keySym
= VK_F20
; break;
4713 case WXK_F21
: keySym
= VK_F21
; break;
4714 case WXK_F22
: keySym
= VK_F22
; break;
4715 case WXK_F23
: keySym
= VK_F23
; break;
4716 case WXK_F24
: keySym
= VK_F24
; break;
4717 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4718 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4729 wxWindow
*wxGetActiveWindow()
4731 HWND hWnd
= GetActiveWindow();
4734 return wxFindWinFromHandle((WXHWND
) hWnd
);
4739 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4741 HWND hwnd
= (HWND
)hWnd
;
4743 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4744 // by code in msw/radiobox.cpp), for all the others we just search up the
4746 wxWindow
*win
= (wxWindow
*)NULL
;
4749 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4752 // all these hacks only work under Win32 anyhow
4756 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4757 // wxWindow class which overrides WM_GETDLGCODE processing to
4758 // do it as well, win would be already non NULL
4759 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
4761 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
4763 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4764 #endif // wxUSE_RADIOBOX
4766 // spin control text buddy window should be mapped to spin ctrl
4767 // itself so try it too
4768 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4771 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
4773 #endif // wxUSE_SPINCTRL
4779 while ( hwnd
&& !win
)
4781 // this is a really ugly hack needed to avoid mistakenly returning the
4782 // parent frame wxWindow for the find/replace modeless dialog HWND -
4783 // this, in turn, is needed to call IsDialogMessage() from
4784 // wxApp::ProcessMessage() as for this we must return NULL from here
4786 // FIXME: this is clearly not the best way to do it but I think we'll
4787 // need to change HWND <-> wxWindow code more heavily than I can
4788 // do it now to fix it
4789 #ifndef __WXMICROWIN__
4790 if ( ::GetWindow(hwnd
, GW_OWNER
) )
4792 // it's a dialog box, don't go upwards
4797 hwnd
= ::GetParent(hwnd
);
4798 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4804 #ifndef __WXMICROWIN__
4806 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4807 // in active frames and dialogs, regardless of where the focus is.
4808 static HHOOK wxTheKeyboardHook
= 0;
4809 static FARPROC wxTheKeyboardHookProc
= 0;
4810 int APIENTRY _EXPORT
4811 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
4813 void wxSetKeyboardHook(bool doIt
)
4817 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
4818 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
4820 #if defined(__WIN32__) && !defined(__TWIN32__)
4821 GetCurrentThreadId()
4822 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4830 UnhookWindowsHookEx(wxTheKeyboardHook
);
4832 // avoids warning about statement with no effect (FreeProcInstance
4833 // doesn't do anything under Win32)
4834 #if !defined(__WIN32__) && !defined(__NT__)
4835 FreeProcInstance(wxTheKeyboardHookProc
);
4840 int APIENTRY _EXPORT
4841 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
4843 DWORD hiWord
= HIWORD(lParam
);
4844 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
4846 int id
= wxCharCodeMSWToWX(wParam
);
4849 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
4850 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
4851 event
.m_altDown
= TRUE
;
4853 event
.m_eventObject
= NULL
;
4854 event
.m_keyCode
= id
;
4855 event
.m_shiftDown
= wxIsShiftDown();
4856 event
.m_controlDown
= wxIsCtrlDown();
4857 event
.SetTimestamp(s_currentMsg
.time
);
4859 wxWindow
*win
= wxGetActiveWindow();
4860 wxEvtHandler
*handler
;
4863 handler
= win
->GetEventHandler();
4864 event
.SetId(win
->GetId());
4872 if ( handler
&& handler
->ProcessEvent(event
) )
4880 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
4883 #endif // !__WXMICROWIN__
4886 const char *wxGetMessageName(int message
)
4890 case 0x0000: return "WM_NULL";
4891 case 0x0001: return "WM_CREATE";
4892 case 0x0002: return "WM_DESTROY";
4893 case 0x0003: return "WM_MOVE";
4894 case 0x0005: return "WM_SIZE";
4895 case 0x0006: return "WM_ACTIVATE";
4896 case 0x0007: return "WM_SETFOCUS";
4897 case 0x0008: return "WM_KILLFOCUS";
4898 case 0x000A: return "WM_ENABLE";
4899 case 0x000B: return "WM_SETREDRAW";
4900 case 0x000C: return "WM_SETTEXT";
4901 case 0x000D: return "WM_GETTEXT";
4902 case 0x000E: return "WM_GETTEXTLENGTH";
4903 case 0x000F: return "WM_PAINT";
4904 case 0x0010: return "WM_CLOSE";
4905 case 0x0011: return "WM_QUERYENDSESSION";
4906 case 0x0012: return "WM_QUIT";
4907 case 0x0013: return "WM_QUERYOPEN";
4908 case 0x0014: return "WM_ERASEBKGND";
4909 case 0x0015: return "WM_SYSCOLORCHANGE";
4910 case 0x0016: return "WM_ENDSESSION";
4911 case 0x0017: return "WM_SYSTEMERROR";
4912 case 0x0018: return "WM_SHOWWINDOW";
4913 case 0x0019: return "WM_CTLCOLOR";
4914 case 0x001A: return "WM_WININICHANGE";
4915 case 0x001B: return "WM_DEVMODECHANGE";
4916 case 0x001C: return "WM_ACTIVATEAPP";
4917 case 0x001D: return "WM_FONTCHANGE";
4918 case 0x001E: return "WM_TIMECHANGE";
4919 case 0x001F: return "WM_CANCELMODE";
4920 case 0x0020: return "WM_SETCURSOR";
4921 case 0x0021: return "WM_MOUSEACTIVATE";
4922 case 0x0022: return "WM_CHILDACTIVATE";
4923 case 0x0023: return "WM_QUEUESYNC";
4924 case 0x0024: return "WM_GETMINMAXINFO";
4925 case 0x0026: return "WM_PAINTICON";
4926 case 0x0027: return "WM_ICONERASEBKGND";
4927 case 0x0028: return "WM_NEXTDLGCTL";
4928 case 0x002A: return "WM_SPOOLERSTATUS";
4929 case 0x002B: return "WM_DRAWITEM";
4930 case 0x002C: return "WM_MEASUREITEM";
4931 case 0x002D: return "WM_DELETEITEM";
4932 case 0x002E: return "WM_VKEYTOITEM";
4933 case 0x002F: return "WM_CHARTOITEM";
4934 case 0x0030: return "WM_SETFONT";
4935 case 0x0031: return "WM_GETFONT";
4936 case 0x0037: return "WM_QUERYDRAGICON";
4937 case 0x0039: return "WM_COMPAREITEM";
4938 case 0x0041: return "WM_COMPACTING";
4939 case 0x0044: return "WM_COMMNOTIFY";
4940 case 0x0046: return "WM_WINDOWPOSCHANGING";
4941 case 0x0047: return "WM_WINDOWPOSCHANGED";
4942 case 0x0048: return "WM_POWER";
4945 case 0x004A: return "WM_COPYDATA";
4946 case 0x004B: return "WM_CANCELJOURNAL";
4947 case 0x004E: return "WM_NOTIFY";
4948 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
4949 case 0x0051: return "WM_INPUTLANGCHANGE";
4950 case 0x0052: return "WM_TCARD";
4951 case 0x0053: return "WM_HELP";
4952 case 0x0054: return "WM_USERCHANGED";
4953 case 0x0055: return "WM_NOTIFYFORMAT";
4954 case 0x007B: return "WM_CONTEXTMENU";
4955 case 0x007C: return "WM_STYLECHANGING";
4956 case 0x007D: return "WM_STYLECHANGED";
4957 case 0x007E: return "WM_DISPLAYCHANGE";
4958 case 0x007F: return "WM_GETICON";
4959 case 0x0080: return "WM_SETICON";
4962 case 0x0081: return "WM_NCCREATE";
4963 case 0x0082: return "WM_NCDESTROY";
4964 case 0x0083: return "WM_NCCALCSIZE";
4965 case 0x0084: return "WM_NCHITTEST";
4966 case 0x0085: return "WM_NCPAINT";
4967 case 0x0086: return "WM_NCACTIVATE";
4968 case 0x0087: return "WM_GETDLGCODE";
4969 case 0x00A0: return "WM_NCMOUSEMOVE";
4970 case 0x00A1: return "WM_NCLBUTTONDOWN";
4971 case 0x00A2: return "WM_NCLBUTTONUP";
4972 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
4973 case 0x00A4: return "WM_NCRBUTTONDOWN";
4974 case 0x00A5: return "WM_NCRBUTTONUP";
4975 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
4976 case 0x00A7: return "WM_NCMBUTTONDOWN";
4977 case 0x00A8: return "WM_NCMBUTTONUP";
4978 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
4979 case 0x0100: return "WM_KEYDOWN";
4980 case 0x0101: return "WM_KEYUP";
4981 case 0x0102: return "WM_CHAR";
4982 case 0x0103: return "WM_DEADCHAR";
4983 case 0x0104: return "WM_SYSKEYDOWN";
4984 case 0x0105: return "WM_SYSKEYUP";
4985 case 0x0106: return "WM_SYSCHAR";
4986 case 0x0107: return "WM_SYSDEADCHAR";
4987 case 0x0108: return "WM_KEYLAST";
4990 case 0x010D: return "WM_IME_STARTCOMPOSITION";
4991 case 0x010E: return "WM_IME_ENDCOMPOSITION";
4992 case 0x010F: return "WM_IME_COMPOSITION";
4995 case 0x0110: return "WM_INITDIALOG";
4996 case 0x0111: return "WM_COMMAND";
4997 case 0x0112: return "WM_SYSCOMMAND";
4998 case 0x0113: return "WM_TIMER";
4999 case 0x0114: return "WM_HSCROLL";
5000 case 0x0115: return "WM_VSCROLL";
5001 case 0x0116: return "WM_INITMENU";
5002 case 0x0117: return "WM_INITMENUPOPUP";
5003 case 0x011F: return "WM_MENUSELECT";
5004 case 0x0120: return "WM_MENUCHAR";
5005 case 0x0121: return "WM_ENTERIDLE";
5006 case 0x0200: return "WM_MOUSEMOVE";
5007 case 0x0201: return "WM_LBUTTONDOWN";
5008 case 0x0202: return "WM_LBUTTONUP";
5009 case 0x0203: return "WM_LBUTTONDBLCLK";
5010 case 0x0204: return "WM_RBUTTONDOWN";
5011 case 0x0205: return "WM_RBUTTONUP";
5012 case 0x0206: return "WM_RBUTTONDBLCLK";
5013 case 0x0207: return "WM_MBUTTONDOWN";
5014 case 0x0208: return "WM_MBUTTONUP";
5015 case 0x0209: return "WM_MBUTTONDBLCLK";
5016 case 0x020A: return "WM_MOUSEWHEEL";
5017 case 0x0210: return "WM_PARENTNOTIFY";
5018 case 0x0211: return "WM_ENTERMENULOOP";
5019 case 0x0212: return "WM_EXITMENULOOP";
5022 case 0x0213: return "WM_NEXTMENU";
5023 case 0x0214: return "WM_SIZING";
5024 case 0x0215: return "WM_CAPTURECHANGED";
5025 case 0x0216: return "WM_MOVING";
5026 case 0x0218: return "WM_POWERBROADCAST";
5027 case 0x0219: return "WM_DEVICECHANGE";
5030 case 0x0220: return "WM_MDICREATE";
5031 case 0x0221: return "WM_MDIDESTROY";
5032 case 0x0222: return "WM_MDIACTIVATE";
5033 case 0x0223: return "WM_MDIRESTORE";
5034 case 0x0224: return "WM_MDINEXT";
5035 case 0x0225: return "WM_MDIMAXIMIZE";
5036 case 0x0226: return "WM_MDITILE";
5037 case 0x0227: return "WM_MDICASCADE";
5038 case 0x0228: return "WM_MDIICONARRANGE";
5039 case 0x0229: return "WM_MDIGETACTIVE";
5040 case 0x0230: return "WM_MDISETMENU";
5041 case 0x0233: return "WM_DROPFILES";
5044 case 0x0281: return "WM_IME_SETCONTEXT";
5045 case 0x0282: return "WM_IME_NOTIFY";
5046 case 0x0283: return "WM_IME_CONTROL";
5047 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5048 case 0x0285: return "WM_IME_SELECT";
5049 case 0x0286: return "WM_IME_CHAR";
5050 case 0x0290: return "WM_IME_KEYDOWN";
5051 case 0x0291: return "WM_IME_KEYUP";
5054 case 0x0300: return "WM_CUT";
5055 case 0x0301: return "WM_COPY";
5056 case 0x0302: return "WM_PASTE";
5057 case 0x0303: return "WM_CLEAR";
5058 case 0x0304: return "WM_UNDO";
5059 case 0x0305: return "WM_RENDERFORMAT";
5060 case 0x0306: return "WM_RENDERALLFORMATS";
5061 case 0x0307: return "WM_DESTROYCLIPBOARD";
5062 case 0x0308: return "WM_DRAWCLIPBOARD";
5063 case 0x0309: return "WM_PAINTCLIPBOARD";
5064 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5065 case 0x030B: return "WM_SIZECLIPBOARD";
5066 case 0x030C: return "WM_ASKCBFORMATNAME";
5067 case 0x030D: return "WM_CHANGECBCHAIN";
5068 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5069 case 0x030F: return "WM_QUERYNEWPALETTE";
5070 case 0x0310: return "WM_PALETTEISCHANGING";
5071 case 0x0311: return "WM_PALETTECHANGED";
5074 // common controls messages - although they're not strictly speaking
5075 // standard, it's nice to decode them nevertheless
5078 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5079 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5080 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5081 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5082 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5083 case 0x1000 + 5: return "LVM_GETITEMA";
5084 case 0x1000 + 75: return "LVM_GETITEMW";
5085 case 0x1000 + 6: return "LVM_SETITEMA";
5086 case 0x1000 + 76: return "LVM_SETITEMW";
5087 case 0x1000 + 7: return "LVM_INSERTITEMA";
5088 case 0x1000 + 77: return "LVM_INSERTITEMW";
5089 case 0x1000 + 8: return "LVM_DELETEITEM";
5090 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5091 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5092 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5093 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5094 case 0x1000 + 13: return "LVM_FINDITEMA";
5095 case 0x1000 + 83: return "LVM_FINDITEMW";
5096 case 0x1000 + 14: return "LVM_GETITEMRECT";
5097 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5098 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5099 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5100 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5101 case 0x1000 + 18: return "LVM_HITTEST";
5102 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5103 case 0x1000 + 20: return "LVM_SCROLL";
5104 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5105 case 0x1000 + 22: return "LVM_ARRANGE";
5106 case 0x1000 + 23: return "LVM_EDITLABELA";
5107 case 0x1000 + 118: return "LVM_EDITLABELW";
5108 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5109 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5110 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5111 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5112 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5113 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5114 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5115 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5116 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5117 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5118 case 0x1000 + 31: return "LVM_GETHEADER";
5119 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5120 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5121 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5122 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5123 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5124 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5125 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5126 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5127 case 0x1000 + 41: return "LVM_GETORIGIN";
5128 case 0x1000 + 42: return "LVM_UPDATE";
5129 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5130 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5131 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5132 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5133 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5134 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5135 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5136 case 0x1000 + 48: return "LVM_SORTITEMS";
5137 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5138 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5139 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5140 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5141 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5142 case 0x1000 + 53: return "LVM_SETICONSPACING";
5143 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5144 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5145 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5146 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5147 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5148 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5149 case 0x1000 + 60: return "LVM_SETHOTITEM";
5150 case 0x1000 + 61: return "LVM_GETHOTITEM";
5151 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5152 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5153 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5154 case 0x1000 + 65: return "LVM_SETWORKAREA";
5157 case 0x1100 + 0: return "TVM_INSERTITEMA";
5158 case 0x1100 + 50: return "TVM_INSERTITEMW";
5159 case 0x1100 + 1: return "TVM_DELETEITEM";
5160 case 0x1100 + 2: return "TVM_EXPAND";
5161 case 0x1100 + 4: return "TVM_GETITEMRECT";
5162 case 0x1100 + 5: return "TVM_GETCOUNT";
5163 case 0x1100 + 6: return "TVM_GETINDENT";
5164 case 0x1100 + 7: return "TVM_SETINDENT";
5165 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5166 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5167 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5168 case 0x1100 + 11: return "TVM_SELECTITEM";
5169 case 0x1100 + 12: return "TVM_GETITEMA";
5170 case 0x1100 + 62: return "TVM_GETITEMW";
5171 case 0x1100 + 13: return "TVM_SETITEMA";
5172 case 0x1100 + 63: return "TVM_SETITEMW";
5173 case 0x1100 + 14: return "TVM_EDITLABELA";
5174 case 0x1100 + 65: return "TVM_EDITLABELW";
5175 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5176 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5177 case 0x1100 + 17: return "TVM_HITTEST";
5178 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5179 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5180 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5181 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5182 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5183 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5184 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5185 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5186 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5189 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5190 case 0x1200 + 1: return "HDM_INSERTITEMA";
5191 case 0x1200 + 10: return "HDM_INSERTITEMW";
5192 case 0x1200 + 2: return "HDM_DELETEITEM";
5193 case 0x1200 + 3: return "HDM_GETITEMA";
5194 case 0x1200 + 11: return "HDM_GETITEMW";
5195 case 0x1200 + 4: return "HDM_SETITEMA";
5196 case 0x1200 + 12: return "HDM_SETITEMW";
5197 case 0x1200 + 5: return "HDM_LAYOUT";
5198 case 0x1200 + 6: return "HDM_HITTEST";
5199 case 0x1200 + 7: return "HDM_GETITEMRECT";
5200 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5201 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5202 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5203 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5204 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5205 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5206 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5209 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5210 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5211 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5212 case 0x1300 + 5: return "TCM_GETITEMA";
5213 case 0x1300 + 60: return "TCM_GETITEMW";
5214 case 0x1300 + 6: return "TCM_SETITEMA";
5215 case 0x1300 + 61: return "TCM_SETITEMW";
5216 case 0x1300 + 7: return "TCM_INSERTITEMA";
5217 case 0x1300 + 62: return "TCM_INSERTITEMW";
5218 case 0x1300 + 8: return "TCM_DELETEITEM";
5219 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5220 case 0x1300 + 10: return "TCM_GETITEMRECT";
5221 case 0x1300 + 11: return "TCM_GETCURSEL";
5222 case 0x1300 + 12: return "TCM_SETCURSEL";
5223 case 0x1300 + 13: return "TCM_HITTEST";
5224 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5225 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5226 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5227 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5228 case 0x1300 + 43: return "TCM_SETPADDING";
5229 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5230 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5231 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5232 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5233 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5234 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5235 case 0x1300 + 50: return "TCM_DESELECTALL";
5238 case WM_USER
+1: return "TB_ENABLEBUTTON";
5239 case WM_USER
+2: return "TB_CHECKBUTTON";
5240 case WM_USER
+3: return "TB_PRESSBUTTON";
5241 case WM_USER
+4: return "TB_HIDEBUTTON";
5242 case WM_USER
+5: return "TB_INDETERMINATE";
5243 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5244 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5245 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5246 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5247 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5248 case WM_USER
+17: return "TB_SETSTATE";
5249 case WM_USER
+18: return "TB_GETSTATE";
5250 case WM_USER
+19: return "TB_ADDBITMAP";
5251 case WM_USER
+20: return "TB_ADDBUTTONS";
5252 case WM_USER
+21: return "TB_INSERTBUTTON";
5253 case WM_USER
+22: return "TB_DELETEBUTTON";
5254 case WM_USER
+23: return "TB_GETBUTTON";
5255 case WM_USER
+24: return "TB_BUTTONCOUNT";
5256 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5257 case WM_USER
+26: return "TB_SAVERESTOREA";
5258 case WM_USER
+76: return "TB_SAVERESTOREW";
5259 case WM_USER
+27: return "TB_CUSTOMIZE";
5260 case WM_USER
+28: return "TB_ADDSTRINGA";
5261 case WM_USER
+77: return "TB_ADDSTRINGW";
5262 case WM_USER
+29: return "TB_GETITEMRECT";
5263 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5264 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5265 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5266 case WM_USER
+33: return "TB_AUTOSIZE";
5267 case WM_USER
+35: return "TB_GETTOOLTIPS";
5268 case WM_USER
+36: return "TB_SETTOOLTIPS";
5269 case WM_USER
+37: return "TB_SETPARENT";
5270 case WM_USER
+39: return "TB_SETROWS";
5271 case WM_USER
+40: return "TB_GETROWS";
5272 case WM_USER
+42: return "TB_SETCMDID";
5273 case WM_USER
+43: return "TB_CHANGEBITMAP";
5274 case WM_USER
+44: return "TB_GETBITMAP";
5275 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5276 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5277 case WM_USER
+46: return "TB_REPLACEBITMAP";
5278 case WM_USER
+47: return "TB_SETINDENT";
5279 case WM_USER
+48: return "TB_SETIMAGELIST";
5280 case WM_USER
+49: return "TB_GETIMAGELIST";
5281 case WM_USER
+50: return "TB_LOADIMAGES";
5282 case WM_USER
+51: return "TB_GETRECT";
5283 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5284 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5285 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5286 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5287 case WM_USER
+56: return "TB_SETSTYLE";
5288 case WM_USER
+57: return "TB_GETSTYLE";
5289 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5290 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5291 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5292 case WM_USER
+61: return "TB_GETTEXTROWS";
5293 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5298 static char s_szBuf
[128];
5299 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5303 #endif //__WXDEBUG__
5305 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5306 int *x
, int *y
, WPARAM
*flags
)
5308 // construct the key mask
5309 WPARAM
& fwKeys
= *flags
;
5311 fwKeys
= MK_RBUTTON
;
5312 if ( wxIsCtrlDown() )
5313 fwKeys
|= MK_CONTROL
;
5314 if ( wxIsShiftDown() )
5317 // simulate right mouse button click
5318 DWORD dwPos
= ::GetMessagePos();
5319 *x
= GET_X_LPARAM(dwPos
);
5320 *y
= GET_Y_LPARAM(dwPos
);
5322 win
->ScreenToClient(x
, y
);
5325 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5329 HWND hwnd
= GetHwndOf(win
);
5330 HDC hdc
= ::GetDC(hwnd
);
5332 #if !wxDIALOG_UNIT_COMPATIBILITY
5333 // and select the current font into it
5334 HFONT hfont
= GetHfontOf(win
->GetFont());
5337 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5341 // finally retrieve the text metrics from it
5342 GetTextMetrics(hdc
, &tm
);
5344 #if !wxDIALOG_UNIT_COMPATIBILITY
5348 (void)::SelectObject(hdc
, hfont
);
5352 ::ReleaseDC(hwnd
, hdc
);
5357 // Find the wxWindow at the current mouse position, returning the mouse
5359 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5361 pt
= wxGetMousePosition();
5362 return wxFindWindowAtPoint(pt
);
5365 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5370 HWND hWndHit
= ::WindowFromPoint(pt2
);
5372 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5373 HWND hWnd
= hWndHit
;
5375 // Try to find a window with a wxWindow associated with it
5376 while (!win
&& (hWnd
!= 0))
5378 hWnd
= ::GetParent(hWnd
);
5379 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5384 // Get the current mouse position.
5385 wxPoint
wxGetMousePosition()
5388 GetCursorPos( & pt
);
5390 return wxPoint(pt
.x
, pt
.y
);