1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
33 #include "wx/msw/winundef.h"
34 #include "wx/window.h"
39 #include "wx/dcclient.h"
40 #include "wx/dcmemory.h"
43 #include "wx/layout.h"
44 #include "wx/dialog.h"
46 #include "wx/listbox.h"
47 #include "wx/button.h"
48 #include "wx/msgdlg.h"
49 #include "wx/settings.h"
50 #include "wx/statbox.h"
54 #include "wx/ownerdrw.h"
57 #if wxUSE_DRAG_AND_DROP
61 #if wxUSE_ACCESSIBILITY
62 #include "wx/access.h"
66 #define WM_GETOBJECT 0x003D
69 #define OBJID_CLIENT 0xFFFFFFFC
73 #include "wx/menuitem.h"
76 #include "wx/msw/private.h"
79 #include "wx/tooltip.h"
87 #include "wx/spinctrl.h"
88 #endif // wxUSE_SPINCTRL
93 #include "wx/textctrl.h"
94 #include "wx/notebook.h"
98 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
100 #include <mmsystem.h>
104 #include <windowsx.h>
107 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__)) || defined(__CYGWIN10__)
109 #include <commctrl.h>
111 #elif !defined(__WXMICROWIN__) // broken compiler
112 #include "wx/msw/gnuwin32/extra.h"
115 #if defined(__GNUG__)
116 #include "wx/msw/missing.h"
119 // ----------------------------------------------------------------------------
120 // standard constants not available with all compilers/headers
121 // ----------------------------------------------------------------------------
123 // This didn't appear in mingw until 2.95.2
125 #define SIF_TRACKPOS 16
129 #ifndef WM_MOUSEWHEEL
130 #define WM_MOUSEWHEEL 0x020A
133 #define WHEEL_DELTA 120
135 #ifndef SPI_GETWHEELSCROLLLINES
136 #define SPI_GETWHEELSCROLLLINES 104
138 #endif // wxUSE_MOUSEWHEEL
141 #define VK_OEM_1 0xBA
142 #define VK_OEM_2 0xBF
143 #define VK_OEM_3 0xC0
144 #define VK_OEM_4 0xDB
145 #define VK_OEM_5 0xDC
146 #define VK_OEM_6 0xDD
147 #define VK_OEM_7 0xDE
151 #define VK_OEM_PLUS 0xBB
152 #define VK_OEM_COMMA 0xBC
153 #define VK_OEM_MINUS 0xBD
154 #define VK_OEM_PERIOD 0xBE
157 // ---------------------------------------------------------------------------
159 // ---------------------------------------------------------------------------
161 // the last Windows message we got (FIXME-MT)
162 extern MSG s_currentMsg
;
164 #if wxUSE_MENUS_NATIVE
165 wxMenu
*wxCurrentPopupMenu
= NULL
;
166 #endif // wxUSE_MENUS_NATIVE
168 extern const wxChar
*wxCanvasClassName
;
170 // true if we had already created the std colour map, used by
171 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
172 static bool gs_hasStdCmap
= FALSE
;
174 // ---------------------------------------------------------------------------
176 // ---------------------------------------------------------------------------
178 // the window proc for all our windows
179 #ifdef __DIGITALMARS__
180 extern "C" LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
181 WPARAM wParam
, LPARAM lParam
);
183 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
184 WPARAM wParam
, LPARAM lParam
);
189 const char *wxGetMessageName(int message
);
192 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
193 #ifdef __DIGITALMARS__
194 extern "C" void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
196 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
198 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
200 // this magical function is used to translate VK_APPS key presses to right
202 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
203 int *x
, int *y
, WPARAM
*flags
);
205 // get the text metrics for the current font
206 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
208 // find the window for the mouse event at the specified position
209 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
211 // wrapper around BringWindowToTop() API
212 static inline void wxBringWindowToTop(HWND hwnd
)
214 #ifdef __WXMICROWIN__
215 // It seems that MicroWindows brings the _parent_ of the window to the top,
216 // which can be the wrong one.
218 // activate (set focus to) specified window
221 // raise top level parent to top of z order
222 ::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
);
223 #else // !__WXMICROWIN__
224 if ( !::BringWindowToTop(hwnd
) )
226 wxLogLastError(_T("BringWindowToTop"));
228 #endif // __WXMICROWIN__/!__WXMICROWIN__
231 // ---------------------------------------------------------------------------
233 // ---------------------------------------------------------------------------
235 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
237 #ifdef __WXUNIVERSAL__
238 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
240 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
241 #endif // __WXUNIVERSAL__/__WXMSW__
243 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
244 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
245 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
246 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
247 EVT_IDLE(wxWindowMSW::OnIdle
)
250 // ===========================================================================
252 // ===========================================================================
254 // ---------------------------------------------------------------------------
255 // wxWindow utility functions
256 // ---------------------------------------------------------------------------
258 // Find an item given the MS Windows id
259 wxWindow
*wxWindowMSW::FindItem(long id
) const
262 wxControl
*item
= wxDynamicCastThis(wxControl
);
265 // is it we or one of our "internal" children?
266 if ( item
->GetId() == id
267 #ifndef __WXUNIVERSAL__
268 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
269 #endif // __WXUNIVERSAL__
275 #endif // wxUSE_CONTROLS
277 wxWindowList::Node
*current
= GetChildren().GetFirst();
280 wxWindow
*childWin
= current
->GetData();
282 wxWindow
*wnd
= childWin
->FindItem(id
);
286 current
= current
->GetNext();
292 // Find an item given the MS Windows handle
293 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
295 wxWindowList::Node
*current
= GetChildren().GetFirst();
298 wxWindow
*parent
= current
->GetData();
300 // Do a recursive search.
301 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
307 || parent
->IsKindOf(CLASSINFO(wxControl
))
308 #endif // wxUSE_CONTROLS
311 wxWindow
*item
= current
->GetData();
312 if ( item
->GetHWND() == hWnd
)
316 if ( item
->ContainsHWND(hWnd
) )
321 current
= current
->GetNext();
326 // Default command handler
327 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
332 // ----------------------------------------------------------------------------
333 // constructors and such
334 // ----------------------------------------------------------------------------
336 void wxWindowMSW::Init()
342 m_isBeingDeleted
= FALSE
;
345 m_mouseInWindow
= FALSE
;
346 m_lastKeydownProcessed
= FALSE
;
348 m_childrenDisabled
= NULL
;
357 m_backgroundTransparent
= FALSE
;
359 // as all windows are created with WS_VISIBLE style...
362 #if wxUSE_MOUSEEVENT_HACK
365 m_lastMouseEvent
= -1;
366 #endif // wxUSE_MOUSEEVENT_HACK
370 wxWindowMSW::~wxWindowMSW()
372 m_isBeingDeleted
= TRUE
;
374 #ifndef __WXUNIVERSAL__
375 // VS: make sure there's no wxFrame with last focus set to us:
376 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
378 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
381 if ( frame
->GetLastFocus() == this )
383 frame
->SetLastFocus(NULL
);
388 #endif // __WXUNIVERSAL__
390 // VS: destroy children first and _then_ detach *this from its parent.
391 // If we'd do it the other way around, children wouldn't be able
392 // find their parent frame (see above).
396 m_parent
->RemoveChild(this);
400 // VZ: test temp removed to understand what really happens here
401 //if (::IsWindow(GetHwnd()))
403 if ( !::DestroyWindow(GetHwnd()) )
404 wxLogLastError(wxT("DestroyWindow"));
407 // remove hWnd <-> wxWindow association
408 wxRemoveHandleAssociation(this);
411 delete m_childrenDisabled
;
414 // real construction (Init() must have been called before!)
415 bool wxWindowMSW::Create(wxWindow
*parent
,
420 const wxString
& name
)
422 wxCHECK_MSG( parent
, FALSE
, wxT("can't create wxWindow without parent") );
424 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
427 parent
->AddChild(this);
430 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
432 #ifdef __WXUNIVERSAL__
433 // no borders, we draw them ourselves
434 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
438 msflags
&= ~WS_BORDER
;
439 #endif // wxUniversal
441 // all windows are created visible by default except popup ones (which are
442 // like the wxTopLevelWindows in this aspect)
443 if ( style
& wxPOPUP_WINDOW
)
445 msflags
&= ~WS_VISIBLE
;
450 msflags
|= WS_VISIBLE
;
453 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
456 // ---------------------------------------------------------------------------
458 // ---------------------------------------------------------------------------
460 void wxWindowMSW::SetFocus()
462 HWND hWnd
= GetHwnd();
463 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
465 #ifndef __WXMICROWIN__
469 if ( !::SetFocus(hWnd
) )
471 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
472 // was there really an error?
473 DWORD dwRes
= ::GetLastError();
476 HWND hwndFocus
= ::GetFocus();
477 if ( hwndFocus
!= hWnd
)
479 wxLogApiError(_T("SetFocus"), dwRes
);
486 void wxWindowMSW::SetFocusFromKbd()
488 wxWindowBase::SetFocusFromKbd();
490 // when the focus is given to the control with DLGC_HASSETSEL style from
491 // keyboard its contents should be entirely selected: this is what
492 // ::IsDialogMessage() does and so we should do it as well to provide the
493 // same LNF as the native programs
494 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
496 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
500 // Get the window with the focus
501 wxWindow
*wxWindowBase::FindFocus()
503 HWND hWnd
= ::GetFocus();
506 return wxGetWindowFromHWND((WXHWND
)hWnd
);
512 bool wxWindowMSW::Enable(bool enable
)
514 if ( !wxWindowBase::Enable(enable
) )
517 HWND hWnd
= GetHwnd();
519 ::EnableWindow(hWnd
, (BOOL
)enable
);
521 // the logic below doesn't apply to the top level windows -- otherwise
522 // showing a modal dialog would result in total greying out (and ungreying
523 // out later) of everything which would be really ugly
527 // when the parent is disabled, all of its children should be disabled as
528 // well but when it is enabled back, only those of the children which
529 // hadn't been already disabled in the beginning should be enabled again,
530 // so we have to keep the list of those children
531 for ( wxWindowList::Node
*node
= GetChildren().GetFirst();
533 node
= node
->GetNext() )
535 wxWindow
*child
= node
->GetData();
536 if ( child
->IsTopLevel() )
538 // the logic below doesn't apply to top level children
544 // enable the child back unless it had been disabled before us
545 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
548 else // we're being disabled
550 if ( child
->IsEnabled() )
552 // disable it as children shouldn't stay enabled while the
556 else // child already disabled, remember it
558 // have we created the list of disabled children already?
559 if ( !m_childrenDisabled
)
560 m_childrenDisabled
= new wxWindowList
;
562 m_childrenDisabled
->Append(child
);
567 if ( enable
&& m_childrenDisabled
)
569 // we don't need this list any more, don't keep unused memory
570 delete m_childrenDisabled
;
571 m_childrenDisabled
= NULL
;
577 bool wxWindowMSW::Show(bool show
)
579 if ( !wxWindowBase::Show(show
) )
582 HWND hWnd
= GetHwnd();
583 int cshow
= show
? SW_SHOW
: SW_HIDE
;
584 ::ShowWindow(hWnd
, cshow
);
588 wxBringWindowToTop(hWnd
);
594 // Raise the window to the top of the Z order
595 void wxWindowMSW::Raise()
597 wxBringWindowToTop(GetHwnd());
600 // Lower the window to the bottom of the Z order
601 void wxWindowMSW::Lower()
603 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
604 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
607 void wxWindowMSW::SetTitle( const wxString
& title
)
609 SetWindowText(GetHwnd(), title
.c_str());
612 wxString
wxWindowMSW::GetTitle() const
614 return wxGetWindowText(GetHWND());
617 void wxWindowMSW::DoCaptureMouse()
619 HWND hWnd
= GetHwnd();
626 void wxWindowMSW::DoReleaseMouse()
628 if ( !::ReleaseCapture() )
630 wxLogLastError(_T("ReleaseCapture"));
634 /* static */ wxWindow
*wxWindowBase::GetCapture()
636 HWND hwnd
= ::GetCapture();
637 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
640 bool wxWindowMSW::SetFont(const wxFont
& font
)
642 if ( !wxWindowBase::SetFont(font
) )
648 HWND hWnd
= GetHwnd();
651 WXHANDLE hFont
= m_font
.GetResourceHandle();
653 wxASSERT_MSG( hFont
, wxT("should have valid font") );
655 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
660 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
662 if ( !wxWindowBase::SetCursor(cursor
) )
670 HWND hWnd
= GetHwnd();
672 // Change the cursor NOW if we're within the correct window
674 ::GetCursorPos(&point
);
676 RECT rect
= wxGetWindowRect(hWnd
);
678 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
679 ::SetCursor(GetHcursorOf(m_cursor
));
685 void wxWindowMSW::WarpPointer (int x
, int y
)
687 ClientToScreen(&x
, &y
);
689 if ( !::SetCursorPos(x
, y
) )
691 wxLogLastError(_T("SetCursorPos"));
695 #if WXWIN_COMPATIBILITY
696 void wxWindowMSW::MSWDeviceToLogical (float *x
, float *y
) const
699 #endif // WXWIN_COMPATIBILITY
701 // ---------------------------------------------------------------------------
703 // ---------------------------------------------------------------------------
705 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
706 static inline int wxDirToWinStyle(int orient
)
708 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
711 #if WXWIN_COMPATIBILITY
712 void wxWindowMSW::SetScrollRange(int orient
, int range
, bool refresh
)
716 // Try to adjust the range to cope with page size > 1
717 // - a Windows API quirk
718 int pageSize
= GetScrollPage(orient
);
719 if ( pageSize
> 1 && range
> 0)
721 range1
+= (pageSize
- 1);
724 WinStruct
<SCROLLINFO
> info
;
725 info
.nPage
= pageSize
; // Have to set this, or scrollbar goes awry
728 info
.fMask
= SIF_RANGE
| SIF_PAGE
;
730 HWND hWnd
= GetHwnd();
732 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
735 void wxWindowMSW::SetScrollPage(int orient
, int page
, bool refresh
)
737 WinStruct
<SCROLLINFO
> info
;
739 info
.fMask
= SIF_PAGE
;
741 HWND hWnd
= GetHwnd();
743 ::SetScrollInfo(hWnd
, wxDirToWinStyle(orient
), &info
, refresh
);
746 int wxWindowMSW::GetScrollPage(int orient
) const
748 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
751 #endif // WXWIN_COMPATIBILITY
753 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
755 #ifdef __WXMICROWIN__
756 return ::GetScrollPosWX(hWnd
, wOrient
);
758 return ::GetScrollPos(hWnd
, wOrient
);
762 int wxWindowMSW::GetScrollPos(int orient
) const
764 HWND hWnd
= GetHwnd();
765 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
767 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
770 // This now returns the whole range, not just the number
771 // of positions that we can scroll.
772 int wxWindowMSW::GetScrollRange(int orient
) const
775 HWND hWnd
= GetHwnd();
779 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
782 // undo "range - 1" done in SetScrollbar()
786 int wxWindowMSW::GetScrollThumb(int orient
) const
788 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
791 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
793 HWND hWnd
= GetHwnd();
794 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
796 WinStruct
<SCROLLINFO
> info
;
800 info
.fMask
= SIF_POS
;
802 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
806 // New function that will replace some of the above.
807 void wxWindowMSW::SetScrollbar(int orient
,
813 WinStruct
<SCROLLINFO
> info
;
814 info
.nPage
= pageSize
;
815 info
.nMin
= 0; // range is nMax - nMin + 1
816 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
818 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
820 HWND hWnd
= GetHwnd();
823 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
827 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
830 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
836 rect
.left
= prect
->x
;
838 rect
.right
= prect
->x
+ prect
->width
;
839 rect
.bottom
= prect
->y
+ prect
->height
;
847 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
850 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
852 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
855 for ( int n
= 0; n
< count
; n
++ )
857 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
859 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
862 // don't bother to continue, we're already at top/bottom
869 return pos
!= posStart
;
872 bool wxWindowMSW::ScrollLines(int lines
)
874 bool down
= lines
> 0;
876 return ScrollVertically(GetHwnd(),
877 down
? SB_LINEDOWN
: SB_LINEUP
,
878 down
? lines
: -lines
);
881 bool wxWindowMSW::ScrollPages(int pages
)
883 bool down
= pages
> 0;
885 return ScrollVertically(GetHwnd(),
886 down
? SB_PAGEDOWN
: SB_PAGEUP
,
887 down
? pages
: -pages
);
890 // ---------------------------------------------------------------------------
892 // ---------------------------------------------------------------------------
894 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
896 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
898 HWND hwnd
= (HWND
)hWnd
;
899 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
901 wxAssociateWinWithHandle(hwnd
, this);
903 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
905 // we don't need to subclass the window of our own class (in the Windows
906 // sense of the word)
907 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
909 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
913 // don't bother restoring it neither: this also makes it easy to
914 // implement IsOfStandardClass() method which returns TRUE for the
915 // standard controls and FALSE for the wxWindows own windows as it can
916 // simply check m_oldWndProc
921 void wxWindowMSW::UnsubclassWin()
923 wxRemoveHandleAssociation(this);
925 // Restore old Window proc
926 HWND hwnd
= GetHwnd();
931 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
935 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
937 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
945 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
947 // Unicows note: the code below works, but only because WNDCLASS contains
948 // original window handler rather that the unicows fake one. This may not
949 // be on purpose, though; if it stops working with future versions of
950 // unicows.dll, we can override unicows hooks by setting
951 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
952 // versions that keep track of fake<->real wnd proc mapping.
954 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
956 wxLogLastError(_T("GetClassInfo"));
961 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
964 // ----------------------------------------------------------------------------
966 // ----------------------------------------------------------------------------
968 void wxWindowMSW::SetWindowStyleFlag(long flags
)
970 long flagsOld
= GetWindowStyleFlag();
971 if ( flags
== flagsOld
)
974 // update the internal variable
975 wxWindowBase::SetWindowStyleFlag(flags
);
977 // now update the Windows style as well if needed - and if the window had
978 // been already created
982 WXDWORD exstyle
, exstyleOld
;
983 long style
= MSWGetStyle(flags
, &exstyle
),
984 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
986 if ( style
!= styleOld
)
988 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
989 // this function so instead of simply setting the style to the new
990 // value we clear the bits which were set in styleOld but are set in
991 // the new one and set the ones which were not set before
992 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
993 styleReal
&= ~styleOld
;
996 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
999 // and the extended style
1000 if ( exstyle
!= exstyleOld
)
1002 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1003 exstyleReal
&= ~exstyleOld
;
1004 exstyleReal
|= exstyle
;
1006 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1008 // we must call SetWindowPos() to flash the cached extended style and
1009 // also to make the change to wxSTAY_ON_TOP style take effect: just
1010 // setting the style simply doesn't work
1011 if ( !::SetWindowPos(GetHwnd(),
1012 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1015 SWP_NOMOVE
| SWP_NOSIZE
) )
1017 wxLogLastError(_T("SetWindowPos"));
1022 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1024 // translate the style
1025 WXDWORD style
= WS_CHILD
| WS_VISIBLE
;
1027 if ( flags
& wxCLIP_CHILDREN
)
1028 style
|= WS_CLIPCHILDREN
;
1030 if ( flags
& wxCLIP_SIBLINGS
)
1031 style
|= WS_CLIPSIBLINGS
;
1033 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
1035 // Check if we want to automatically give it a sunken style.
1036 // Note than because 'sunken' actually maps to WS_EX_CLIENTEDGE, which
1037 // is a more neutral term, we don't necessarily get a sunken effect in
1038 // Windows XP. Instead we get the appropriate style for the theme.
1040 if (border
== wxBORDER_DEFAULT
&& wxTheApp
->GetAuto3D() &&
1041 IsKindOf(CLASSINFO(wxControl
)) &&
1042 GetParent() && (GetParent()->IsKindOf(CLASSINFO(wxPanel
)) ||
1043 GetParent()->IsKindOf(CLASSINFO(wxDialog
))) &&
1044 ((GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS
) != wxUSER_COLOURS
))
1046 border
= (wxBorder
)((flags
& wxBORDER_MASK
) | wxBORDER_SUNKEN
);
1049 // Only give it WS_BORDER for wxBORDER_SIMPLE
1050 if (border
& wxBORDER_SIMPLE
)
1053 // now deal with ext style if the caller wants it
1058 if ( flags
& wxTRANSPARENT_WINDOW
)
1059 *exstyle
|= WS_EX_TRANSPARENT
;
1064 wxFAIL_MSG( _T("unknown border style") );
1068 case wxBORDER_SIMPLE
:
1069 case wxBORDER_DEFAULT
:
1072 case wxBORDER_STATIC
:
1073 *exstyle
|= WS_EX_STATICEDGE
;
1076 case wxBORDER_RAISED
:
1077 *exstyle
|= WS_EX_DLGMODALFRAME
;
1080 case wxBORDER_SUNKEN
:
1081 *exstyle
|= WS_EX_CLIENTEDGE
;
1082 style
&= ~WS_BORDER
;
1085 case wxBORDER_DOUBLE
:
1086 *exstyle
|= WS_EX_DLGMODALFRAME
;
1090 // wxUniv doesn't use Windows dialog navigation functions at all
1091 #ifndef __WXUNIVERSAL__
1092 // to make the dialog navigation work with the nested panels we must
1093 // use this style (top level windows such as dialogs don't need it)
1094 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1096 *exstyle
|= WS_EX_CONTROLPARENT
;
1098 #endif // __WXUNIVERSAL__
1104 #if WXWIN_COMPATIBILITY
1105 // If nothing defined for this, try the parent.
1106 // E.g. we may be a button loaded from a resource, with no callback function
1108 void wxWindowMSW::OnCommand(wxWindow
& win
, wxCommandEvent
& event
)
1110 if ( GetEventHandler()->ProcessEvent(event
) )
1113 m_parent
->GetEventHandler()->OnCommand(win
, event
);
1115 #endif // WXWIN_COMPATIBILITY_2
1117 #if WXWIN_COMPATIBILITY
1118 wxObject
* wxWindowMSW::GetChild(int number
) const
1120 // Return a pointer to the Nth object in the Panel
1121 wxNode
*node
= GetChildren().First();
1124 node
= node
->Next();
1127 wxObject
*obj
= (wxObject
*)node
->Data();
1133 #endif // WXWIN_COMPATIBILITY
1135 // Setup background and foreground colours correctly
1136 void wxWindowMSW::SetupColours()
1139 SetBackgroundColour(GetParent()->GetBackgroundColour());
1142 bool wxWindowMSW::IsMouseInWindow() const
1144 // get the mouse position
1146 ::GetCursorPos(&pt
);
1148 // find the window which currently has the cursor and go up the window
1149 // chain until we find this window - or exhaust it
1150 HWND hwnd
= ::WindowFromPoint(pt
);
1151 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1152 hwnd
= ::GetParent(hwnd
);
1154 return hwnd
!= NULL
;
1157 void wxWindowMSW::OnIdle(wxIdleEvent
& WXUNUSED(event
))
1159 // Check if we need to send a LEAVE event
1160 if ( m_mouseInWindow
)
1162 // note that we should generate the leave event whether the window has
1163 // or doesn't have mouse capture
1164 if ( !IsMouseInWindow() )
1166 // Generate a LEAVE event
1167 m_mouseInWindow
= FALSE
;
1169 // Unfortunately the mouse button and keyboard state may have
1170 // changed by the time the OnIdle function is called, so 'state'
1171 // may be meaningless.
1173 if ( wxIsShiftDown() )
1175 if ( wxIsCtrlDown() )
1176 state
|= MK_CONTROL
;
1177 if ( GetKeyState( VK_LBUTTON
) )
1178 state
|= MK_LBUTTON
;
1179 if ( GetKeyState( VK_MBUTTON
) )
1180 state
|= MK_MBUTTON
;
1181 if ( GetKeyState( VK_RBUTTON
) )
1182 state
|= MK_RBUTTON
;
1185 if ( !::GetCursorPos(&pt
) )
1187 wxLogLastError(_T("GetCursorPos"));
1190 // we need to have client coordinates here for symmetry with
1191 // wxEVT_ENTER_WINDOW
1192 RECT rect
= wxGetWindowRect(GetHwnd());
1196 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1197 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1199 (void)GetEventHandler()->ProcessEvent(event2
);
1206 // Set this window to be the child of 'parent'.
1207 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1209 if ( !wxWindowBase::Reparent(parent
) )
1212 HWND hWndChild
= GetHwnd();
1213 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1215 ::SetParent(hWndChild
, hWndParent
);
1220 void wxWindowMSW::Clear()
1222 wxClientDC
dc((wxWindow
*)this);
1223 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1224 dc
.SetBackground(brush
);
1228 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1230 #ifndef __WXMICROWIN__
1231 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1235 void wxWindowMSW::Freeze()
1237 SendSetRedraw(GetHwnd(), FALSE
);
1240 void wxWindowMSW::Thaw()
1242 SendSetRedraw(GetHwnd(), TRUE
);
1244 // we need to refresh everything or otherwise he invalidated area is not
1249 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1251 HWND hWnd
= GetHwnd();
1257 mswRect
.left
= rect
->x
;
1258 mswRect
.top
= rect
->y
;
1259 mswRect
.right
= rect
->x
+ rect
->width
;
1260 mswRect
.bottom
= rect
->y
+ rect
->height
;
1262 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1265 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1269 void wxWindowMSW::Update()
1271 if ( !::UpdateWindow(GetHwnd()) )
1273 wxLogLastError(_T("UpdateWindow"));
1276 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1277 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1278 // handler needs to be really drawn right now
1283 // ---------------------------------------------------------------------------
1285 // ---------------------------------------------------------------------------
1288 #if wxUSE_DRAG_AND_DROP
1289 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1291 if ( m_dropTarget
!= 0 ) {
1292 m_dropTarget
->Revoke(m_hWnd
);
1293 delete m_dropTarget
;
1296 m_dropTarget
= pDropTarget
;
1297 if ( m_dropTarget
!= 0 )
1298 m_dropTarget
->Register(m_hWnd
);
1300 #endif // wxUSE_DRAG_AND_DROP
1302 // old style file-manager drag&drop support: we retain the old-style
1303 // DragAcceptFiles in parallel with SetDropTarget.
1304 void wxWindowMSW::DragAcceptFiles(bool accept
)
1306 HWND hWnd
= GetHwnd();
1308 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1311 // ----------------------------------------------------------------------------
1313 // ----------------------------------------------------------------------------
1317 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1319 wxWindowBase::DoSetToolTip(tooltip
);
1322 m_tooltip
->SetWindow((wxWindow
*)this);
1325 #endif // wxUSE_TOOLTIPS
1327 // ---------------------------------------------------------------------------
1328 // moving and resizing
1329 // ---------------------------------------------------------------------------
1332 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1334 RECT rect
= wxGetWindowRect(GetHwnd());
1337 *x
= rect
.right
- rect
.left
;
1339 *y
= rect
.bottom
- rect
.top
;
1342 // Get size *available for subwindows* i.e. excluding menu bar etc.
1343 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1345 RECT rect
= wxGetClientRect(GetHwnd());
1353 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1355 RECT rect
= wxGetWindowRect(GetHwnd());
1358 point
.x
= rect
.left
;
1361 // we do the adjustments with respect to the parent only for the "real"
1362 // children, not for the dialogs/frames
1363 if ( !IsTopLevel() )
1365 HWND hParentWnd
= 0;
1366 wxWindow
*parent
= GetParent();
1368 hParentWnd
= GetWinHwnd(parent
);
1370 // Since we now have the absolute screen coords, if there's a parent we
1371 // must subtract its top left corner
1374 ::ScreenToClient(hParentWnd
, &point
);
1379 // We may be faking the client origin. So a window that's really at (0,
1380 // 30) may appear (to wxWin apps) to be at (0, 0).
1381 wxPoint
pt(parent
->GetClientAreaOrigin());
1393 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1401 ::ScreenToClient(GetHwnd(), &pt
);
1409 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1417 ::ClientToScreen(GetHwnd(), &pt
);
1425 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1427 // TODO: is this consistent with other platforms?
1428 // Still, negative width or height shouldn't be allowed
1433 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1435 wxLogLastError(wxT("MoveWindow"));
1439 // set the size of the window: if the dimensions are positive, just use them,
1440 // but if any of them is equal to -1, it means that we must find the value for
1441 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1442 // which case -1 is a valid value for x and y)
1444 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1445 // the width/height to best suit our contents, otherwise we reuse the current
1447 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1449 // get the current size and position...
1450 int currentX
, currentY
;
1451 GetPosition(¤tX
, ¤tY
);
1452 int currentW
,currentH
;
1453 GetSize(¤tW
, ¤tH
);
1455 // ... and don't do anything (avoiding flicker) if it's already ok
1456 if ( x
== currentX
&& y
== currentY
&&
1457 width
== currentW
&& height
== currentH
)
1462 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1464 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1467 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1469 wxSize
size(-1, -1);
1472 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1474 size
= DoGetBestSize();
1479 // just take the current one
1486 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1490 size
= DoGetBestSize();
1492 //else: already called DoGetBestSize() above
1498 // just take the current one
1503 DoMoveWindow(x
, y
, width
, height
);
1506 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1508 // setting the client size is less obvious than it it could have been
1509 // because in the result of changing the total size the window scrollbar
1510 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1511 // will not be correct as the difference between the total and client size
1512 // changes - so we keep changing it until we get it right
1514 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1515 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1516 // may become 3 if the window had 0 size originally and so we didn't
1517 // calculate the scrollbar correction correctly during the first iteration)
1518 // but just to be on the safe side we check for it instead of making it an
1519 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1520 for ( int i
= 0; i
< 4; i
++ )
1523 ::GetClientRect(GetHwnd(), &rectClient
);
1525 // if the size is already ok, stop here (rectClient.left = top = 0)
1526 if ( (rectClient
.right
== width
|| width
== -1) &&
1527 (rectClient
.bottom
== height
|| height
== -1) )
1532 int widthClient
= width
,
1533 heightClient
= height
;
1535 // Find the difference between the entire window (title bar and all)
1536 // and the client area; add this to the new client size to move the
1539 ::GetWindowRect(GetHwnd(), &rectWin
);
1541 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1542 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1545 point
.x
= rectWin
.left
;
1546 point
.y
= rectWin
.top
;
1548 // MoveWindow positions the child windows relative to the parent, so
1549 // adjust if necessary
1550 if ( !IsTopLevel() )
1552 wxWindow
*parent
= GetParent();
1555 ::ScreenToClient(GetHwndOf(parent
), &point
);
1559 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1563 // For implementation purposes - sometimes decorations make the client area
1565 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1567 return wxPoint(0, 0);
1570 // ---------------------------------------------------------------------------
1572 // ---------------------------------------------------------------------------
1574 int wxWindowMSW::GetCharHeight() const
1576 return wxGetTextMetrics(this).tmHeight
;
1579 int wxWindowMSW::GetCharWidth() const
1581 // +1 is needed because Windows apparently adds it when calculating the
1582 // dialog units size in pixels
1583 #if wxDIALOG_UNIT_COMPATIBILITY
1584 return wxGetTextMetrics(this).tmAveCharWidth
;
1586 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1590 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1592 int *descent
, int *externalLeading
,
1593 const wxFont
*theFont
) const
1595 const wxFont
*fontToUse
= theFont
;
1597 fontToUse
= &m_font
;
1599 HWND hWnd
= GetHwnd();
1600 HDC dc
= ::GetDC(hWnd
);
1604 if ( fontToUse
&& fontToUse
->Ok() )
1606 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1608 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1613 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1614 GetTextMetrics(dc
, &tm
);
1616 if ( fontToUse
&& fnt
&& hfontOld
)
1617 SelectObject(dc
, hfontOld
);
1619 ReleaseDC(hWnd
, dc
);
1626 *descent
= tm
.tmDescent
;
1627 if ( externalLeading
)
1628 *externalLeading
= tm
.tmExternalLeading
;
1631 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1632 // ---------------------------------------------------------------------------
1633 // Caret manipulation
1634 // ---------------------------------------------------------------------------
1636 void wxWindowMSW::CreateCaret(int w
, int h
)
1638 SetCaret(new wxCaret(this, w
, h
));
1641 void wxWindowMSW::CreateCaret(const wxBitmap
*WXUNUSED(bitmap
))
1643 wxFAIL_MSG("not implemented");
1646 void wxWindowMSW::ShowCaret(bool show
)
1648 wxCHECK_RET( m_caret
, "no caret to show" );
1650 m_caret
->Show(show
);
1653 void wxWindowMSW::DestroyCaret()
1658 void wxWindowMSW::SetCaretPos(int x
, int y
)
1660 wxCHECK_RET( m_caret
, "no caret to move" );
1662 m_caret
->Move(x
, y
);
1665 void wxWindowMSW::GetCaretPos(int *x
, int *y
) const
1667 wxCHECK_RET( m_caret
, "no caret to get position of" );
1669 m_caret
->GetPosition(x
, y
);
1671 #endif // wxUSE_CARET
1673 // ---------------------------------------------------------------------------
1675 // ---------------------------------------------------------------------------
1677 #if wxUSE_MENUS_NATIVE
1679 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1680 // immediately, without waiting for the next event loop iteration
1682 // NB: this function should probably be made public later as it can almost
1683 // surely replace wxYield() elsewhere as well
1684 static void wxYieldForCommandsOnly()
1686 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1687 // want to process it here)
1689 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
)
1690 && msg
.message
!= WM_QUIT
)
1692 wxTheApp
->DoMessage((WXMSG
*)&msg
);
1695 // If we retrieved a WM_QUIT, insert back into the message queue.
1696 if (msg
.message
== WM_QUIT
)
1697 ::PostQuitMessage(0);
1700 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1702 menu
->SetInvokingWindow(this);
1705 HWND hWnd
= GetHwnd();
1706 HMENU hMenu
= GetHmenuOf(menu
);
1710 ::ClientToScreen(hWnd
, &point
);
1711 wxCurrentPopupMenu
= menu
;
1712 ::TrackPopupMenu(hMenu
, TPM_RIGHTBUTTON
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1714 // we need to do it righ now as otherwise the events are never going to be
1715 // sent to wxCurrentPopupMenu from HandleCommand()
1717 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1718 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1719 // destroyed as soon as we return (it can be a local variable in the caller
1720 // for example) and so we do need to process the event immediately
1721 wxYieldForCommandsOnly();
1723 wxCurrentPopupMenu
= NULL
;
1725 menu
->SetInvokingWindow(NULL
);
1730 #endif // wxUSE_MENUS_NATIVE
1732 // ===========================================================================
1733 // pre/post message processing
1734 // ===========================================================================
1736 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1739 #ifdef __DIGITALMARS__
1740 return ::CallWindowProc( (FARPROC
) m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1742 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1745 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1748 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1750 // wxUniversal implements tab traversal itself
1751 #ifndef __WXUNIVERSAL__
1752 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1754 // intercept dialog navigation keys
1755 MSG
*msg
= (MSG
*)pMsg
;
1757 // here we try to do all the job which ::IsDialogMessage() usually does
1760 if ( msg
->message
== WM_KEYDOWN
)
1762 bool bCtrlDown
= wxIsCtrlDown();
1763 bool bShiftDown
= wxIsShiftDown();
1765 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1766 // don't process it if it's the case (except for Ctrl-Tab/Enter
1767 // combinations which are always processed)
1771 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1773 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1774 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1775 // it, of course, implies them
1776 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1778 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1782 bool bForward
= TRUE
,
1783 bWindowChange
= FALSE
;
1785 // should we process this message specially?
1786 bool bProcess
= TRUE
;
1787 switch ( msg
->wParam
)
1790 // assume that nobody wants Shift-TAB for himself - if we
1791 // don't do it there is no easy way for a control to grab
1792 // TABs but still let Shift-TAB work as navugation key
1793 if ( (lDlgCode
& DLGC_WANTTAB
) && !bShiftDown
) {
1797 // Ctrl-Tab cycles thru notebook pages
1798 bWindowChange
= bCtrlDown
;
1799 bForward
= !bShiftDown
;
1805 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1813 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1819 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1821 // control wants to process Enter itself, don't
1822 // call IsDialogMessage() which would interpret
1826 else if ( lDlgCode
& DLGC_BUTTON
)
1828 // let IsDialogMessage() handle this for all
1829 // buttons except the owner-drawn ones which it
1830 // just seems to ignore
1831 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1832 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1834 // emulate the button click
1835 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1837 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1842 // FIXME: this should be handled by
1843 // wxNavigationKeyEvent handler and not here!!
1847 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1849 if ( btn
&& btn
->IsEnabled() )
1851 // if we do have a default button, do press it
1852 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1856 else // no default button
1858 #endif // wxUSE_BUTTON
1859 // this is a quick and dirty test for a text
1861 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1863 // don't process Enter, the control might
1864 // need it for itself and don't let
1865 // ::IsDialogMessage() have it as it can
1866 // eat the Enter events sometimes
1869 else if (!IsTopLevel())
1871 // if not a top level window, let parent
1875 //else: treat Enter as TAB: pass to the next
1876 // control as this is the best thing to do
1877 // if the text doesn't handle Enter itself
1889 wxNavigationKeyEvent event
;
1890 event
.SetDirection(bForward
);
1891 event
.SetWindowChange(bWindowChange
);
1892 event
.SetEventObject(this);
1894 if ( GetEventHandler()->ProcessEvent(event
) )
1901 // let ::IsDialogMessage() do almost everything and handle just the
1902 // things it doesn't here: Ctrl-TAB for switching notebook pages
1903 if ( msg
->message
== WM_KEYDOWN
)
1905 // don't process system keys here
1906 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1908 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1910 // find the first notebook parent and change its page
1911 wxWindow
*win
= this;
1912 wxNotebook
*nbook
= NULL
;
1913 while ( win
&& !nbook
)
1915 nbook
= wxDynamicCast(win
, wxNotebook
);
1916 win
= win
->GetParent();
1921 bool forward
= !wxIsShiftDown();
1923 nbook
->AdvanceSelection(forward
);
1930 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1931 // shouldn't let IsDialogMessage() get it as it _always_ eats the
1932 // message even when there is no cancel button and when the message is
1933 // needed by the control itself: in particular, it prevents the tree in
1934 // place edit control from being closed with Escape in a dialog
1935 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
1937 // ::IsDialogMessage() can enter in an infinite loop when the
1938 // currently focused window is disabled or hidden and its parent
1939 // has WS_EX_CONTROLPARENT style, so don't call it in this case
1940 bool canSafelyCallIsDlgMsg
= TRUE
;
1942 HWND hwndFocus
= ::GetFocus();
1945 if ( !::IsWindowEnabled(hwndFocus
) ||
1946 !::IsWindowVisible(hwndFocus
) )
1948 // it would enter an infinite loop if we do this!
1949 canSafelyCallIsDlgMsg
= FALSE
;
1954 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
1956 // it's a top level window, don't go further -- e.g. even
1957 // if the parent of a dialog is disabled, this doesn't
1958 // break navigation inside the dialog
1962 hwndFocus
= ::GetParent(hwndFocus
);
1965 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
1967 // IsDialogMessage() did something...
1972 #endif // __WXUNIVERSAL__
1977 // relay mouse move events to the tooltip control
1978 MSG
*msg
= (MSG
*)pMsg
;
1979 if ( msg
->message
== WM_MOUSEMOVE
)
1980 m_tooltip
->RelayEvent(pMsg
);
1982 #endif // wxUSE_TOOLTIPS
1987 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
1989 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
1990 return m_acceleratorTable
.Translate(this, pMsg
);
1994 #endif // wxUSE_ACCEL
1997 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
1999 // preprocess all messages by default
2003 // ---------------------------------------------------------------------------
2004 // message params unpackers (different for Win16 and Win32)
2005 // ---------------------------------------------------------------------------
2009 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2010 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2012 *id
= LOWORD(wParam
);
2013 *hwnd
= (WXHWND
)lParam
;
2014 *cmd
= HIWORD(wParam
);
2017 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2018 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2020 *state
= LOWORD(wParam
);
2021 *minimized
= HIWORD(wParam
);
2022 *hwnd
= (WXHWND
)lParam
;
2025 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2026 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2028 *code
= LOWORD(wParam
);
2029 *pos
= HIWORD(wParam
);
2030 *hwnd
= (WXHWND
)lParam
;
2033 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2034 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2036 #ifndef __WXMICROWIN__
2037 *nCtlColor
= CTLCOLOR_BTN
;
2038 *hwnd
= (WXHWND
)lParam
;
2039 *hdc
= (WXHDC
)wParam
;
2043 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2044 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2046 *item
= (WXWORD
)wParam
;
2047 *flags
= HIWORD(wParam
);
2048 *hmenu
= (WXHMENU
)lParam
;
2053 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2054 WXWORD
*id
, WXHWND
*hwnd
, WXWORD
*cmd
)
2056 *id
= (WXWORD
)wParam
;
2057 *hwnd
= (WXHWND
)LOWORD(lParam
);
2058 *cmd
= HIWORD(lParam
);
2061 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2062 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2064 *state
= (WXWORD
)wParam
;
2065 *minimized
= LOWORD(lParam
);
2066 *hwnd
= (WXHWND
)HIWORD(lParam
);
2069 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2070 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2072 *code
= (WXWORD
)wParam
;
2073 *pos
= LOWORD(lParam
);
2074 *hwnd
= (WXHWND
)HIWORD(lParam
);
2077 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2078 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2080 *hwnd
= (WXHWND
)LOWORD(lParam
);
2081 *nCtlColor
= (int)HIWORD(lParam
);
2082 *hdc
= (WXHDC
)wParam
;
2085 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2086 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2088 *item
= (WXWORD
)wParam
;
2089 *flags
= LOWORD(lParam
);
2090 *hmenu
= (WXHMENU
)HIWORD(lParam
);
2095 // ---------------------------------------------------------------------------
2096 // Main wxWindows window proc and the window proc for wxWindow
2097 // ---------------------------------------------------------------------------
2099 // Hook for new window just as it's being created, when the window isn't yet
2100 // associated with the handle
2101 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2103 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2104 // window being created and insures that it's always unset back later
2105 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2107 gs_winBeingCreated
= winBeingCreated
;
2110 wxWindowCreationHook::~wxWindowCreationHook()
2112 gs_winBeingCreated
= NULL
;
2116 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2118 // trace all messages - useful for the debugging
2121 wxLogTrace(wxTraceMessages
, wxT("Processing %s(wParam=%8lx, lParam=%8lx)"),
2122 wxGetMessageName(message
), (long) wParam
, lParam
);
2124 #endif // __WXDEBUG__
2126 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2128 // when we get the first message for the HWND we just created, we associate
2129 // it with wxWindow stored in gs_winBeingCreated
2130 if ( !wnd
&& gs_winBeingCreated
)
2132 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2133 wnd
= gs_winBeingCreated
;
2134 gs_winBeingCreated
= NULL
;
2135 wnd
->SetHWND((WXHWND
)hWnd
);
2141 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2143 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2148 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2150 // did we process the message?
2151 bool processed
= FALSE
;
2162 // for most messages we should return 0 when we do process the message
2170 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2173 // return 0 to allow window creation
2174 rc
.result
= mayCreate
? 0 : -1;
2180 // never set processed to TRUE and *always* pass WM_DESTROY to
2181 // DefWindowProc() as Windows may do some internal cleanup when
2182 // processing it and failing to pass the message along may cause
2183 // memory and resource leaks!
2184 (void)HandleDestroy();
2188 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2196 // we're not interested in these messages at all
2199 case SIZE_MINIMIZED
:
2200 // we shouldn't send sizev events for these messages as the
2201 // client size may be negative which breaks existing code
2203 // OTOH we might send another (wxMinimizedEvent?) one or
2204 // add an additional parameter to wxSizeEvent if this is
2205 // useful to anybody
2209 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2210 // fall through nevertheless
2212 case SIZE_MAXIMIZED
:
2214 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2219 #ifndef __WXMICROWIN__
2220 case WM_ACTIVATEAPP
:
2221 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2227 WXWORD state
, minimized
;
2229 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2231 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2236 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2240 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2244 processed
= HandlePaint();
2248 #ifdef __WXUNIVERSAL__
2249 // Universal uses its own wxFrame/wxDialog, so we don't receive
2250 // close events unless we have this.
2255 // don't let the DefWindowProc() destroy our window - we'll do it
2256 // ourselves in ~wxWindow
2263 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2267 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2268 GET_Y_LPARAM(lParam
),
2272 #if wxUSE_MOUSEWHEEL
2274 processed
= HandleMouseWheel(wParam
, lParam
);
2278 case WM_LBUTTONDOWN
:
2280 case WM_LBUTTONDBLCLK
:
2281 case WM_RBUTTONDOWN
:
2283 case WM_RBUTTONDBLCLK
:
2284 case WM_MBUTTONDOWN
:
2286 case WM_MBUTTONDBLCLK
:
2288 #ifdef __WXMICROWIN__
2289 // MicroWindows seems to ignore the fact that a window is
2290 // disabled. So catch mouse events and throw them away if
2292 wxWindowMSW
* win
= this;
2295 if (!win
->IsEnabled())
2301 win
= win
->GetParent();
2302 if ( !win
|| win
->IsTopLevel() )
2309 #endif // __WXMICROWIN__
2310 int x
= GET_X_LPARAM(lParam
),
2311 y
= GET_Y_LPARAM(lParam
);
2313 // redirect the event to a static control if necessary by
2314 // finding one under mouse
2316 if ( GetCapture() == this )
2318 // but don't do it if the mouse is captured by this window
2319 // because then it should really get this event itself
2324 win
= FindWindowForMouseEvent(this, &x
, &y
);
2326 // this should never happen
2327 wxCHECK_MSG( win
, 0,
2328 _T("FindWindowForMouseEvent() returned NULL") );
2330 // for the standard classes their WndProc sets the focus to
2331 // them anyhow and doing it from here results in some weird
2332 // problems, but for our windows we want them to acquire
2333 // focus when clicked
2334 if ( !win
->IsOfStandardClass() )
2336 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2341 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2350 case MM_JOY1BUTTONDOWN
:
2351 case MM_JOY2BUTTONDOWN
:
2352 case MM_JOY1BUTTONUP
:
2353 case MM_JOY2BUTTONUP
:
2354 processed
= HandleJoystickEvent(message
,
2355 GET_X_LPARAM(lParam
),
2356 GET_Y_LPARAM(lParam
),
2359 #endif // __WXMICROWIN__
2362 processed
= HandleSysCommand(wParam
, lParam
);
2369 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2371 processed
= HandleCommand(id
, cmd
, hwnd
);
2377 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2381 // for these messages we must return TRUE if process the message
2384 case WM_MEASUREITEM
:
2386 int idCtrl
= (UINT
)wParam
;
2387 if ( message
== WM_DRAWITEM
)
2389 processed
= MSWOnDrawItem(idCtrl
,
2390 (WXDRAWITEMSTRUCT
*)lParam
);
2394 processed
= MSWOnMeasureItem(idCtrl
,
2395 (WXMEASUREITEMSTRUCT
*)lParam
);
2402 #endif // defined(WM_DRAWITEM)
2405 if ( !IsOfStandardClass() )
2407 // we always want to get the char events
2408 rc
.result
= DLGC_WANTCHARS
;
2410 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2412 // in fact, we want everything
2413 rc
.result
|= DLGC_WANTARROWS
|
2420 //else: get the dlg code from the DefWindowProc()
2425 // If this has been processed by an event handler, return 0 now
2426 // (we've handled it).
2427 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2428 if ( m_lastKeydownProcessed
)
2437 // we consider these message "not interesting" to OnChar, so
2438 // just don't do anything more with them
2448 // avoid duplicate messages to OnChar for these ASCII keys:
2449 // they will be translated by TranslateMessage() and received
2471 // but set processed to FALSE, not TRUE to still pass them
2472 // to the control's default window proc - otherwise
2473 // built-in keyboard handling won't work
2478 // special case of VK_APPS: treat it the same as right mouse
2479 // click because both usually pop up a context menu
2485 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2486 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2492 // do generate a CHAR event
2493 processed
= HandleChar((WORD
)wParam
, lParam
);
2496 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2503 // special case of VK_APPS: treat it the same as right mouse button
2504 if ( wParam
== VK_APPS
)
2509 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2510 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2515 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2520 case WM_CHAR
: // Always an ASCII character
2521 if ( m_lastKeydownProcessed
)
2523 // The key was handled in the EVT_KEY_DOWN and handling
2524 // a key in an EVT_KEY_DOWN handler is meant, by
2525 // design, to prevent EVT_CHARs from happening
2526 m_lastKeydownProcessed
= FALSE
;
2531 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2540 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2542 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2548 // CTLCOLOR messages are sent by children to query the parent for their
2549 // colors#ifndef __WXMICROWIN__
2550 #ifndef __WXMICROWIN__
2552 case WM_CTLCOLORMSGBOX
:
2553 case WM_CTLCOLOREDIT
:
2554 case WM_CTLCOLORLISTBOX
:
2555 case WM_CTLCOLORBTN
:
2556 case WM_CTLCOLORDLG
:
2557 case WM_CTLCOLORSCROLLBAR
:
2558 case WM_CTLCOLORSTATIC
:
2566 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2568 processed
= HandleCtlColor(&rc
.hBrush
,
2577 #endif // !__WXMICROWIN__
2579 case WM_SYSCOLORCHANGE
:
2580 // the return value for this message is ignored
2581 processed
= HandleSysColorChange();
2584 case WM_DISPLAYCHANGE
:
2585 processed
= HandleDisplayChange();
2588 case WM_PALETTECHANGED
:
2589 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2592 case WM_CAPTURECHANGED
:
2593 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2596 case WM_QUERYNEWPALETTE
:
2597 processed
= HandleQueryNewPalette();
2601 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2604 // we processed the message, i.e. erased the background
2610 processed
= HandleDropFiles(wParam
);
2614 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2618 // we never set focus from here
2623 case WM_QUERYENDSESSION
:
2624 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2628 processed
= HandleEndSession(wParam
!= 0, lParam
);
2631 case WM_GETMINMAXINFO
:
2632 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2636 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2637 LOWORD(lParam
), // hit test
2638 HIWORD(lParam
)); // mouse msg
2642 // returning TRUE stops the DefWindowProc() from further
2643 // processing this message - exactly what we need because we've
2644 // just set the cursor.
2649 #if wxUSE_ACCESSIBILITY
2652 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2653 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2655 if (dwObjId
== OBJID_CLIENT
&& GetOrCreateAccessible())
2657 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2663 #if defined(__WIN32__) && defined(WM_HELP)
2666 HELPINFO
* info
= (HELPINFO
*) lParam
;
2667 // Don't yet process menu help events, just windows
2668 if (info
->iContextType
== HELPINFO_WINDOW
)
2670 wxWindowMSW
* subjectOfHelp
= this;
2671 bool eventProcessed
= FALSE
;
2672 while (subjectOfHelp
&& !eventProcessed
)
2674 wxHelpEvent
helpEvent(wxEVT_HELP
,
2675 subjectOfHelp
->GetId(),
2676 wxPoint(info
->MousePos
.x
,
2677 info
->MousePos
.y
) );
2678 helpEvent
.SetEventObject(this);
2680 GetEventHandler()->ProcessEvent(helpEvent
);
2682 // Go up the window hierarchy until the event is
2684 subjectOfHelp
= subjectOfHelp
->GetParent();
2687 processed
= eventProcessed
;
2689 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2691 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2692 helpEvent
.SetEventObject(this);
2693 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2696 //else: processed is already FALSE
2700 case WM_CONTEXTMENU
:
2702 // we don't convert from screen to client coordinates as
2703 // the event may be handled by a parent window
2704 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2706 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2707 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2712 // we're only interested in our own menus, not MF_SYSMENU
2713 if ( HIWORD(wParam
) == MF_POPUP
)
2715 // handle menu chars for ownerdrawn menu items
2716 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2717 if ( i
!= wxNOT_FOUND
)
2719 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2731 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2732 wxGetMessageName(message
));
2734 #endif // __WXDEBUG__
2735 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2741 // ----------------------------------------------------------------------------
2742 // wxWindow <-> HWND map
2743 // ----------------------------------------------------------------------------
2745 wxWinHashTable
*wxWinHandleHash
= NULL
;
2747 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2749 return wxWinHandleHash
->Get((long)hWnd
);
2752 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2754 // adding NULL hWnd is (first) surely a result of an error and
2755 // (secondly) breaks menu command processing
2756 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2757 wxT("attempt to add a NULL hWnd to window list ignored") );
2759 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2761 if ( oldWin
&& (oldWin
!= win
) )
2763 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2764 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2767 #endif // __WXDEBUG__
2770 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2774 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2776 wxWinHandleHash
->Delete((long)win
->GetHWND());
2779 // ----------------------------------------------------------------------------
2780 // various MSW speciic class dependent functions
2781 // ----------------------------------------------------------------------------
2783 // Default destroyer - override if you destroy it in some other way
2784 // (e.g. with MDI child windows)
2785 void wxWindowMSW::MSWDestroyWindow()
2789 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2792 int& w
, int& h
) const
2794 static const int DEFAULT_Y
= 200;
2795 static const int DEFAULT_H
= 250;
2797 bool nonDefault
= FALSE
;
2801 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2802 // just as well set it to CW_USEDEFAULT as well
2808 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2809 // neither because it is not handled as a special value by Windows then
2810 // and so we have to choose some default value for it
2812 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2818 NB: there used to be some code here which set the initial size of the
2819 window to the client size of the parent if no explicit size was
2820 specified. This was wrong because wxWindows programs often assume
2821 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2822 it. To see why, you should understand that Windows sends WM_SIZE from
2823 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2824 from some base class ctor and so this WM_SIZE is not processed in the
2825 real class' OnSize() (because it's not fully constructed yet and the
2826 event goes to some base class OnSize() instead). So the WM_SIZE we
2827 rely on is the one sent when the parent frame resizes its children
2828 but here is the problem: if the child already has just the right
2829 size, nothing will happen as both wxWindows and Windows check for
2830 this and ignore any attempts to change the window size to the size it
2831 already has - so no WM_SIZE would be sent.
2835 // as above, h is not used at all in this case anyhow
2841 // and, again as above, we can't set the height to CW_USEDEFAULT here
2843 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
2851 WXHWND
wxWindowMSW::MSWGetParent() const
2853 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
2856 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
2857 const wxChar
*title
,
2861 WXDWORD extendedStyle
)
2863 // choose the position/size for the new window
2865 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
2867 // controlId is menu handle for the top level windows, so set it to 0
2868 // unless we're creating a child window
2869 int controlId
= style
& WS_CHILD
? GetId() : 0;
2871 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2872 // which is the same but without CS_[HV]REDRAW class styles so using it
2873 // ensures that the window is not fully repainted on each resize
2874 wxString
className(wclass
);
2875 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE
)
2877 className
+= wxT("NR");
2880 // do create the window
2881 wxWindowCreationHook
hook(this);
2883 m_hWnd
= (WXHWND
)::CreateWindowEx
2887 title
? title
: wxT(""),
2890 (HWND
)MSWGetParent(),
2893 NULL
// no extra data
2898 wxLogSysError(_("Can't create window of class %s"), wclass
);
2903 SubclassWin(m_hWnd
);
2905 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
2910 // ===========================================================================
2911 // MSW message handlers
2912 // ===========================================================================
2914 // ---------------------------------------------------------------------------
2916 // ---------------------------------------------------------------------------
2920 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
2922 #ifndef __WXMICROWIN__
2923 LPNMHDR hdr
= (LPNMHDR
)lParam
;
2924 HWND hWnd
= hdr
->hwndFrom
;
2925 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
2927 // if the control is one of our windows, let it handle the message itself
2930 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
2933 // VZ: why did we do it? normally this is unnecessary and, besides, it
2934 // breaks the message processing for the toolbars because the tooltip
2935 // notifications were being forwarded to the toolbar child controls
2936 // (if it had any) before being passed to the toolbar itself, so in my
2937 // example the tooltip for the combobox was always shown instead of the
2938 // correct button tooltips
2940 // try all our children
2941 wxWindowList::Node
*node
= GetChildren().GetFirst();
2944 wxWindow
*child
= node
->GetData();
2945 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
2950 node
= node
->GetNext();
2954 // by default, handle it ourselves
2955 return MSWOnNotify(idCtrl
, lParam
, result
);
2956 #else // __WXMICROWIN__
2963 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
2965 const wxString
& ttip
)
2967 // I don't know why it happens, but the versions of comctl32.dll starting
2968 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
2969 // this message is supposed to be sent to Unicode programs only) -- hence
2970 // we need to handle it as well, otherwise no tooltips will be shown in
2973 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
2975 // not a tooltip message or no tooltip to show anyhow
2979 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
2982 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
2984 // we pass just the pointer as we store the string internally anyhow
2985 ttText
->lpszText
= (char *)ttip
.c_str();
2987 else // TTN_NEEDTEXTW
2991 // in Unicode mode this is just what we need
2992 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
2994 MultiByteToWideChar(CP_ACP
, 0, ttip
, ttip
.length()+1,
2995 (wchar_t *)ttText
->szText
,
2996 sizeof(ttText
->szText
) / sizeof(wchar_t));
2997 #endif // Unicode/!Unicode
3003 #endif // wxUSE_TOOLTIPS
3005 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3007 WXLPARAM
* WXUNUSED(result
))
3012 NMHDR
* hdr
= (NMHDR
*)lParam
;
3013 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3019 #endif // wxUSE_TOOLTIPS
3026 // ---------------------------------------------------------------------------
3027 // end session messages
3028 // ---------------------------------------------------------------------------
3030 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3032 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3033 event
.SetEventObject(wxTheApp
);
3034 event
.SetCanVeto(TRUE
);
3035 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3037 bool rc
= wxTheApp
->ProcessEvent(event
);
3041 // we may end only if the app didn't veto session closing (double
3043 *mayEnd
= !event
.GetVeto();
3049 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3051 // do nothing if the session isn't ending
3056 if ( (this != wxTheApp
->GetTopWindow()) )
3059 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3060 event
.SetEventObject(wxTheApp
);
3061 event
.SetCanVeto(FALSE
);
3062 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3064 return wxTheApp
->ProcessEvent(event
);
3067 // ---------------------------------------------------------------------------
3068 // window creation/destruction
3069 // ---------------------------------------------------------------------------
3071 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3073 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3074 // parent as well as otherwise several Win32 functions using
3075 // GetNextDlgTabItem() to iterate over all controls such as
3076 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3077 // all of them iterate over all the controls starting from the focus and
3078 // stop iterating when they get back to the focus but unless all parents
3079 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3080 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3082 // there is no need to do anything for the top level windows
3083 const wxWindow
*parent
= GetParent();
3084 while ( parent
&& !parent
->IsTopLevel() )
3086 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
3087 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
3089 // force the parent to have this style
3090 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
3091 exStyle
| WS_EX_CONTROLPARENT
);
3094 parent
= parent
->GetParent();
3098 // TODO: should generate this event from WM_NCCREATE
3099 wxWindowCreateEvent
event((wxWindow
*)this);
3100 (void)GetEventHandler()->ProcessEvent(event
);
3107 bool wxWindowMSW::HandleDestroy()
3111 // delete our drop target if we've got one
3112 #if wxUSE_DRAG_AND_DROP
3113 if ( m_dropTarget
!= NULL
)
3115 m_dropTarget
->Revoke(m_hWnd
);
3117 delete m_dropTarget
;
3118 m_dropTarget
= NULL
;
3120 #endif // wxUSE_DRAG_AND_DROP
3122 // WM_DESTROY handled
3126 // ---------------------------------------------------------------------------
3128 // ---------------------------------------------------------------------------
3130 bool wxWindowMSW::HandleActivate(int state
,
3131 bool WXUNUSED(minimized
),
3132 WXHWND
WXUNUSED(activate
))
3134 wxActivateEvent
event(wxEVT_ACTIVATE
,
3135 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3137 event
.SetEventObject(this);
3139 return GetEventHandler()->ProcessEvent(event
);
3142 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3144 // notify the parent keeping track of focus for the kbd navigation
3145 // purposes that we got it
3146 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3147 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3153 m_caret
->OnSetFocus();
3155 #endif // wxUSE_CARET
3158 // If it's a wxTextCtrl don't send the event as it will be done
3159 // after the control gets to process it from EN_FOCUS handler
3160 if ( wxDynamicCastThis(wxTextCtrl
) )
3164 #endif // wxUSE_TEXTCTRL
3166 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3167 event
.SetEventObject(this);
3169 // wxFindWinFromHandle() may return NULL, it is ok
3170 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3172 return GetEventHandler()->ProcessEvent(event
);
3175 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3181 m_caret
->OnKillFocus();
3183 #endif // wxUSE_CARET
3186 // If it's a wxTextCtrl don't send the event as it will be done
3187 // after the control gets to process it.
3188 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3195 // Don't send the event when in the process of being deleted. This can
3196 // only cause problems if the event handler tries to access the object.
3197 if ( m_isBeingDeleted
)
3202 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3203 event
.SetEventObject(this);
3205 // wxFindWinFromHandle() may return NULL, it is ok
3206 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3208 return GetEventHandler()->ProcessEvent(event
);
3211 // ---------------------------------------------------------------------------
3213 // ---------------------------------------------------------------------------
3215 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3217 wxShowEvent
event(GetId(), show
);
3218 event
.m_eventObject
= this;
3220 return GetEventHandler()->ProcessEvent(event
);
3223 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3225 wxInitDialogEvent
event(GetId());
3226 event
.m_eventObject
= this;
3228 return GetEventHandler()->ProcessEvent(event
);
3231 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3233 #if defined (__WXMICROWIN__)
3235 #else // __WXMICROWIN__
3236 HDROP hFilesInfo
= (HDROP
) wParam
;
3238 // Get the total number of files dropped
3239 UINT gwFilesDropped
= ::DragQueryFile
3247 wxString
*files
= new wxString
[gwFilesDropped
];
3248 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3250 // first get the needed buffer length (+1 for terminating NUL)
3251 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3253 // and now get the file name
3254 ::DragQueryFile(hFilesInfo
, wIndex
,
3255 files
[wIndex
].GetWriteBuf(len
), len
);
3257 files
[wIndex
].UngetWriteBuf();
3259 DragFinish (hFilesInfo
);
3261 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3262 event
.m_eventObject
= this;
3265 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3266 event
.m_pos
.x
= dropPoint
.x
;
3267 event
.m_pos
.y
= dropPoint
.y
;
3269 return GetEventHandler()->ProcessEvent(event
);
3273 #ifdef __DIGITALMARS__
3274 extern "C" HCURSOR
wxGetCurrentBusyCursor();
3277 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3279 int WXUNUSED(mouseMsg
))
3281 #ifndef __WXMICROWIN__
3282 // the logic is as follows:
3283 // -1. don't set cursor for non client area, including but not limited to
3284 // the title bar, scrollbars, &c
3285 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3286 // 1. if we have the cursor set it unless wxIsBusy()
3287 // 2. if we're a top level window, set some cursor anyhow
3288 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3290 if ( nHitTest
!= HTCLIENT
)
3295 HCURSOR hcursor
= 0;
3297 // first ask the user code - it may wish to set the cursor in some very
3298 // specific way (for example, depending on the current position)
3301 if ( !::GetCursorPos(&pt
) )
3303 wxLogLastError(wxT("GetCursorPos"));
3306 // In WIN16 it doesn't return a value.
3307 ::GetCursorPos(&pt
);
3312 ScreenToClient(&x
, &y
);
3313 wxSetCursorEvent
event(x
, y
);
3315 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3316 if ( processedEvtSetCursor
&& event
.HasCursor() )
3318 hcursor
= GetHcursorOf(event
.GetCursor());
3323 bool isBusy
= wxIsBusy();
3325 // the test for processedEvtSetCursor is here to prevent using m_cursor
3326 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3327 // it - this is a way to say that our cursor shouldn't be used for this
3329 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3331 hcursor
= GetHcursorOf(m_cursor
);
3338 hcursor
= wxGetCurrentBusyCursor();
3340 else if ( !hcursor
)
3342 const wxCursor
*cursor
= wxGetGlobalCursor();
3343 if ( cursor
&& cursor
->Ok() )
3345 hcursor
= GetHcursorOf(*cursor
);
3353 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3355 ::SetCursor(hcursor
);
3357 // cursor set, stop here
3360 #endif // __WXMICROWIN__
3362 // pass up the window chain
3366 // ---------------------------------------------------------------------------
3367 // owner drawn stuff
3368 // ---------------------------------------------------------------------------
3370 bool wxWindowMSW::MSWOnDrawItem(int id
, WXDRAWITEMSTRUCT
*itemStruct
)
3372 #if wxUSE_OWNER_DRAWN
3374 #if wxUSE_MENUS_NATIVE
3375 // is it a menu item?
3376 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3377 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3379 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3381 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3383 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3384 // the DC from being released
3385 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3386 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3387 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3388 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3390 return pMenuItem
->OnDrawItem
3394 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3395 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3398 #endif // wxUSE_MENUS_NATIVE
3401 wxWindow
*item
= FindItem(id
);
3402 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3404 return ((wxControl
*)item
)->MSWOnDraw(itemStruct
);
3406 #endif // wxUSE_CONTROLS
3408 #endif // USE_OWNER_DRAWN
3413 bool wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3415 #if wxUSE_OWNER_DRAWN
3416 // is it a menu item?
3417 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3418 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3420 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3422 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3424 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3425 &pMeasureStruct
->itemHeight
);
3428 wxWindow
*item
= FindItem(id
);
3429 if ( item
&& item
->IsKindOf(CLASSINFO(wxControl
)) )
3431 return ((wxControl
*)item
)->MSWOnMeasure(itemStruct
);
3433 #endif // owner-drawn menus
3437 // ---------------------------------------------------------------------------
3438 // colours and palettes
3439 // ---------------------------------------------------------------------------
3441 bool wxWindowMSW::HandleSysColorChange()
3443 wxSysColourChangedEvent event
;
3444 event
.SetEventObject(this);
3446 (void)GetEventHandler()->ProcessEvent(event
);
3448 // always let the system carry on the default processing to allow the
3449 // native controls to react to the colours update
3453 bool wxWindowMSW::HandleDisplayChange()
3455 wxDisplayChangedEvent event
;
3456 event
.SetEventObject(this);
3458 return GetEventHandler()->ProcessEvent(event
);
3461 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3469 #ifndef __WXMICROWIN__
3470 WXHBRUSH hBrush
= 0;
3472 if ( nCtlColor
== CTLCOLOR_DLG
)
3474 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3479 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3481 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3483 #endif // wxUSE_CONTROLS
3489 #else // __WXMICROWIN__
3494 // Define for each class of dialog and control
3495 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3496 WXHWND
WXUNUSED(hWnd
),
3497 WXUINT
WXUNUSED(nCtlColor
),
3498 WXUINT
WXUNUSED(message
),
3499 WXWPARAM
WXUNUSED(wParam
),
3500 WXLPARAM
WXUNUSED(lParam
))
3505 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3508 // same as below except we don't respond to our own messages
3509 if ( hWndPalChange
!= GetHWND() )
3511 // check to see if we our our parents have a custom palette
3512 wxWindowMSW
*win
= this;
3513 while ( win
&& !win
->HasCustomPalette() )
3515 win
= win
->GetParent();
3518 if ( win
&& win
->HasCustomPalette() )
3520 // realize the palette to see whether redrawing is needed
3521 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3522 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3523 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3525 int result
= ::RealizePalette(hdc
);
3527 // restore the palette (before releasing the DC)
3528 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3529 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3530 ::RealizePalette(hdc
);
3531 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3533 // now check for the need to redraw
3535 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3539 #endif // wxUSE_PALETTE
3541 wxPaletteChangedEvent
event(GetId());
3542 event
.SetEventObject(this);
3543 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3545 return GetEventHandler()->ProcessEvent(event
);
3548 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3550 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3551 event
.SetEventObject(this);
3553 return GetEventHandler()->ProcessEvent(event
);
3556 bool wxWindowMSW::HandleQueryNewPalette()
3560 // check to see if we our our parents have a custom palette
3561 wxWindowMSW
*win
= this;
3562 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3563 if (win
->HasCustomPalette()) {
3564 /* realize the palette to see whether redrawing is needed */
3565 HDC hdc
= GetDC((HWND
) GetHWND());
3566 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3567 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3569 int result
= ::RealizePalette(hdc
);
3570 /* restore the palette (before releasing the DC) */
3571 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3572 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3573 ::RealizePalette(hdc
);
3574 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3575 /* now check for the need to redraw */
3577 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3579 #endif // wxUSE_PALETTE
3581 wxQueryNewPaletteEvent
event(GetId());
3582 event
.SetEventObject(this);
3584 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3587 // Responds to colour changes: passes event on to children.
3588 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3590 // the top level window also reset the standard colour map as it might have
3591 // changed (there is no need to do it for the non top level windows as we
3592 // only have to do it once)
3596 gs_hasStdCmap
= FALSE
;
3598 wxWindowList::Node
*node
= GetChildren().GetFirst();
3601 // Only propagate to non-top-level windows because Windows already
3602 // sends this event to all top-level ones
3603 wxWindow
*win
= node
->GetData();
3604 if ( !win
->IsTopLevel() )
3606 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3607 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3608 // the standard controls
3609 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3612 node
= node
->GetNext();
3615 // update the colours we use if they were not set explicitly by the user:
3616 // this must be done or OnCtlColor() would continue to use the old colours
3619 m_foregroundColour
= wxSystemSettings::
3620 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3625 m_backgroundColour
= wxSystemSettings::
3626 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3630 extern wxCOLORMAP
*wxGetStdColourMap()
3632 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3633 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3635 if ( !gs_hasStdCmap
)
3637 static bool s_coloursInit
= FALSE
;
3639 if ( !s_coloursInit
)
3641 // When a bitmap is loaded, the RGB values can change (apparently
3642 // because Windows adjusts them to care for the old programs always
3643 // using 0xc0c0c0 while the transparent colour for the new Windows
3644 // versions is different). But we do this adjustment ourselves so
3645 // we want to avoid Windows' "help" and for this we need to have a
3646 // reference bitmap which can tell us what the RGB values change
3648 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3649 if ( stdColourBitmap
.Ok() )
3651 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3652 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3653 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3656 memDC
.SelectObject(stdColourBitmap
);
3659 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3661 memDC
.GetPixel(i
, 0, &colour
);
3662 s_stdColours
[i
] = wxColourToRGB(colour
);
3665 else // wxBITMAP_STD_COLOURS couldn't be loaded
3667 s_stdColours
[0] = RGB(000,000,000); // black
3668 s_stdColours
[1] = RGB(128,128,128); // dark grey
3669 s_stdColours
[2] = RGB(192,192,192); // light grey
3670 s_stdColours
[3] = RGB(255,255,255); // white
3671 //s_stdColours[4] = RGB(000,000,255); // blue
3672 //s_stdColours[5] = RGB(255,000,255); // magenta
3675 s_coloursInit
= TRUE
;
3678 gs_hasStdCmap
= TRUE
;
3680 // create the colour map
3681 #define INIT_CMAP_ENTRY(col) \
3682 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3683 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3685 INIT_CMAP_ENTRY(BTNTEXT
);
3686 INIT_CMAP_ENTRY(BTNSHADOW
);
3687 INIT_CMAP_ENTRY(BTNFACE
);
3688 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3690 #undef INIT_CMAP_ENTRY
3696 // ---------------------------------------------------------------------------
3698 // ---------------------------------------------------------------------------
3700 bool wxWindowMSW::HandlePaint()
3703 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3705 wxLogLastError(wxT("CreateRectRgn"));
3706 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3707 wxLogLastError(wxT("GetUpdateRgn"));
3709 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3712 ::GetUpdateRect(GetHwnd(), &updateRect
, FALSE
);
3714 m_updateRegion
= wxRegion(updateRect
.left
, updateRect
.top
,
3715 updateRect
.right
- updateRect
.left
,
3716 updateRect
.bottom
- updateRect
.top
);
3719 wxPaintEvent
event(m_windowId
);
3720 event
.SetEventObject(this);
3722 bool processed
= GetEventHandler()->ProcessEvent(event
);
3724 // note that we must generate NC event after the normal one as otherwise
3725 // BeginPaint() will happily overwrite our decorations with the background
3727 wxNcPaintEvent
eventNc(m_windowId
);
3728 eventNc
.SetEventObject(this);
3729 GetEventHandler()->ProcessEvent(eventNc
);
3734 // Can be called from an application's OnPaint handler
3735 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3737 #ifdef __WXUNIVERSAL__
3740 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3743 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3748 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3750 // Prevents flicker when dragging
3751 if ( ::IsIconic(GetHwnd()) )
3757 dc
.SetWindow((wxWindow
*)this);
3760 wxEraseEvent
event(m_windowId
, &dc
);
3761 event
.SetEventObject(this);
3762 bool rc
= GetEventHandler()->ProcessEvent(event
);
3766 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3767 dc
.SelectOldObjects(hdc
);
3772 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
3775 ::GetClientRect(GetHwnd(), &rect
);
3777 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
3778 m_backgroundColour
.Green(),
3779 m_backgroundColour
.Blue());
3780 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
3782 wxLogLastError(wxT("CreateSolidBrush"));
3784 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
3786 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
3788 ::FillRect(hdc
, &rect
, hBrush
);
3789 ::DeleteObject(hBrush
);
3790 ::SetMapMode(hdc
, mode
);
3793 // ---------------------------------------------------------------------------
3794 // moving and resizing
3795 // ---------------------------------------------------------------------------
3797 bool wxWindowMSW::HandleMinimize()
3799 wxIconizeEvent
event(m_windowId
);
3800 event
.SetEventObject(this);
3802 return GetEventHandler()->ProcessEvent(event
);
3805 bool wxWindowMSW::HandleMaximize()
3807 wxMaximizeEvent
event(m_windowId
);
3808 event
.SetEventObject(this);
3810 return GetEventHandler()->ProcessEvent(event
);
3813 bool wxWindowMSW::HandleMove(int x
, int y
)
3815 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
3816 event
.SetEventObject(this);
3818 return GetEventHandler()->ProcessEvent(event
);
3821 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
3822 WXUINT
WXUNUSED(flag
))
3824 // don't use w and h parameters as they specify the client size while
3825 // according to the docs EVT_SIZE handler is supposed to receive the total
3827 wxSizeEvent
event(GetSize(), m_windowId
);
3828 event
.SetEventObject(this);
3830 return GetEventHandler()->ProcessEvent(event
);
3833 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
3835 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
3839 int minWidth
= GetMinWidth(),
3840 minHeight
= GetMinHeight(),
3841 maxWidth
= GetMaxWidth(),
3842 maxHeight
= GetMaxHeight();
3844 if ( minWidth
!= -1 )
3846 info
->ptMinTrackSize
.x
= minWidth
;
3850 if ( minHeight
!= -1 )
3852 info
->ptMinTrackSize
.y
= minHeight
;
3856 if ( maxWidth
!= -1 )
3858 info
->ptMaxTrackSize
.x
= maxWidth
;
3862 if ( maxHeight
!= -1 )
3864 info
->ptMaxTrackSize
.y
= maxHeight
;
3871 // ---------------------------------------------------------------------------
3873 // ---------------------------------------------------------------------------
3875 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
3877 #if wxUSE_MENUS_NATIVE
3878 if ( !cmd
&& wxCurrentPopupMenu
)
3880 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
3881 wxCurrentPopupMenu
= NULL
;
3883 return popupMenu
->MSWCommand(cmd
, id
);
3885 #endif // wxUSE_MENUS_NATIVE
3887 wxWindow
*win
= NULL
;
3889 // first try to find it from HWND - this works even with the broken
3890 // programs using the same ids for different controls
3893 win
= wxFindWinFromHandle(control
);
3899 // must cast to a signed type before comparing with other ids!
3900 win
= FindItem((signed short)id
);
3905 return win
->MSWCommand(cmd
, id
);
3908 // the messages sent from the in-place edit control used by the treectrl
3909 // for label editing have id == 0, but they should _not_ be treated as menu
3910 // messages (they are EN_XXX ones, in fact) so don't translate anything
3911 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
3914 // If no child window, it may be an accelerator, e.g. for a popup menu
3917 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
3918 event
.SetEventObject(this);
3922 return GetEventHandler()->ProcessEvent(event
);
3924 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
3927 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
3928 // notifications to its parent which we want to reflect back to
3930 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
3931 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
3934 #endif // wxUSE_SPINCTRL
3939 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
3941 // 4 bits are reserved
3942 switch ( wParam
& 0xFFFFFFF0 )
3945 return HandleMaximize();
3948 return HandleMinimize();
3954 // ---------------------------------------------------------------------------
3956 // ---------------------------------------------------------------------------
3958 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
3962 // our client coords are not quite the same as Windows ones
3963 wxPoint pt
= GetClientAreaOrigin();
3964 event
.m_x
= x
- pt
.x
;
3965 event
.m_y
= y
- pt
.y
;
3967 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
3968 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
3969 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
3970 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
3971 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
3972 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
3973 // Returns different negative values on WinME and WinNT,
3974 // so simply test for negative value.
3975 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
3977 event
.SetTimestamp(s_currentMsg
.time
);
3978 event
.m_eventObject
= this;
3979 event
.SetId(GetId());
3981 #if wxUSE_MOUSEEVENT_HACK
3984 m_lastMouseEvent
= event
.GetEventType();
3985 #endif // wxUSE_MOUSEEVENT_HACK
3988 // Windows doesn't send the mouse events to the static controls (which are
3989 // transparent in the sense that their WM_NCHITTEST handler returns
3990 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
3991 // and so we manually check if we don't have a child window under mouse and if
3992 // we do, send the event to it instead of the window Windows had sent WM_XXX
3995 // Notice that this is not done for the mouse move events because this could
3996 // (would?) be too slow, but only for clicks which means that the static texts
3997 // still don't get move, enter nor leave events.
3998 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4000 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4002 // first try to find a non transparent child: this allows us to send events
4003 // to a static text which is inside a static box, for example
4004 POINT pt
= { *x
, *y
};
4005 HWND hwnd
= GetHwndOf(win
),
4009 hwndUnderMouse
= ::ChildWindowFromPointEx
4018 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4021 // now try any child window at all
4022 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4025 // check that we have a child window which is susceptible to receive mouse
4026 // events: for this it must be shown and enabled
4027 if ( hwndUnderMouse
&&
4028 hwndUnderMouse
!= hwnd
&&
4029 ::IsWindowVisible(hwndUnderMouse
) &&
4030 ::IsWindowEnabled(hwndUnderMouse
) )
4032 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4033 if ( winUnderMouse
)
4035 // translate the mouse coords to the other window coords
4036 win
->ClientToScreen(x
, y
);
4037 winUnderMouse
->ScreenToClient(x
, y
);
4039 win
= winUnderMouse
;
4046 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4048 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4049 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4050 // from the message id and take the value in the table to get wxWin event
4052 static const wxEventType eventsMouse
[] =
4066 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4067 InitMouseEvent(event
, x
, y
, flags
);
4069 return GetEventHandler()->ProcessEvent(event
);
4072 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4074 if ( !m_mouseInWindow
)
4076 // it would be wrong to assume that just because we get a mouse move
4077 // event that the mouse is inside the window: although this is usually
4078 // true, it is not if we had captured the mouse, so we need to check
4079 // the mouse coordinates here
4080 if ( !HasCapture() || IsMouseInWindow() )
4082 // Generate an ENTER event
4083 m_mouseInWindow
= TRUE
;
4085 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4086 InitMouseEvent(event
, x
, y
, flags
);
4088 (void)GetEventHandler()->ProcessEvent(event
);
4092 #if wxUSE_MOUSEEVENT_HACK
4093 // Window gets a click down message followed by a mouse move message even
4094 // if position isn't changed! We want to discard the trailing move event
4095 // if x and y are the same.
4096 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4097 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4098 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4099 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4101 m_lastMouseEvent
= wxEVT_MOTION
;
4105 #endif // wxUSE_MOUSEEVENT_HACK
4107 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4111 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4113 #if wxUSE_MOUSEWHEEL
4114 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4115 InitMouseEvent(event
,
4116 GET_X_LPARAM(lParam
),
4117 GET_Y_LPARAM(lParam
),
4119 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4120 event
.m_wheelDelta
= WHEEL_DELTA
;
4123 static int s_linesPerRotation
= -1;
4124 if ( s_linesPerRotation
== -1 )
4126 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4127 &s_linesPerRotation
, 0))
4129 // this is not supposed to happen
4130 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4132 // the default is 3, so use it if SystemParametersInfo() failed
4133 s_linesPerRotation
= 3;
4137 // no SystemParametersInfo() under Win16
4138 static const int s_linesPerRotation
= 3;
4141 event
.m_linesPerAction
= s_linesPerRotation
;
4142 return GetEventHandler()->ProcessEvent(event
);
4153 // ---------------------------------------------------------------------------
4154 // keyboard handling
4155 // ---------------------------------------------------------------------------
4157 // create the key event of the given type for the given key - used by
4158 // HandleChar and HandleKeyDown/Up
4159 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4162 WXWPARAM wParam
) const
4164 wxKeyEvent
event(evType
);
4165 event
.SetId(GetId());
4166 event
.m_shiftDown
= wxIsShiftDown();
4167 event
.m_controlDown
= wxIsCtrlDown();
4168 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4170 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4171 event
.m_keyCode
= id
;
4172 event
.m_rawCode
= (wxUint32
) wParam
;
4173 event
.m_rawFlags
= (wxUint32
) lParam
;
4174 event
.SetTimestamp(s_currentMsg
.time
);
4176 // translate the position to client coords
4180 GetWindowRect(GetHwnd(),&rect
);
4190 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4192 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4194 bool ctrlDown
= FALSE
;
4199 // If 1 -> 26, translate to either special keycode or just set
4200 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4201 // ControlDown() == TRUE.
4203 if ( (id
> 0) && (id
< 27) )
4225 else // we're called from WM_KEYDOWN
4227 id
= wxCharCodeMSWToWX(wParam
);
4230 // it's ASCII and will be processed here only when called from
4231 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4236 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4238 // the alphanumeric keys produced by pressing AltGr+something on European
4239 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4240 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4241 // alphanumeric, so pretend that there are no modifiers at all (the
4242 // KEY_DOWN event would still have the correct modifiers if they're really
4244 if ( event
.m_controlDown
&& event
.m_altDown
&&
4245 (id
>= 32 && id
< 256) )
4247 event
.m_controlDown
=
4248 event
.m_altDown
= FALSE
;
4251 return GetEventHandler()->ProcessEvent(event
);
4254 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4256 int id
= wxCharCodeMSWToWX(wParam
);
4260 // normal ASCII char
4264 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4266 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4267 if ( GetEventHandler()->ProcessEvent(event
) )
4276 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4278 int id
= wxCharCodeMSWToWX(wParam
);
4282 // normal ASCII char
4286 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4288 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4289 if ( GetEventHandler()->ProcessEvent(event
) )
4298 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4300 const HMENU hmenu
= (HMENU
)lParam
;
4304 mii
.cbSize
= sizeof(MENUITEMINFO
);
4305 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4307 // find if we have this letter in any owner drawn item
4308 const int count
= ::GetMenuItemCount(hmenu
);
4309 for ( int i
= 0; i
< count
; i
++ )
4311 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4313 if ( mii
.fType
== MFT_OWNERDRAW
)
4315 // dwItemData member of the MENUITEMINFO is a
4316 // pointer to the associated wxMenuItem -- see the
4317 // menu creation code
4318 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4320 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4323 if ( *p
== _T('&') )
4325 // this is not the accel char, find the real one
4326 p
= wxStrchr(p
+ 1, _T('&'));
4328 else // got the accel char
4330 // FIXME-UNICODE: this comparison doesn't risk to work
4331 // for non ASCII accelerator characters I'm afraid, but
4333 if ( wxToupper(*p
) == chAccel
)
4339 // this one doesn't match
4346 else // failed ot get the menu text?
4348 // it's not fatal, so don't show error, but still log
4350 wxLogLastError(_T("GetMenuItemInfo"));
4359 // ---------------------------------------------------------------------------
4361 // ---------------------------------------------------------------------------
4363 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4367 if ( flags
& JOY_BUTTON1CHG
)
4368 change
= wxJOY_BUTTON1
;
4369 if ( flags
& JOY_BUTTON2CHG
)
4370 change
= wxJOY_BUTTON2
;
4371 if ( flags
& JOY_BUTTON3CHG
)
4372 change
= wxJOY_BUTTON3
;
4373 if ( flags
& JOY_BUTTON4CHG
)
4374 change
= wxJOY_BUTTON4
;
4377 if ( flags
& JOY_BUTTON1
)
4378 buttons
|= wxJOY_BUTTON1
;
4379 if ( flags
& JOY_BUTTON2
)
4380 buttons
|= wxJOY_BUTTON2
;
4381 if ( flags
& JOY_BUTTON3
)
4382 buttons
|= wxJOY_BUTTON3
;
4383 if ( flags
& JOY_BUTTON4
)
4384 buttons
|= wxJOY_BUTTON4
;
4386 // the event ids aren't consecutive so we can't use table based lookup
4388 wxEventType eventType
;
4393 eventType
= wxEVT_JOY_MOVE
;
4398 eventType
= wxEVT_JOY_MOVE
;
4403 eventType
= wxEVT_JOY_ZMOVE
;
4408 eventType
= wxEVT_JOY_ZMOVE
;
4411 case MM_JOY1BUTTONDOWN
:
4413 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4416 case MM_JOY2BUTTONDOWN
:
4418 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4421 case MM_JOY1BUTTONUP
:
4423 eventType
= wxEVT_JOY_BUTTON_UP
;
4426 case MM_JOY2BUTTONUP
:
4428 eventType
= wxEVT_JOY_BUTTON_UP
;
4432 wxFAIL_MSG(wxT("no such joystick event"));
4437 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4438 event
.SetPosition(wxPoint(x
, y
));
4439 event
.SetEventObject(this);
4441 return GetEventHandler()->ProcessEvent(event
);
4447 // ---------------------------------------------------------------------------
4449 // ---------------------------------------------------------------------------
4451 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4452 WXWORD pos
, WXHWND control
)
4456 wxWindow
*child
= wxFindWinFromHandle(control
);
4458 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4461 wxScrollWinEvent event
;
4462 event
.SetPosition(pos
);
4463 event
.SetOrientation(orientation
);
4464 event
.m_eventObject
= this;
4469 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4473 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4477 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4481 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4485 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4489 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4492 case SB_THUMBPOSITION
:
4495 // under Win32, the scrollbar range and position are 32 bit integers,
4496 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4497 // explicitly query the scrollbar for the correct position (this must
4498 // be done only for these two SB_ events as they are the only one
4499 // carrying the scrollbar position)
4501 WinStruct
<SCROLLINFO
> scrollInfo
;
4502 scrollInfo
.fMask
= SIF_TRACKPOS
;
4504 if ( !::GetScrollInfo(GetHwnd(),
4505 orientation
== wxHORIZONTAL
? SB_HORZ
4509 wxLogLastError(_T("GetScrollInfo"));
4512 event
.SetPosition(scrollInfo
.nTrackPos
);
4516 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4517 ? wxEVT_SCROLLWIN_THUMBRELEASE
4518 : wxEVT_SCROLLWIN_THUMBTRACK
;
4525 return GetEventHandler()->ProcessEvent(event
);
4528 // ===========================================================================
4530 // ===========================================================================
4532 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4535 HDC dc
= ::GetDC((HWND
) wnd
);
4540 // the_font->UseResource();
4541 // the_font->RealizeResource();
4542 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4544 was
= (HFONT
) SelectObject(dc
,fnt
);
4546 GetTextMetrics(dc
, &tm
);
4547 if ( the_font
&& fnt
&& was
)
4549 SelectObject(dc
,was
);
4551 ReleaseDC((HWND
)wnd
, dc
);
4554 *x
= tm
.tmAveCharWidth
;
4556 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4559 // the_font->ReleaseResource();
4562 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4563 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4564 int wxCharCodeMSWToWX(int keySym
)
4569 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4570 case VK_BACK
: id
= WXK_BACK
; break;
4571 case VK_TAB
: id
= WXK_TAB
; break;
4572 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4573 case VK_RETURN
: id
= WXK_RETURN
; break;
4574 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4575 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4576 case VK_MENU
: id
= WXK_MENU
; break;
4577 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4578 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4579 case VK_SPACE
: id
= WXK_SPACE
; break;
4580 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4581 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4582 case VK_NEXT
: id
= WXK_NEXT
; break;
4583 case VK_END
: id
= WXK_END
; break;
4584 case VK_HOME
: id
= WXK_HOME
; break;
4585 case VK_LEFT
: id
= WXK_LEFT
; break;
4586 case VK_UP
: id
= WXK_UP
; break;
4587 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4588 case VK_DOWN
: id
= WXK_DOWN
; break;
4589 case VK_SELECT
: id
= WXK_SELECT
; break;
4590 case VK_PRINT
: id
= WXK_PRINT
; break;
4591 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4592 case VK_INSERT
: id
= WXK_INSERT
; break;
4593 case VK_DELETE
: id
= WXK_DELETE
; break;
4594 case VK_HELP
: id
= WXK_HELP
; break;
4595 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4596 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4597 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4598 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4599 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4600 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4601 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4602 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4603 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4604 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4605 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4606 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4607 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4608 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4609 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4610 case VK_F1
: id
= WXK_F1
; break;
4611 case VK_F2
: id
= WXK_F2
; break;
4612 case VK_F3
: id
= WXK_F3
; break;
4613 case VK_F4
: id
= WXK_F4
; break;
4614 case VK_F5
: id
= WXK_F5
; break;
4615 case VK_F6
: id
= WXK_F6
; break;
4616 case VK_F7
: id
= WXK_F7
; break;
4617 case VK_F8
: id
= WXK_F8
; break;
4618 case VK_F9
: id
= WXK_F9
; break;
4619 case VK_F10
: id
= WXK_F10
; break;
4620 case VK_F11
: id
= WXK_F11
; break;
4621 case VK_F12
: id
= WXK_F12
; break;
4622 case VK_F13
: id
= WXK_F13
; break;
4623 case VK_F14
: id
= WXK_F14
; break;
4624 case VK_F15
: id
= WXK_F15
; break;
4625 case VK_F16
: id
= WXK_F16
; break;
4626 case VK_F17
: id
= WXK_F17
; break;
4627 case VK_F18
: id
= WXK_F18
; break;
4628 case VK_F19
: id
= WXK_F19
; break;
4629 case VK_F20
: id
= WXK_F20
; break;
4630 case VK_F21
: id
= WXK_F21
; break;
4631 case VK_F22
: id
= WXK_F22
; break;
4632 case VK_F23
: id
= WXK_F23
; break;
4633 case VK_F24
: id
= WXK_F24
; break;
4634 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4635 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4637 case VK_OEM_1
: id
= ';'; break;
4638 case VK_OEM_PLUS
: id
= '+'; break;
4639 case VK_OEM_COMMA
: id
= ','; break;
4640 case VK_OEM_MINUS
: id
= '-'; break;
4641 case VK_OEM_PERIOD
: id
= '.'; break;
4642 case VK_OEM_2
: id
= '/'; break;
4643 case VK_OEM_3
: id
= '~'; break;
4644 case VK_OEM_4
: id
= '['; break;
4645 case VK_OEM_5
: id
= '\\'; break;
4646 case VK_OEM_6
: id
= ']'; break;
4647 case VK_OEM_7
: id
= '\''; break;
4650 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4651 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4652 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4653 #endif // VK_APPS defined
4662 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4668 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4669 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4670 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4671 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4672 case WXK_MENU
: keySym
= VK_MENU
; break;
4673 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4674 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4675 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4676 case WXK_END
: keySym
= VK_END
; break;
4677 case WXK_HOME
: keySym
= VK_HOME
; break;
4678 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4679 case WXK_UP
: keySym
= VK_UP
; break;
4680 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4681 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4682 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4683 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4684 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4685 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4686 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4687 case WXK_HELP
: keySym
= VK_HELP
; break;
4688 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4689 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4690 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4691 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4692 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4693 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4694 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4695 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4696 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4697 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4698 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4699 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4700 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4701 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4702 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4703 case WXK_F1
: keySym
= VK_F1
; break;
4704 case WXK_F2
: keySym
= VK_F2
; break;
4705 case WXK_F3
: keySym
= VK_F3
; break;
4706 case WXK_F4
: keySym
= VK_F4
; break;
4707 case WXK_F5
: keySym
= VK_F5
; break;
4708 case WXK_F6
: keySym
= VK_F6
; break;
4709 case WXK_F7
: keySym
= VK_F7
; break;
4710 case WXK_F8
: keySym
= VK_F8
; break;
4711 case WXK_F9
: keySym
= VK_F9
; break;
4712 case WXK_F10
: keySym
= VK_F10
; break;
4713 case WXK_F11
: keySym
= VK_F11
; break;
4714 case WXK_F12
: keySym
= VK_F12
; break;
4715 case WXK_F13
: keySym
= VK_F13
; break;
4716 case WXK_F14
: keySym
= VK_F14
; break;
4717 case WXK_F15
: keySym
= VK_F15
; break;
4718 case WXK_F16
: keySym
= VK_F16
; break;
4719 case WXK_F17
: keySym
= VK_F17
; break;
4720 case WXK_F18
: keySym
= VK_F18
; break;
4721 case WXK_F19
: keySym
= VK_F19
; break;
4722 case WXK_F20
: keySym
= VK_F20
; break;
4723 case WXK_F21
: keySym
= VK_F21
; break;
4724 case WXK_F22
: keySym
= VK_F22
; break;
4725 case WXK_F23
: keySym
= VK_F23
; break;
4726 case WXK_F24
: keySym
= VK_F24
; break;
4727 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
4728 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
4739 wxWindow
*wxGetActiveWindow()
4741 HWND hWnd
= GetActiveWindow();
4744 return wxFindWinFromHandle((WXHWND
) hWnd
);
4749 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
4751 HWND hwnd
= (HWND
)hWnd
;
4753 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4754 // by code in msw/radiobox.cpp), for all the others we just search up the
4756 wxWindow
*win
= (wxWindow
*)NULL
;
4759 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4762 // all these hacks only work under Win32 anyhow
4766 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4767 // wxWindow class which overrides WM_GETDLGCODE processing to
4768 // do it as well, win would be already non NULL
4769 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
4771 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
4773 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4774 #endif // wxUSE_RADIOBOX
4776 // spin control text buddy window should be mapped to spin ctrl
4777 // itself so try it too
4778 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4781 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
4783 #endif // wxUSE_SPINCTRL
4789 while ( hwnd
&& !win
)
4791 // this is a really ugly hack needed to avoid mistakenly returning the
4792 // parent frame wxWindow for the find/replace modeless dialog HWND -
4793 // this, in turn, is needed to call IsDialogMessage() from
4794 // wxApp::ProcessMessage() as for this we must return NULL from here
4796 // FIXME: this is clearly not the best way to do it but I think we'll
4797 // need to change HWND <-> wxWindow code more heavily than I can
4798 // do it now to fix it
4799 #ifndef __WXMICROWIN__
4800 if ( ::GetWindow(hwnd
, GW_OWNER
) )
4802 // it's a dialog box, don't go upwards
4807 hwnd
= ::GetParent(hwnd
);
4808 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
4814 #ifndef __WXMICROWIN__
4816 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4817 // in active frames and dialogs, regardless of where the focus is.
4818 static HHOOK wxTheKeyboardHook
= 0;
4819 static FARPROC wxTheKeyboardHookProc
= 0;
4820 int APIENTRY _EXPORT
4821 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
4823 void wxSetKeyboardHook(bool doIt
)
4827 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
4828 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
4830 #if defined(__WIN32__)
4831 GetCurrentThreadId()
4832 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4840 UnhookWindowsHookEx(wxTheKeyboardHook
);
4842 // avoids warning about statement with no effect (FreeProcInstance
4843 // doesn't do anything under Win32)
4844 #if !defined(__WIN32__) && !defined(__NT__)
4845 FreeProcInstance(wxTheKeyboardHookProc
);
4850 int APIENTRY _EXPORT
4851 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
4853 DWORD hiWord
= HIWORD(lParam
);
4854 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
4856 int id
= wxCharCodeMSWToWX(wParam
);
4859 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
4860 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
4861 event
.m_altDown
= TRUE
;
4863 event
.m_eventObject
= NULL
;
4864 event
.m_keyCode
= id
;
4865 event
.m_shiftDown
= wxIsShiftDown();
4866 event
.m_controlDown
= wxIsCtrlDown();
4867 event
.SetTimestamp(s_currentMsg
.time
);
4869 wxWindow
*win
= wxGetActiveWindow();
4870 wxEvtHandler
*handler
;
4873 handler
= win
->GetEventHandler();
4874 event
.SetId(win
->GetId());
4882 if ( handler
&& handler
->ProcessEvent(event
) )
4890 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
4893 #endif // !__WXMICROWIN__
4896 const char *wxGetMessageName(int message
)
4900 case 0x0000: return "WM_NULL";
4901 case 0x0001: return "WM_CREATE";
4902 case 0x0002: return "WM_DESTROY";
4903 case 0x0003: return "WM_MOVE";
4904 case 0x0005: return "WM_SIZE";
4905 case 0x0006: return "WM_ACTIVATE";
4906 case 0x0007: return "WM_SETFOCUS";
4907 case 0x0008: return "WM_KILLFOCUS";
4908 case 0x000A: return "WM_ENABLE";
4909 case 0x000B: return "WM_SETREDRAW";
4910 case 0x000C: return "WM_SETTEXT";
4911 case 0x000D: return "WM_GETTEXT";
4912 case 0x000E: return "WM_GETTEXTLENGTH";
4913 case 0x000F: return "WM_PAINT";
4914 case 0x0010: return "WM_CLOSE";
4915 case 0x0011: return "WM_QUERYENDSESSION";
4916 case 0x0012: return "WM_QUIT";
4917 case 0x0013: return "WM_QUERYOPEN";
4918 case 0x0014: return "WM_ERASEBKGND";
4919 case 0x0015: return "WM_SYSCOLORCHANGE";
4920 case 0x0016: return "WM_ENDSESSION";
4921 case 0x0017: return "WM_SYSTEMERROR";
4922 case 0x0018: return "WM_SHOWWINDOW";
4923 case 0x0019: return "WM_CTLCOLOR";
4924 case 0x001A: return "WM_WININICHANGE";
4925 case 0x001B: return "WM_DEVMODECHANGE";
4926 case 0x001C: return "WM_ACTIVATEAPP";
4927 case 0x001D: return "WM_FONTCHANGE";
4928 case 0x001E: return "WM_TIMECHANGE";
4929 case 0x001F: return "WM_CANCELMODE";
4930 case 0x0020: return "WM_SETCURSOR";
4931 case 0x0021: return "WM_MOUSEACTIVATE";
4932 case 0x0022: return "WM_CHILDACTIVATE";
4933 case 0x0023: return "WM_QUEUESYNC";
4934 case 0x0024: return "WM_GETMINMAXINFO";
4935 case 0x0026: return "WM_PAINTICON";
4936 case 0x0027: return "WM_ICONERASEBKGND";
4937 case 0x0028: return "WM_NEXTDLGCTL";
4938 case 0x002A: return "WM_SPOOLERSTATUS";
4939 case 0x002B: return "WM_DRAWITEM";
4940 case 0x002C: return "WM_MEASUREITEM";
4941 case 0x002D: return "WM_DELETEITEM";
4942 case 0x002E: return "WM_VKEYTOITEM";
4943 case 0x002F: return "WM_CHARTOITEM";
4944 case 0x0030: return "WM_SETFONT";
4945 case 0x0031: return "WM_GETFONT";
4946 case 0x0037: return "WM_QUERYDRAGICON";
4947 case 0x0039: return "WM_COMPAREITEM";
4948 case 0x0041: return "WM_COMPACTING";
4949 case 0x0044: return "WM_COMMNOTIFY";
4950 case 0x0046: return "WM_WINDOWPOSCHANGING";
4951 case 0x0047: return "WM_WINDOWPOSCHANGED";
4952 case 0x0048: return "WM_POWER";
4955 case 0x004A: return "WM_COPYDATA";
4956 case 0x004B: return "WM_CANCELJOURNAL";
4957 case 0x004E: return "WM_NOTIFY";
4958 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
4959 case 0x0051: return "WM_INPUTLANGCHANGE";
4960 case 0x0052: return "WM_TCARD";
4961 case 0x0053: return "WM_HELP";
4962 case 0x0054: return "WM_USERCHANGED";
4963 case 0x0055: return "WM_NOTIFYFORMAT";
4964 case 0x007B: return "WM_CONTEXTMENU";
4965 case 0x007C: return "WM_STYLECHANGING";
4966 case 0x007D: return "WM_STYLECHANGED";
4967 case 0x007E: return "WM_DISPLAYCHANGE";
4968 case 0x007F: return "WM_GETICON";
4969 case 0x0080: return "WM_SETICON";
4972 case 0x0081: return "WM_NCCREATE";
4973 case 0x0082: return "WM_NCDESTROY";
4974 case 0x0083: return "WM_NCCALCSIZE";
4975 case 0x0084: return "WM_NCHITTEST";
4976 case 0x0085: return "WM_NCPAINT";
4977 case 0x0086: return "WM_NCACTIVATE";
4978 case 0x0087: return "WM_GETDLGCODE";
4979 case 0x00A0: return "WM_NCMOUSEMOVE";
4980 case 0x00A1: return "WM_NCLBUTTONDOWN";
4981 case 0x00A2: return "WM_NCLBUTTONUP";
4982 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
4983 case 0x00A4: return "WM_NCRBUTTONDOWN";
4984 case 0x00A5: return "WM_NCRBUTTONUP";
4985 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
4986 case 0x00A7: return "WM_NCMBUTTONDOWN";
4987 case 0x00A8: return "WM_NCMBUTTONUP";
4988 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
4989 case 0x0100: return "WM_KEYDOWN";
4990 case 0x0101: return "WM_KEYUP";
4991 case 0x0102: return "WM_CHAR";
4992 case 0x0103: return "WM_DEADCHAR";
4993 case 0x0104: return "WM_SYSKEYDOWN";
4994 case 0x0105: return "WM_SYSKEYUP";
4995 case 0x0106: return "WM_SYSCHAR";
4996 case 0x0107: return "WM_SYSDEADCHAR";
4997 case 0x0108: return "WM_KEYLAST";
5000 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5001 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5002 case 0x010F: return "WM_IME_COMPOSITION";
5005 case 0x0110: return "WM_INITDIALOG";
5006 case 0x0111: return "WM_COMMAND";
5007 case 0x0112: return "WM_SYSCOMMAND";
5008 case 0x0113: return "WM_TIMER";
5009 case 0x0114: return "WM_HSCROLL";
5010 case 0x0115: return "WM_VSCROLL";
5011 case 0x0116: return "WM_INITMENU";
5012 case 0x0117: return "WM_INITMENUPOPUP";
5013 case 0x011F: return "WM_MENUSELECT";
5014 case 0x0120: return "WM_MENUCHAR";
5015 case 0x0121: return "WM_ENTERIDLE";
5016 case 0x0200: return "WM_MOUSEMOVE";
5017 case 0x0201: return "WM_LBUTTONDOWN";
5018 case 0x0202: return "WM_LBUTTONUP";
5019 case 0x0203: return "WM_LBUTTONDBLCLK";
5020 case 0x0204: return "WM_RBUTTONDOWN";
5021 case 0x0205: return "WM_RBUTTONUP";
5022 case 0x0206: return "WM_RBUTTONDBLCLK";
5023 case 0x0207: return "WM_MBUTTONDOWN";
5024 case 0x0208: return "WM_MBUTTONUP";
5025 case 0x0209: return "WM_MBUTTONDBLCLK";
5026 case 0x020A: return "WM_MOUSEWHEEL";
5027 case 0x0210: return "WM_PARENTNOTIFY";
5028 case 0x0211: return "WM_ENTERMENULOOP";
5029 case 0x0212: return "WM_EXITMENULOOP";
5032 case 0x0213: return "WM_NEXTMENU";
5033 case 0x0214: return "WM_SIZING";
5034 case 0x0215: return "WM_CAPTURECHANGED";
5035 case 0x0216: return "WM_MOVING";
5036 case 0x0218: return "WM_POWERBROADCAST";
5037 case 0x0219: return "WM_DEVICECHANGE";
5040 case 0x0220: return "WM_MDICREATE";
5041 case 0x0221: return "WM_MDIDESTROY";
5042 case 0x0222: return "WM_MDIACTIVATE";
5043 case 0x0223: return "WM_MDIRESTORE";
5044 case 0x0224: return "WM_MDINEXT";
5045 case 0x0225: return "WM_MDIMAXIMIZE";
5046 case 0x0226: return "WM_MDITILE";
5047 case 0x0227: return "WM_MDICASCADE";
5048 case 0x0228: return "WM_MDIICONARRANGE";
5049 case 0x0229: return "WM_MDIGETACTIVE";
5050 case 0x0230: return "WM_MDISETMENU";
5051 case 0x0233: return "WM_DROPFILES";
5054 case 0x0281: return "WM_IME_SETCONTEXT";
5055 case 0x0282: return "WM_IME_NOTIFY";
5056 case 0x0283: return "WM_IME_CONTROL";
5057 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5058 case 0x0285: return "WM_IME_SELECT";
5059 case 0x0286: return "WM_IME_CHAR";
5060 case 0x0290: return "WM_IME_KEYDOWN";
5061 case 0x0291: return "WM_IME_KEYUP";
5064 case 0x0300: return "WM_CUT";
5065 case 0x0301: return "WM_COPY";
5066 case 0x0302: return "WM_PASTE";
5067 case 0x0303: return "WM_CLEAR";
5068 case 0x0304: return "WM_UNDO";
5069 case 0x0305: return "WM_RENDERFORMAT";
5070 case 0x0306: return "WM_RENDERALLFORMATS";
5071 case 0x0307: return "WM_DESTROYCLIPBOARD";
5072 case 0x0308: return "WM_DRAWCLIPBOARD";
5073 case 0x0309: return "WM_PAINTCLIPBOARD";
5074 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5075 case 0x030B: return "WM_SIZECLIPBOARD";
5076 case 0x030C: return "WM_ASKCBFORMATNAME";
5077 case 0x030D: return "WM_CHANGECBCHAIN";
5078 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5079 case 0x030F: return "WM_QUERYNEWPALETTE";
5080 case 0x0310: return "WM_PALETTEISCHANGING";
5081 case 0x0311: return "WM_PALETTECHANGED";
5084 // common controls messages - although they're not strictly speaking
5085 // standard, it's nice to decode them nevertheless
5088 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5089 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5090 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5091 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5092 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5093 case 0x1000 + 5: return "LVM_GETITEMA";
5094 case 0x1000 + 75: return "LVM_GETITEMW";
5095 case 0x1000 + 6: return "LVM_SETITEMA";
5096 case 0x1000 + 76: return "LVM_SETITEMW";
5097 case 0x1000 + 7: return "LVM_INSERTITEMA";
5098 case 0x1000 + 77: return "LVM_INSERTITEMW";
5099 case 0x1000 + 8: return "LVM_DELETEITEM";
5100 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5101 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5102 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5103 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5104 case 0x1000 + 13: return "LVM_FINDITEMA";
5105 case 0x1000 + 83: return "LVM_FINDITEMW";
5106 case 0x1000 + 14: return "LVM_GETITEMRECT";
5107 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5108 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5109 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5110 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5111 case 0x1000 + 18: return "LVM_HITTEST";
5112 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5113 case 0x1000 + 20: return "LVM_SCROLL";
5114 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5115 case 0x1000 + 22: return "LVM_ARRANGE";
5116 case 0x1000 + 23: return "LVM_EDITLABELA";
5117 case 0x1000 + 118: return "LVM_EDITLABELW";
5118 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5119 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5120 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5121 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5122 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5123 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5124 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5125 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5126 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5127 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5128 case 0x1000 + 31: return "LVM_GETHEADER";
5129 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5130 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5131 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5132 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5133 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5134 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5135 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5136 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5137 case 0x1000 + 41: return "LVM_GETORIGIN";
5138 case 0x1000 + 42: return "LVM_UPDATE";
5139 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5140 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5141 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5142 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5143 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5144 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5145 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5146 case 0x1000 + 48: return "LVM_SORTITEMS";
5147 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5148 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5149 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5150 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5151 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5152 case 0x1000 + 53: return "LVM_SETICONSPACING";
5153 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5154 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5155 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5156 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5157 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5158 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5159 case 0x1000 + 60: return "LVM_SETHOTITEM";
5160 case 0x1000 + 61: return "LVM_GETHOTITEM";
5161 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5162 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5163 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5164 case 0x1000 + 65: return "LVM_SETWORKAREA";
5167 case 0x1100 + 0: return "TVM_INSERTITEMA";
5168 case 0x1100 + 50: return "TVM_INSERTITEMW";
5169 case 0x1100 + 1: return "TVM_DELETEITEM";
5170 case 0x1100 + 2: return "TVM_EXPAND";
5171 case 0x1100 + 4: return "TVM_GETITEMRECT";
5172 case 0x1100 + 5: return "TVM_GETCOUNT";
5173 case 0x1100 + 6: return "TVM_GETINDENT";
5174 case 0x1100 + 7: return "TVM_SETINDENT";
5175 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5176 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5177 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5178 case 0x1100 + 11: return "TVM_SELECTITEM";
5179 case 0x1100 + 12: return "TVM_GETITEMA";
5180 case 0x1100 + 62: return "TVM_GETITEMW";
5181 case 0x1100 + 13: return "TVM_SETITEMA";
5182 case 0x1100 + 63: return "TVM_SETITEMW";
5183 case 0x1100 + 14: return "TVM_EDITLABELA";
5184 case 0x1100 + 65: return "TVM_EDITLABELW";
5185 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5186 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5187 case 0x1100 + 17: return "TVM_HITTEST";
5188 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5189 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5190 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5191 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5192 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5193 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5194 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5195 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5196 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5199 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5200 case 0x1200 + 1: return "HDM_INSERTITEMA";
5201 case 0x1200 + 10: return "HDM_INSERTITEMW";
5202 case 0x1200 + 2: return "HDM_DELETEITEM";
5203 case 0x1200 + 3: return "HDM_GETITEMA";
5204 case 0x1200 + 11: return "HDM_GETITEMW";
5205 case 0x1200 + 4: return "HDM_SETITEMA";
5206 case 0x1200 + 12: return "HDM_SETITEMW";
5207 case 0x1200 + 5: return "HDM_LAYOUT";
5208 case 0x1200 + 6: return "HDM_HITTEST";
5209 case 0x1200 + 7: return "HDM_GETITEMRECT";
5210 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5211 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5212 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5213 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5214 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5215 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5216 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5219 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5220 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5221 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5222 case 0x1300 + 5: return "TCM_GETITEMA";
5223 case 0x1300 + 60: return "TCM_GETITEMW";
5224 case 0x1300 + 6: return "TCM_SETITEMA";
5225 case 0x1300 + 61: return "TCM_SETITEMW";
5226 case 0x1300 + 7: return "TCM_INSERTITEMA";
5227 case 0x1300 + 62: return "TCM_INSERTITEMW";
5228 case 0x1300 + 8: return "TCM_DELETEITEM";
5229 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5230 case 0x1300 + 10: return "TCM_GETITEMRECT";
5231 case 0x1300 + 11: return "TCM_GETCURSEL";
5232 case 0x1300 + 12: return "TCM_SETCURSEL";
5233 case 0x1300 + 13: return "TCM_HITTEST";
5234 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5235 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5236 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5237 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5238 case 0x1300 + 43: return "TCM_SETPADDING";
5239 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5240 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5241 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5242 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5243 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5244 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5245 case 0x1300 + 50: return "TCM_DESELECTALL";
5248 case WM_USER
+1: return "TB_ENABLEBUTTON";
5249 case WM_USER
+2: return "TB_CHECKBUTTON";
5250 case WM_USER
+3: return "TB_PRESSBUTTON";
5251 case WM_USER
+4: return "TB_HIDEBUTTON";
5252 case WM_USER
+5: return "TB_INDETERMINATE";
5253 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5254 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5255 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5256 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5257 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5258 case WM_USER
+17: return "TB_SETSTATE";
5259 case WM_USER
+18: return "TB_GETSTATE";
5260 case WM_USER
+19: return "TB_ADDBITMAP";
5261 case WM_USER
+20: return "TB_ADDBUTTONS";
5262 case WM_USER
+21: return "TB_INSERTBUTTON";
5263 case WM_USER
+22: return "TB_DELETEBUTTON";
5264 case WM_USER
+23: return "TB_GETBUTTON";
5265 case WM_USER
+24: return "TB_BUTTONCOUNT";
5266 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5267 case WM_USER
+26: return "TB_SAVERESTOREA";
5268 case WM_USER
+76: return "TB_SAVERESTOREW";
5269 case WM_USER
+27: return "TB_CUSTOMIZE";
5270 case WM_USER
+28: return "TB_ADDSTRINGA";
5271 case WM_USER
+77: return "TB_ADDSTRINGW";
5272 case WM_USER
+29: return "TB_GETITEMRECT";
5273 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5274 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5275 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5276 case WM_USER
+33: return "TB_AUTOSIZE";
5277 case WM_USER
+35: return "TB_GETTOOLTIPS";
5278 case WM_USER
+36: return "TB_SETTOOLTIPS";
5279 case WM_USER
+37: return "TB_SETPARENT";
5280 case WM_USER
+39: return "TB_SETROWS";
5281 case WM_USER
+40: return "TB_GETROWS";
5282 case WM_USER
+42: return "TB_SETCMDID";
5283 case WM_USER
+43: return "TB_CHANGEBITMAP";
5284 case WM_USER
+44: return "TB_GETBITMAP";
5285 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5286 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5287 case WM_USER
+46: return "TB_REPLACEBITMAP";
5288 case WM_USER
+47: return "TB_SETINDENT";
5289 case WM_USER
+48: return "TB_SETIMAGELIST";
5290 case WM_USER
+49: return "TB_GETIMAGELIST";
5291 case WM_USER
+50: return "TB_LOADIMAGES";
5292 case WM_USER
+51: return "TB_GETRECT";
5293 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5294 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5295 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5296 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5297 case WM_USER
+56: return "TB_SETSTYLE";
5298 case WM_USER
+57: return "TB_GETSTYLE";
5299 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5300 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5301 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5302 case WM_USER
+61: return "TB_GETTEXTROWS";
5303 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5308 static char s_szBuf
[128];
5309 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5313 #endif //__WXDEBUG__
5315 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5316 int *x
, int *y
, WPARAM
*flags
)
5318 // construct the key mask
5319 WPARAM
& fwKeys
= *flags
;
5321 fwKeys
= MK_RBUTTON
;
5322 if ( wxIsCtrlDown() )
5323 fwKeys
|= MK_CONTROL
;
5324 if ( wxIsShiftDown() )
5327 // simulate right mouse button click
5328 DWORD dwPos
= ::GetMessagePos();
5329 *x
= GET_X_LPARAM(dwPos
);
5330 *y
= GET_Y_LPARAM(dwPos
);
5332 win
->ScreenToClient(x
, y
);
5335 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5339 HWND hwnd
= GetHwndOf(win
);
5340 HDC hdc
= ::GetDC(hwnd
);
5342 #if !wxDIALOG_UNIT_COMPATIBILITY
5343 // and select the current font into it
5344 HFONT hfont
= GetHfontOf(win
->GetFont());
5347 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5351 // finally retrieve the text metrics from it
5352 GetTextMetrics(hdc
, &tm
);
5354 #if !wxDIALOG_UNIT_COMPATIBILITY
5358 (void)::SelectObject(hdc
, hfont
);
5362 ::ReleaseDC(hwnd
, hdc
);
5367 // Find the wxWindow at the current mouse position, returning the mouse
5369 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5371 pt
= wxGetMousePosition();
5372 return wxFindWindowAtPoint(pt
);
5375 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5380 HWND hWndHit
= ::WindowFromPoint(pt2
);
5382 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5383 HWND hWnd
= hWndHit
;
5385 // Try to find a window with a wxWindow associated with it
5386 while (!win
&& (hWnd
!= 0))
5388 hWnd
= ::GetParent(hWnd
);
5389 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5394 // Get the current mouse position.
5395 wxPoint
wxGetMousePosition()
5398 GetCursorPos( & pt
);
5400 return wxPoint(pt
.x
, pt
.y
);