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 // ---------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
38 #include "wx/dcclient.h"
39 #include "wx/dcmemory.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
47 #include "wx/msgdlg.h"
48 #include "wx/settings.h"
49 #include "wx/statbox.h"
52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
53 #include "wx/ownerdrw.h"
56 #include "wx/module.h"
58 #if wxUSE_DRAG_AND_DROP
62 #if wxUSE_ACCESSIBILITY
63 #include "wx/access.h"
67 #define WM_GETOBJECT 0x003D
70 #define OBJID_CLIENT 0xFFFFFFFC
74 #include "wx/menuitem.h"
77 #include "wx/msw/private.h"
80 #include "wx/tooltip.h"
88 #include "wx/spinctrl.h"
89 #endif // wxUSE_SPINCTRL
94 #include "wx/textctrl.h"
95 #include "wx/notebook.h"
96 #include "wx/listctrl.h"
100 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
101 #include <shellapi.h>
102 #include <mmsystem.h>
106 #include <windowsx.h>
109 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
111 #include <commctrl.h>
113 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
114 #include "wx/msw/gnuwin32/extra.h"
117 #include "wx/msw/missing.h"
119 #if defined(__WXWINCE__)
120 #include "wx/msw/wince/missing.h"
123 // ---------------------------------------------------------------------------
125 // ---------------------------------------------------------------------------
127 #if wxUSE_MENUS_NATIVE
128 wxMenu
*wxCurrentPopupMenu
= NULL
;
129 #endif // wxUSE_MENUS_NATIVE
132 extern wxChar
*wxCanvasClassName
;
134 extern const wxChar
*wxCanvasClassName
;
137 // true if we had already created the std colour map, used by
138 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
139 static bool gs_hasStdCmap
= false;
141 // ---------------------------------------------------------------------------
143 // ---------------------------------------------------------------------------
145 // the window proc for all our windows
146 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
147 WPARAM wParam
, LPARAM lParam
);
151 const char *wxGetMessageName(int message
);
154 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
155 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
156 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
158 // this magical function is used to translate VK_APPS key presses to right
160 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
161 int *x
, int *y
, WPARAM
*flags
);
163 // get the text metrics for the current font
164 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
166 // find the window for the mouse event at the specified position
167 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
169 // wrapper around BringWindowToTop() API
170 static inline void wxBringWindowToTop(HWND hwnd
)
172 #ifdef __WXMICROWIN__
173 // It seems that MicroWindows brings the _parent_ of the window to the top,
174 // which can be the wrong one.
176 // activate (set focus to) specified window
180 // raise top level parent to top of z order
181 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
183 wxLogLastError(_T("SetWindowPos"));
189 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
190 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
193 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
194 parent as well as otherwise several Win32 functions using
195 GetNextDlgTabItem() to iterate over all controls such as
196 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
197 all of them iterate over all the controls starting from the currently
198 focused one and stop iterating when they get back to the focus but
199 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
200 get back to the initial (focused) window: as we do have this style,
201 GetNextDlgTabItem() will leave this window and continue in its parent,
202 but if the parent doesn't have it, it wouldn't recurse inside it later
203 on and so wouldn't have a chance of getting back to this window neither.
205 while ( parent
&& !parent
->IsTopLevel() )
207 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
208 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
210 // force the parent to have this style
211 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
212 exStyle
| WS_EX_CONTROLPARENT
);
215 parent
= parent
->GetParent();
219 #endif // !__WXWINCE__
221 // ---------------------------------------------------------------------------
223 // ---------------------------------------------------------------------------
225 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
227 #ifdef __WXUNIVERSAL__
228 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
230 #if wxUSE_EXTENDED_RTTI
232 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
233 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
234 // windows with negative ids never can be recreated anyway
236 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
238 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
239 if ( win
&& win
->GetId() < 0 )
244 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
246 // make wxWindowList known before the property is used
248 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
250 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
252 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
255 WX_DEFINE_FLAGS( wxWindowStyle
)
257 wxBEGIN_FLAGS( wxWindowStyle
)
258 // new style border flags, we put them first to
259 // use them for streaming out
261 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
262 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
263 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
264 wxFLAGS_MEMBER(wxBORDER_RAISED
)
265 wxFLAGS_MEMBER(wxBORDER_STATIC
)
266 wxFLAGS_MEMBER(wxBORDER_NONE
)
268 // old style border flags
269 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
270 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
271 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
272 wxFLAGS_MEMBER(wxRAISED_BORDER
)
273 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
274 wxFLAGS_MEMBER(wxBORDER
)
276 // standard window styles
277 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
278 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
279 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
280 wxFLAGS_MEMBER(wxWANTS_CHARS
)
281 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
282 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
283 wxFLAGS_MEMBER(wxVSCROLL
)
284 wxFLAGS_MEMBER(wxHSCROLL
)
286 wxEND_FLAGS( wxWindowStyle
)
288 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
289 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
290 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
291 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
292 // Always constructor Properties first
294 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
295 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, wxID_ANY
, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
296 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
297 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
298 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
300 // Then all relations of the object graph
302 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
304 // and finally all other properties
306 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
307 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
308 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
309 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
310 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
312 // possible property candidates (not in xrc) or not valid in all subclasses
313 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxT("") )
314 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
315 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxT("") )
316 // MaxHeight, Width , MinHeight , Width
317 // TODO switch label to control and title to toplevels
319 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
320 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
321 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
322 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
327 wxEND_PROPERTIES_TABLE()
329 wxBEGIN_HANDLERS_TABLE(wxWindow
)
330 wxEND_HANDLERS_TABLE()
332 wxCONSTRUCTOR_DUMMY(wxWindow
)
335 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
337 #endif // __WXUNIVERSAL__/__WXMSW__
339 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
340 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
341 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
343 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
347 // ===========================================================================
349 // ===========================================================================
351 // ---------------------------------------------------------------------------
352 // wxWindow utility functions
353 // ---------------------------------------------------------------------------
355 // Find an item given the MS Windows id
356 wxWindow
*wxWindowMSW::FindItem(long id
) const
359 wxControl
*item
= wxDynamicCastThis(wxControl
);
362 // is it we or one of our "internal" children?
363 if ( item
->GetId() == id
364 #ifndef __WXUNIVERSAL__
365 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
366 #endif // __WXUNIVERSAL__
372 #endif // wxUSE_CONTROLS
374 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
377 wxWindow
*childWin
= current
->GetData();
379 wxWindow
*wnd
= childWin
->FindItem(id
);
383 current
= current
->GetNext();
389 // Find an item given the MS Windows handle
390 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
392 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
395 wxWindow
*parent
= current
->GetData();
397 // Do a recursive search.
398 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
404 || parent
->IsKindOf(CLASSINFO(wxControl
))
405 #endif // wxUSE_CONTROLS
408 wxWindow
*item
= current
->GetData();
409 if ( item
->GetHWND() == hWnd
)
413 if ( item
->ContainsHWND(hWnd
) )
418 current
= current
->GetNext();
423 // Default command handler
424 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
429 // ----------------------------------------------------------------------------
430 // constructors and such
431 // ----------------------------------------------------------------------------
433 void wxWindowMSW::Init()
436 m_isBeingDeleted
= false;
438 m_mouseInWindow
= false;
439 m_lastKeydownProcessed
= false;
441 m_childrenDisabled
= NULL
;
452 #if wxUSE_MOUSEEVENT_HACK
455 m_lastMouseEvent
= -1;
456 #endif // wxUSE_MOUSEEVENT_HACK
460 wxWindowMSW::~wxWindowMSW()
462 m_isBeingDeleted
= true;
464 #ifndef __WXUNIVERSAL__
465 // VS: make sure there's no wxFrame with last focus set to us:
466 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
468 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
471 if ( frame
->GetLastFocus() == this )
473 frame
->SetLastFocus(NULL
);
478 #endif // __WXUNIVERSAL__
480 // VS: destroy children first and _then_ detach *this from its parent.
481 // If we'd do it the other way around, children wouldn't be able
482 // find their parent frame (see above).
487 // VZ: test temp removed to understand what really happens here
488 //if (::IsWindow(GetHwnd()))
490 if ( !::DestroyWindow(GetHwnd()) )
491 wxLogLastError(wxT("DestroyWindow"));
494 // remove hWnd <-> wxWindow association
495 wxRemoveHandleAssociation(this);
498 delete m_childrenDisabled
;
501 // real construction (Init() must have been called before!)
502 bool wxWindowMSW::Create(wxWindow
*parent
,
507 const wxString
& name
)
509 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
511 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
514 parent
->AddChild(this);
517 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
519 #ifdef __WXUNIVERSAL__
520 // no borders, we draw them ourselves
521 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
525 msflags
&= ~WS_BORDER
;
526 #endif // wxUniversal
530 msflags
|= WS_VISIBLE
;
533 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
541 // ---------------------------------------------------------------------------
543 // ---------------------------------------------------------------------------
545 void wxWindowMSW::SetFocus()
547 HWND hWnd
= GetHwnd();
548 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
550 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
554 if ( !::SetFocus(hWnd
) )
556 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
557 // was there really an error?
558 DWORD dwRes
= ::GetLastError();
561 HWND hwndFocus
= ::GetFocus();
562 if ( hwndFocus
!= hWnd
)
564 wxLogApiError(_T("SetFocus"), dwRes
);
571 void wxWindowMSW::SetFocusFromKbd()
573 // when the focus is given to the control with DLGC_HASSETSEL style from
574 // keyboard its contents should be entirely selected: this is what
575 // ::IsDialogMessage() does and so we should do it as well to provide the
576 // same LNF as the native programs
577 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
579 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
582 // do this after (maybe) setting the selection as like this when
583 // wxEVT_SET_FOCUS handler is called, the selection would have been already
584 // set correctly -- this may be important
585 wxWindowBase::SetFocusFromKbd();
588 // Get the window with the focus
589 wxWindow
*wxWindowBase::FindFocus()
591 HWND hWnd
= ::GetFocus();
594 return wxGetWindowFromHWND((WXHWND
)hWnd
);
600 bool wxWindowMSW::Enable(bool enable
)
602 if ( !wxWindowBase::Enable(enable
) )
605 HWND hWnd
= GetHwnd();
607 ::EnableWindow(hWnd
, (BOOL
)enable
);
609 // the logic below doesn't apply to the top level windows -- otherwise
610 // showing a modal dialog would result in total greying out (and ungreying
611 // out later) of everything which would be really ugly
615 // when the parent is disabled, all of its children should be disabled as
616 // well but when it is enabled back, only those of the children which
617 // hadn't been already disabled in the beginning should be enabled again,
618 // so we have to keep the list of those children
619 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
621 node
= node
->GetNext() )
623 wxWindow
*child
= node
->GetData();
624 if ( child
->IsTopLevel() )
626 // the logic below doesn't apply to top level children
632 // enable the child back unless it had been disabled before us
633 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
636 else // we're being disabled
638 if ( child
->IsEnabled() )
640 // disable it as children shouldn't stay enabled while the
644 else // child already disabled, remember it
646 // have we created the list of disabled children already?
647 if ( !m_childrenDisabled
)
648 m_childrenDisabled
= new wxWindowList
;
650 m_childrenDisabled
->Append(child
);
655 if ( enable
&& m_childrenDisabled
)
657 // we don't need this list any more, don't keep unused memory
658 delete m_childrenDisabled
;
659 m_childrenDisabled
= NULL
;
665 bool wxWindowMSW::Show(bool show
)
667 if ( !wxWindowBase::Show(show
) )
670 HWND hWnd
= GetHwnd();
671 int cshow
= show
? SW_SHOW
: SW_HIDE
;
672 ::ShowWindow(hWnd
, cshow
);
674 if ( show
&& IsTopLevel() )
676 wxBringWindowToTop(hWnd
);
682 // Raise the window to the top of the Z order
683 void wxWindowMSW::Raise()
685 wxBringWindowToTop(GetHwnd());
688 // Lower the window to the bottom of the Z order
689 void wxWindowMSW::Lower()
691 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
692 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
695 void wxWindowMSW::SetTitle( const wxString
& title
)
697 SetWindowText(GetHwnd(), title
.c_str());
700 wxString
wxWindowMSW::GetTitle() const
702 return wxGetWindowText(GetHWND());
705 void wxWindowMSW::DoCaptureMouse()
707 HWND hWnd
= GetHwnd();
714 void wxWindowMSW::DoReleaseMouse()
716 if ( !::ReleaseCapture() )
718 wxLogLastError(_T("ReleaseCapture"));
722 /* static */ wxWindow
*wxWindowBase::GetCapture()
724 HWND hwnd
= ::GetCapture();
725 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
728 bool wxWindowMSW::SetFont(const wxFont
& font
)
730 if ( !wxWindowBase::SetFont(font
) )
736 HWND hWnd
= GetHwnd();
739 WXHANDLE hFont
= m_font
.GetResourceHandle();
741 wxASSERT_MSG( hFont
, wxT("should have valid font") );
743 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
748 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
750 if ( !wxWindowBase::SetCursor(cursor
) )
758 HWND hWnd
= GetHwnd();
760 // Change the cursor NOW if we're within the correct window
762 ::GetCursorPos(&point
);
764 RECT rect
= wxGetWindowRect(hWnd
);
766 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
767 ::SetCursor(GetHcursorOf(m_cursor
));
773 void wxWindowMSW::WarpPointer (int x
, int y
)
775 ClientToScreen(&x
, &y
);
777 if ( !::SetCursorPos(x
, y
) )
779 wxLogLastError(_T("SetCursorPos"));
783 // ---------------------------------------------------------------------------
785 // ---------------------------------------------------------------------------
787 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
788 static inline int wxDirToWinStyle(int orient
)
790 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
793 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
795 #ifdef __WXMICROWIN__
796 return ::GetScrollPosWX(hWnd
, wOrient
);
798 WinStruct
<SCROLLINFO
> scrollInfo
;
799 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
800 scrollInfo
.fMask
= SIF_POS
;
801 if ( !::GetScrollInfo(hWnd
,
805 // Not neccessarily an error, if there are no scrollbars yet.
806 // wxLogLastError(_T("GetScrollInfo"));
808 return scrollInfo
.nPos
;
809 // return ::GetScrollPos(hWnd, wOrient);
813 int wxWindowMSW::GetScrollPos(int orient
) const
815 HWND hWnd
= GetHwnd();
816 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
818 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
821 // This now returns the whole range, not just the number
822 // of positions that we can scroll.
823 int wxWindowMSW::GetScrollRange(int orient
) const
826 HWND hWnd
= GetHwnd();
830 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
833 WinStruct
<SCROLLINFO
> scrollInfo
;
834 scrollInfo
.fMask
= SIF_RANGE
;
835 if ( !::GetScrollInfo(hWnd
,
836 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
839 // Most of the time this is not really an error, since the return
840 // value can also be zero when there is no scrollbar yet.
841 // wxLogLastError(_T("GetScrollInfo"));
843 maxPos
= scrollInfo
.nMax
;
845 // undo "range - 1" done in SetScrollbar()
849 int wxWindowMSW::GetScrollThumb(int orient
) const
851 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
854 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
856 HWND hWnd
= GetHwnd();
857 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
859 WinStruct
<SCROLLINFO
> info
;
863 info
.fMask
= SIF_POS
;
864 if ( HasFlag(wxALWAYS_SHOW_SB
) )
866 // disable scrollbar instead of removing it then
867 info
.fMask
|= SIF_DISABLENOSCROLL
;
870 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
874 // New function that will replace some of the above.
875 void wxWindowMSW::SetScrollbar(int orient
,
881 WinStruct
<SCROLLINFO
> info
;
882 info
.nPage
= pageSize
;
883 info
.nMin
= 0; // range is nMax - nMin + 1
884 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
886 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
887 if ( HasFlag(wxALWAYS_SHOW_SB
) )
889 // disable scrollbar instead of removing it then
890 info
.fMask
|= SIF_DISABLENOSCROLL
;
893 HWND hWnd
= GetHwnd();
896 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
900 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
903 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
909 rect
.left
= prect
->x
;
911 rect
.right
= prect
->x
+ prect
->width
;
912 rect
.bottom
= prect
->y
+ prect
->height
;
922 // FIXME: is this the exact equivalent of the line below?
923 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
925 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
929 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
931 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
934 for ( int n
= 0; n
< count
; n
++ )
936 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
938 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
941 // don't bother to continue, we're already at top/bottom
948 return pos
!= posStart
;
951 bool wxWindowMSW::ScrollLines(int lines
)
953 bool down
= lines
> 0;
955 return ScrollVertically(GetHwnd(),
956 down
? SB_LINEDOWN
: SB_LINEUP
,
957 down
? lines
: -lines
);
960 bool wxWindowMSW::ScrollPages(int pages
)
962 bool down
= pages
> 0;
964 return ScrollVertically(GetHwnd(),
965 down
? SB_PAGEDOWN
: SB_PAGEUP
,
966 down
? pages
: -pages
);
969 // ---------------------------------------------------------------------------
971 // ---------------------------------------------------------------------------
973 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
975 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
977 HWND hwnd
= (HWND
)hWnd
;
978 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
980 wxAssociateWinWithHandle(hwnd
, this);
982 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
984 // we don't need to subclass the window of our own class (in the Windows
985 // sense of the word)
986 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
988 wxSetWindowProc(hwnd
, wxWndProc
);
992 // don't bother restoring it neither: this also makes it easy to
993 // implement IsOfStandardClass() method which returns true for the
994 // standard controls and false for the wxWidgets own windows as it can
995 // simply check m_oldWndProc
1000 void wxWindowMSW::UnsubclassWin()
1002 wxRemoveHandleAssociation(this);
1004 // Restore old Window proc
1005 HWND hwnd
= GetHwnd();
1010 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1014 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1016 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1019 m_oldWndProc
= NULL
;
1024 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1028 if ( !::DestroyWindow(GetHwnd()) )
1029 wxLogLastError(wxT("DestroyWindow"));
1032 WXHWND wxhwnd
= (WXHWND
)handle
;
1035 SubclassWin(wxhwnd
);
1038 void wxWindowMSW::DissociateHandle()
1040 // this also calls SetHWND(0) for us
1045 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1047 // Unicows note: the code below works, but only because WNDCLASS contains
1048 // original window handler rather that the unicows fake one. This may not
1049 // be on purpose, though; if it stops working with future versions of
1050 // unicows.dll, we can override unicows hooks by setting
1051 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1052 // versions that keep track of fake<->real wnd proc mapping.
1054 // On WinCE (at least), the wndproc comparison doesn't work,
1055 // so have to use something like this.
1057 extern wxChar
*wxCanvasClassName
;
1058 extern wxChar
*wxCanvasClassNameNR
;
1059 extern const wxChar
*wxMDIFrameClassName
;
1060 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1061 extern const wxChar
*wxMDIChildFrameClassName
;
1062 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1063 wxString
str(wxGetWindowClass(hWnd
));
1064 if (str
== wxCanvasClassName
||
1065 str
== wxCanvasClassNameNR
||
1066 str
== wxMDIFrameClassName
||
1067 str
== wxMDIFrameClassNameNoRedraw
||
1068 str
== wxMDIChildFrameClassName
||
1069 str
== wxMDIChildFrameClassNameNoRedraw
||
1070 str
== _T("wxTLWHiddenParent"))
1071 return true; // Effectively means don't subclass
1076 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1078 wxLogLastError(_T("GetClassInfo"));
1083 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1087 // ----------------------------------------------------------------------------
1089 // ----------------------------------------------------------------------------
1091 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1093 long flagsOld
= GetWindowStyleFlag();
1094 if ( flags
== flagsOld
)
1097 // update the internal variable
1098 wxWindowBase::SetWindowStyleFlag(flags
);
1100 // now update the Windows style as well if needed - and if the window had
1101 // been already created
1105 WXDWORD exstyle
, exstyleOld
;
1106 long style
= MSWGetStyle(flags
, &exstyle
),
1107 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1109 if ( style
!= styleOld
)
1111 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1112 // this function so instead of simply setting the style to the new
1113 // value we clear the bits which were set in styleOld but are set in
1114 // the new one and set the ones which were not set before
1115 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1116 styleReal
&= ~styleOld
;
1119 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1122 // and the extended style
1123 if ( exstyle
!= exstyleOld
)
1125 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1126 exstyleReal
&= ~exstyleOld
;
1127 exstyleReal
|= exstyle
;
1129 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1131 // we must call SetWindowPos() to flash the cached extended style and
1132 // also to make the change to wxSTAY_ON_TOP style take effect: just
1133 // setting the style simply doesn't work
1134 if ( !::SetWindowPos(GetHwnd(),
1135 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1138 SWP_NOMOVE
| SWP_NOSIZE
) )
1140 wxLogLastError(_T("SetWindowPos"));
1145 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1147 // translate common wxWidgets styles to Windows ones
1149 // most of windows are child ones, those which are not (such as
1150 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1151 WXDWORD style
= WS_CHILD
;
1153 if ( flags
& wxCLIP_CHILDREN
)
1154 style
|= WS_CLIPCHILDREN
;
1156 if ( flags
& wxCLIP_SIBLINGS
)
1157 style
|= WS_CLIPSIBLINGS
;
1159 if ( flags
& wxVSCROLL
)
1160 style
|= WS_VSCROLL
;
1162 if ( flags
& wxHSCROLL
)
1163 style
|= WS_HSCROLL
;
1165 const wxBorder border
= GetBorder(flags
);
1167 // WS_BORDER is only required for wxBORDER_SIMPLE
1168 if ( border
== wxBORDER_SIMPLE
)
1171 // now deal with ext style if the caller wants it
1177 if ( flags
& wxTRANSPARENT_WINDOW
)
1178 *exstyle
|= WS_EX_TRANSPARENT
;
1184 case wxBORDER_DEFAULT
:
1185 wxFAIL_MSG( _T("unknown border style") );
1189 case wxBORDER_SIMPLE
:
1192 case wxBORDER_STATIC
:
1193 *exstyle
|= WS_EX_STATICEDGE
;
1196 case wxBORDER_RAISED
:
1197 *exstyle
|= WS_EX_DLGMODALFRAME
;
1200 case wxBORDER_SUNKEN
:
1201 *exstyle
|= WS_EX_CLIENTEDGE
;
1202 style
&= ~WS_BORDER
;
1205 case wxBORDER_DOUBLE
:
1206 *exstyle
|= WS_EX_DLGMODALFRAME
;
1210 // wxUniv doesn't use Windows dialog navigation functions at all
1211 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1212 // to make the dialog navigation work with the nested panels we must
1213 // use this style (top level windows such as dialogs don't need it)
1214 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1216 *exstyle
|= WS_EX_CONTROLPARENT
;
1218 #endif // __WXUNIVERSAL__
1224 // Setup background and foreground colours correctly
1225 void wxWindowMSW::SetupColours()
1228 SetBackgroundColour(GetParent()->GetBackgroundColour());
1231 bool wxWindowMSW::IsMouseInWindow() const
1233 // get the mouse position
1235 ::GetCursorPos(&pt
);
1237 // find the window which currently has the cursor and go up the window
1238 // chain until we find this window - or exhaust it
1239 HWND hwnd
= ::WindowFromPoint(pt
);
1240 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1241 hwnd
= ::GetParent(hwnd
);
1243 return hwnd
!= NULL
;
1246 void wxWindowMSW::OnInternalIdle()
1248 // Check if we need to send a LEAVE event
1249 if ( m_mouseInWindow
)
1251 // note that we should generate the leave event whether the window has
1252 // or doesn't have mouse capture
1253 if ( !IsMouseInWindow() )
1255 // Generate a LEAVE event
1256 m_mouseInWindow
= false;
1258 // Unfortunately the mouse button and keyboard state may have
1259 // changed by the time the OnInternalIdle function is called, so 'state'
1260 // may be meaningless.
1262 if ( wxIsShiftDown() )
1264 if ( wxIsCtrlDown() )
1265 state
|= MK_CONTROL
;
1266 if ( GetKeyState( VK_LBUTTON
) )
1267 state
|= MK_LBUTTON
;
1268 if ( GetKeyState( VK_MBUTTON
) )
1269 state
|= MK_MBUTTON
;
1270 if ( GetKeyState( VK_RBUTTON
) )
1271 state
|= MK_RBUTTON
;
1274 if ( !::GetCursorPos(&pt
) )
1276 wxLogLastError(_T("GetCursorPos"));
1279 // we need to have client coordinates here for symmetry with
1280 // wxEVT_ENTER_WINDOW
1281 RECT rect
= wxGetWindowRect(GetHwnd());
1285 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1286 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1288 (void)GetEventHandler()->ProcessEvent(event2
);
1292 if (wxUpdateUIEvent::CanUpdate(this))
1293 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1296 // Set this window to be the child of 'parent'.
1297 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1299 if ( !wxWindowBase::Reparent(parent
) )
1302 HWND hWndChild
= GetHwnd();
1303 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1305 ::SetParent(hWndChild
, hWndParent
);
1308 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1310 EnsureParentHasControlParentStyle(GetParent());
1312 #endif // !__WXWINCE__
1317 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1319 #ifndef __WXMICROWIN__
1320 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1324 void wxWindowMSW::Freeze()
1326 if ( !m_frozenness
++ )
1328 SendSetRedraw(GetHwnd(), false);
1332 void wxWindowMSW::Thaw()
1334 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1336 if ( !--m_frozenness
)
1338 SendSetRedraw(GetHwnd(), true);
1340 // we need to refresh everything or otherwise he invalidated area is not
1346 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1348 HWND hWnd
= GetHwnd();
1354 mswRect
.left
= rect
->x
;
1355 mswRect
.top
= rect
->y
;
1356 mswRect
.right
= rect
->x
+ rect
->width
;
1357 mswRect
.bottom
= rect
->y
+ rect
->height
;
1359 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1362 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1366 void wxWindowMSW::Update()
1368 if ( !::UpdateWindow(GetHwnd()) )
1370 wxLogLastError(_T("UpdateWindow"));
1373 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1374 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1375 // handler needs to be really drawn right now
1380 // ---------------------------------------------------------------------------
1382 // ---------------------------------------------------------------------------
1385 #if wxUSE_DRAG_AND_DROP
1386 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1388 if ( m_dropTarget
!= 0 ) {
1389 m_dropTarget
->Revoke(m_hWnd
);
1390 delete m_dropTarget
;
1393 m_dropTarget
= pDropTarget
;
1394 if ( m_dropTarget
!= 0 )
1395 m_dropTarget
->Register(m_hWnd
);
1397 #endif // wxUSE_DRAG_AND_DROP
1399 // old style file-manager drag&drop support: we retain the old-style
1400 // DragAcceptFiles in parallel with SetDropTarget.
1401 void wxWindowMSW::DragAcceptFiles(bool accept
)
1403 #if !defined(__WXWINCE__)
1404 HWND hWnd
= GetHwnd();
1406 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1408 wxUnusedVar(accept
);
1412 // ----------------------------------------------------------------------------
1414 // ----------------------------------------------------------------------------
1418 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1420 wxWindowBase::DoSetToolTip(tooltip
);
1423 m_tooltip
->SetWindow((wxWindow
*)this);
1426 #endif // wxUSE_TOOLTIPS
1428 // ---------------------------------------------------------------------------
1429 // moving and resizing
1430 // ---------------------------------------------------------------------------
1433 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1435 RECT rect
= wxGetWindowRect(GetHwnd());
1438 *x
= rect
.right
- rect
.left
;
1440 *y
= rect
.bottom
- rect
.top
;
1443 // Get size *available for subwindows* i.e. excluding menu bar etc.
1444 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1446 RECT rect
= wxGetClientRect(GetHwnd());
1454 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1456 RECT rect
= wxGetWindowRect(GetHwnd());
1459 point
.x
= rect
.left
;
1462 // we do the adjustments with respect to the parent only for the "real"
1463 // children, not for the dialogs/frames
1464 if ( !IsTopLevel() )
1466 HWND hParentWnd
= 0;
1467 wxWindow
*parent
= GetParent();
1469 hParentWnd
= GetWinHwnd(parent
);
1471 // Since we now have the absolute screen coords, if there's a parent we
1472 // must subtract its top left corner
1475 ::ScreenToClient(hParentWnd
, &point
);
1480 // We may be faking the client origin. So a window that's really at (0,
1481 // 30) may appear (to wxWin apps) to be at (0, 0).
1482 wxPoint
pt(parent
->GetClientAreaOrigin());
1494 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1502 ::ScreenToClient(GetHwnd(), &pt
);
1510 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1518 ::ClientToScreen(GetHwnd(), &pt
);
1526 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1528 // TODO: is this consistent with other platforms?
1529 // Still, negative width or height shouldn't be allowed
1534 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, IsShown() /*Repaint?*/) )
1536 wxLogLastError(wxT("MoveWindow"));
1540 // set the size of the window: if the dimensions are positive, just use them,
1541 // but if any of them is equal to -1, it means that we must find the value for
1542 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1543 // which case -1 is a valid value for x and y)
1545 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1546 // the width/height to best suit our contents, otherwise we reuse the current
1548 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1550 // get the current size and position...
1551 int currentX
, currentY
;
1552 GetPosition(¤tX
, ¤tY
);
1553 int currentW
,currentH
;
1554 GetSize(¤tW
, ¤tH
);
1556 // ... and don't do anything (avoiding flicker) if it's already ok
1557 if ( x
== currentX
&& y
== currentY
&&
1558 width
== currentW
&& height
== currentH
)
1563 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1565 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1568 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1570 wxSize size
= wxDefaultSize
;
1571 if ( width
== wxDefaultCoord
)
1573 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1575 size
= DoGetBestSize();
1580 // just take the current one
1585 if ( height
== wxDefaultCoord
)
1587 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1589 if ( size
.x
== wxDefaultCoord
)
1591 size
= DoGetBestSize();
1593 //else: already called DoGetBestSize() above
1599 // just take the current one
1604 DoMoveWindow(x
, y
, width
, height
);
1607 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1609 // setting the client size is less obvious than it it could have been
1610 // because in the result of changing the total size the window scrollbar
1611 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1612 // will not be correct as the difference between the total and client size
1613 // changes - so we keep changing it until we get it right
1615 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1616 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1617 // may become 3 if the window had 0 size originally and so we didn't
1618 // calculate the scrollbar correction correctly during the first iteration)
1619 // but just to be on the safe side we check for it instead of making it an
1620 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1621 for ( int i
= 0; i
< 4; i
++ )
1624 ::GetClientRect(GetHwnd(), &rectClient
);
1626 // if the size is already ok, stop here (rectClient.left = top = 0)
1627 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1628 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1633 int widthClient
= width
,
1634 heightClient
= height
;
1636 // Find the difference between the entire window (title bar and all)
1637 // and the client area; add this to the new client size to move the
1640 ::GetWindowRect(GetHwnd(), &rectWin
);
1642 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1643 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1646 point
.x
= rectWin
.left
;
1647 point
.y
= rectWin
.top
;
1649 // MoveWindow positions the child windows relative to the parent, so
1650 // adjust if necessary
1651 if ( !IsTopLevel() )
1653 wxWindow
*parent
= GetParent();
1656 ::ScreenToClient(GetHwndOf(parent
), &point
);
1660 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1664 // For implementation purposes - sometimes decorations make the client area
1666 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1668 return wxPoint(0, 0);
1671 // ---------------------------------------------------------------------------
1673 // ---------------------------------------------------------------------------
1675 int wxWindowMSW::GetCharHeight() const
1677 return wxGetTextMetrics(this).tmHeight
;
1680 int wxWindowMSW::GetCharWidth() const
1682 // +1 is needed because Windows apparently adds it when calculating the
1683 // dialog units size in pixels
1684 #if wxDIALOG_UNIT_COMPATIBILITY
1685 return wxGetTextMetrics(this).tmAveCharWidth
;
1687 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1691 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1693 int *descent
, int *externalLeading
,
1694 const wxFont
*theFont
) const
1696 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1697 _T("invalid font in GetTextExtent()") );
1701 fontToUse
= *theFont
;
1703 fontToUse
= GetFont();
1705 WindowHDC
hdc(GetHwnd());
1706 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1710 GetTextExtentPoint(hdc
, string
, string
.length(), &sizeRect
);
1711 GetTextMetrics(hdc
, &tm
);
1718 *descent
= tm
.tmDescent
;
1719 if ( externalLeading
)
1720 *externalLeading
= tm
.tmExternalLeading
;
1723 // ---------------------------------------------------------------------------
1725 // ---------------------------------------------------------------------------
1727 #if wxUSE_MENUS_NATIVE
1729 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1730 // immediately, without waiting for the next event loop iteration
1732 // NB: this function should probably be made public later as it can almost
1733 // surely replace wxYield() elsewhere as well
1734 static void wxYieldForCommandsOnly()
1736 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1737 // want to process it here)
1739 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1741 if ( msg
.message
== WM_QUIT
)
1743 // if we retrieved a WM_QUIT, insert back into the message queue.
1744 ::PostQuitMessage(0);
1748 // luckily (as we don't have access to wxEventLoopImpl method from here
1749 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1751 ::TranslateMessage(&msg
);
1752 ::DispatchMessage(&msg
);
1756 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1758 menu
->SetInvokingWindow(this);
1761 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1763 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1764 x
= mouse
.x
; y
= mouse
.y
;
1767 HWND hWnd
= GetHwnd();
1768 HMENU hMenu
= GetHmenuOf(menu
);
1772 ::ClientToScreen(hWnd
, &point
);
1773 wxCurrentPopupMenu
= menu
;
1774 #if defined(__WXWINCE__)
1777 UINT flags
= TPM_RIGHTBUTTON
;
1779 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1781 // we need to do it righ now as otherwise the events are never going to be
1782 // sent to wxCurrentPopupMenu from HandleCommand()
1784 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1785 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1786 // destroyed as soon as we return (it can be a local variable in the caller
1787 // for example) and so we do need to process the event immediately
1788 wxYieldForCommandsOnly();
1790 wxCurrentPopupMenu
= NULL
;
1792 menu
->SetInvokingWindow(NULL
);
1797 #endif // wxUSE_MENUS_NATIVE
1799 // ===========================================================================
1800 // pre/post message processing
1801 // ===========================================================================
1803 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1806 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1808 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1811 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1813 // wxUniversal implements tab traversal itself
1814 #ifndef __WXUNIVERSAL__
1815 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1817 // intercept dialog navigation keys
1818 MSG
*msg
= (MSG
*)pMsg
;
1820 // here we try to do all the job which ::IsDialogMessage() usually does
1823 if ( msg
->message
== WM_KEYDOWN
)
1825 bool bCtrlDown
= wxIsCtrlDown();
1826 bool bShiftDown
= wxIsShiftDown();
1828 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1829 // don't process it if it's the case (except for Ctrl-Tab/Enter
1830 // combinations which are always processed)
1834 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1836 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1837 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1838 // it, of course, implies them
1839 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1841 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1845 bool bForward
= true,
1846 bWindowChange
= false;
1848 // should we process this message specially?
1849 bool bProcess
= true;
1850 switch ( msg
->wParam
)
1853 if ( lDlgCode
& DLGC_WANTTAB
) {
1857 // Ctrl-Tab cycles thru notebook pages
1858 bWindowChange
= bCtrlDown
;
1859 bForward
= !bShiftDown
;
1865 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1873 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1880 wxButton
*btn
= wxDynamicCast(FindWindow(wxID_CANCEL
),
1882 if ( btn
&& btn
->IsEnabled() )
1884 // if we do have a cancel button, do press it
1885 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1887 // we consumed the message
1890 #endif // wxUSE_BUTTON
1898 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1900 // control wants to process Enter itself, don't
1901 // call IsDialogMessage() which would interpret
1905 else if ( lDlgCode
& DLGC_BUTTON
)
1907 // let IsDialogMessage() handle this for all
1908 // buttons except the owner-drawn ones which it
1909 // just seems to ignore
1910 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1911 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1913 // emulate the button click
1914 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1916 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1921 // FIXME: this should be handled by
1922 // wxNavigationKeyEvent handler and not here!!
1926 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1928 if ( btn
&& btn
->IsEnabled() )
1930 // if we do have a default button, do press it
1931 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1935 else // no default button
1936 #endif // wxUSE_BUTTON
1938 // this is a quick and dirty test for a text
1940 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1942 // don't process Enter, the control might
1943 // need it for itself and don't let
1944 // ::IsDialogMessage() have it as it can
1945 // eat the Enter events sometimes
1948 else if (!IsTopLevel())
1950 // if not a top level window, let parent
1954 //else: treat Enter as TAB: pass to the next
1955 // control as this is the best thing to do
1956 // if the text doesn't handle Enter itself
1968 wxNavigationKeyEvent event
;
1969 event
.SetDirection(bForward
);
1970 event
.SetWindowChange(bWindowChange
);
1971 event
.SetEventObject(this);
1973 if ( GetEventHandler()->ProcessEvent(event
) )
1980 // let ::IsDialogMessage() do almost everything and handle just the
1981 // things it doesn't here: Ctrl-TAB for switching notebook pages
1982 if ( msg
->message
== WM_KEYDOWN
)
1984 // don't process system keys here
1985 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1987 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1989 // find the first notebook parent and change its page
1990 wxWindow
*win
= this;
1991 wxNotebook
*nbook
= NULL
;
1992 while ( win
&& !nbook
)
1994 nbook
= wxDynamicCast(win
, wxNotebook
);
1995 win
= win
->GetParent();
2000 bool forward
= !wxIsShiftDown();
2002 nbook
->AdvanceSelection(forward
);
2009 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2010 // message even when there is no cancel button and when the message is
2011 // needed by the control itself: in particular, it prevents the tree in
2012 // place edit control from being closed with Escape in a dialog
2013 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2015 // ::IsDialogMessage() is broken and may sometimes hang the
2016 // application by going into an infinite loop, so we try to detect
2017 // [some of] the situatations when this may happen and not call it
2020 // assume we can call it by default
2021 bool canSafelyCallIsDlgMsg
= true;
2023 HWND hwndFocus
= ::GetFocus();
2025 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2026 // an infinite loop, because it will recursively check the child
2027 // windows but not the window itself and so if none of the children
2028 // accepts focus it loops forever (as it only stops when it gets
2029 // back to the window it started from)
2031 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2032 // style has the focus, it can happen. One such possibility is if
2033 // all windows are either toplevel, wxDialog, wxPanel or static
2034 // controls and no window can actually accept keyboard input.
2035 #if !defined(__WXWINCE__)
2036 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2038 // passimistic by default
2039 canSafelyCallIsDlgMsg
= false;
2040 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2042 node
= node
->GetNext() )
2044 wxWindow
* const win
= node
->GetData();
2045 if ( win
->AcceptsFocus() &&
2046 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2047 WS_EX_CONTROLPARENT
) )
2049 // it shouldn't hang...
2050 canSafelyCallIsDlgMsg
= true;
2056 #endif // !__WXWINCE__
2058 if ( canSafelyCallIsDlgMsg
)
2060 // ::IsDialogMessage() can enter in an infinite loop when the
2061 // currently focused window is disabled or hidden and its
2062 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2066 if ( !::IsWindowEnabled(hwndFocus
) ||
2067 !::IsWindowVisible(hwndFocus
) )
2069 // it would enter an infinite loop if we do this!
2070 canSafelyCallIsDlgMsg
= false;
2075 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2077 // it's a top level window, don't go further -- e.g. even
2078 // if the parent of a dialog is disabled, this doesn't
2079 // break navigation inside the dialog
2083 hwndFocus
= ::GetParent(hwndFocus
);
2087 // let IsDialogMessage() have the message if it's safe to call it
2088 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2090 // IsDialogMessage() did something...
2095 #endif // __WXUNIVERSAL__
2100 // relay mouse move events to the tooltip control
2101 MSG
*msg
= (MSG
*)pMsg
;
2102 if ( msg
->message
== WM_MOUSEMOVE
)
2103 m_tooltip
->RelayEvent(pMsg
);
2105 #endif // wxUSE_TOOLTIPS
2110 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2112 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2113 return m_acceleratorTable
.Translate(this, pMsg
);
2117 #endif // wxUSE_ACCEL
2120 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2122 // preprocess all messages by default
2126 // ---------------------------------------------------------------------------
2127 // message params unpackers
2128 // ---------------------------------------------------------------------------
2130 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2131 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2133 *id
= LOWORD(wParam
);
2134 *hwnd
= (WXHWND
)lParam
;
2135 *cmd
= HIWORD(wParam
);
2138 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2139 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2141 *state
= LOWORD(wParam
);
2142 *minimized
= HIWORD(wParam
);
2143 *hwnd
= (WXHWND
)lParam
;
2146 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2147 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2149 *code
= LOWORD(wParam
);
2150 *pos
= HIWORD(wParam
);
2151 *hwnd
= (WXHWND
)lParam
;
2154 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2155 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2157 #ifndef __WXMICROWIN__
2158 *nCtlColor
= CTLCOLOR_BTN
;
2159 *hwnd
= (WXHWND
)lParam
;
2160 *hdc
= (WXHDC
)wParam
;
2164 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2165 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2167 *item
= (WXWORD
)wParam
;
2168 *flags
= HIWORD(wParam
);
2169 *hmenu
= (WXHMENU
)lParam
;
2172 // ---------------------------------------------------------------------------
2173 // Main wxWidgets window proc and the window proc for wxWindow
2174 // ---------------------------------------------------------------------------
2176 // Hook for new window just as it's being created, when the window isn't yet
2177 // associated with the handle
2178 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2180 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2181 // window being created and insures that it's always unset back later
2182 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2184 gs_winBeingCreated
= winBeingCreated
;
2187 wxWindowCreationHook::~wxWindowCreationHook()
2189 gs_winBeingCreated
= NULL
;
2193 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2195 // trace all messages - useful for the debugging
2197 wxLogTrace(wxTraceMessages
,
2198 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2199 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2200 #endif // __WXDEBUG__
2202 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2204 // when we get the first message for the HWND we just created, we associate
2205 // it with wxWindow stored in gs_winBeingCreated
2206 if ( !wnd
&& gs_winBeingCreated
)
2208 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2209 wnd
= gs_winBeingCreated
;
2210 gs_winBeingCreated
= NULL
;
2211 wnd
->SetHWND((WXHWND
)hWnd
);
2217 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2219 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2224 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2226 // did we process the message?
2227 bool processed
= false;
2238 // for most messages we should return 0 when we do process the message
2246 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2249 // return 0 to allow window creation
2250 rc
.result
= mayCreate
? 0 : -1;
2256 // never set processed to true and *always* pass WM_DESTROY to
2257 // DefWindowProc() as Windows may do some internal cleanup when
2258 // processing it and failing to pass the message along may cause
2259 // memory and resource leaks!
2260 (void)HandleDestroy();
2264 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2267 #if !defined(__WXWINCE__)
2270 LPRECT pRect
= (LPRECT
)lParam
;
2272 rc
.SetLeft(pRect
->left
);
2273 rc
.SetTop(pRect
->top
);
2274 rc
.SetRight(pRect
->right
);
2275 rc
.SetBottom(pRect
->bottom
);
2276 processed
= HandleMoving(rc
);
2278 pRect
->left
= rc
.GetLeft();
2279 pRect
->top
= rc
.GetTop();
2280 pRect
->right
= rc
.GetRight();
2281 pRect
->bottom
= rc
.GetBottom();
2288 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2291 #if !defined(__WXWINCE__)
2294 LPRECT pRect
= (LPRECT
)lParam
;
2296 rc
.SetLeft(pRect
->left
);
2297 rc
.SetTop(pRect
->top
);
2298 rc
.SetRight(pRect
->right
);
2299 rc
.SetBottom(pRect
->bottom
);
2300 processed
= HandleSizing(rc
);
2302 pRect
->left
= rc
.GetLeft();
2303 pRect
->top
= rc
.GetTop();
2304 pRect
->right
= rc
.GetRight();
2305 pRect
->bottom
= rc
.GetBottom();
2311 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2312 case WM_ACTIVATEAPP
:
2313 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2319 WXWORD state
, minimized
;
2321 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2323 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2328 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2332 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2339 // cast to wxWindow is needed for wxUniv
2340 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2341 processed
= HandlePaint();
2345 processed
= HandlePaint();
2354 // Don't call the wx handlers in this case
2355 if ( wxIsKindOf(this, wxListCtrl
) )
2359 if ( lParam
& PRF_ERASEBKGND
)
2360 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2362 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2363 processed
= HandlePaint();
2369 #ifdef __WXUNIVERSAL__
2370 // Universal uses its own wxFrame/wxDialog, so we don't receive
2371 // close events unless we have this.
2376 // don't let the DefWindowProc() destroy our window - we'll do it
2377 // ourselves in ~wxWindow
2384 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2388 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2389 GET_Y_LPARAM(lParam
),
2393 // Seems to be broken currently
2394 #if 0 // ndef __WXWINCE__
2397 wxASSERT_MSG( !m_mouseInWindow
, wxT("the mouse should be in a window to generate this event!") );
2399 // only process this message if the mouse is not in the window,
2400 // This can also check for children in composite windows.
2401 // however, this may mean the the wxEVT_LEAVE_WINDOW is never sent
2402 // if the mouse does not enter the window from it's child before
2403 // leaving the scope of the window. ( perhaps this can be picked
2404 // up in the OnIdle code as before, for this special case )
2405 if ( /*IsComposite() && */ !IsMouseInWindow() )
2407 m_mouseInWindow
= false;
2409 // Unfortunately no mouse state is passed with a WM_MOUSE_LEAVE
2411 if ( wxIsShiftDown() )
2413 if ( wxIsCtrlDown() )
2414 state
|= MK_CONTROL
;
2415 if ( GetKeyState( VK_LBUTTON
) )
2416 state
|= MK_LBUTTON
;
2417 if ( GetKeyState( VK_MBUTTON
) )
2418 state
|= MK_MBUTTON
;
2419 if ( GetKeyState( VK_RBUTTON
) )
2420 state
|= MK_RBUTTON
;
2423 if ( !::GetCursorPos(&pt
) )
2425 wxLogLastError(_T("GetCursorPos"));
2428 // we need to have client coordinates here for symmetry with
2429 // wxEVT_ENTER_WINDOW
2430 RECT rect
= wxGetWindowRect(GetHwnd());
2434 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
2435 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
2437 (void)GetEventHandler()->ProcessEvent(event2
);
2439 // always pass processed back as false, this allows the window
2440 // manager to process the message too. This is needed to ensure
2441 // windows XP themes work properly as the mouse moves over widgets
2449 #if wxUSE_MOUSEWHEEL
2451 processed
= HandleMouseWheel(wParam
, lParam
);
2455 case WM_LBUTTONDOWN
:
2457 case WM_LBUTTONDBLCLK
:
2458 case WM_RBUTTONDOWN
:
2460 case WM_RBUTTONDBLCLK
:
2461 case WM_MBUTTONDOWN
:
2463 case WM_MBUTTONDBLCLK
:
2465 #ifdef __WXMICROWIN__
2466 // MicroWindows seems to ignore the fact that a window is
2467 // disabled. So catch mouse events and throw them away if
2469 wxWindowMSW
* win
= this;
2472 if (!win
->IsEnabled())
2478 win
= win
->GetParent();
2479 if ( !win
|| win
->IsTopLevel() )
2486 #endif // __WXMICROWIN__
2487 int x
= GET_X_LPARAM(lParam
),
2488 y
= GET_Y_LPARAM(lParam
);
2490 // redirect the event to a static control if necessary by
2491 // finding one under mouse
2493 if ( GetCapture() == this )
2495 // but don't do it if the mouse is captured by this window
2496 // because then it should really get this event itself
2501 win
= FindWindowForMouseEvent(this, &x
, &y
);
2503 // this should never happen
2504 wxCHECK_MSG( win
, 0,
2505 _T("FindWindowForMouseEvent() returned NULL") );
2507 // for the standard classes their WndProc sets the focus to
2508 // them anyhow and doing it from here results in some weird
2509 // problems, but for our windows we want them to acquire
2510 // focus when clicked
2511 if ( !win
->IsOfStandardClass() )
2513 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2518 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2527 case MM_JOY1BUTTONDOWN
:
2528 case MM_JOY2BUTTONDOWN
:
2529 case MM_JOY1BUTTONUP
:
2530 case MM_JOY2BUTTONUP
:
2531 processed
= HandleJoystickEvent(message
,
2532 GET_X_LPARAM(lParam
),
2533 GET_Y_LPARAM(lParam
),
2536 #endif // __WXMICROWIN__
2542 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2544 processed
= HandleCommand(id
, cmd
, hwnd
);
2549 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2552 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2553 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2554 // apparently doesn't always behave properly and needs some help
2555 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2556 case WM_NOTIFYFORMAT
:
2557 if ( lParam
== NF_QUERY
)
2560 rc
.result
= NFR_UNICODE
;
2563 #endif // wxUSE_UNICODE_MSLU
2565 // for these messages we must return true if process the message
2568 case WM_MEASUREITEM
:
2570 int idCtrl
= (UINT
)wParam
;
2571 if ( message
== WM_DRAWITEM
)
2573 processed
= MSWOnDrawItem(idCtrl
,
2574 (WXDRAWITEMSTRUCT
*)lParam
);
2578 processed
= MSWOnMeasureItem(idCtrl
,
2579 (WXMEASUREITEMSTRUCT
*)lParam
);
2586 #endif // defined(WM_DRAWITEM)
2589 if ( !IsOfStandardClass() )
2591 // we always want to get the char events
2592 rc
.result
= DLGC_WANTCHARS
;
2594 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2596 // in fact, we want everything
2597 rc
.result
|= DLGC_WANTARROWS
|
2604 //else: get the dlg code from the DefWindowProc()
2609 // If this has been processed by an event handler, return 0 now
2610 // (we've handled it).
2611 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2612 if ( m_lastKeydownProcessed
)
2621 // we consider these message "not interesting" to OnChar, so
2622 // just don't do anything more with them
2632 // avoid duplicate messages to OnChar for these ASCII keys:
2633 // they will be translated by TranslateMessage() and received
2655 // but set processed to false, not true to still pass them
2656 // to the control's default window proc - otherwise
2657 // built-in keyboard handling won't work
2662 // special case of VK_APPS: treat it the same as right mouse
2663 // click because both usually pop up a context menu
2669 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2670 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2676 // do generate a CHAR event
2677 processed
= HandleChar((WORD
)wParam
, lParam
);
2680 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2687 // special case of VK_APPS: treat it the same as right mouse button
2688 if ( wParam
== VK_APPS
)
2693 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2694 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2699 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2704 case WM_CHAR
: // Always an ASCII character
2705 if ( m_lastKeydownProcessed
)
2707 // The key was handled in the EVT_KEY_DOWN and handling
2708 // a key in an EVT_KEY_DOWN handler is meant, by
2709 // design, to prevent EVT_CHARs from happening
2710 m_lastKeydownProcessed
= false;
2715 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2721 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2723 #endif // wxUSE_HOTKEY
2730 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2732 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2738 // CTLCOLOR messages are sent by children to query the parent for their
2739 // colors#ifndef __WXMICROWIN__
2740 #ifndef __WXMICROWIN__
2741 case WM_CTLCOLORMSGBOX
:
2742 case WM_CTLCOLOREDIT
:
2743 case WM_CTLCOLORLISTBOX
:
2744 case WM_CTLCOLORBTN
:
2745 case WM_CTLCOLORDLG
:
2746 case WM_CTLCOLORSCROLLBAR
:
2747 case WM_CTLCOLORSTATIC
:
2752 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2754 processed
= HandleCtlColor(&rc
.hBrush
,
2763 #endif // !__WXMICROWIN__
2765 case WM_SYSCOLORCHANGE
:
2766 // the return value for this message is ignored
2767 processed
= HandleSysColorChange();
2770 #if !defined(__WXWINCE__)
2771 case WM_DISPLAYCHANGE
:
2772 processed
= HandleDisplayChange();
2776 case WM_PALETTECHANGED
:
2777 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2780 case WM_CAPTURECHANGED
:
2781 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2784 case WM_QUERYNEWPALETTE
:
2785 processed
= HandleQueryNewPalette();
2789 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2792 // we processed the message, i.e. erased the background
2797 #if !defined(__WXWINCE__)
2799 processed
= HandleDropFiles(wParam
);
2804 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2808 // we never set focus from here
2813 #if !defined(__WXWINCE__)
2814 case WM_QUERYENDSESSION
:
2815 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2819 processed
= HandleEndSession(wParam
!= 0, lParam
);
2822 case WM_GETMINMAXINFO
:
2823 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2828 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2829 LOWORD(lParam
), // hit test
2830 HIWORD(lParam
)); // mouse msg
2834 // returning TRUE stops the DefWindowProc() from further
2835 // processing this message - exactly what we need because we've
2836 // just set the cursor.
2841 #if wxUSE_ACCESSIBILITY
2844 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2845 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2847 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2849 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2855 #if defined(WM_HELP)
2858 // HELPINFO doesn't seem to be supported on WinCE.
2860 HELPINFO
* info
= (HELPINFO
*) lParam
;
2861 // Don't yet process menu help events, just windows
2862 if (info
->iContextType
== HELPINFO_WINDOW
)
2865 wxWindowMSW
* subjectOfHelp
= this;
2866 bool eventProcessed
= false;
2867 while (subjectOfHelp
&& !eventProcessed
)
2869 wxHelpEvent
helpEvent(wxEVT_HELP
,
2870 subjectOfHelp
->GetId(),
2874 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2878 helpEvent
.SetEventObject(this);
2880 GetEventHandler()->ProcessEvent(helpEvent
);
2882 // Go up the window hierarchy until the event is
2884 subjectOfHelp
= subjectOfHelp
->GetParent();
2887 processed
= eventProcessed
;
2890 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2892 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2893 helpEvent
.SetEventObject(this);
2894 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2897 //else: processed is already false
2903 #if !defined(__WXWINCE__)
2904 case WM_CONTEXTMENU
:
2906 // we don't convert from screen to client coordinates as
2907 // the event may be handled by a parent window
2908 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2910 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2912 // we could have got an event from our child, reflect it back
2913 // to it if this is the case
2914 wxWindowMSW
*win
= NULL
;
2915 if ( (WXHWND
)wParam
!= m_hWnd
)
2917 win
= FindItemByHWND((WXHWND
)wParam
);
2923 evtCtx
.SetEventObject(win
);
2924 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
2930 // we're only interested in our own menus, not MF_SYSMENU
2931 if ( HIWORD(wParam
) == MF_POPUP
)
2933 // handle menu chars for ownerdrawn menu items
2934 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2935 if ( i
!= wxNOT_FOUND
)
2937 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2947 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2948 wxGetMessageName(message
));
2949 #endif // __WXDEBUG__
2950 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2956 // ----------------------------------------------------------------------------
2957 // wxWindow <-> HWND map
2958 // ----------------------------------------------------------------------------
2960 wxWinHashTable
*wxWinHandleHash
= NULL
;
2962 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2964 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
2967 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2969 // adding NULL hWnd is (first) surely a result of an error and
2970 // (secondly) breaks menu command processing
2971 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2972 wxT("attempt to add a NULL hWnd to window list ignored") );
2974 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2976 if ( oldWin
&& (oldWin
!= win
) )
2978 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2979 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2982 #endif // __WXDEBUG__
2985 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2989 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2991 wxWinHandleHash
->Delete((long)win
->GetHWND());
2994 // ----------------------------------------------------------------------------
2995 // various MSW speciic class dependent functions
2996 // ----------------------------------------------------------------------------
2998 // Default destroyer - override if you destroy it in some other way
2999 // (e.g. with MDI child windows)
3000 void wxWindowMSW::MSWDestroyWindow()
3004 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3007 int& w
, int& h
) const
3009 // yes, those are just some arbitrary hardcoded numbers
3010 static const int DEFAULT_Y
= 200;
3012 bool nonDefault
= false;
3014 if ( pos
.x
== wxDefaultCoord
)
3016 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3017 // can just as well set it to CW_USEDEFAULT as well
3023 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3024 // neither because it is not handled as a special value by Windows then
3025 // and so we have to choose some default value for it
3027 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3033 NB: there used to be some code here which set the initial size of the
3034 window to the client size of the parent if no explicit size was
3035 specified. This was wrong because wxWidgets programs often assume
3036 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3037 it. To see why, you should understand that Windows sends WM_SIZE from
3038 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3039 from some base class ctor and so this WM_SIZE is not processed in the
3040 real class' OnSize() (because it's not fully constructed yet and the
3041 event goes to some base class OnSize() instead). So the WM_SIZE we
3042 rely on is the one sent when the parent frame resizes its children
3043 but here is the problem: if the child already has just the right
3044 size, nothing will happen as both wxWidgets and Windows check for
3045 this and ignore any attempts to change the window size to the size it
3046 already has - so no WM_SIZE would be sent.
3050 // we don't use CW_USEDEFAULT here for several reasons:
3052 // 1. it results in huge frames on modern screens (1000*800 is not
3053 // uncommon on my 1280*1024 screen) which is way too big for a half
3054 // empty frame of most of wxWidgets samples for example)
3056 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3057 // the default is for whatever reason 8*8 which breaks client <->
3058 // window size calculations (it would be nice if it didn't, but it
3059 // does and the simplest way to fix it seemed to change the broken
3060 // default size anyhow)
3062 // 3. there is just no advantage in doing it: with x and y it is
3063 // possible that [future versions of] Windows position the new top
3064 // level window in some smart way which we can't do, but we can
3065 // guess a reasonably good size for a new window just as well
3068 // However, on PocketPC devices, we must use the default
3069 // size if possible.
3071 if (size
.x
== wxDefaultCoord
)
3075 if (size
.y
== wxDefaultCoord
)
3080 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3084 w
= WidthDefault(size
.x
);
3085 h
= HeightDefault(size
.y
);
3088 AdjustForParentClientOrigin(x
, y
);
3093 WXHWND
wxWindowMSW::MSWGetParent() const
3095 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3098 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3099 const wxChar
*title
,
3103 WXDWORD extendedStyle
)
3105 // choose the position/size for the new window
3107 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3109 // controlId is menu handle for the top level windows, so set it to 0
3110 // unless we're creating a child window
3111 int controlId
= style
& WS_CHILD
? GetId() : 0;
3113 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3114 // which is the same but without CS_[HV]REDRAW class styles so using it
3115 // ensures that the window is not fully repainted on each resize
3116 wxString
className(wclass
);
3117 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3119 className
+= wxT("NR");
3122 // do create the window
3123 wxWindowCreationHook
hook(this);
3125 // VZ: anyonce cares to explain why is this done for CE?
3127 if (extendedStyle
== 0)
3129 m_hWnd
= (WXHWND
)::CreateWindow
3132 title
? title
: wxEmptyString
,
3135 (HWND
)MSWGetParent(),
3138 NULL
// no extra data
3142 #endif // __WXWINCE__
3144 m_hWnd
= (WXHWND
)::CreateWindowEx
3148 title
? title
: wxEmptyString
,
3151 (HWND
)MSWGetParent(),
3154 NULL
// no extra data
3160 wxLogSysError(_("Can't create window of class %s"), wclass
);
3165 SubclassWin(m_hWnd
);
3170 // ===========================================================================
3171 // MSW message handlers
3172 // ===========================================================================
3174 // ---------------------------------------------------------------------------
3176 // ---------------------------------------------------------------------------
3180 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3182 #ifndef __WXMICROWIN__
3183 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3184 HWND hWnd
= hdr
->hwndFrom
;
3185 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3187 // if the control is one of our windows, let it handle the message itself
3190 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3193 // VZ: why did we do it? normally this is unnecessary and, besides, it
3194 // breaks the message processing for the toolbars because the tooltip
3195 // notifications were being forwarded to the toolbar child controls
3196 // (if it had any) before being passed to the toolbar itself, so in my
3197 // example the tooltip for the combobox was always shown instead of the
3198 // correct button tooltips
3200 // try all our children
3201 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3204 wxWindow
*child
= node
->GetData();
3205 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3210 node
= node
->GetNext();
3214 // by default, handle it ourselves
3215 return MSWOnNotify(idCtrl
, lParam
, result
);
3216 #else // __WXMICROWIN__
3223 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3225 const wxString
& ttip
)
3227 // I don't know why it happens, but the versions of comctl32.dll starting
3228 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3229 // this message is supposed to be sent to Unicode programs only) -- hence
3230 // we need to handle it as well, otherwise no tooltips will be shown in
3233 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3236 // not a tooltip message or no tooltip to show anyhow
3241 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3243 // We don't want to use the szText buffer because it has a limit of 80
3244 // bytes and this is not enough, especially for Unicode build where it
3245 // limits the tooltip string length to only 40 characters
3247 // The best would be, of course, to not impose any length limitations at
3248 // all but then the buffer would have to be dynamic and someone would have
3249 // to free it and we don't have the tooltip owner object here any more, so
3250 // for now use our own static buffer with a higher fixed max length.
3252 // Note that using a static buffer should not be a problem as only a single
3253 // tooltip can be shown at the same time anyhow.
3255 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3257 // We need to convert tooltip from multi byte to Unicode on the fly.
3258 static wchar_t buf
[513];
3260 // Truncate tooltip length if needed as otherwise we might not have
3261 // enough space for it in the buffer and MultiByteToWideChar() would
3263 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3265 // Convert to WideChar without adding the NULL character. The NULL
3266 // character is added afterwards (this is more efficient).
3267 int len
= ::MultiByteToWideChar
3279 wxLogLastError(_T("MultiByteToWideChar()"));
3283 ttText
->lpszText
= (LPSTR
) buf
;
3285 else // TTN_NEEDTEXTA
3286 #endif // !wxUSE_UNICODE
3288 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3289 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3290 // to copy the string we have into the buffer
3291 static wxChar buf
[513];
3292 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3293 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3294 ttText
->lpszText
= buf
;
3300 #endif // wxUSE_TOOLTIPS
3302 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3304 WXLPARAM
* WXUNUSED(result
))
3309 NMHDR
* hdr
= (NMHDR
*)lParam
;
3310 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3317 wxUnusedVar(lParam
);
3318 #endif // wxUSE_TOOLTIPS
3325 // ---------------------------------------------------------------------------
3326 // end session messages
3327 // ---------------------------------------------------------------------------
3329 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3332 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3333 event
.SetEventObject(wxTheApp
);
3334 event
.SetCanVeto(true);
3335 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3337 bool rc
= wxTheApp
->ProcessEvent(event
);
3341 // we may end only if the app didn't veto session closing (double
3343 *mayEnd
= !event
.GetVeto();
3352 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3355 // do nothing if the session isn't ending
3360 if ( (this != wxTheApp
->GetTopWindow()) )
3363 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3364 event
.SetEventObject(wxTheApp
);
3365 event
.SetCanVeto(false);
3366 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3368 return wxTheApp
->ProcessEvent(event
);
3374 // ---------------------------------------------------------------------------
3375 // window creation/destruction
3376 // ---------------------------------------------------------------------------
3378 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3380 // VZ: why is this commented out for WinCE? If it doesn't support
3381 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3382 // not with multiple #ifdef's!
3384 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3385 EnsureParentHasControlParentStyle(GetParent());
3386 #endif // !__WXWINCE__
3388 // TODO: should generate this event from WM_NCCREATE
3389 wxWindowCreateEvent
event((wxWindow
*)this);
3390 (void)GetEventHandler()->ProcessEvent(event
);
3397 bool wxWindowMSW::HandleDestroy()
3401 // delete our drop target if we've got one
3402 #if wxUSE_DRAG_AND_DROP
3403 if ( m_dropTarget
!= NULL
)
3405 m_dropTarget
->Revoke(m_hWnd
);
3407 delete m_dropTarget
;
3408 m_dropTarget
= NULL
;
3410 #endif // wxUSE_DRAG_AND_DROP
3412 // WM_DESTROY handled
3416 // ---------------------------------------------------------------------------
3418 // ---------------------------------------------------------------------------
3420 bool wxWindowMSW::HandleActivate(int state
,
3421 bool WXUNUSED(minimized
),
3422 WXHWND
WXUNUSED(activate
))
3424 wxActivateEvent
event(wxEVT_ACTIVATE
,
3425 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3427 event
.SetEventObject(this);
3429 return GetEventHandler()->ProcessEvent(event
);
3432 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3434 // Strangly enough, some controls get set focus events when they are being
3435 // deleted, even if they already had focus before.
3436 if ( m_isBeingDeleted
)
3441 // notify the parent keeping track of focus for the kbd navigation
3442 // purposes that we got it
3443 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3444 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3450 m_caret
->OnSetFocus();
3452 #endif // wxUSE_CARET
3455 // If it's a wxTextCtrl don't send the event as it will be done
3456 // after the control gets to process it from EN_FOCUS handler
3457 if ( wxDynamicCastThis(wxTextCtrl
) )
3461 #endif // wxUSE_TEXTCTRL
3463 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3464 event
.SetEventObject(this);
3466 // wxFindWinFromHandle() may return NULL, it is ok
3467 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3469 return GetEventHandler()->ProcessEvent(event
);
3472 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3478 m_caret
->OnKillFocus();
3480 #endif // wxUSE_CARET
3483 // If it's a wxTextCtrl don't send the event as it will be done
3484 // after the control gets to process it.
3485 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3492 // Don't send the event when in the process of being deleted. This can
3493 // only cause problems if the event handler tries to access the object.
3494 if ( m_isBeingDeleted
)
3499 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3500 event
.SetEventObject(this);
3502 // wxFindWinFromHandle() may return NULL, it is ok
3503 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3505 return GetEventHandler()->ProcessEvent(event
);
3508 // ---------------------------------------------------------------------------
3510 // ---------------------------------------------------------------------------
3512 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3514 wxShowEvent
event(GetId(), show
);
3515 event
.m_eventObject
= this;
3517 return GetEventHandler()->ProcessEvent(event
);
3520 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3522 wxInitDialogEvent
event(GetId());
3523 event
.m_eventObject
= this;
3525 return GetEventHandler()->ProcessEvent(event
);
3528 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3530 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3531 wxUnusedVar(wParam
);
3533 #else // __WXMICROWIN__
3534 HDROP hFilesInfo
= (HDROP
) wParam
;
3536 // Get the total number of files dropped
3537 UINT gwFilesDropped
= ::DragQueryFile
3545 wxString
*files
= new wxString
[gwFilesDropped
];
3546 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3548 // first get the needed buffer length (+1 for terminating NUL)
3549 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3551 // and now get the file name
3552 ::DragQueryFile(hFilesInfo
, wIndex
,
3553 wxStringBuffer(files
[wIndex
], len
), len
);
3555 DragFinish (hFilesInfo
);
3557 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3558 event
.m_eventObject
= this;
3561 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3562 event
.m_pos
.x
= dropPoint
.x
;
3563 event
.m_pos
.y
= dropPoint
.y
;
3565 return GetEventHandler()->ProcessEvent(event
);
3570 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3572 int WXUNUSED(mouseMsg
))
3574 #ifndef __WXMICROWIN__
3575 // the logic is as follows:
3576 // -1. don't set cursor for non client area, including but not limited to
3577 // the title bar, scrollbars, &c
3578 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3579 // 1. if we have the cursor set it unless wxIsBusy()
3580 // 2. if we're a top level window, set some cursor anyhow
3581 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3583 if ( nHitTest
!= HTCLIENT
)
3588 HCURSOR hcursor
= 0;
3590 // first ask the user code - it may wish to set the cursor in some very
3591 // specific way (for example, depending on the current position)
3593 if ( !::GetCursorPos(&pt
) )
3595 wxLogLastError(wxT("GetCursorPos"));
3600 ScreenToClient(&x
, &y
);
3601 wxSetCursorEvent
event(x
, y
);
3603 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3604 if ( processedEvtSetCursor
&& event
.HasCursor() )
3606 hcursor
= GetHcursorOf(event
.GetCursor());
3611 bool isBusy
= wxIsBusy();
3613 // the test for processedEvtSetCursor is here to prevent using m_cursor
3614 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3615 // it - this is a way to say that our cursor shouldn't be used for this
3617 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3619 hcursor
= GetHcursorOf(m_cursor
);
3626 hcursor
= wxGetCurrentBusyCursor();
3628 else if ( !hcursor
)
3630 const wxCursor
*cursor
= wxGetGlobalCursor();
3631 if ( cursor
&& cursor
->Ok() )
3633 hcursor
= GetHcursorOf(*cursor
);
3641 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3643 ::SetCursor(hcursor
);
3645 // cursor set, stop here
3648 #endif // __WXMICROWIN__
3650 // pass up the window chain
3654 // ---------------------------------------------------------------------------
3655 // owner drawn stuff
3656 // ---------------------------------------------------------------------------
3658 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3659 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3660 #define WXUNUSED_UNLESS_ODRAWN(param) param
3662 #define WXUNUSED_UNLESS_ODRAWN(param)
3666 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3667 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3669 #if wxUSE_OWNER_DRAWN
3671 #if wxUSE_MENUS_NATIVE
3672 // is it a menu item?
3673 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3674 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3676 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3678 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), false );
3680 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3681 // the DC from being released
3682 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3683 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3684 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3685 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3687 return pMenuItem
->OnDrawItem
3691 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3692 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3695 #endif // wxUSE_MENUS_NATIVE
3697 #endif // USE_OWNER_DRAWN
3699 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3701 #if wxUSE_OWNER_DRAWN
3702 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3703 #else // !wxUSE_OWNER_DRAWN
3704 // we may still have owner-drawn buttons internally because we have to make
3705 // them owner-drawn to support colour change
3708 wxDynamicCast(FindItem(id
), wxButton
)
3713 #endif // USE_OWNER_DRAWN
3717 return item
->MSWOnDraw(itemStruct
);
3720 #endif // wxUSE_CONTROLS
3726 wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3727 WXMEASUREITEMSTRUCT
*
3728 WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3730 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3731 // is it a menu item?
3732 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3733 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3735 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3737 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), false );
3740 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3742 pMeasureStruct
->itemWidth
= w
;
3743 pMeasureStruct
->itemHeight
= h
;
3748 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3751 return item
->MSWOnMeasure(itemStruct
);
3753 #endif // wxUSE_OWNER_DRAWN
3758 // ---------------------------------------------------------------------------
3759 // colours and palettes
3760 // ---------------------------------------------------------------------------
3762 bool wxWindowMSW::HandleSysColorChange()
3764 wxSysColourChangedEvent event
;
3765 event
.SetEventObject(this);
3767 (void)GetEventHandler()->ProcessEvent(event
);
3769 // always let the system carry on the default processing to allow the
3770 // native controls to react to the colours update
3774 bool wxWindowMSW::HandleDisplayChange()
3776 wxDisplayChangedEvent event
;
3777 event
.SetEventObject(this);
3779 return GetEventHandler()->ProcessEvent(event
);
3782 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3790 #ifndef __WXMICROWIN__
3791 WXHBRUSH hBrush
= 0;
3796 if ( nCtlColor
== CTLCOLOR_DLG
)
3799 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3804 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, true);
3806 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3808 #endif // wxUSE_CONTROLS
3814 #else // __WXMICROWIN__
3819 // Define for each class of dialog and control
3820 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3821 WXHWND
WXUNUSED(hWnd
),
3822 WXUINT
WXUNUSED(nCtlColor
),
3823 WXUINT
WXUNUSED(message
),
3824 WXWPARAM
WXUNUSED(wParam
),
3825 WXLPARAM
WXUNUSED(lParam
))
3830 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3833 // same as below except we don't respond to our own messages
3834 if ( hWndPalChange
!= GetHWND() )
3836 // check to see if we our our parents have a custom palette
3837 wxWindowMSW
*win
= this;
3838 while ( win
&& !win
->HasCustomPalette() )
3840 win
= win
->GetParent();
3843 if ( win
&& win
->HasCustomPalette() )
3845 // realize the palette to see whether redrawing is needed
3846 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3847 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3848 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3850 int result
= ::RealizePalette(hdc
);
3852 // restore the palette (before releasing the DC)
3853 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3854 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3855 ::RealizePalette(hdc
);
3856 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3858 // now check for the need to redraw
3860 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3864 #endif // wxUSE_PALETTE
3866 wxPaletteChangedEvent
event(GetId());
3867 event
.SetEventObject(this);
3868 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3870 return GetEventHandler()->ProcessEvent(event
);
3873 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3875 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3876 event
.SetEventObject(this);
3878 return GetEventHandler()->ProcessEvent(event
);
3881 bool wxWindowMSW::HandleQueryNewPalette()
3885 // check to see if we our our parents have a custom palette
3886 wxWindowMSW
*win
= this;
3887 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3888 if (win
->HasCustomPalette()) {
3889 /* realize the palette to see whether redrawing is needed */
3890 HDC hdc
= ::GetDC((HWND
) GetHWND());
3891 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3892 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3894 int result
= ::RealizePalette(hdc
);
3895 /* restore the palette (before releasing the DC) */
3896 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3897 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3898 ::RealizePalette(hdc
);
3899 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3900 /* now check for the need to redraw */
3902 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3904 #endif // wxUSE_PALETTE
3906 wxQueryNewPaletteEvent
event(GetId());
3907 event
.SetEventObject(this);
3909 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3912 // Responds to colour changes: passes event on to children.
3913 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3915 // the top level window also reset the standard colour map as it might have
3916 // changed (there is no need to do it for the non top level windows as we
3917 // only have to do it once)
3921 gs_hasStdCmap
= false;
3923 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3926 // Only propagate to non-top-level windows because Windows already
3927 // sends this event to all top-level ones
3928 wxWindow
*win
= node
->GetData();
3929 if ( !win
->IsTopLevel() )
3931 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3932 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3933 // the standard controls
3934 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3937 node
= node
->GetNext();
3941 extern wxCOLORMAP
*wxGetStdColourMap()
3943 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3944 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3946 if ( !gs_hasStdCmap
)
3948 static bool s_coloursInit
= false;
3950 if ( !s_coloursInit
)
3952 // When a bitmap is loaded, the RGB values can change (apparently
3953 // because Windows adjusts them to care for the old programs always
3954 // using 0xc0c0c0 while the transparent colour for the new Windows
3955 // versions is different). But we do this adjustment ourselves so
3956 // we want to avoid Windows' "help" and for this we need to have a
3957 // reference bitmap which can tell us what the RGB values change
3959 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3960 if ( stdColourBitmap
.Ok() )
3962 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3963 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3964 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3967 memDC
.SelectObject(stdColourBitmap
);
3970 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3972 memDC
.GetPixel(i
, 0, &colour
);
3973 s_stdColours
[i
] = wxColourToRGB(colour
);
3976 else // wxBITMAP_STD_COLOURS couldn't be loaded
3978 s_stdColours
[0] = RGB(000,000,000); // black
3979 s_stdColours
[1] = RGB(128,128,128); // dark grey
3980 s_stdColours
[2] = RGB(192,192,192); // light grey
3981 s_stdColours
[3] = RGB(255,255,255); // white
3982 //s_stdColours[4] = RGB(000,000,255); // blue
3983 //s_stdColours[5] = RGB(255,000,255); // magenta
3986 s_coloursInit
= true;
3989 gs_hasStdCmap
= true;
3991 // create the colour map
3992 #define INIT_CMAP_ENTRY(col) \
3993 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3994 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3996 INIT_CMAP_ENTRY(BTNTEXT
);
3997 INIT_CMAP_ENTRY(BTNSHADOW
);
3998 INIT_CMAP_ENTRY(BTNFACE
);
3999 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4001 #undef INIT_CMAP_ENTRY
4007 // ---------------------------------------------------------------------------
4009 // ---------------------------------------------------------------------------
4011 bool wxWindowMSW::HandlePaint()
4013 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
4016 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4018 wxLogLastError(wxT("CreateRectRgn"));
4019 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4020 wxLogLastError(wxT("GetUpdateRgn"));
4022 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4024 wxPaintEvent
event(m_windowId
);
4025 event
.SetEventObject(this);
4027 bool processed
= GetEventHandler()->ProcessEvent(event
);
4029 // note that we must generate NC event after the normal one as otherwise
4030 // BeginPaint() will happily overwrite our decorations with the background
4032 wxNcPaintEvent
eventNc(m_windowId
);
4033 eventNc
.SetEventObject(this);
4034 GetEventHandler()->ProcessEvent(eventNc
);
4039 // Can be called from an application's OnPaint handler
4040 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4042 #ifdef __WXUNIVERSAL__
4045 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
4048 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4053 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4055 // Prevents flicker when dragging
4056 if ( ::IsIconic(GetHwnd()) )
4060 if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
4065 if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
4067 if (wxUxThemeEngine::Get())
4069 WXHTHEME hTheme
= wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L
"TAB");
4073 ::GetClientRect((HWND
) GetHWND(), (RECT
*) & rect
);
4074 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme
, hdc
, 10 /* TABP_BODY */, 0, &rect
, &rect
);
4075 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme
);
4085 dc
.SetWindow((wxWindow
*)this);
4088 wxEraseEvent
event(m_windowId
, &dc
);
4089 event
.SetEventObject(this);
4090 bool rc
= GetEventHandler()->ProcessEvent(event
);
4094 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4095 dc
.SelectOldObjects(hdc
);
4100 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4103 ::GetClientRect(GetHwnd(), &rect
);
4105 wxColour
backgroundColour( GetBackgroundColour());
4106 COLORREF ref
= PALETTERGB(backgroundColour
.Red(),
4107 backgroundColour
.Green(),
4108 backgroundColour
.Blue());
4109 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
4111 wxLogLastError(wxT("CreateSolidBrush"));
4113 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
4116 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
4119 ::FillRect(hdc
, &rect
, hBrush
);
4120 ::DeleteObject(hBrush
);
4123 ::SetMapMode(hdc
, mode
);
4127 // ---------------------------------------------------------------------------
4128 // moving and resizing
4129 // ---------------------------------------------------------------------------
4131 bool wxWindowMSW::HandleMinimize()
4133 wxIconizeEvent
event(m_windowId
);
4134 event
.SetEventObject(this);
4136 return GetEventHandler()->ProcessEvent(event
);
4139 bool wxWindowMSW::HandleMaximize()
4141 wxMaximizeEvent
event(m_windowId
);
4142 event
.SetEventObject(this);
4144 return GetEventHandler()->ProcessEvent(event
);
4147 bool wxWindowMSW::HandleMove(int x
, int y
)
4149 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
4150 event
.SetEventObject(this);
4152 return GetEventHandler()->ProcessEvent(event
);
4155 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4157 wxMoveEvent
event(rect
, m_windowId
);
4158 event
.SetEventObject(this);
4160 bool rc
= GetEventHandler()->ProcessEvent(event
);
4162 rect
= event
.GetRect();
4166 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4168 bool processed
= false;
4173 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4174 // fall through nevertheless
4178 // we're not interested in these messages at all
4181 case SIZE_MINIMIZED
:
4182 processed
= HandleMinimize();
4185 case SIZE_MAXIMIZED
:
4186 /* processed = */ HandleMaximize();
4187 // fall through to send a normal size event as well
4190 // don't use w and h parameters as they specify the client size
4191 // while according to the docs EVT_SIZE handler is supposed to
4192 // receive the total size
4193 wxSizeEvent
event(GetSize(), m_windowId
);
4194 event
.SetEventObject(this);
4196 processed
= GetEventHandler()->ProcessEvent(event
);
4202 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4204 wxSizeEvent
event(rect
, m_windowId
);
4205 event
.SetEventObject(this);
4207 bool rc
= GetEventHandler()->ProcessEvent(event
);
4209 rect
= event
.GetRect();
4213 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
4216 wxUnusedVar(mmInfo
);
4219 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4223 int minWidth
= GetMinWidth(),
4224 minHeight
= GetMinHeight(),
4225 maxWidth
= GetMaxWidth(),
4226 maxHeight
= GetMaxHeight();
4228 if ( minWidth
!= wxDefaultCoord
)
4230 info
->ptMinTrackSize
.x
= minWidth
;
4234 if ( minHeight
!= wxDefaultCoord
)
4236 info
->ptMinTrackSize
.y
= minHeight
;
4240 if ( maxWidth
!= wxDefaultCoord
)
4242 info
->ptMaxTrackSize
.x
= maxWidth
;
4246 if ( maxHeight
!= wxDefaultCoord
)
4248 info
->ptMaxTrackSize
.y
= maxHeight
;
4256 // ---------------------------------------------------------------------------
4258 // ---------------------------------------------------------------------------
4260 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4262 #if wxUSE_MENUS_NATIVE
4263 if ( !cmd
&& wxCurrentPopupMenu
)
4265 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4266 wxCurrentPopupMenu
= NULL
;
4268 return popupMenu
->MSWCommand(cmd
, id
);
4270 #endif // wxUSE_MENUS_NATIVE
4272 wxWindow
*win
= NULL
;
4274 // first try to find it from HWND - this works even with the broken
4275 // programs using the same ids for different controls
4278 win
= wxFindWinFromHandle(control
);
4284 // must cast to a signed type before comparing with other ids!
4285 win
= FindItem((signed short)id
);
4290 return win
->MSWCommand(cmd
, id
);
4293 // the messages sent from the in-place edit control used by the treectrl
4294 // for label editing have id == 0, but they should _not_ be treated as menu
4295 // messages (they are EN_XXX ones, in fact) so don't translate anything
4296 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4299 // If no child window, it may be an accelerator, e.g. for a popup menu
4302 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4303 event
.SetEventObject(this);
4307 return GetEventHandler()->ProcessEvent(event
);
4309 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4312 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4313 // notifications to its parent which we want to reflect back to
4315 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4316 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4319 #endif // wxUSE_SPINCTRL
4324 // ---------------------------------------------------------------------------
4326 // ---------------------------------------------------------------------------
4328 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4332 // our client coords are not quite the same as Windows ones
4333 wxPoint pt
= GetClientAreaOrigin();
4334 event
.m_x
= x
- pt
.x
;
4335 event
.m_y
= y
- pt
.y
;
4337 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4338 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4339 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4340 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4341 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4342 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4343 // Returns different negative values on WinME and WinNT,
4344 // so simply test for negative value.
4345 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4348 event
.SetTimestamp(::GetMessageTime());
4351 event
.m_eventObject
= this;
4352 event
.SetId(GetId());
4354 #if wxUSE_MOUSEEVENT_HACK
4357 m_lastMouseEvent
= event
.GetEventType();
4358 #endif // wxUSE_MOUSEEVENT_HACK
4361 // Windows doesn't send the mouse events to the static controls (which are
4362 // transparent in the sense that their WM_NCHITTEST handler returns
4363 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4364 // and so we manually check if we don't have a child window under mouse and if
4365 // we do, send the event to it instead of the window Windows had sent WM_XXX
4368 // Notice that this is not done for the mouse move events because this could
4369 // (would?) be too slow, but only for clicks which means that the static texts
4370 // still don't get move, enter nor leave events.
4371 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4373 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4375 // first try to find a non transparent child: this allows us to send events
4376 // to a static text which is inside a static box, for example
4377 POINT pt
= { *x
, *y
};
4378 HWND hwnd
= GetHwndOf(win
),
4382 hwndUnderMouse
= ::ChildWindowFromPoint
4388 hwndUnderMouse
= ::ChildWindowFromPointEx
4398 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4400 // now try any child window at all
4401 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4404 // check that we have a child window which is susceptible to receive mouse
4405 // events: for this it must be shown and enabled
4406 if ( hwndUnderMouse
&&
4407 hwndUnderMouse
!= hwnd
&&
4408 ::IsWindowVisible(hwndUnderMouse
) &&
4409 ::IsWindowEnabled(hwndUnderMouse
) )
4411 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4412 if ( winUnderMouse
)
4414 // translate the mouse coords to the other window coords
4415 win
->ClientToScreen(x
, y
);
4416 winUnderMouse
->ScreenToClient(x
, y
);
4418 win
= winUnderMouse
;
4425 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4427 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4428 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4429 // from the message id and take the value in the table to get wxWin event
4431 static const wxEventType eventsMouse
[] =
4445 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4446 InitMouseEvent(event
, x
, y
, flags
);
4448 return GetEventHandler()->ProcessEvent(event
);
4451 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4453 if ( !m_mouseInWindow
)
4455 // it would be wrong to assume that just because we get a mouse move
4456 // event that the mouse is inside the window: although this is usually
4457 // true, it is not if we had captured the mouse, so we need to check
4458 // the mouse coordinates here
4459 if ( !HasCapture() || IsMouseInWindow() )
4461 // Generate an ENTER event
4462 m_mouseInWindow
= true;
4463 #if _WIN32_WINNT >= 0x0400
4465 TRACKMOUSEEVENT trackinfo
;
4467 trackinfo
.cbSize
= sizeof(trackinfo
);
4468 trackinfo
.dwFlags
= TME_LEAVE
;
4469 trackinfo
.hwndTrack
= GetHwnd();
4470 //Use the commctrl.h _TrackMouseEvent, which will call the
4471 // appropriate TrackMouseEvent or emulate it ( win95 )
4472 // else we need _WIN32_WINNT >= 0x0400
4473 _TrackMouseEvent(&trackinfo
);
4476 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4477 InitMouseEvent(event
, x
, y
, flags
);
4479 (void)GetEventHandler()->ProcessEvent(event
);
4483 #if wxUSE_MOUSEEVENT_HACK
4484 // Window gets a click down message followed by a mouse move message even
4485 // if position isn't changed! We want to discard the trailing move event
4486 // if x and y are the same.
4487 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4488 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4489 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4490 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4492 m_lastMouseEvent
= wxEVT_MOTION
;
4496 #endif // wxUSE_MOUSEEVENT_HACK
4498 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4502 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4504 #if wxUSE_MOUSEWHEEL
4505 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4506 InitMouseEvent(event
,
4507 GET_X_LPARAM(lParam
),
4508 GET_Y_LPARAM(lParam
),
4510 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4511 event
.m_wheelDelta
= WHEEL_DELTA
;
4513 static int s_linesPerRotation
= -1;
4514 if ( s_linesPerRotation
== -1 )
4516 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4517 &s_linesPerRotation
, 0))
4519 // this is not supposed to happen
4520 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4522 // the default is 3, so use it if SystemParametersInfo() failed
4523 s_linesPerRotation
= 3;
4527 event
.m_linesPerAction
= s_linesPerRotation
;
4528 return GetEventHandler()->ProcessEvent(event
);
4539 // ---------------------------------------------------------------------------
4540 // keyboard handling
4541 // ---------------------------------------------------------------------------
4543 // create the key event of the given type for the given key - used by
4544 // HandleChar and HandleKeyDown/Up
4545 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4548 WXWPARAM wParam
) const
4550 wxKeyEvent
event(evType
);
4551 event
.SetId(GetId());
4552 event
.m_shiftDown
= wxIsShiftDown();
4553 event
.m_controlDown
= wxIsCtrlDown();
4554 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4556 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4557 event
.m_keyCode
= id
;
4559 event
.m_uniChar
= wParam
;
4561 event
.m_rawCode
= (wxUint32
) wParam
;
4562 event
.m_rawFlags
= (wxUint32
) lParam
;
4564 event
.SetTimestamp(::GetMessageTime());
4567 // translate the position to client coords
4571 GetWindowRect(GetHwnd(),&rect
);
4581 // isASCII is true only when we're called from WM_CHAR handler and not from
4583 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4588 // If 1 -> 26, translate to either special keycode or just set
4589 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4590 // ControlDown() == true.
4592 if ( (id
> 0) && (id
< 27) )
4614 else // we're called from WM_KEYDOWN
4616 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4619 // it's ASCII and will be processed here only when called from
4620 // WM_CHAR (i.e. when isASCII = true), don't process it now
4625 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4627 // the alphanumeric keys produced by pressing AltGr+something on European
4628 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4629 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4630 // alphanumeric, so pretend that there are no modifiers at all (the
4631 // KEY_DOWN event would still have the correct modifiers if they're really
4633 if ( event
.m_controlDown
&& event
.m_altDown
&&
4634 (id
>= 32 && id
< 256) )
4636 event
.m_controlDown
=
4637 event
.m_altDown
= false;
4640 return GetEventHandler()->ProcessEvent(event
);
4643 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4645 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4649 // normal ASCII char
4653 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4655 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4656 if ( GetEventHandler()->ProcessEvent(event
) )
4665 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4667 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4671 // normal ASCII char
4675 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4677 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4678 if ( GetEventHandler()->ProcessEvent(event
) )
4685 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4687 // FIXME: implement GetMenuItemCount for WinCE, possibly
4688 // in terms of GetMenuItemInfo
4690 const HMENU hmenu
= (HMENU
)lParam
;
4694 mii
.cbSize
= sizeof(MENUITEMINFO
);
4695 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4697 // find if we have this letter in any owner drawn item
4698 const int count
= ::GetMenuItemCount(hmenu
);
4699 for ( int i
= 0; i
< count
; i
++ )
4701 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4703 if ( mii
.fType
== MFT_OWNERDRAW
)
4705 // dwItemData member of the MENUITEMINFO is a
4706 // pointer to the associated wxMenuItem -- see the
4707 // menu creation code
4708 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4710 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4713 if ( *p
== _T('&') )
4715 // this is not the accel char, find the real one
4716 p
= wxStrchr(p
+ 1, _T('&'));
4718 else // got the accel char
4720 // FIXME-UNICODE: this comparison doesn't risk to work
4721 // for non ASCII accelerator characters I'm afraid, but
4723 if ( wxToupper(*p
) == chAccel
)
4729 // this one doesn't match
4736 else // failed to get the menu text?
4738 // it's not fatal, so don't show error, but still log
4740 wxLogLastError(_T("GetMenuItemInfo"));
4744 wxUnusedVar(chAccel
);
4745 wxUnusedVar(lParam
);
4750 // ---------------------------------------------------------------------------
4752 // ---------------------------------------------------------------------------
4754 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4758 if ( flags
& JOY_BUTTON1CHG
)
4759 change
= wxJOY_BUTTON1
;
4760 if ( flags
& JOY_BUTTON2CHG
)
4761 change
= wxJOY_BUTTON2
;
4762 if ( flags
& JOY_BUTTON3CHG
)
4763 change
= wxJOY_BUTTON3
;
4764 if ( flags
& JOY_BUTTON4CHG
)
4765 change
= wxJOY_BUTTON4
;
4768 if ( flags
& JOY_BUTTON1
)
4769 buttons
|= wxJOY_BUTTON1
;
4770 if ( flags
& JOY_BUTTON2
)
4771 buttons
|= wxJOY_BUTTON2
;
4772 if ( flags
& JOY_BUTTON3
)
4773 buttons
|= wxJOY_BUTTON3
;
4774 if ( flags
& JOY_BUTTON4
)
4775 buttons
|= wxJOY_BUTTON4
;
4777 // the event ids aren't consecutive so we can't use table based lookup
4779 wxEventType eventType
;
4784 eventType
= wxEVT_JOY_MOVE
;
4789 eventType
= wxEVT_JOY_MOVE
;
4794 eventType
= wxEVT_JOY_ZMOVE
;
4799 eventType
= wxEVT_JOY_ZMOVE
;
4802 case MM_JOY1BUTTONDOWN
:
4804 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4807 case MM_JOY2BUTTONDOWN
:
4809 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4812 case MM_JOY1BUTTONUP
:
4814 eventType
= wxEVT_JOY_BUTTON_UP
;
4817 case MM_JOY2BUTTONUP
:
4819 eventType
= wxEVT_JOY_BUTTON_UP
;
4823 wxFAIL_MSG(wxT("no such joystick event"));
4828 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4829 event
.SetPosition(wxPoint(x
, y
));
4830 event
.SetEventObject(this);
4832 return GetEventHandler()->ProcessEvent(event
);
4842 // ---------------------------------------------------------------------------
4844 // ---------------------------------------------------------------------------
4846 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4847 WXWORD pos
, WXHWND control
)
4849 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
4851 wxWindow
*child
= wxFindWinFromHandle(control
);
4853 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4856 wxScrollWinEvent event
;
4857 event
.SetPosition(pos
);
4858 event
.SetOrientation(orientation
);
4859 event
.m_eventObject
= this;
4864 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4868 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4872 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4876 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4880 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4884 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4887 case SB_THUMBPOSITION
:
4889 // under Win32, the scrollbar range and position are 32 bit integers,
4890 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4891 // explicitly query the scrollbar for the correct position (this must
4892 // be done only for these two SB_ events as they are the only one
4893 // carrying the scrollbar position)
4895 WinStruct
<SCROLLINFO
> scrollInfo
;
4896 scrollInfo
.fMask
= SIF_TRACKPOS
;
4898 if ( !::GetScrollInfo(GetHwnd(),
4899 orientation
== wxHORIZONTAL
? SB_HORZ
4903 // Not neccessarily an error, if there are no scrollbars yet.
4904 // wxLogLastError(_T("GetScrollInfo"));
4907 event
.SetPosition(scrollInfo
.nTrackPos
);
4910 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4911 ? wxEVT_SCROLLWIN_THUMBRELEASE
4912 : wxEVT_SCROLLWIN_THUMBTRACK
;
4919 return GetEventHandler()->ProcessEvent(event
);
4922 // ===========================================================================
4924 // ===========================================================================
4926 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
4929 HDC dc
= ::GetDC((HWND
) wnd
);
4932 // the_font.UseResource();
4933 // the_font.RealizeResource();
4934 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
4936 was
= (HFONT
) SelectObject(dc
,fnt
);
4938 GetTextMetrics(dc
, &tm
);
4941 SelectObject(dc
,was
);
4943 ReleaseDC((HWND
)wnd
, dc
);
4946 *x
= tm
.tmAveCharWidth
;
4948 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4950 // the_font.ReleaseResource();
4953 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4954 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4955 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
4960 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4961 case VK_BACK
: id
= WXK_BACK
; break;
4962 case VK_TAB
: id
= WXK_TAB
; break;
4963 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4964 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4965 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4966 case VK_MENU
: id
= WXK_MENU
; break;
4967 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4968 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4969 case VK_SPACE
: id
= WXK_SPACE
; break;
4970 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4971 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4972 case VK_NEXT
: id
= WXK_NEXT
; break;
4973 case VK_END
: id
= WXK_END
; break;
4974 case VK_HOME
: id
= WXK_HOME
; break;
4975 case VK_LEFT
: id
= WXK_LEFT
; break;
4976 case VK_UP
: id
= WXK_UP
; break;
4977 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4978 case VK_DOWN
: id
= WXK_DOWN
; break;
4979 case VK_SELECT
: id
= WXK_SELECT
; break;
4980 case VK_PRINT
: id
= WXK_PRINT
; break;
4981 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4982 case VK_INSERT
: id
= WXK_INSERT
; break;
4983 case VK_DELETE
: id
= WXK_DELETE
; break;
4984 case VK_HELP
: id
= WXK_HELP
; break;
4985 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4986 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4987 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4988 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4989 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4990 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4991 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4992 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4993 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4994 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4995 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4996 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4997 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4998 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4999 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
5000 case VK_F1
: id
= WXK_F1
; break;
5001 case VK_F2
: id
= WXK_F2
; break;
5002 case VK_F3
: id
= WXK_F3
; break;
5003 case VK_F4
: id
= WXK_F4
; break;
5004 case VK_F5
: id
= WXK_F5
; break;
5005 case VK_F6
: id
= WXK_F6
; break;
5006 case VK_F7
: id
= WXK_F7
; break;
5007 case VK_F8
: id
= WXK_F8
; break;
5008 case VK_F9
: id
= WXK_F9
; break;
5009 case VK_F10
: id
= WXK_F10
; break;
5010 case VK_F11
: id
= WXK_F11
; break;
5011 case VK_F12
: id
= WXK_F12
; break;
5012 case VK_F13
: id
= WXK_F13
; break;
5013 case VK_F14
: id
= WXK_F14
; break;
5014 case VK_F15
: id
= WXK_F15
; break;
5015 case VK_F16
: id
= WXK_F16
; break;
5016 case VK_F17
: id
= WXK_F17
; break;
5017 case VK_F18
: id
= WXK_F18
; break;
5018 case VK_F19
: id
= WXK_F19
; break;
5019 case VK_F20
: id
= WXK_F20
; break;
5020 case VK_F21
: id
= WXK_F21
; break;
5021 case VK_F22
: id
= WXK_F22
; break;
5022 case VK_F23
: id
= WXK_F23
; break;
5023 case VK_F24
: id
= WXK_F24
; break;
5024 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
5025 case VK_SCROLL
: id
= WXK_SCROLL
; break;
5027 case VK_OEM_1
: id
= ';'; break;
5028 case VK_OEM_PLUS
: id
= '+'; break;
5029 case VK_OEM_COMMA
: id
= ','; break;
5030 case VK_OEM_MINUS
: id
= '-'; break;
5031 case VK_OEM_PERIOD
: id
= '.'; break;
5032 case VK_OEM_2
: id
= '/'; break;
5033 case VK_OEM_3
: id
= '~'; break;
5034 case VK_OEM_4
: id
= '['; break;
5035 case VK_OEM_5
: id
= '\\'; break;
5036 case VK_OEM_6
: id
= ']'; break;
5037 case VK_OEM_7
: id
= '\''; break;
5040 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
5041 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
5042 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
5043 #endif // VK_APPS defined
5046 // the same key is sent for both the "return" key on the main
5047 // keyboard and the numeric keypad but we want to distinguish
5048 // between them: we do this using the "extended" bit (24) of lParam
5049 id
= lParam
& (1 << 24) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5059 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5065 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5066 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5067 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5068 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5069 case WXK_ALT
: keySym
= VK_MENU
; break;
5070 case WXK_MENU
: keySym
= VK_MENU
; break;
5071 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5072 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5073 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5074 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5075 case WXK_END
: keySym
= VK_END
; break;
5076 case WXK_HOME
: keySym
= VK_HOME
; break;
5077 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5078 case WXK_UP
: keySym
= VK_UP
; break;
5079 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5080 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5081 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5082 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5083 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5084 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5085 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5086 case WXK_HELP
: keySym
= VK_HELP
; break;
5087 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5088 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5089 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5090 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5091 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5092 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5093 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5094 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5095 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5096 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5097 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5098 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5099 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5100 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5101 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5102 case WXK_F1
: keySym
= VK_F1
; break;
5103 case WXK_F2
: keySym
= VK_F2
; break;
5104 case WXK_F3
: keySym
= VK_F3
; break;
5105 case WXK_F4
: keySym
= VK_F4
; break;
5106 case WXK_F5
: keySym
= VK_F5
; break;
5107 case WXK_F6
: keySym
= VK_F6
; break;
5108 case WXK_F7
: keySym
= VK_F7
; break;
5109 case WXK_F8
: keySym
= VK_F8
; break;
5110 case WXK_F9
: keySym
= VK_F9
; break;
5111 case WXK_F10
: keySym
= VK_F10
; break;
5112 case WXK_F11
: keySym
= VK_F11
; break;
5113 case WXK_F12
: keySym
= VK_F12
; break;
5114 case WXK_F13
: keySym
= VK_F13
; break;
5115 case WXK_F14
: keySym
= VK_F14
; break;
5116 case WXK_F15
: keySym
= VK_F15
; break;
5117 case WXK_F16
: keySym
= VK_F16
; break;
5118 case WXK_F17
: keySym
= VK_F17
; break;
5119 case WXK_F18
: keySym
= VK_F18
; break;
5120 case WXK_F19
: keySym
= VK_F19
; break;
5121 case WXK_F20
: keySym
= VK_F20
; break;
5122 case WXK_F21
: keySym
= VK_F21
; break;
5123 case WXK_F22
: keySym
= VK_F22
; break;
5124 case WXK_F23
: keySym
= VK_F23
; break;
5125 case WXK_F24
: keySym
= VK_F24
; break;
5126 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5127 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5138 bool wxGetKeyState(wxKeyCode key
)
5141 int vkey
= wxCharCodeWXToMSW(key
, &bVirtual
);
5149 // get the toggle state of the special key
5150 state
= GetKeyState(vkey
);
5154 // Get the current state of the physical key
5155 state
= GetAsyncKeyState(vkey
);
5158 // if the most significant bit is set then the key is down
5159 return ( state
& 0x0001 ) != 0;
5162 wxWindow
*wxGetActiveWindow()
5164 HWND hWnd
= GetActiveWindow();
5167 return wxFindWinFromHandle((WXHWND
) hWnd
);
5172 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5174 HWND hwnd
= (HWND
)hWnd
;
5176 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5177 // by code in msw/radiobox.cpp), for all the others we just search up the
5179 wxWindow
*win
= (wxWindow
*)NULL
;
5182 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5186 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5187 // wxWindow class which overrides WM_GETDLGCODE processing to
5188 // do it as well, win would be already non NULL
5189 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5191 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5193 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5194 #endif // wxUSE_RADIOBOX
5196 // spin control text buddy window should be mapped to spin ctrl
5197 // itself so try it too
5198 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5201 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5203 #endif // wxUSE_SPINCTRL
5207 while ( hwnd
&& !win
)
5209 // this is a really ugly hack needed to avoid mistakenly returning the
5210 // parent frame wxWindow for the find/replace modeless dialog HWND -
5211 // this, in turn, is needed to call IsDialogMessage() from
5212 // wxApp::ProcessMessage() as for this we must return NULL from here
5214 // FIXME: this is clearly not the best way to do it but I think we'll
5215 // need to change HWND <-> wxWindow code more heavily than I can
5216 // do it now to fix it
5217 #ifndef __WXMICROWIN__
5218 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5220 // it's a dialog box, don't go upwards
5225 hwnd
= ::GetParent(hwnd
);
5226 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5232 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5234 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5235 // in active frames and dialogs, regardless of where the focus is.
5236 static HHOOK wxTheKeyboardHook
= 0;
5237 static FARPROC wxTheKeyboardHookProc
= 0;
5238 int APIENTRY _EXPORT
5239 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5241 void wxSetKeyboardHook(bool doIt
)
5245 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5246 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5248 GetCurrentThreadId()
5249 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5254 UnhookWindowsHookEx(wxTheKeyboardHook
);
5258 int APIENTRY _EXPORT
5259 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5261 DWORD hiWord
= HIWORD(lParam
);
5262 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5264 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5267 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5268 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5269 event
.m_altDown
= true;
5271 event
.m_eventObject
= NULL
;
5272 event
.m_keyCode
= id
;
5273 event
.m_shiftDown
= wxIsShiftDown();
5274 event
.m_controlDown
= wxIsCtrlDown();
5276 event
.SetTimestamp(::GetMessageTime());
5278 wxWindow
*win
= wxGetActiveWindow();
5279 wxEvtHandler
*handler
;
5282 handler
= win
->GetEventHandler();
5283 event
.SetId(win
->GetId());
5288 event
.SetId(wxID_ANY
);
5291 if ( handler
&& handler
->ProcessEvent(event
) )
5299 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5302 #endif // !__WXMICROWIN__
5305 const char *wxGetMessageName(int message
)
5309 case 0x0000: return "WM_NULL";
5310 case 0x0001: return "WM_CREATE";
5311 case 0x0002: return "WM_DESTROY";
5312 case 0x0003: return "WM_MOVE";
5313 case 0x0005: return "WM_SIZE";
5314 case 0x0006: return "WM_ACTIVATE";
5315 case 0x0007: return "WM_SETFOCUS";
5316 case 0x0008: return "WM_KILLFOCUS";
5317 case 0x000A: return "WM_ENABLE";
5318 case 0x000B: return "WM_SETREDRAW";
5319 case 0x000C: return "WM_SETTEXT";
5320 case 0x000D: return "WM_GETTEXT";
5321 case 0x000E: return "WM_GETTEXTLENGTH";
5322 case 0x000F: return "WM_PAINT";
5323 case 0x0010: return "WM_CLOSE";
5324 case 0x0011: return "WM_QUERYENDSESSION";
5325 case 0x0012: return "WM_QUIT";
5326 case 0x0013: return "WM_QUERYOPEN";
5327 case 0x0014: return "WM_ERASEBKGND";
5328 case 0x0015: return "WM_SYSCOLORCHANGE";
5329 case 0x0016: return "WM_ENDSESSION";
5330 case 0x0017: return "WM_SYSTEMERROR";
5331 case 0x0018: return "WM_SHOWWINDOW";
5332 case 0x0019: return "WM_CTLCOLOR";
5333 case 0x001A: return "WM_WININICHANGE";
5334 case 0x001B: return "WM_DEVMODECHANGE";
5335 case 0x001C: return "WM_ACTIVATEAPP";
5336 case 0x001D: return "WM_FONTCHANGE";
5337 case 0x001E: return "WM_TIMECHANGE";
5338 case 0x001F: return "WM_CANCELMODE";
5339 case 0x0020: return "WM_SETCURSOR";
5340 case 0x0021: return "WM_MOUSEACTIVATE";
5341 case 0x0022: return "WM_CHILDACTIVATE";
5342 case 0x0023: return "WM_QUEUESYNC";
5343 case 0x0024: return "WM_GETMINMAXINFO";
5344 case 0x0026: return "WM_PAINTICON";
5345 case 0x0027: return "WM_ICONERASEBKGND";
5346 case 0x0028: return "WM_NEXTDLGCTL";
5347 case 0x002A: return "WM_SPOOLERSTATUS";
5348 case 0x002B: return "WM_DRAWITEM";
5349 case 0x002C: return "WM_MEASUREITEM";
5350 case 0x002D: return "WM_DELETEITEM";
5351 case 0x002E: return "WM_VKEYTOITEM";
5352 case 0x002F: return "WM_CHARTOITEM";
5353 case 0x0030: return "WM_SETFONT";
5354 case 0x0031: return "WM_GETFONT";
5355 case 0x0037: return "WM_QUERYDRAGICON";
5356 case 0x0039: return "WM_COMPAREITEM";
5357 case 0x0041: return "WM_COMPACTING";
5358 case 0x0044: return "WM_COMMNOTIFY";
5359 case 0x0046: return "WM_WINDOWPOSCHANGING";
5360 case 0x0047: return "WM_WINDOWPOSCHANGED";
5361 case 0x0048: return "WM_POWER";
5363 case 0x004A: return "WM_COPYDATA";
5364 case 0x004B: return "WM_CANCELJOURNAL";
5365 case 0x004E: return "WM_NOTIFY";
5366 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5367 case 0x0051: return "WM_INPUTLANGCHANGE";
5368 case 0x0052: return "WM_TCARD";
5369 case 0x0053: return "WM_HELP";
5370 case 0x0054: return "WM_USERCHANGED";
5371 case 0x0055: return "WM_NOTIFYFORMAT";
5372 case 0x007B: return "WM_CONTEXTMENU";
5373 case 0x007C: return "WM_STYLECHANGING";
5374 case 0x007D: return "WM_STYLECHANGED";
5375 case 0x007E: return "WM_DISPLAYCHANGE";
5376 case 0x007F: return "WM_GETICON";
5377 case 0x0080: return "WM_SETICON";
5379 case 0x0081: return "WM_NCCREATE";
5380 case 0x0082: return "WM_NCDESTROY";
5381 case 0x0083: return "WM_NCCALCSIZE";
5382 case 0x0084: return "WM_NCHITTEST";
5383 case 0x0085: return "WM_NCPAINT";
5384 case 0x0086: return "WM_NCACTIVATE";
5385 case 0x0087: return "WM_GETDLGCODE";
5386 case 0x00A0: return "WM_NCMOUSEMOVE";
5387 case 0x00A1: return "WM_NCLBUTTONDOWN";
5388 case 0x00A2: return "WM_NCLBUTTONUP";
5389 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5390 case 0x00A4: return "WM_NCRBUTTONDOWN";
5391 case 0x00A5: return "WM_NCRBUTTONUP";
5392 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5393 case 0x00A7: return "WM_NCMBUTTONDOWN";
5394 case 0x00A8: return "WM_NCMBUTTONUP";
5395 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5396 case 0x0100: return "WM_KEYDOWN";
5397 case 0x0101: return "WM_KEYUP";
5398 case 0x0102: return "WM_CHAR";
5399 case 0x0103: return "WM_DEADCHAR";
5400 case 0x0104: return "WM_SYSKEYDOWN";
5401 case 0x0105: return "WM_SYSKEYUP";
5402 case 0x0106: return "WM_SYSCHAR";
5403 case 0x0107: return "WM_SYSDEADCHAR";
5404 case 0x0108: return "WM_KEYLAST";
5406 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5407 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5408 case 0x010F: return "WM_IME_COMPOSITION";
5410 case 0x0110: return "WM_INITDIALOG";
5411 case 0x0111: return "WM_COMMAND";
5412 case 0x0112: return "WM_SYSCOMMAND";
5413 case 0x0113: return "WM_TIMER";
5414 case 0x0114: return "WM_HSCROLL";
5415 case 0x0115: return "WM_VSCROLL";
5416 case 0x0116: return "WM_INITMENU";
5417 case 0x0117: return "WM_INITMENUPOPUP";
5418 case 0x011F: return "WM_MENUSELECT";
5419 case 0x0120: return "WM_MENUCHAR";
5420 case 0x0121: return "WM_ENTERIDLE";
5421 case 0x0200: return "WM_MOUSEMOVE";
5422 case 0x0201: return "WM_LBUTTONDOWN";
5423 case 0x0202: return "WM_LBUTTONUP";
5424 case 0x0203: return "WM_LBUTTONDBLCLK";
5425 case 0x0204: return "WM_RBUTTONDOWN";
5426 case 0x0205: return "WM_RBUTTONUP";
5427 case 0x0206: return "WM_RBUTTONDBLCLK";
5428 case 0x0207: return "WM_MBUTTONDOWN";
5429 case 0x0208: return "WM_MBUTTONUP";
5430 case 0x0209: return "WM_MBUTTONDBLCLK";
5431 case 0x020A: return "WM_MOUSEWHEEL";
5432 case 0x0210: return "WM_PARENTNOTIFY";
5433 case 0x0211: return "WM_ENTERMENULOOP";
5434 case 0x0212: return "WM_EXITMENULOOP";
5436 case 0x0213: return "WM_NEXTMENU";
5437 case 0x0214: return "WM_SIZING";
5438 case 0x0215: return "WM_CAPTURECHANGED";
5439 case 0x0216: return "WM_MOVING";
5440 case 0x0218: return "WM_POWERBROADCAST";
5441 case 0x0219: return "WM_DEVICECHANGE";
5443 case 0x0220: return "WM_MDICREATE";
5444 case 0x0221: return "WM_MDIDESTROY";
5445 case 0x0222: return "WM_MDIACTIVATE";
5446 case 0x0223: return "WM_MDIRESTORE";
5447 case 0x0224: return "WM_MDINEXT";
5448 case 0x0225: return "WM_MDIMAXIMIZE";
5449 case 0x0226: return "WM_MDITILE";
5450 case 0x0227: return "WM_MDICASCADE";
5451 case 0x0228: return "WM_MDIICONARRANGE";
5452 case 0x0229: return "WM_MDIGETACTIVE";
5453 case 0x0230: return "WM_MDISETMENU";
5454 case 0x0233: return "WM_DROPFILES";
5456 case 0x0281: return "WM_IME_SETCONTEXT";
5457 case 0x0282: return "WM_IME_NOTIFY";
5458 case 0x0283: return "WM_IME_CONTROL";
5459 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5460 case 0x0285: return "WM_IME_SELECT";
5461 case 0x0286: return "WM_IME_CHAR";
5462 case 0x0290: return "WM_IME_KEYDOWN";
5463 case 0x0291: return "WM_IME_KEYUP";
5465 case 0x0300: return "WM_CUT";
5466 case 0x0301: return "WM_COPY";
5467 case 0x0302: return "WM_PASTE";
5468 case 0x0303: return "WM_CLEAR";
5469 case 0x0304: return "WM_UNDO";
5470 case 0x0305: return "WM_RENDERFORMAT";
5471 case 0x0306: return "WM_RENDERALLFORMATS";
5472 case 0x0307: return "WM_DESTROYCLIPBOARD";
5473 case 0x0308: return "WM_DRAWCLIPBOARD";
5474 case 0x0309: return "WM_PAINTCLIPBOARD";
5475 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5476 case 0x030B: return "WM_SIZECLIPBOARD";
5477 case 0x030C: return "WM_ASKCBFORMATNAME";
5478 case 0x030D: return "WM_CHANGECBCHAIN";
5479 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5480 case 0x030F: return "WM_QUERYNEWPALETTE";
5481 case 0x0310: return "WM_PALETTEISCHANGING";
5482 case 0x0311: return "WM_PALETTECHANGED";
5484 case 0x0312: return "WM_HOTKEY";
5487 // common controls messages - although they're not strictly speaking
5488 // standard, it's nice to decode them nevertheless
5491 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5492 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5493 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5494 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5495 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5496 case 0x1000 + 5: return "LVM_GETITEMA";
5497 case 0x1000 + 75: return "LVM_GETITEMW";
5498 case 0x1000 + 6: return "LVM_SETITEMA";
5499 case 0x1000 + 76: return "LVM_SETITEMW";
5500 case 0x1000 + 7: return "LVM_INSERTITEMA";
5501 case 0x1000 + 77: return "LVM_INSERTITEMW";
5502 case 0x1000 + 8: return "LVM_DELETEITEM";
5503 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5504 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5505 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5506 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5507 case 0x1000 + 13: return "LVM_FINDITEMA";
5508 case 0x1000 + 83: return "LVM_FINDITEMW";
5509 case 0x1000 + 14: return "LVM_GETITEMRECT";
5510 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5511 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5512 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5513 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5514 case 0x1000 + 18: return "LVM_HITTEST";
5515 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5516 case 0x1000 + 20: return "LVM_SCROLL";
5517 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5518 case 0x1000 + 22: return "LVM_ARRANGE";
5519 case 0x1000 + 23: return "LVM_EDITLABELA";
5520 case 0x1000 + 118: return "LVM_EDITLABELW";
5521 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5522 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5523 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5524 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5525 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5526 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5527 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5528 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5529 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5530 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5531 case 0x1000 + 31: return "LVM_GETHEADER";
5532 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5533 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5534 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5535 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5536 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5537 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5538 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5539 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5540 case 0x1000 + 41: return "LVM_GETORIGIN";
5541 case 0x1000 + 42: return "LVM_UPDATE";
5542 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5543 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5544 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5545 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5546 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5547 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5548 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5549 case 0x1000 + 48: return "LVM_SORTITEMS";
5550 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5551 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5552 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5553 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5554 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5555 case 0x1000 + 53: return "LVM_SETICONSPACING";
5556 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5557 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5558 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5559 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5560 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5561 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5562 case 0x1000 + 60: return "LVM_SETHOTITEM";
5563 case 0x1000 + 61: return "LVM_GETHOTITEM";
5564 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5565 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5566 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5567 case 0x1000 + 65: return "LVM_SETWORKAREA";
5570 case 0x1100 + 0: return "TVM_INSERTITEMA";
5571 case 0x1100 + 50: return "TVM_INSERTITEMW";
5572 case 0x1100 + 1: return "TVM_DELETEITEM";
5573 case 0x1100 + 2: return "TVM_EXPAND";
5574 case 0x1100 + 4: return "TVM_GETITEMRECT";
5575 case 0x1100 + 5: return "TVM_GETCOUNT";
5576 case 0x1100 + 6: return "TVM_GETINDENT";
5577 case 0x1100 + 7: return "TVM_SETINDENT";
5578 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5579 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5580 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5581 case 0x1100 + 11: return "TVM_SELECTITEM";
5582 case 0x1100 + 12: return "TVM_GETITEMA";
5583 case 0x1100 + 62: return "TVM_GETITEMW";
5584 case 0x1100 + 13: return "TVM_SETITEMA";
5585 case 0x1100 + 63: return "TVM_SETITEMW";
5586 case 0x1100 + 14: return "TVM_EDITLABELA";
5587 case 0x1100 + 65: return "TVM_EDITLABELW";
5588 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5589 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5590 case 0x1100 + 17: return "TVM_HITTEST";
5591 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5592 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5593 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5594 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5595 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5596 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5597 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5598 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5599 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5602 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5603 case 0x1200 + 1: return "HDM_INSERTITEMA";
5604 case 0x1200 + 10: return "HDM_INSERTITEMW";
5605 case 0x1200 + 2: return "HDM_DELETEITEM";
5606 case 0x1200 + 3: return "HDM_GETITEMA";
5607 case 0x1200 + 11: return "HDM_GETITEMW";
5608 case 0x1200 + 4: return "HDM_SETITEMA";
5609 case 0x1200 + 12: return "HDM_SETITEMW";
5610 case 0x1200 + 5: return "HDM_LAYOUT";
5611 case 0x1200 + 6: return "HDM_HITTEST";
5612 case 0x1200 + 7: return "HDM_GETITEMRECT";
5613 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5614 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5615 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5616 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5617 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5618 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5619 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5622 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5623 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5624 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5625 case 0x1300 + 5: return "TCM_GETITEMA";
5626 case 0x1300 + 60: return "TCM_GETITEMW";
5627 case 0x1300 + 6: return "TCM_SETITEMA";
5628 case 0x1300 + 61: return "TCM_SETITEMW";
5629 case 0x1300 + 7: return "TCM_INSERTITEMA";
5630 case 0x1300 + 62: return "TCM_INSERTITEMW";
5631 case 0x1300 + 8: return "TCM_DELETEITEM";
5632 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5633 case 0x1300 + 10: return "TCM_GETITEMRECT";
5634 case 0x1300 + 11: return "TCM_GETCURSEL";
5635 case 0x1300 + 12: return "TCM_SETCURSEL";
5636 case 0x1300 + 13: return "TCM_HITTEST";
5637 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5638 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5639 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5640 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5641 case 0x1300 + 43: return "TCM_SETPADDING";
5642 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5643 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5644 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5645 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5646 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5647 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5648 case 0x1300 + 50: return "TCM_DESELECTALL";
5651 case WM_USER
+1: return "TB_ENABLEBUTTON";
5652 case WM_USER
+2: return "TB_CHECKBUTTON";
5653 case WM_USER
+3: return "TB_PRESSBUTTON";
5654 case WM_USER
+4: return "TB_HIDEBUTTON";
5655 case WM_USER
+5: return "TB_INDETERMINATE";
5656 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5657 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5658 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5659 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5660 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5661 case WM_USER
+17: return "TB_SETSTATE";
5662 case WM_USER
+18: return "TB_GETSTATE";
5663 case WM_USER
+19: return "TB_ADDBITMAP";
5664 case WM_USER
+20: return "TB_ADDBUTTONS";
5665 case WM_USER
+21: return "TB_INSERTBUTTON";
5666 case WM_USER
+22: return "TB_DELETEBUTTON";
5667 case WM_USER
+23: return "TB_GETBUTTON";
5668 case WM_USER
+24: return "TB_BUTTONCOUNT";
5669 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5670 case WM_USER
+26: return "TB_SAVERESTOREA";
5671 case WM_USER
+76: return "TB_SAVERESTOREW";
5672 case WM_USER
+27: return "TB_CUSTOMIZE";
5673 case WM_USER
+28: return "TB_ADDSTRINGA";
5674 case WM_USER
+77: return "TB_ADDSTRINGW";
5675 case WM_USER
+29: return "TB_GETITEMRECT";
5676 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5677 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5678 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5679 case WM_USER
+33: return "TB_AUTOSIZE";
5680 case WM_USER
+35: return "TB_GETTOOLTIPS";
5681 case WM_USER
+36: return "TB_SETTOOLTIPS";
5682 case WM_USER
+37: return "TB_SETPARENT";
5683 case WM_USER
+39: return "TB_SETROWS";
5684 case WM_USER
+40: return "TB_GETROWS";
5685 case WM_USER
+42: return "TB_SETCMDID";
5686 case WM_USER
+43: return "TB_CHANGEBITMAP";
5687 case WM_USER
+44: return "TB_GETBITMAP";
5688 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5689 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5690 case WM_USER
+46: return "TB_REPLACEBITMAP";
5691 case WM_USER
+47: return "TB_SETINDENT";
5692 case WM_USER
+48: return "TB_SETIMAGELIST";
5693 case WM_USER
+49: return "TB_GETIMAGELIST";
5694 case WM_USER
+50: return "TB_LOADIMAGES";
5695 case WM_USER
+51: return "TB_GETRECT";
5696 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5697 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5698 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5699 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5700 case WM_USER
+56: return "TB_SETSTYLE";
5701 case WM_USER
+57: return "TB_GETSTYLE";
5702 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5703 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5704 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5705 case WM_USER
+61: return "TB_GETTEXTROWS";
5706 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5709 static char s_szBuf
[128];
5710 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5714 #endif //__WXDEBUG__
5716 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5717 int *x
, int *y
, WPARAM
*flags
)
5719 // construct the key mask
5720 WPARAM
& fwKeys
= *flags
;
5722 fwKeys
= MK_RBUTTON
;
5723 if ( wxIsCtrlDown() )
5724 fwKeys
|= MK_CONTROL
;
5725 if ( wxIsShiftDown() )
5728 // simulate right mouse button click
5729 DWORD dwPos
= ::GetMessagePos();
5730 *x
= GET_X_LPARAM(dwPos
);
5731 *y
= GET_Y_LPARAM(dwPos
);
5733 win
->ScreenToClient(x
, y
);
5736 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5740 HWND hwnd
= GetHwndOf(win
);
5741 HDC hdc
= ::GetDC(hwnd
);
5743 #if !wxDIALOG_UNIT_COMPATIBILITY
5744 // and select the current font into it
5745 HFONT hfont
= GetHfontOf(win
->GetFont());
5748 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5752 // finally retrieve the text metrics from it
5753 GetTextMetrics(hdc
, &tm
);
5755 #if !wxDIALOG_UNIT_COMPATIBILITY
5759 (void)::SelectObject(hdc
, hfont
);
5763 ::ReleaseDC(hwnd
, hdc
);
5768 // Find the wxWindow at the current mouse position, returning the mouse
5770 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5772 pt
= wxGetMousePosition();
5773 return wxFindWindowAtPoint(pt
);
5776 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5781 HWND hWndHit
= ::WindowFromPoint(pt2
);
5783 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5784 HWND hWnd
= hWndHit
;
5786 // Try to find a window with a wxWindow associated with it
5787 while (!win
&& (hWnd
!= 0))
5789 hWnd
= ::GetParent(hWnd
);
5790 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5795 // Get the current mouse position.
5796 wxPoint
wxGetMousePosition()
5799 GetCursorPos( & pt
);
5801 return wxPoint(pt
.x
, pt
.y
);
5806 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5808 UINT win_modifiers
=0;
5809 if ( modifiers
& wxMOD_ALT
)
5810 win_modifiers
|= MOD_ALT
;
5811 if ( modifiers
& wxMOD_SHIFT
)
5812 win_modifiers
|= MOD_SHIFT
;
5813 if ( modifiers
& wxMOD_CONTROL
)
5814 win_modifiers
|= MOD_CONTROL
;
5815 if ( modifiers
& wxMOD_WIN
)
5816 win_modifiers
|= MOD_WIN
;
5818 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5820 wxLogLastError(_T("RegisterHotKey"));
5828 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
5830 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5832 wxLogLastError(_T("UnregisterHotKey"));
5842 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5844 int hotkeyId
= wParam
;
5845 int virtualKey
= HIWORD(lParam
);
5846 int win_modifiers
= LOWORD(lParam
);
5848 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5849 event
.SetId(hotkeyId
);
5850 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5851 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5852 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5853 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5855 return GetEventHandler()->ProcessEvent(event
);
5858 #endif // wxUSE_ACCEL
5860 #endif // wxUSE_HOTKEY
5862 // Not tested under WinCE
5865 // this class installs a message hook which really wakes up our idle processing
5866 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
5867 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
5868 // being dragged or even inside ::MessageBox()) and so don't control message
5869 // dispatching otherwise
5870 class wxIdleWakeUpModule
: public wxModule
5873 virtual bool OnInit()
5875 ms_hMsgHookProc
= ::SetWindowsHookEx
5878 &wxIdleWakeUpModule::MsgHookProc
,
5880 GetCurrentThreadId()
5883 if ( !ms_hMsgHookProc
)
5885 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
5893 virtual void OnExit()
5895 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
5898 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
5900 MSG
*msg
= (MSG
*)lParam
;
5901 if ( msg
->message
== WM_NULL
)
5903 wxTheApp
->ProcessPendingEvents();
5906 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
5910 static HHOOK ms_hMsgHookProc
;
5912 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
5915 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
5917 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
5919 #endif // __WXWINCE__
5924 static void wxAdjustZOrder(wxWindow
* parent
)
5926 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
5928 // Set the z-order correctly
5929 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
5932 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
5935 wxWindow
*childWin
= current
->GetData();
5936 wxAdjustZOrder(childWin
);
5937 current
= current
->GetNext();
5942 // We need to adjust the z-order of static boxes in WinCE, to
5943 // make 'contained' controls visible
5944 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
5947 wxAdjustZOrder(this);