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 // get the text metrics for the current font
159 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
161 // find the window for the mouse event at the specified position
162 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
164 // wrapper around BringWindowToTop() API
165 static inline void wxBringWindowToTop(HWND hwnd
)
167 #ifdef __WXMICROWIN__
168 // It seems that MicroWindows brings the _parent_ of the window to the top,
169 // which can be the wrong one.
171 // activate (set focus to) specified window
175 // raise top level parent to top of z order
176 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
178 wxLogLastError(_T("SetWindowPos"));
184 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
185 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
188 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
189 parent as well as otherwise several Win32 functions using
190 GetNextDlgTabItem() to iterate over all controls such as
191 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
192 all of them iterate over all the controls starting from the currently
193 focused one and stop iterating when they get back to the focus but
194 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
195 get back to the initial (focused) window: as we do have this style,
196 GetNextDlgTabItem() will leave this window and continue in its parent,
197 but if the parent doesn't have it, it wouldn't recurse inside it later
198 on and so wouldn't have a chance of getting back to this window neither.
200 while ( parent
&& !parent
->IsTopLevel() )
202 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
203 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
205 // force the parent to have this style
206 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
207 exStyle
| WS_EX_CONTROLPARENT
);
210 parent
= parent
->GetParent();
214 #endif // !__WXWINCE__
216 // ---------------------------------------------------------------------------
218 // ---------------------------------------------------------------------------
220 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
222 #ifdef __WXUNIVERSAL__
223 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
225 #if wxUSE_EXTENDED_RTTI
227 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
228 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
229 // windows with negative ids never can be recreated anyway
231 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
233 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
234 if ( win
&& win
->GetId() < 0 )
239 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
241 // make wxWindowList known before the property is used
243 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
245 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
247 wxListCollectionToVariantArray
<wxWindowList
::compatibility_iterator
>( theList
, value
) ;
250 WX_DEFINE_FLAGS( wxWindowStyle
)
252 wxBEGIN_FLAGS( wxWindowStyle
)
253 // new style border flags, we put them first to
254 // use them for streaming out
256 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
257 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
258 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
259 wxFLAGS_MEMBER(wxBORDER_RAISED
)
260 wxFLAGS_MEMBER(wxBORDER_STATIC
)
261 wxFLAGS_MEMBER(wxBORDER_NONE
)
263 // old style border flags
264 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
265 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
266 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
267 wxFLAGS_MEMBER(wxRAISED_BORDER
)
268 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
269 wxFLAGS_MEMBER(wxBORDER
)
271 // standard window styles
272 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
273 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
274 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
275 wxFLAGS_MEMBER(wxWANTS_CHARS
)
276 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
277 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
278 wxFLAGS_MEMBER(wxVSCROLL
)
279 wxFLAGS_MEMBER(wxHSCROLL
)
281 wxEND_FLAGS( wxWindowStyle
)
283 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
284 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
285 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
286 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
287 // Always constructor Properties first
289 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
290 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, wxID_ANY
, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
291 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
292 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
293 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
295 // Then all relations of the object graph
297 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
299 // and finally all other properties
301 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
302 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
303 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
304 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
305 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
307 // possible property candidates (not in xrc) or not valid in all subclasses
308 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxT("") )
309 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
310 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxT("") )
311 // MaxHeight, Width , MinHeight , Width
312 // TODO switch label to control and title to toplevels
314 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
315 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
316 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
317 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
322 wxEND_PROPERTIES_TABLE()
324 wxBEGIN_HANDLERS_TABLE(wxWindow
)
325 wxEND_HANDLERS_TABLE()
327 wxCONSTRUCTOR_DUMMY(wxWindow
)
330 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
332 #endif // __WXUNIVERSAL__/__WXMSW__
334 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
335 EVT_SYS_COLOUR_CHANGED(wxWindowMSW
::OnSysColourChanged
)
336 EVT_ERASE_BACKGROUND(wxWindowMSW
::OnEraseBackground
)
338 EVT_INIT_DIALOG(wxWindowMSW
::OnInitDialog
)
342 // ===========================================================================
344 // ===========================================================================
346 // ---------------------------------------------------------------------------
347 // wxWindow utility functions
348 // ---------------------------------------------------------------------------
350 // Find an item given the MS Windows id
351 wxWindow
*wxWindowMSW
::FindItem(long id
) const
354 wxControl
*item
= wxDynamicCastThis(wxControl
);
357 // is it we or one of our "internal" children?
358 if ( item
->GetId() == id
359 #ifndef __WXUNIVERSAL__
360 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
361 #endif // __WXUNIVERSAL__
367 #endif // wxUSE_CONTROLS
369 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
372 wxWindow
*childWin
= current
->GetData();
374 wxWindow
*wnd
= childWin
->FindItem(id
);
378 current
= current
->GetNext();
384 // Find an item given the MS Windows handle
385 wxWindow
*wxWindowMSW
::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
387 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
390 wxWindow
*parent
= current
->GetData();
392 // Do a recursive search.
393 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
399 || parent
->IsKindOf(CLASSINFO(wxControl
))
400 #endif // wxUSE_CONTROLS
403 wxWindow
*item
= current
->GetData();
404 if ( item
->GetHWND() == hWnd
)
408 if ( item
->ContainsHWND(hWnd
) )
413 current
= current
->GetNext();
418 // Default command handler
419 bool wxWindowMSW
::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
424 // ----------------------------------------------------------------------------
425 // constructors and such
426 // ----------------------------------------------------------------------------
428 void wxWindowMSW
::Init()
431 m_isBeingDeleted
= false;
433 m_mouseInWindow
= false;
434 m_lastKeydownProcessed
= false;
436 m_childrenDisabled
= NULL
;
445 #if wxUSE_MOUSEEVENT_HACK
448 m_lastMouseEvent
= -1;
449 #endif // wxUSE_MOUSEEVENT_HACK
453 wxWindowMSW
::~wxWindowMSW()
455 m_isBeingDeleted
= true;
457 #ifndef __WXUNIVERSAL__
458 // VS: make sure there's no wxFrame with last focus set to us:
459 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
461 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
464 if ( frame
->GetLastFocus() == this )
466 frame
->SetLastFocus(NULL
);
471 #endif // __WXUNIVERSAL__
473 // VS: destroy children first and _then_ detach *this from its parent.
474 // If we'd do it the other way around, children wouldn't be able
475 // find their parent frame (see above).
480 // VZ: test temp removed to understand what really happens here
481 //if (::IsWindow(GetHwnd()))
483 if ( !::DestroyWindow(GetHwnd()) )
484 wxLogLastError(wxT("DestroyWindow"));
487 // remove hWnd <-> wxWindow association
488 wxRemoveHandleAssociation(this);
491 delete m_childrenDisabled
;
494 // real construction (Init() must have been called before!)
495 bool wxWindowMSW
::Create(wxWindow
*parent
,
500 const wxString
& name
)
502 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
504 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
507 parent
->AddChild(this);
510 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
512 #ifdef __WXUNIVERSAL__
513 // no borders, we draw them ourselves
514 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
518 msflags
&= ~WS_BORDER
;
519 #endif // wxUniversal
523 msflags
|= WS_VISIBLE
;
526 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
534 // ---------------------------------------------------------------------------
536 // ---------------------------------------------------------------------------
538 void wxWindowMSW
::SetFocus()
540 HWND hWnd
= GetHwnd();
541 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
543 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
547 if ( !::SetFocus(hWnd
) )
549 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
550 // was there really an error?
551 DWORD dwRes
= ::GetLastError();
554 HWND hwndFocus
= ::GetFocus();
555 if ( hwndFocus
!= hWnd
)
557 wxLogApiError(_T("SetFocus"), dwRes
);
564 void wxWindowMSW
::SetFocusFromKbd()
566 // when the focus is given to the control with DLGC_HASSETSEL style from
567 // keyboard its contents should be entirely selected: this is what
568 // ::IsDialogMessage() does and so we should do it as well to provide the
569 // same LNF as the native programs
570 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
572 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
575 // do this after (maybe) setting the selection as like this when
576 // wxEVT_SET_FOCUS handler is called, the selection would have been already
577 // set correctly -- this may be important
578 wxWindowBase
::SetFocusFromKbd();
581 // Get the window with the focus
582 wxWindow
*wxWindowBase
::DoFindFocus()
584 HWND hWnd
= ::GetFocus();
587 return wxGetWindowFromHWND((WXHWND
)hWnd
);
593 bool wxWindowMSW
::Enable(bool enable
)
595 if ( !wxWindowBase
::Enable(enable
) )
598 HWND hWnd
= GetHwnd();
600 ::EnableWindow(hWnd
, (BOOL
)enable
);
602 // the logic below doesn't apply to the top level windows -- otherwise
603 // showing a modal dialog would result in total greying out (and ungreying
604 // out later) of everything which would be really ugly
608 // when the parent is disabled, all of its children should be disabled as
609 // well but when it is enabled back, only those of the children which
610 // hadn't been already disabled in the beginning should be enabled again,
611 // so we have to keep the list of those children
612 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
614 node
= node
->GetNext() )
616 wxWindow
*child
= node
->GetData();
617 if ( child
->IsTopLevel() )
619 // the logic below doesn't apply to top level children
625 // enable the child back unless it had been disabled before us
626 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
629 else // we're being disabled
631 if ( child
->IsEnabled() )
633 // disable it as children shouldn't stay enabled while the
637 else // child already disabled, remember it
639 // have we created the list of disabled children already?
640 if ( !m_childrenDisabled
)
641 m_childrenDisabled
= new wxWindowList
;
643 m_childrenDisabled
->Append(child
);
648 if ( enable
&& m_childrenDisabled
)
650 // we don't need this list any more, don't keep unused memory
651 delete m_childrenDisabled
;
652 m_childrenDisabled
= NULL
;
658 bool wxWindowMSW
::Show(bool show
)
660 if ( !wxWindowBase
::Show(show
) )
663 HWND hWnd
= GetHwnd();
664 int cshow
= show ? SW_SHOW
: SW_HIDE
;
665 ::ShowWindow(hWnd
, cshow
);
667 if ( show
&& IsTopLevel() )
669 wxBringWindowToTop(hWnd
);
675 // Raise the window to the top of the Z order
676 void wxWindowMSW
::Raise()
678 wxBringWindowToTop(GetHwnd());
681 // Lower the window to the bottom of the Z order
682 void wxWindowMSW
::Lower()
684 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
685 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
688 void wxWindowMSW
::SetTitle( const wxString
& title
)
690 SetWindowText(GetHwnd(), title
.c_str());
693 wxString wxWindowMSW
::GetTitle() const
695 return wxGetWindowText(GetHWND());
698 void wxWindowMSW
::DoCaptureMouse()
700 HWND hWnd
= GetHwnd();
707 void wxWindowMSW
::DoReleaseMouse()
709 if ( !::ReleaseCapture() )
711 wxLogLastError(_T("ReleaseCapture"));
715 /* static */ wxWindow
*wxWindowBase
::GetCapture()
717 HWND hwnd
= ::GetCapture();
718 return hwnd ?
wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
721 bool wxWindowMSW
::SetFont(const wxFont
& font
)
723 if ( !wxWindowBase
::SetFont(font
) )
729 HWND hWnd
= GetHwnd();
732 WXHANDLE hFont
= m_font
.GetResourceHandle();
734 wxASSERT_MSG( hFont
, wxT("should have valid font") );
736 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
741 bool wxWindowMSW
::SetCursor(const wxCursor
& cursor
)
743 if ( !wxWindowBase
::SetCursor(cursor
) )
751 HWND hWnd
= GetHwnd();
753 // Change the cursor NOW if we're within the correct window
755 ::GetCursorPos(&point
);
757 RECT rect
= wxGetWindowRect(hWnd
);
759 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
760 ::SetCursor(GetHcursorOf(m_cursor
));
766 void wxWindowMSW
::WarpPointer (int x
, int y
)
768 ClientToScreen(&x
, &y
);
770 if ( !::SetCursorPos(x
, y
) )
772 wxLogLastError(_T("SetCursorPos"));
776 // ---------------------------------------------------------------------------
778 // ---------------------------------------------------------------------------
780 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
781 static inline int wxDirToWinStyle(int orient
)
783 return orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
;
786 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
788 #ifdef __WXMICROWIN__
789 return ::GetScrollPosWX(hWnd
, wOrient
);
791 WinStruct
<SCROLLINFO
> scrollInfo
;
792 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
793 scrollInfo
.fMask
= SIF_POS
;
794 if ( !::GetScrollInfo(hWnd
,
798 // Not neccessarily an error, if there are no scrollbars yet.
799 // wxLogLastError(_T("GetScrollInfo"));
801 return scrollInfo
.nPos
;
802 // return ::GetScrollPos(hWnd, wOrient);
806 int wxWindowMSW
::GetScrollPos(int orient
) const
808 HWND hWnd
= GetHwnd();
809 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
811 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
);
814 // This now returns the whole range, not just the number
815 // of positions that we can scroll.
816 int wxWindowMSW
::GetScrollRange(int orient
) const
819 HWND hWnd
= GetHwnd();
823 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
826 WinStruct
<SCROLLINFO
> scrollInfo
;
827 scrollInfo
.fMask
= SIF_RANGE
;
828 if ( !::GetScrollInfo(hWnd
,
829 orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
832 // Most of the time this is not really an error, since the return
833 // value can also be zero when there is no scrollbar yet.
834 // wxLogLastError(_T("GetScrollInfo"));
836 maxPos
= scrollInfo
.nMax
;
838 // undo "range - 1" done in SetScrollbar()
842 int wxWindowMSW
::GetScrollThumb(int orient
) const
844 return orient
== wxHORIZONTAL ? m_xThumbSize
: m_yThumbSize
;
847 void wxWindowMSW
::SetScrollPos(int orient
, int pos
, bool refresh
)
849 HWND hWnd
= GetHwnd();
850 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
852 WinStruct
<SCROLLINFO
> info
;
856 info
.fMask
= SIF_POS
;
857 if ( HasFlag(wxALWAYS_SHOW_SB
) )
859 // disable scrollbar instead of removing it then
860 info
.fMask
|= SIF_DISABLENOSCROLL
;
863 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
867 // New function that will replace some of the above.
868 void wxWindowMSW
::SetScrollbar(int orient
,
874 WinStruct
<SCROLLINFO
> info
;
875 info
.nPage
= pageSize
;
876 info
.nMin
= 0; // range is nMax - nMin + 1
877 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
879 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
880 if ( HasFlag(wxALWAYS_SHOW_SB
) )
882 // disable scrollbar instead of removing it then
883 info
.fMask
|= SIF_DISABLENOSCROLL
;
886 HWND hWnd
= GetHwnd();
889 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
893 *(orient
== wxHORIZONTAL ?
&m_xThumbSize
: &m_yThumbSize
) = pageSize
;
896 void wxWindowMSW
::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
902 rect
.left
= prect
->x
;
904 rect
.right
= prect
->x
+ prect
->width
;
905 rect
.bottom
= prect
->y
+ prect
->height
;
915 // FIXME: is this the exact equivalent of the line below?
916 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
918 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
922 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
924 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
927 for ( int n
= 0; n
< count
; n
++ )
929 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
931 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
934 // don't bother to continue, we're already at top/bottom
941 return pos
!= posStart
;
944 bool wxWindowMSW
::ScrollLines(int lines
)
946 bool down
= lines
> 0;
948 return ScrollVertically(GetHwnd(),
949 down ? SB_LINEDOWN
: SB_LINEUP
,
950 down ? lines
: -lines
);
953 bool wxWindowMSW
::ScrollPages(int pages
)
955 bool down
= pages
> 0;
957 return ScrollVertically(GetHwnd(),
958 down ? SB_PAGEDOWN
: SB_PAGEUP
,
959 down ? pages
: -pages
);
962 // ---------------------------------------------------------------------------
964 // ---------------------------------------------------------------------------
966 void wxWindowMSW
::SubclassWin(WXHWND hWnd
)
968 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
970 HWND hwnd
= (HWND
)hWnd
;
971 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
973 wxAssociateWinWithHandle(hwnd
, this);
975 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
977 // we don't need to subclass the window of our own class (in the Windows
978 // sense of the word)
979 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
981 wxSetWindowProc(hwnd
, wxWndProc
);
985 // don't bother restoring it neither: this also makes it easy to
986 // implement IsOfStandardClass() method which returns true for the
987 // standard controls and false for the wxWidgets own windows as it can
988 // simply check m_oldWndProc
993 void wxWindowMSW
::UnsubclassWin()
995 wxRemoveHandleAssociation(this);
997 // Restore old Window proc
998 HWND hwnd
= GetHwnd();
1003 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1007 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1009 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1012 m_oldWndProc
= NULL
;
1017 void wxWindowMSW
::AssociateHandle(WXWidget handle
)
1021 if ( !::DestroyWindow(GetHwnd()) )
1022 wxLogLastError(wxT("DestroyWindow"));
1025 WXHWND wxhwnd
= (WXHWND
)handle
;
1028 SubclassWin(wxhwnd
);
1031 void wxWindowMSW
::DissociateHandle()
1033 // this also calls SetHWND(0) for us
1038 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1040 // Unicows note: the code below works, but only because WNDCLASS contains
1041 // original window handler rather that the unicows fake one. This may not
1042 // be on purpose, though; if it stops working with future versions of
1043 // unicows.dll, we can override unicows hooks by setting
1044 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1045 // versions that keep track of fake<->real wnd proc mapping.
1047 // On WinCE (at least), the wndproc comparison doesn't work,
1048 // so have to use something like this.
1050 extern wxChar
*wxCanvasClassName
;
1051 extern wxChar
*wxCanvasClassNameNR
;
1052 extern const wxChar
*wxMDIFrameClassName
;
1053 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1054 extern const wxChar
*wxMDIChildFrameClassName
;
1055 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1056 wxString
str(wxGetWindowClass(hWnd
));
1057 if (str
== wxCanvasClassName
||
1058 str
== wxCanvasClassNameNR
||
1059 str
== wxMDIFrameClassName
||
1060 str
== wxMDIFrameClassNameNoRedraw
||
1061 str
== wxMDIChildFrameClassName
||
1062 str
== wxMDIChildFrameClassNameNoRedraw
||
1063 str
== _T("wxTLWHiddenParent"))
1064 return true; // Effectively means don't subclass
1069 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1071 wxLogLastError(_T("GetClassInfo"));
1076 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1080 // ----------------------------------------------------------------------------
1082 // ----------------------------------------------------------------------------
1084 void wxWindowMSW
::SetWindowStyleFlag(long flags
)
1086 long flagsOld
= GetWindowStyleFlag();
1087 if ( flags
== flagsOld
)
1090 // update the internal variable
1091 wxWindowBase
::SetWindowStyleFlag(flags
);
1093 // now update the Windows style as well if needed - and if the window had
1094 // been already created
1098 WXDWORD exstyle
, exstyleOld
;
1099 long style
= MSWGetStyle(flags
, &exstyle
),
1100 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1102 if ( style
!= styleOld
)
1104 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1105 // this function so instead of simply setting the style to the new
1106 // value we clear the bits which were set in styleOld but are set in
1107 // the new one and set the ones which were not set before
1108 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1109 styleReal
&= ~styleOld
;
1112 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1115 // and the extended style
1116 if ( exstyle
!= exstyleOld
)
1118 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1119 exstyleReal
&= ~exstyleOld
;
1120 exstyleReal
|= exstyle
;
1122 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1124 // we must call SetWindowPos() to flash the cached extended style and
1125 // also to make the change to wxSTAY_ON_TOP style take effect: just
1126 // setting the style simply doesn't work
1127 if ( !::SetWindowPos(GetHwnd(),
1128 exstyleReal
& WS_EX_TOPMOST ? HWND_TOPMOST
1131 SWP_NOMOVE
| SWP_NOSIZE
) )
1133 wxLogLastError(_T("SetWindowPos"));
1138 WXDWORD wxWindowMSW
::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1140 // translate common wxWidgets styles to Windows ones
1142 // most of windows are child ones, those which are not (such as
1143 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1144 WXDWORD style
= WS_CHILD
;
1146 // using this flag results in very significant reduction in flicker,
1147 // especially with controls inside the static boxes (as the interior of the
1148 // box is not redrawn twice)
1149 style
|= WS_CLIPCHILDREN
;
1151 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1152 // don't support overlapping windows and it only makes sense for them and,
1153 // presumably, gives the system some extra work (to manage more clipping
1154 // regions), so avoid it alltogether
1157 if ( flags
& wxVSCROLL
)
1158 style
|= WS_VSCROLL
;
1160 if ( flags
& wxHSCROLL
)
1161 style
|= WS_HSCROLL
;
1163 const wxBorder border
= GetBorder(flags
);
1165 // WS_BORDER is only required for wxBORDER_SIMPLE
1166 if ( border
== wxBORDER_SIMPLE
)
1169 // now deal with ext style if the caller wants it
1175 if ( flags
& wxTRANSPARENT_WINDOW
)
1176 *exstyle
|= WS_EX_TRANSPARENT
;
1182 case wxBORDER_DEFAULT
:
1183 wxFAIL_MSG( _T("unknown border style") );
1187 case wxBORDER_SIMPLE
:
1190 case wxBORDER_STATIC
:
1191 *exstyle
|= WS_EX_STATICEDGE
;
1194 case wxBORDER_RAISED
:
1195 *exstyle
|= WS_EX_DLGMODALFRAME
;
1198 case wxBORDER_SUNKEN
:
1199 *exstyle
|= WS_EX_CLIENTEDGE
;
1200 style
&= ~WS_BORDER
;
1203 case wxBORDER_DOUBLE
:
1204 *exstyle
|= WS_EX_DLGMODALFRAME
;
1208 // wxUniv doesn't use Windows dialog navigation functions at all
1209 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1210 // to make the dialog navigation work with the nested panels we must
1211 // use this style (top level windows such as dialogs don't need it)
1212 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1214 *exstyle
|= WS_EX_CONTROLPARENT
;
1216 #endif // __WXUNIVERSAL__
1222 // Setup background and foreground colours correctly
1223 void wxWindowMSW
::SetupColours()
1226 SetBackgroundColour(GetParent()->GetBackgroundColour());
1229 bool wxWindowMSW
::IsMouseInWindow() const
1231 // get the mouse position
1233 ::GetCursorPos(&pt
);
1235 // find the window which currently has the cursor and go up the window
1236 // chain until we find this window - or exhaust it
1237 HWND hwnd
= ::WindowFromPoint(pt
);
1238 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1239 hwnd
= ::GetParent(hwnd
);
1241 return hwnd
!= NULL
;
1244 void wxWindowMSW
::OnInternalIdle()
1246 // Check if we need to send a LEAVE event
1247 if ( m_mouseInWindow
)
1249 // note that we should generate the leave event whether the window has
1250 // or doesn't have mouse capture
1251 if ( !IsMouseInWindow() )
1253 // Generate a LEAVE event
1254 m_mouseInWindow
= false;
1256 // Unfortunately the mouse button and keyboard state may have
1257 // changed by the time the OnInternalIdle function is called, so 'state'
1258 // may be meaningless.
1260 if ( wxIsShiftDown() )
1262 if ( wxIsCtrlDown() )
1263 state
|= MK_CONTROL
;
1265 // Only the high-order bit should be tested
1266 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
1267 state
|= MK_LBUTTON
;
1268 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
1269 state
|= MK_MBUTTON
;
1270 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
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
1535 // if our parent had prepared a defer window handle for us, use it
1536 wxWindowMSW
*parent
=
1537 #ifdef __WXUNIVERSAL__
1538 wxDynamicCast(m_parent
, wxWindowMSW
)
1543 HDWP hdwp
= parent ?
(HDWP
)parent
->m_hDWP
: NULL
;
1546 hdwp
= ::DeferWindowPos(hdwp
, GetHwnd(), NULL
,
1547 x
, y
, width
, height
,
1551 wxLogLastError(_T("DeferWindowPos"));
1554 // hdwp must be updated as it may have been changed
1555 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1558 // otherwise (or if deferring failed) move the window in place immediately
1561 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1563 wxLogLastError(wxT("MoveWindow"));
1568 // set the size of the window: if the dimensions are positive, just use them,
1569 // but if any of them is equal to -1, it means that we must find the value for
1570 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1571 // which case -1 is a valid value for x and y)
1573 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1574 // the width/height to best suit our contents, otherwise we reuse the current
1576 void wxWindowMSW
::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1578 // get the current size and position...
1579 int currentX
, currentY
;
1580 GetPosition(¤tX
, ¤tY
);
1581 int currentW
,currentH
;
1582 GetSize(¤tW
, ¤tH
);
1584 // ... and don't do anything (avoiding flicker) if it's already ok
1585 if ( x
== currentX
&& y
== currentY
&&
1586 width
== currentW
&& height
== currentH
)
1591 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1593 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1596 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1598 wxSize size
= wxDefaultSize
;
1599 if ( width
== wxDefaultCoord
)
1601 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1603 size
= DoGetBestSize();
1608 // just take the current one
1613 if ( height
== wxDefaultCoord
)
1615 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1617 if ( size
.x
== wxDefaultCoord
)
1619 size
= DoGetBestSize();
1621 //else: already called DoGetBestSize() above
1627 // just take the current one
1632 DoMoveWindow(x
, y
, width
, height
);
1635 void wxWindowMSW
::DoSetClientSize(int width
, int height
)
1637 // setting the client size is less obvious than it it could have been
1638 // because in the result of changing the total size the window scrollbar
1639 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1640 // will not be correct as the difference between the total and client size
1641 // changes - so we keep changing it until we get it right
1643 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1644 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1645 // may become 3 if the window had 0 size originally and so we didn't
1646 // calculate the scrollbar correction correctly during the first iteration)
1647 // but just to be on the safe side we check for it instead of making it an
1648 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1649 for ( int i
= 0; i
< 4; i
++ )
1652 ::GetClientRect(GetHwnd(), &rectClient
);
1654 // if the size is already ok, stop here (rectClient.left = top = 0)
1655 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1656 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1661 int widthClient
= width
,
1662 heightClient
= height
;
1664 // Find the difference between the entire window (title bar and all)
1665 // and the client area; add this to the new client size to move the
1668 ::GetWindowRect(GetHwnd(), &rectWin
);
1670 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1671 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1674 point
.x
= rectWin
.left
;
1675 point
.y
= rectWin
.top
;
1677 // MoveWindow positions the child windows relative to the parent, so
1678 // adjust if necessary
1679 if ( !IsTopLevel() )
1681 wxWindow
*parent
= GetParent();
1684 ::ScreenToClient(GetHwndOf(parent
), &point
);
1688 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1692 // For implementation purposes - sometimes decorations make the client area
1694 wxPoint wxWindowMSW
::GetClientAreaOrigin() const
1696 return wxPoint(0, 0);
1699 // ---------------------------------------------------------------------------
1701 // ---------------------------------------------------------------------------
1703 int wxWindowMSW
::GetCharHeight() const
1705 return wxGetTextMetrics(this).tmHeight
;
1708 int wxWindowMSW
::GetCharWidth() const
1710 // +1 is needed because Windows apparently adds it when calculating the
1711 // dialog units size in pixels
1712 #if wxDIALOG_UNIT_COMPATIBILITY
1713 return wxGetTextMetrics(this).tmAveCharWidth
;
1715 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1719 void wxWindowMSW
::GetTextExtent(const wxString
& string
,
1721 int *descent
, int *externalLeading
,
1722 const wxFont
*theFont
) const
1724 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1725 _T("invalid font in GetTextExtent()") );
1729 fontToUse
= *theFont
;
1731 fontToUse
= GetFont();
1733 WindowHDC
hdc(GetHwnd());
1734 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1738 GetTextExtentPoint(hdc
, string
, string
.length(), &sizeRect
);
1739 GetTextMetrics(hdc
, &tm
);
1746 *descent
= tm
.tmDescent
;
1747 if ( externalLeading
)
1748 *externalLeading
= tm
.tmExternalLeading
;
1751 // ---------------------------------------------------------------------------
1753 // ---------------------------------------------------------------------------
1755 #if wxUSE_MENUS_NATIVE
1757 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1758 // immediately, without waiting for the next event loop iteration
1760 // NB: this function should probably be made public later as it can almost
1761 // surely replace wxYield() elsewhere as well
1762 static void wxYieldForCommandsOnly()
1764 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1765 // want to process it here)
1767 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1769 if ( msg
.message
== WM_QUIT
)
1771 // if we retrieved a WM_QUIT, insert back into the message queue.
1772 ::PostQuitMessage(0);
1776 // luckily (as we don't have access to wxEventLoopImpl method from here
1777 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1779 ::TranslateMessage(&msg
);
1780 ::DispatchMessage(&msg
);
1784 bool wxWindowMSW
::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1786 menu
->SetInvokingWindow(this);
1789 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1791 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1792 x
= mouse
.x
; y
= mouse
.y
;
1795 HWND hWnd
= GetHwnd();
1796 HMENU hMenu
= GetHmenuOf(menu
);
1800 ::ClientToScreen(hWnd
, &point
);
1801 wxCurrentPopupMenu
= menu
;
1802 #if defined(__WXWINCE__)
1805 UINT flags
= TPM_RIGHTBUTTON
;
1807 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1809 // we need to do it righ now as otherwise the events are never going to be
1810 // sent to wxCurrentPopupMenu from HandleCommand()
1812 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1813 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1814 // destroyed as soon as we return (it can be a local variable in the caller
1815 // for example) and so we do need to process the event immediately
1816 wxYieldForCommandsOnly();
1818 wxCurrentPopupMenu
= NULL
;
1820 menu
->SetInvokingWindow(NULL
);
1825 #endif // wxUSE_MENUS_NATIVE
1827 // ===========================================================================
1828 // pre/post message processing
1829 // ===========================================================================
1831 WXLRESULT wxWindowMSW
::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1834 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1836 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1839 bool wxWindowMSW
::MSWProcessMessage(WXMSG
* pMsg
)
1841 // wxUniversal implements tab traversal itself
1842 #ifndef __WXUNIVERSAL__
1843 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1845 // intercept dialog navigation keys
1846 MSG
*msg
= (MSG
*)pMsg
;
1848 // here we try to do all the job which ::IsDialogMessage() usually does
1850 if ( msg
->message
== WM_KEYDOWN
)
1852 bool bCtrlDown
= wxIsCtrlDown();
1853 bool bShiftDown
= wxIsShiftDown();
1855 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1856 // don't process it if it's the case (except for Ctrl-Tab/Enter
1857 // combinations which are always processed)
1861 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1863 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1864 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1865 // it, of course, implies them
1866 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1868 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1872 bool bForward
= true,
1873 bWindowChange
= false;
1875 // should we process this message specially?
1876 bool bProcess
= true;
1877 switch ( msg
->wParam
)
1880 if ( lDlgCode
& DLGC_WANTTAB
) {
1884 // Ctrl-Tab cycles thru notebook pages
1885 bWindowChange
= bCtrlDown
;
1886 bForward
= !bShiftDown
;
1892 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1900 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1907 wxButton
*btn
= wxDynamicCast(FindWindow(wxID_CANCEL
),wxButton
);
1909 // our own wxLogDialog should react to Esc
1910 // without Cancel button but this is a private class
1911 // so let's try recognize it by content
1912 #if wxUSE_LOG_DIALOG
1914 wxDynamicCast(this,wxDialog
) &&
1915 FindWindow(wxID_MORE
) &&
1916 FindWindow(wxID_OK
) &&
1917 !FindWindow(wxID_CANCEL
) &&
1918 GetTitle().MakeLower().StartsWith(wxTheApp
->GetAppName().c_str())
1920 btn
= wxDynamicCast(FindWindow(wxID_OK
),wxButton
);
1921 #endif // wxUSE_LOG_DIALOG
1922 if ( btn
&& btn
->IsEnabled() )
1924 // if we do have a cancel button, do press it
1925 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1927 // we consumed the message
1930 #endif // wxUSE_BUTTON
1938 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1940 // control wants to process Enter itself, don't
1941 // call IsDialogMessage() which would interpret
1945 else if ( lDlgCode
& DLGC_BUTTON
)
1947 // let IsDialogMessage() handle this for all
1948 // buttons except the owner-drawn ones which it
1949 // just seems to ignore
1950 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1951 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1953 // emulate the button click
1954 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1956 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1961 // FIXME: this should be handled by
1962 // wxNavigationKeyEvent handler and not here!
1966 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1968 if ( btn
&& btn
->IsEnabled() )
1970 // if we do have a default button, do press it
1971 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1975 else // no default button
1976 #endif // wxUSE_BUTTON
1978 // this is a quick and dirty test for a text
1980 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1982 // don't process Enter, the control might
1983 // need it for itself and don't let
1984 // ::IsDialogMessage() have it as it can
1985 // eat the Enter events sometimes
1988 else if (!IsTopLevel())
1990 // if not a top level window, let parent
1994 //else: treat Enter as TAB: pass to the next
1995 // control as this is the best thing to do
1996 // if the text doesn't handle Enter itself
2008 wxNavigationKeyEvent event
;
2009 event
.SetDirection(bForward
);
2010 event
.SetWindowChange(bWindowChange
);
2011 event
.SetEventObject(this);
2013 if ( GetEventHandler()->ProcessEvent(event
) )
2020 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2021 // message even when there is no cancel button and when the message is
2022 // needed by the control itself: in particular, it prevents the tree in
2023 // place edit control from being closed with Escape in a dialog
2024 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2026 // ::IsDialogMessage() is broken and may sometimes hang the
2027 // application by going into an infinite loop, so we try to detect
2028 // [some of] the situatations when this may happen and not call it
2031 // assume we can call it by default
2032 bool canSafelyCallIsDlgMsg
= true;
2034 HWND hwndFocus
= ::GetFocus();
2036 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2037 // an infinite loop, because it will recursively check the child
2038 // windows but not the window itself and so if none of the children
2039 // accepts focus it loops forever (as it only stops when it gets
2040 // back to the window it started from)
2042 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2043 // style has the focus, it can happen. One such possibility is if
2044 // all windows are either toplevel, wxDialog, wxPanel or static
2045 // controls and no window can actually accept keyboard input.
2046 #if !defined(__WXWINCE__)
2047 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2049 // passimistic by default
2050 canSafelyCallIsDlgMsg
= false;
2051 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
2053 node
= node
->GetNext() )
2055 wxWindow
* const win
= node
->GetData();
2056 if ( win
->AcceptsFocus() &&
2057 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2058 WS_EX_CONTROLPARENT
) )
2060 // it shouldn't hang...
2061 canSafelyCallIsDlgMsg
= true;
2067 #endif // !__WXWINCE__
2069 if ( canSafelyCallIsDlgMsg
)
2071 // ::IsDialogMessage() can enter in an infinite loop when the
2072 // currently focused window is disabled or hidden and its
2073 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2077 if ( !::IsWindowEnabled(hwndFocus
) ||
2078 !::IsWindowVisible(hwndFocus
) )
2080 // it would enter an infinite loop if we do this!
2081 canSafelyCallIsDlgMsg
= false;
2086 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2088 // it's a top level window, don't go further -- e.g. even
2089 // if the parent of a dialog is disabled, this doesn't
2090 // break navigation inside the dialog
2094 hwndFocus
= ::GetParent(hwndFocus
);
2098 // let IsDialogMessage() have the message if it's safe to call it
2099 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2101 // IsDialogMessage() did something...
2106 #endif // __WXUNIVERSAL__
2111 // relay mouse move events to the tooltip control
2112 MSG
*msg
= (MSG
*)pMsg
;
2113 if ( msg
->message
== WM_MOUSEMOVE
)
2114 m_tooltip
->RelayEvent(pMsg
);
2116 #endif // wxUSE_TOOLTIPS
2121 bool wxWindowMSW
::MSWTranslateMessage(WXMSG
* pMsg
)
2123 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2124 return m_acceleratorTable
.Translate(this, pMsg
);
2128 #endif // wxUSE_ACCEL
2131 bool wxWindowMSW
::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2133 // preprocess all messages by default
2137 // ---------------------------------------------------------------------------
2138 // message params unpackers
2139 // ---------------------------------------------------------------------------
2141 void wxWindowMSW
::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2142 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2144 *id
= LOWORD(wParam
);
2145 *hwnd
= (WXHWND
)lParam
;
2146 *cmd
= HIWORD(wParam
);
2149 void wxWindowMSW
::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2150 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2152 *state
= LOWORD(wParam
);
2153 *minimized
= HIWORD(wParam
);
2154 *hwnd
= (WXHWND
)lParam
;
2157 void wxWindowMSW
::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2158 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2160 *code
= LOWORD(wParam
);
2161 *pos
= HIWORD(wParam
);
2162 *hwnd
= (WXHWND
)lParam
;
2165 void wxWindowMSW
::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2166 WXHDC
*hdc
, WXHWND
*hwnd
)
2168 *hwnd
= (WXHWND
)lParam
;
2169 *hdc
= (WXHDC
)wParam
;
2172 void wxWindowMSW
::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2173 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2175 *item
= (WXWORD
)wParam
;
2176 *flags
= HIWORD(wParam
);
2177 *hmenu
= (WXHMENU
)lParam
;
2180 // ---------------------------------------------------------------------------
2181 // Main wxWidgets window proc and the window proc for wxWindow
2182 // ---------------------------------------------------------------------------
2184 // Hook for new window just as it's being created, when the window isn't yet
2185 // associated with the handle
2186 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2188 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2189 // window being created and insures that it's always unset back later
2190 wxWindowCreationHook
::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2192 gs_winBeingCreated
= winBeingCreated
;
2195 wxWindowCreationHook
::~wxWindowCreationHook()
2197 gs_winBeingCreated
= NULL
;
2201 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2203 // trace all messages - useful for the debugging
2205 wxLogTrace(wxTraceMessages
,
2206 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2207 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2208 #endif // __WXDEBUG__
2210 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2212 // when we get the first message for the HWND we just created, we associate
2213 // it with wxWindow stored in gs_winBeingCreated
2214 if ( !wnd
&& gs_winBeingCreated
)
2216 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2217 wnd
= gs_winBeingCreated
;
2218 gs_winBeingCreated
= NULL
;
2219 wnd
->SetHWND((WXHWND
)hWnd
);
2225 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2227 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2232 WXLRESULT wxWindowMSW
::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2234 // did we process the message?
2235 bool processed
= false;
2246 // for most messages we should return 0 when we do process the message
2254 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2257 // return 0 to allow window creation
2258 rc
.result
= mayCreate ?
0 : -1;
2264 // never set processed to true and *always* pass WM_DESTROY to
2265 // DefWindowProc() as Windows may do some internal cleanup when
2266 // processing it and failing to pass the message along may cause
2267 // memory and resource leaks!
2268 (void)HandleDestroy();
2271 #ifndef __SMARTPHONE__ // or wxWinCE in general ?
2272 case WM_WINDOWPOSCHANGING
:
2274 WINDOWPOS
*wp
= wx_reinterpret_cast(WINDOWPOS
*, lParam
);
2276 if ( wp
->flags
& SWP_NOSIZE
)
2279 // when we resize this window, its children are probably going
2280 // to be repositioned as well, prepare to use DeferWindowPos()
2282 const int numChildren
= GetChildren().GetCount();
2283 if ( numChildren
> 1 )
2285 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
2288 wxLogLastError(_T("BeginDeferWindowPos"));
2294 case WM_WINDOWPOSCHANGED
:
2295 // first let DefWindowProc() handle the message: it will generate
2296 // WM_MOVE and WM_SIZE as needed
2297 processed
= MSWDefWindowProc(message
, wParam
, lParam
) == 0;
2299 // then change the positions of all child windows at once
2302 // put all child controls in place at once now
2303 if ( !::EndDeferWindowPos((HDWP
)m_hDWP
) )
2305 wxLogLastError(_T("EndDeferWindowPos"));
2311 #endif // __SMARTPHONE__
2314 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2318 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2321 #if !defined(__WXWINCE__)
2322 // TODO: move those in WM_WINDOWPOSCHANGING case above
2325 LPRECT pRect
= (LPRECT
)lParam
;
2327 rc
.SetLeft(pRect
->left
);
2328 rc
.SetTop(pRect
->top
);
2329 rc
.SetRight(pRect
->right
);
2330 rc
.SetBottom(pRect
->bottom
);
2331 processed
= HandleMoving(rc
);
2333 pRect
->left
= rc
.GetLeft();
2334 pRect
->top
= rc
.GetTop();
2335 pRect
->right
= rc
.GetRight();
2336 pRect
->bottom
= rc
.GetBottom();
2343 LPRECT pRect
= (LPRECT
)lParam
;
2345 rc
.SetLeft(pRect
->left
);
2346 rc
.SetTop(pRect
->top
);
2347 rc
.SetRight(pRect
->right
);
2348 rc
.SetBottom(pRect
->bottom
);
2349 processed
= HandleSizing(rc
);
2351 pRect
->left
= rc
.GetLeft();
2352 pRect
->top
= rc
.GetTop();
2353 pRect
->right
= rc
.GetRight();
2354 pRect
->bottom
= rc
.GetBottom();
2358 #endif // !__WXWINCE__
2360 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2361 case WM_ACTIVATEAPP
:
2362 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2368 WXWORD state
, minimized
;
2370 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2372 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2377 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2381 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2388 // cast to wxWindow is needed for wxUniv
2389 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2390 processed
= HandlePaint();
2394 processed
= HandlePaint();
2403 // Don't call the wx handlers in this case
2404 if ( wxIsKindOf(this, wxListCtrl
) )
2408 if ( lParam
& PRF_ERASEBKGND
)
2409 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2411 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2412 processed
= HandlePaint();
2418 #ifdef __WXUNIVERSAL__
2419 // Universal uses its own wxFrame/wxDialog, so we don't receive
2420 // close events unless we have this.
2425 // don't let the DefWindowProc() destroy our window - we'll do it
2426 // ourselves in ~wxWindow
2433 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2437 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2438 GET_Y_LPARAM(lParam
),
2442 // Seems to be broken currently
2443 #if 0 // ndef __WXWINCE__
2446 wxASSERT_MSG( !m_mouseInWindow
, wxT("the mouse should be in a window to generate this event!") );
2448 // only process this message if the mouse is not in the window,
2449 // This can also check for children in composite windows.
2450 // however, this may mean the the wxEVT_LEAVE_WINDOW is never sent
2451 // if the mouse does not enter the window from it's child before
2452 // leaving the scope of the window. ( perhaps this can be picked
2453 // up in the OnIdle code as before, for this special case )
2454 if ( /*IsComposite() && */ !IsMouseInWindow() )
2456 m_mouseInWindow
= false;
2458 // Unfortunately no mouse state is passed with a WM_MOUSE_LEAVE
2460 if ( wxIsShiftDown() )
2462 if ( wxIsCtrlDown() )
2463 state
|= MK_CONTROL
;
2464 if ( GetKeyState( VK_LBUTTON
) )
2465 state
|= MK_LBUTTON
;
2466 if ( GetKeyState( VK_MBUTTON
) )
2467 state
|= MK_MBUTTON
;
2468 if ( GetKeyState( VK_RBUTTON
) )
2469 state
|= MK_RBUTTON
;
2472 if ( !::GetCursorPos(&pt
) )
2474 wxLogLastError(_T("GetCursorPos"));
2477 // we need to have client coordinates here for symmetry with
2478 // wxEVT_ENTER_WINDOW
2479 RECT rect
= wxGetWindowRect(GetHwnd());
2483 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
2484 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
2486 (void)GetEventHandler()->ProcessEvent(event2
);
2488 // always pass processed back as false, this allows the window
2489 // manager to process the message too. This is needed to ensure
2490 // windows XP themes work properly as the mouse moves over widgets
2498 #if wxUSE_MOUSEWHEEL
2500 processed
= HandleMouseWheel(wParam
, lParam
);
2504 case WM_LBUTTONDOWN
:
2506 case WM_LBUTTONDBLCLK
:
2507 case WM_RBUTTONDOWN
:
2509 case WM_RBUTTONDBLCLK
:
2510 case WM_MBUTTONDOWN
:
2512 case WM_MBUTTONDBLCLK
:
2514 #ifdef __WXMICROWIN__
2515 // MicroWindows seems to ignore the fact that a window is
2516 // disabled. So catch mouse events and throw them away if
2518 wxWindowMSW
* win
= this;
2521 if (!win
->IsEnabled())
2527 win
= win
->GetParent();
2528 if ( !win
|| win
->IsTopLevel() )
2535 #endif // __WXMICROWIN__
2536 int x
= GET_X_LPARAM(lParam
),
2537 y
= GET_Y_LPARAM(lParam
);
2539 // redirect the event to a static control if necessary by
2540 // finding one under mouse
2542 if ( GetCapture() == this )
2544 // but don't do it if the mouse is captured by this window
2545 // because then it should really get this event itself
2550 win
= FindWindowForMouseEvent(this, &x
, &y
);
2552 // this should never happen
2553 wxCHECK_MSG( win
, 0,
2554 _T("FindWindowForMouseEvent() returned NULL") );
2557 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2559 // if the app didn't eat the event, handle it in the default
2560 // way, that is by giving this window the focus
2563 // for the standard classes their WndProc sets the focus to
2564 // them anyhow and doing it from here results in some weird
2565 // problems, so don't do it for them (unnecessary anyhow)
2566 if ( !win
->IsOfStandardClass() )
2568 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2580 case MM_JOY1BUTTONDOWN
:
2581 case MM_JOY2BUTTONDOWN
:
2582 case MM_JOY1BUTTONUP
:
2583 case MM_JOY2BUTTONUP
:
2584 processed
= HandleJoystickEvent(message
,
2585 GET_X_LPARAM(lParam
),
2586 GET_Y_LPARAM(lParam
),
2589 #endif // __WXMICROWIN__
2595 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2597 processed
= HandleCommand(id
, cmd
, hwnd
);
2602 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2605 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2606 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2607 // apparently doesn't always behave properly and needs some help
2608 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2609 case WM_NOTIFYFORMAT
:
2610 if ( lParam
== NF_QUERY
)
2613 rc
.result
= NFR_UNICODE
;
2616 #endif // wxUSE_UNICODE_MSLU
2618 // for these messages we must return true if process the message
2621 case WM_MEASUREITEM
:
2623 int idCtrl
= (UINT
)wParam
;
2624 if ( message
== WM_DRAWITEM
)
2626 processed
= MSWOnDrawItem(idCtrl
,
2627 (WXDRAWITEMSTRUCT
*)lParam
);
2631 processed
= MSWOnMeasureItem(idCtrl
,
2632 (WXMEASUREITEMSTRUCT
*)lParam
);
2639 #endif // defined(WM_DRAWITEM)
2642 if ( !IsOfStandardClass() )
2644 // we always want to get the char events
2645 rc
.result
= DLGC_WANTCHARS
;
2647 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2649 // in fact, we want everything
2650 rc
.result
|= DLGC_WANTARROWS
|
2657 //else: get the dlg code from the DefWindowProc()
2662 // If this has been processed by an event handler, return 0 now
2663 // (we've handled it).
2664 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2665 if ( m_lastKeydownProcessed
)
2674 // we consider these message "not interesting" to OnChar, so
2675 // just don't do anything more with them
2685 // avoid duplicate messages to OnChar for these ASCII keys:
2686 // they will be translated by TranslateMessage() and received
2708 // but set processed to false, not true to still pass them
2709 // to the control's default window proc - otherwise
2710 // built-in keyboard handling won't work
2715 // special case of VK_APPS: treat it the same as right mouse
2716 // click because both usually pop up a context menu
2718 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2723 // do generate a CHAR event
2724 processed
= HandleChar((WORD
)wParam
, lParam
);
2727 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2734 // special case of VK_APPS: treat it the same as right mouse button
2735 if ( wParam
== VK_APPS
)
2737 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2742 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2747 case WM_CHAR
: // Always an ASCII character
2748 if ( m_lastKeydownProcessed
)
2750 // The key was handled in the EVT_KEY_DOWN and handling
2751 // a key in an EVT_KEY_DOWN handler is meant, by
2752 // design, to prevent EVT_CHARs from happening
2753 m_lastKeydownProcessed
= false;
2758 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2764 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2766 #endif // wxUSE_HOTKEY
2773 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2775 processed
= MSWOnScroll(message
== WM_HSCROLL ? wxHORIZONTAL
2781 // CTLCOLOR messages are sent by children to query the parent for their
2783 #ifndef __WXMICROWIN__
2784 case WM_CTLCOLORMSGBOX
:
2785 case WM_CTLCOLOREDIT
:
2786 case WM_CTLCOLORLISTBOX
:
2787 case WM_CTLCOLORBTN
:
2788 case WM_CTLCOLORDLG
:
2789 case WM_CTLCOLORSCROLLBAR
:
2790 case WM_CTLCOLORSTATIC
:
2794 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2796 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2799 #endif // !__WXMICROWIN__
2801 case WM_SYSCOLORCHANGE
:
2802 // the return value for this message is ignored
2803 processed
= HandleSysColorChange();
2806 #if !defined(__WXWINCE__)
2807 case WM_DISPLAYCHANGE
:
2808 processed
= HandleDisplayChange();
2812 case WM_PALETTECHANGED
:
2813 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2816 case WM_CAPTURECHANGED
:
2817 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2820 case WM_QUERYNEWPALETTE
:
2821 processed
= HandleQueryNewPalette();
2825 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2828 // we processed the message, i.e. erased the background
2833 #if !defined(__WXWINCE__)
2835 processed
= HandleDropFiles(wParam
);
2840 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2844 // we never set focus from here
2849 #if !defined(__WXWINCE__)
2850 case WM_QUERYENDSESSION
:
2851 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2855 processed
= HandleEndSession(wParam
!= 0, lParam
);
2858 case WM_GETMINMAXINFO
:
2859 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2864 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2865 LOWORD(lParam
), // hit test
2866 HIWORD(lParam
)); // mouse msg
2870 // returning TRUE stops the DefWindowProc() from further
2871 // processing this message - exactly what we need because we've
2872 // just set the cursor.
2877 #if wxUSE_ACCESSIBILITY
2880 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2881 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2883 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2885 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2891 #if defined(WM_HELP)
2894 // HELPINFO doesn't seem to be supported on WinCE.
2896 HELPINFO
* info
= (HELPINFO
*) lParam
;
2897 // Don't yet process menu help events, just windows
2898 if (info
->iContextType
== HELPINFO_WINDOW
)
2901 wxWindowMSW
* subjectOfHelp
= this;
2902 bool eventProcessed
= false;
2903 while (subjectOfHelp
&& !eventProcessed
)
2905 wxHelpEvent
helpEvent(wxEVT_HELP
,
2906 subjectOfHelp
->GetId(),
2910 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2914 helpEvent
.SetEventObject(this);
2916 GetEventHandler()->ProcessEvent(helpEvent
);
2918 // Go up the window hierarchy until the event is
2920 subjectOfHelp
= subjectOfHelp
->GetParent();
2923 processed
= eventProcessed
;
2926 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2928 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2929 helpEvent
.SetEventObject(this);
2930 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2933 //else: processed is already false
2939 #if !defined(__WXWINCE__)
2940 case WM_CONTEXTMENU
:
2942 // we don't convert from screen to client coordinates as
2943 // the event may be handled by a parent window
2944 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2946 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2948 // we could have got an event from our child, reflect it back
2949 // to it if this is the case
2950 wxWindowMSW
*win
= NULL
;
2951 if ( (WXHWND
)wParam
!= m_hWnd
)
2953 win
= FindItemByHWND((WXHWND
)wParam
);
2959 evtCtx
.SetEventObject(win
);
2960 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
2966 // we're only interested in our own menus, not MF_SYSMENU
2967 if ( HIWORD(wParam
) == MF_POPUP
)
2969 // handle menu chars for ownerdrawn menu items
2970 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2971 if ( i
!= wxNOT_FOUND
)
2973 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2983 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2984 wxGetMessageName(message
));
2985 #endif // __WXDEBUG__
2986 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2992 // ----------------------------------------------------------------------------
2993 // wxWindow <-> HWND map
2994 // ----------------------------------------------------------------------------
2996 wxWinHashTable
*wxWinHandleHash
= NULL
;
2998 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3000 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3003 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3005 // adding NULL hWnd is (first) surely a result of an error and
3006 // (secondly) breaks menu command processing
3007 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3008 wxT("attempt to add a NULL hWnd to window list ignored") );
3010 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3012 if ( oldWin
&& (oldWin
!= win
) )
3014 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3015 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3018 #endif // __WXDEBUG__
3021 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3025 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3027 wxWinHandleHash
->Delete((long)win
->GetHWND());
3030 // ----------------------------------------------------------------------------
3031 // various MSW speciic class dependent functions
3032 // ----------------------------------------------------------------------------
3034 // Default destroyer - override if you destroy it in some other way
3035 // (e.g. with MDI child windows)
3036 void wxWindowMSW
::MSWDestroyWindow()
3040 bool wxWindowMSW
::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3043 int& w
, int& h
) const
3045 // yes, those are just some arbitrary hardcoded numbers
3046 static const int DEFAULT_Y
= 200;
3048 bool nonDefault
= false;
3050 if ( pos
.x
== wxDefaultCoord
)
3052 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3053 // can just as well set it to CW_USEDEFAULT as well
3059 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3060 // neither because it is not handled as a special value by Windows then
3061 // and so we have to choose some default value for it
3063 y
= pos
.y
== wxDefaultCoord ? DEFAULT_Y
: pos
.y
;
3069 NB: there used to be some code here which set the initial size of the
3070 window to the client size of the parent if no explicit size was
3071 specified. This was wrong because wxWidgets programs often assume
3072 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3073 it. To see why, you should understand that Windows sends WM_SIZE from
3074 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3075 from some base class ctor and so this WM_SIZE is not processed in the
3076 real class' OnSize() (because it's not fully constructed yet and the
3077 event goes to some base class OnSize() instead). So the WM_SIZE we
3078 rely on is the one sent when the parent frame resizes its children
3079 but here is the problem: if the child already has just the right
3080 size, nothing will happen as both wxWidgets and Windows check for
3081 this and ignore any attempts to change the window size to the size it
3082 already has - so no WM_SIZE would be sent.
3086 // we don't use CW_USEDEFAULT here for several reasons:
3088 // 1. it results in huge frames on modern screens (1000*800 is not
3089 // uncommon on my 1280*1024 screen) which is way too big for a half
3090 // empty frame of most of wxWidgets samples for example)
3092 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3093 // the default is for whatever reason 8*8 which breaks client <->
3094 // window size calculations (it would be nice if it didn't, but it
3095 // does and the simplest way to fix it seemed to change the broken
3096 // default size anyhow)
3098 // 3. there is just no advantage in doing it: with x and y it is
3099 // possible that [future versions of] Windows position the new top
3100 // level window in some smart way which we can't do, but we can
3101 // guess a reasonably good size for a new window just as well
3104 // However, on PocketPC devices, we must use the default
3105 // size if possible.
3107 if (size
.x
== wxDefaultCoord
)
3111 if (size
.y
== wxDefaultCoord
)
3116 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3120 w
= WidthDefault(size
.x
);
3121 h
= HeightDefault(size
.y
);
3124 AdjustForParentClientOrigin(x
, y
);
3129 WXHWND wxWindowMSW
::MSWGetParent() const
3131 return m_parent ? m_parent
->GetHWND() : WXHWND(NULL
);
3134 bool wxWindowMSW
::MSWCreate(const wxChar
*wclass
,
3135 const wxChar
*title
,
3139 WXDWORD extendedStyle
)
3141 // choose the position/size for the new window
3143 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3145 // controlId is menu handle for the top level windows, so set it to 0
3146 // unless we're creating a child window
3147 int controlId
= style
& WS_CHILD ?
GetId() : 0;
3149 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3150 // which is the same but without CS_[HV]REDRAW class styles so using it
3151 // ensures that the window is not fully repainted on each resize
3152 wxString
className(wclass
);
3153 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3155 className
+= wxT("NR");
3158 // do create the window
3159 wxWindowCreationHook
hook(this);
3161 // VZ: anyone care to explain why this is done for CE?
3163 if (extendedStyle
== 0)
3165 m_hWnd
= (WXHWND
)::CreateWindow
3168 title ? title
: wxEmptyString
,
3171 (HWND
)MSWGetParent(),
3174 NULL
// no extra data
3178 #endif // __WXWINCE__
3180 m_hWnd
= (WXHWND
)::CreateWindowEx
3184 title ? title
: wxEmptyString
,
3187 (HWND
)MSWGetParent(),
3190 NULL
// no extra data
3196 wxLogSysError(_("Can't create window of class %s"), wclass
);
3201 SubclassWin(m_hWnd
);
3206 // ===========================================================================
3207 // MSW message handlers
3208 // ===========================================================================
3210 // ---------------------------------------------------------------------------
3212 // ---------------------------------------------------------------------------
3216 bool wxWindowMSW
::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3218 #ifndef __WXMICROWIN__
3219 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3220 HWND hWnd
= hdr
->hwndFrom
;
3221 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3223 // if the control is one of our windows, let it handle the message itself
3226 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3229 // VZ: why did we do it? normally this is unnecessary and, besides, it
3230 // breaks the message processing for the toolbars because the tooltip
3231 // notifications were being forwarded to the toolbar child controls
3232 // (if it had any) before being passed to the toolbar itself, so in my
3233 // example the tooltip for the combobox was always shown instead of the
3234 // correct button tooltips
3236 // try all our children
3237 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3240 wxWindow
*child
= node
->GetData();
3241 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3246 node
= node
->GetNext();
3250 // by default, handle it ourselves
3251 return MSWOnNotify(idCtrl
, lParam
, result
);
3252 #else // __WXMICROWIN__
3259 bool wxWindowMSW
::HandleTooltipNotify(WXUINT code
,
3261 const wxString
& ttip
)
3263 // I don't know why it happens, but the versions of comctl32.dll starting
3264 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3265 // this message is supposed to be sent to Unicode programs only) -- hence
3266 // we need to handle it as well, otherwise no tooltips will be shown in
3269 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3272 // not a tooltip message or no tooltip to show anyhow
3277 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3279 // We don't want to use the szText buffer because it has a limit of 80
3280 // bytes and this is not enough, especially for Unicode build where it
3281 // limits the tooltip string length to only 40 characters
3283 // The best would be, of course, to not impose any length limitations at
3284 // all but then the buffer would have to be dynamic and someone would have
3285 // to free it and we don't have the tooltip owner object here any more, so
3286 // for now use our own static buffer with a higher fixed max length.
3288 // Note that using a static buffer should not be a problem as only a single
3289 // tooltip can be shown at the same time anyhow.
3291 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3293 // We need to convert tooltip from multi byte to Unicode on the fly.
3294 static wchar_t buf
[513];
3296 // Truncate tooltip length if needed as otherwise we might not have
3297 // enough space for it in the buffer and MultiByteToWideChar() would
3299 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3301 // Convert to WideChar without adding the NULL character. The NULL
3302 // character is added afterwards (this is more efficient).
3303 int len
= ::MultiByteToWideChar
3315 wxLogLastError(_T("MultiByteToWideChar()"));
3319 ttText
->lpszText
= (LPSTR
) buf
;
3321 else // TTN_NEEDTEXTA
3322 #endif // !wxUSE_UNICODE
3324 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3325 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3326 // to copy the string we have into the buffer
3327 static wxChar buf
[513];
3328 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3329 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3330 ttText
->lpszText
= buf
;
3336 #endif // wxUSE_TOOLTIPS
3338 bool wxWindowMSW
::MSWOnNotify(int WXUNUSED(idCtrl
),
3340 WXLPARAM
* WXUNUSED(result
))
3345 NMHDR
* hdr
= (NMHDR
*)lParam
;
3346 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3353 wxUnusedVar(lParam
);
3354 #endif // wxUSE_TOOLTIPS
3361 // ---------------------------------------------------------------------------
3362 // end session messages
3363 // ---------------------------------------------------------------------------
3365 bool wxWindowMSW
::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3368 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3369 event
.SetEventObject(wxTheApp
);
3370 event
.SetCanVeto(true);
3371 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3373 bool rc
= wxTheApp
->ProcessEvent(event
);
3377 // we may end only if the app didn't veto session closing (double
3379 *mayEnd
= !event
.GetVeto();
3388 bool wxWindowMSW
::HandleEndSession(bool endSession
, long logOff
)
3391 // do nothing if the session isn't ending
3396 if ( (this != wxTheApp
->GetTopWindow()) )
3399 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3400 event
.SetEventObject(wxTheApp
);
3401 event
.SetCanVeto(false);
3402 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3404 return wxTheApp
->ProcessEvent(event
);
3410 // ---------------------------------------------------------------------------
3411 // window creation/destruction
3412 // ---------------------------------------------------------------------------
3414 bool wxWindowMSW
::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3416 // VZ: why is this commented out for WinCE? If it doesn't support
3417 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3418 // not with multiple #ifdef's!
3420 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3421 EnsureParentHasControlParentStyle(GetParent());
3424 #endif // !__WXWINCE__
3426 // TODO: should generate this event from WM_NCCREATE
3427 wxWindowCreateEvent
event((wxWindow
*)this);
3428 (void)GetEventHandler()->ProcessEvent(event
);
3435 bool wxWindowMSW
::HandleDestroy()
3439 // delete our drop target if we've got one
3440 #if wxUSE_DRAG_AND_DROP
3441 if ( m_dropTarget
!= NULL
)
3443 m_dropTarget
->Revoke(m_hWnd
);
3445 delete m_dropTarget
;
3446 m_dropTarget
= NULL
;
3448 #endif // wxUSE_DRAG_AND_DROP
3450 // WM_DESTROY handled
3454 // ---------------------------------------------------------------------------
3456 // ---------------------------------------------------------------------------
3458 bool wxWindowMSW
::HandleActivate(int state
,
3459 bool WXUNUSED(minimized
),
3460 WXHWND
WXUNUSED(activate
))
3462 wxActivateEvent
event(wxEVT_ACTIVATE
,
3463 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3465 event
.SetEventObject(this);
3467 return GetEventHandler()->ProcessEvent(event
);
3470 bool wxWindowMSW
::HandleSetFocus(WXHWND hwnd
)
3472 // Strangly enough, some controls get set focus events when they are being
3473 // deleted, even if they already had focus before.
3474 if ( m_isBeingDeleted
)
3479 // notify the parent keeping track of focus for the kbd navigation
3480 // purposes that we got it
3481 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3482 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3488 m_caret
->OnSetFocus();
3490 #endif // wxUSE_CARET
3493 // If it's a wxTextCtrl don't send the event as it will be done
3494 // after the control gets to process it from EN_FOCUS handler
3495 if ( wxDynamicCastThis(wxTextCtrl
) )
3499 #endif // wxUSE_TEXTCTRL
3501 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3502 event
.SetEventObject(this);
3504 // wxFindWinFromHandle() may return NULL, it is ok
3505 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3507 return GetEventHandler()->ProcessEvent(event
);
3510 bool wxWindowMSW
::HandleKillFocus(WXHWND hwnd
)
3516 m_caret
->OnKillFocus();
3518 #endif // wxUSE_CARET
3521 // If it's a wxTextCtrl don't send the event as it will be done
3522 // after the control gets to process it.
3523 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3530 // Don't send the event when in the process of being deleted. This can
3531 // only cause problems if the event handler tries to access the object.
3532 if ( m_isBeingDeleted
)
3537 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3538 event
.SetEventObject(this);
3540 // wxFindWinFromHandle() may return NULL, it is ok
3541 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3543 return GetEventHandler()->ProcessEvent(event
);
3546 // ---------------------------------------------------------------------------
3548 // ---------------------------------------------------------------------------
3550 bool wxWindowMSW
::HandleShow(bool show
, int WXUNUSED(status
))
3552 wxShowEvent
event(GetId(), show
);
3553 event
.m_eventObject
= this;
3555 return GetEventHandler()->ProcessEvent(event
);
3558 bool wxWindowMSW
::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3560 wxInitDialogEvent
event(GetId());
3561 event
.m_eventObject
= this;
3563 return GetEventHandler()->ProcessEvent(event
);
3566 bool wxWindowMSW
::HandleDropFiles(WXWPARAM wParam
)
3568 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3569 wxUnusedVar(wParam
);
3571 #else // __WXMICROWIN__
3572 HDROP hFilesInfo
= (HDROP
) wParam
;
3574 // Get the total number of files dropped
3575 UINT gwFilesDropped
= ::DragQueryFile
3583 wxString
*files
= new wxString
[gwFilesDropped
];
3584 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3586 // first get the needed buffer length (+1 for terminating NUL)
3587 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3589 // and now get the file name
3590 ::DragQueryFile(hFilesInfo
, wIndex
,
3591 wxStringBuffer(files
[wIndex
], len
), len
);
3593 DragFinish (hFilesInfo
);
3595 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3596 event
.m_eventObject
= this;
3599 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3600 event
.m_pos
.x
= dropPoint
.x
;
3601 event
.m_pos
.y
= dropPoint
.y
;
3603 return GetEventHandler()->ProcessEvent(event
);
3608 bool wxWindowMSW
::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3610 int WXUNUSED(mouseMsg
))
3612 #ifndef __WXMICROWIN__
3613 // the logic is as follows:
3614 // -1. don't set cursor for non client area, including but not limited to
3615 // the title bar, scrollbars, &c
3616 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3617 // 1. if we have the cursor set it unless wxIsBusy()
3618 // 2. if we're a top level window, set some cursor anyhow
3619 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3621 if ( nHitTest
!= HTCLIENT
)
3626 HCURSOR hcursor
= 0;
3628 // first ask the user code - it may wish to set the cursor in some very
3629 // specific way (for example, depending on the current position)
3631 if ( !::GetCursorPos(&pt
) )
3633 wxLogLastError(wxT("GetCursorPos"));
3638 ScreenToClient(&x
, &y
);
3639 wxSetCursorEvent
event(x
, y
);
3641 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3642 if ( processedEvtSetCursor
&& event
.HasCursor() )
3644 hcursor
= GetHcursorOf(event
.GetCursor());
3649 bool isBusy
= wxIsBusy();
3651 // the test for processedEvtSetCursor is here to prevent using m_cursor
3652 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3653 // it - this is a way to say that our cursor shouldn't be used for this
3655 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3657 hcursor
= GetHcursorOf(m_cursor
);
3664 hcursor
= wxGetCurrentBusyCursor();
3666 else if ( !hcursor
)
3668 const wxCursor
*cursor
= wxGetGlobalCursor();
3669 if ( cursor
&& cursor
->Ok() )
3671 hcursor
= GetHcursorOf(*cursor
);
3679 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3681 ::SetCursor(hcursor
);
3683 // cursor set, stop here
3686 #endif // __WXMICROWIN__
3688 // pass up the window chain
3692 // ---------------------------------------------------------------------------
3693 // owner drawn stuff
3694 // ---------------------------------------------------------------------------
3696 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3697 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3698 #define WXUNUSED_UNLESS_ODRAWN(param) param
3700 #define WXUNUSED_UNLESS_ODRAWN(param)
3704 wxWindowMSW
::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3705 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3707 #if wxUSE_OWNER_DRAWN
3709 #if wxUSE_MENUS_NATIVE
3710 // is it a menu item?
3711 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3712 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3714 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3716 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3717 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3719 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3720 // the DC from being released
3721 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3722 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3723 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3724 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3726 return pMenuItem
->OnDrawItem
3730 (wxOwnerDrawn
::wxODAction
)pDrawStruct
->itemAction
,
3731 (wxOwnerDrawn
::wxODStatus
)pDrawStruct
->itemState
3734 #endif // wxUSE_MENUS_NATIVE
3736 #endif // USE_OWNER_DRAWN
3738 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3740 #if wxUSE_OWNER_DRAWN
3741 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3742 #else // !wxUSE_OWNER_DRAWN
3743 // we may still have owner-drawn buttons internally because we have to make
3744 // them owner-drawn to support colour change
3747 wxDynamicCast(FindItem(id
), wxButton
)
3752 #endif // USE_OWNER_DRAWN
3756 return item
->MSWOnDraw(itemStruct
);
3759 #endif // wxUSE_CONTROLS
3765 wxWindowMSW
::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3767 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3768 // is it a menu item?
3769 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3770 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3772 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3774 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3775 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3778 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3780 pMeasureStruct
->itemWidth
= w
;
3781 pMeasureStruct
->itemHeight
= h
;
3786 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3789 return item
->MSWOnMeasure(itemStruct
);
3793 wxUnusedVar(itemStruct
);
3794 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3799 // ---------------------------------------------------------------------------
3800 // colours and palettes
3801 // ---------------------------------------------------------------------------
3803 bool wxWindowMSW
::HandleSysColorChange()
3805 wxSysColourChangedEvent event
;
3806 event
.SetEventObject(this);
3808 (void)GetEventHandler()->ProcessEvent(event
);
3810 // always let the system carry on the default processing to allow the
3811 // native controls to react to the colours update
3815 bool wxWindowMSW
::HandleDisplayChange()
3817 wxDisplayChangedEvent event
;
3818 event
.SetEventObject(this);
3820 return GetEventHandler()->ProcessEvent(event
);
3823 #ifndef __WXMICROWIN__
3825 bool wxWindowMSW
::HandleCtlColor(WXHBRUSH
*brush
, WXHDC pDC
, WXHWND pWnd
)
3828 wxWindow
*item
= FindItemByHWND(pWnd
, true);
3830 *brush
= item
->MSWControlColor(pDC
);
3832 #endif // wxUSE_CONTROLS
3835 return *brush
!= NULL
;
3838 #endif // __WXMICROWIN__
3840 WXHBRUSH wxWindowMSW
::MSWControlColor(WXHDC
WXUNUSED(hDC
))
3845 bool wxWindowMSW
::HandlePaletteChanged(WXHWND hWndPalChange
)
3848 // same as below except we don't respond to our own messages
3849 if ( hWndPalChange
!= GetHWND() )
3851 // check to see if we our our parents have a custom palette
3852 wxWindowMSW
*win
= this;
3853 while ( win
&& !win
->HasCustomPalette() )
3855 win
= win
->GetParent();
3858 if ( win
&& win
->HasCustomPalette() )
3860 // realize the palette to see whether redrawing is needed
3861 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3862 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3863 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3865 int result
= ::RealizePalette(hdc
);
3867 // restore the palette (before releasing the DC)
3868 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3869 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3870 ::RealizePalette(hdc
);
3871 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3873 // now check for the need to redraw
3875 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3879 #endif // wxUSE_PALETTE
3881 wxPaletteChangedEvent
event(GetId());
3882 event
.SetEventObject(this);
3883 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3885 return GetEventHandler()->ProcessEvent(event
);
3888 bool wxWindowMSW
::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3890 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3891 event
.SetEventObject(this);
3893 return GetEventHandler()->ProcessEvent(event
);
3896 bool wxWindowMSW
::HandleQueryNewPalette()
3900 // check to see if we our our parents have a custom palette
3901 wxWindowMSW
*win
= this;
3902 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3903 if (win
->HasCustomPalette()) {
3904 /* realize the palette to see whether redrawing is needed */
3905 HDC hdc
= ::GetDC((HWND
) GetHWND());
3906 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3907 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3909 int result
= ::RealizePalette(hdc
);
3910 /* restore the palette (before releasing the DC) */
3911 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3912 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3913 ::RealizePalette(hdc
);
3914 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3915 /* now check for the need to redraw */
3917 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3919 #endif // wxUSE_PALETTE
3921 wxQueryNewPaletteEvent
event(GetId());
3922 event
.SetEventObject(this);
3924 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3927 // Responds to colour changes: passes event on to children.
3928 void wxWindowMSW
::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3930 // the top level window also reset the standard colour map as it might have
3931 // changed (there is no need to do it for the non top level windows as we
3932 // only have to do it once)
3936 gs_hasStdCmap
= false;
3938 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3941 // Only propagate to non-top-level windows because Windows already
3942 // sends this event to all top-level ones
3943 wxWindow
*win
= node
->GetData();
3944 if ( !win
->IsTopLevel() )
3946 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3947 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3948 // the standard controls
3949 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3952 node
= node
->GetNext();
3956 extern wxCOLORMAP
*wxGetStdColourMap()
3958 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3959 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3961 if ( !gs_hasStdCmap
)
3963 static bool s_coloursInit
= false;
3965 if ( !s_coloursInit
)
3967 // When a bitmap is loaded, the RGB values can change (apparently
3968 // because Windows adjusts them to care for the old programs always
3969 // using 0xc0c0c0 while the transparent colour for the new Windows
3970 // versions is different). But we do this adjustment ourselves so
3971 // we want to avoid Windows' "help" and for this we need to have a
3972 // reference bitmap which can tell us what the RGB values change
3974 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3975 if ( stdColourBitmap
.Ok() )
3977 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3978 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3979 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3982 memDC
.SelectObject(stdColourBitmap
);
3985 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3987 memDC
.GetPixel(i
, 0, &colour
);
3988 s_stdColours
[i
] = wxColourToRGB(colour
);
3991 else // wxBITMAP_STD_COLOURS couldn't be loaded
3993 s_stdColours
[0] = RGB(000,000,000); // black
3994 s_stdColours
[1] = RGB(128,128,128); // dark grey
3995 s_stdColours
[2] = RGB(192,192,192); // light grey
3996 s_stdColours
[3] = RGB(255,255,255); // white
3997 //s_stdColours[4] = RGB(000,000,255); // blue
3998 //s_stdColours[5] = RGB(255,000,255); // magenta
4001 s_coloursInit
= true;
4004 gs_hasStdCmap
= true;
4006 // create the colour map
4007 #define INIT_CMAP_ENTRY(col) \
4008 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4009 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4011 INIT_CMAP_ENTRY(BTNTEXT
);
4012 INIT_CMAP_ENTRY(BTNSHADOW
);
4013 INIT_CMAP_ENTRY(BTNFACE
);
4014 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4016 #undef INIT_CMAP_ENTRY
4022 // ---------------------------------------------------------------------------
4024 // ---------------------------------------------------------------------------
4026 bool wxWindowMSW
::HandlePaint()
4028 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4030 wxLogLastError(wxT("CreateRectRgn"));
4031 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4032 wxLogLastError(wxT("GetUpdateRgn"));
4034 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4036 wxPaintEvent
event(m_windowId
);
4037 event
.SetEventObject(this);
4039 bool processed
= GetEventHandler()->ProcessEvent(event
);
4041 // note that we must generate NC event after the normal one as otherwise
4042 // BeginPaint() will happily overwrite our decorations with the background
4044 wxNcPaintEvent
eventNc(m_windowId
);
4045 eventNc
.SetEventObject(this);
4046 GetEventHandler()->ProcessEvent(eventNc
);
4051 // Can be called from an application's OnPaint handler
4052 void wxWindowMSW
::OnPaint(wxPaintEvent
& event
)
4054 #ifdef __WXUNIVERSAL__
4057 HDC hDC
= (HDC
) wxPaintDC
::FindDCInCache((wxWindow
*) event
.GetEventObject());
4060 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4065 bool wxWindowMSW
::HandleEraseBkgnd(WXHDC hdc
)
4070 dc
.SetWindow((wxWindow
*)this);
4073 wxEraseEvent
event(m_windowId
, &dc
);
4074 event
.SetEventObject(this);
4075 bool rc
= GetEventHandler()->ProcessEvent(event
);
4079 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4080 dc
.SelectOldObjects(hdc
);
4085 void wxWindowMSW
::OnEraseBackground(wxEraseEvent
& event
)
4087 // standard controls always erase their background themselves (although the
4088 // user may try to override it in a derived class)
4089 if ( IsOfStandardClass() )
4095 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4097 // don't skip the event here, custom background means that the app
4098 // is drawing it itself in its OnPaint(), so don't draw it at all
4099 // now to avoid flicker
4104 // do default background painting
4105 if ( !DoEraseBackground(*event
.GetDC()) )
4107 // let the system paint the background
4112 bool wxWindowMSW
::DoEraseBackground(wxDC
& dc
)
4114 HBRUSH hBrush
= (HBRUSH
)MSWGetBgBrush(dc
.GetHDC());
4119 ::GetClientRect(GetHwnd(), &rc
);
4120 ::FillRect(GetHdcOf(dc
), &rc
, hBrush
);
4125 WXHBRUSH wxWindowMSW
::MSWGetSolidBgBrushForChild(wxWindow
*child
)
4127 wxColour col
= MSWGetBgColourForChild(child
);
4130 // draw children with the same colour as the parent
4131 wxBrush
*brush
= wxTheBrushList
->FindOrCreateBrush(col
, wxSOLID
);
4133 return (WXHBRUSH
)brush
->GetResourceHandle();
4139 wxColour wxWindowMSW
::MSWGetBgColourForChild(wxWindow
*child
)
4143 if ( m_inheritBgCol
||
4145 child
->HasTransparentBackground() )
4147 return GetBackgroundColour();
4151 return wxNullColour
;
4154 WXHBRUSH wxWindowMSW
::MSWGetBgBrushForSelf(wxWindow
*parent
, WXHDC hDC
)
4156 return parent
->MSWGetBgBrushForChild(hDC
, (wxWindow
*)this);
4159 WXHBRUSH wxWindowMSW
::MSWGetBgBrush(WXHDC hDC
)
4161 for ( wxWindow
*win
= (wxWindow
*)this; win
; win
= win
->GetParent() )
4163 WXHBRUSH hBrush
= MSWGetBgBrushForSelf(win
, hDC
);
4167 // background is not inherited beyond the windows which have their own
4168 // fixed background such as top level windows and notebooks and for
4169 // windows for which a custom colour had been explicitly set with
4170 // SetOwnBackgroundColour() and so shouldn't affect its children
4171 if ( win
->ProvidesBackground() ||
4172 (win
->m_hasBgCol
&& !win
->m_inheritBgCol
) )
4179 // ---------------------------------------------------------------------------
4180 // moving and resizing
4181 // ---------------------------------------------------------------------------
4183 bool wxWindowMSW
::HandleMinimize()
4185 wxIconizeEvent
event(m_windowId
);
4186 event
.SetEventObject(this);
4188 return GetEventHandler()->ProcessEvent(event
);
4191 bool wxWindowMSW
::HandleMaximize()
4193 wxMaximizeEvent
event(m_windowId
);
4194 event
.SetEventObject(this);
4196 return GetEventHandler()->ProcessEvent(event
);
4199 bool wxWindowMSW
::HandleMove(int x
, int y
)
4202 wxMoveEvent
event(point
, m_windowId
);
4203 event
.SetEventObject(this);
4205 return GetEventHandler()->ProcessEvent(event
);
4208 bool wxWindowMSW
::HandleMoving(wxRect
& rect
)
4210 wxMoveEvent
event(rect
, m_windowId
);
4211 event
.SetEventObject(this);
4213 bool rc
= GetEventHandler()->ProcessEvent(event
);
4215 rect
= event
.GetRect();
4219 bool wxWindowMSW
::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4221 bool processed
= false;
4226 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4227 // fall through nevertheless
4231 // we're not interested in these messages at all
4234 case SIZE_MINIMIZED
:
4235 processed
= HandleMinimize();
4238 case SIZE_MAXIMIZED
:
4239 /* processed = */ HandleMaximize();
4240 // fall through to send a normal size event as well
4243 // don't use w and h parameters as they specify the client size
4244 // while according to the docs EVT_SIZE handler is supposed to
4245 // receive the total size
4246 wxSizeEvent
event(GetSize(), m_windowId
);
4247 event
.SetEventObject(this);
4249 processed
= GetEventHandler()->ProcessEvent(event
);
4255 bool wxWindowMSW
::HandleSizing(wxRect
& rect
)
4257 wxSizeEvent
event(rect
, m_windowId
);
4258 event
.SetEventObject(this);
4260 bool rc
= GetEventHandler()->ProcessEvent(event
);
4262 rect
= event
.GetRect();
4266 bool wxWindowMSW
::HandleGetMinMaxInfo(void *mmInfo
)
4269 wxUnusedVar(mmInfo
);
4272 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4276 int minWidth
= GetMinWidth(),
4277 minHeight
= GetMinHeight(),
4278 maxWidth
= GetMaxWidth(),
4279 maxHeight
= GetMaxHeight();
4281 if ( minWidth
!= wxDefaultCoord
)
4283 info
->ptMinTrackSize
.x
= minWidth
;
4287 if ( minHeight
!= wxDefaultCoord
)
4289 info
->ptMinTrackSize
.y
= minHeight
;
4293 if ( maxWidth
!= wxDefaultCoord
)
4295 info
->ptMaxTrackSize
.x
= maxWidth
;
4299 if ( maxHeight
!= wxDefaultCoord
)
4301 info
->ptMaxTrackSize
.y
= maxHeight
;
4309 // ---------------------------------------------------------------------------
4311 // ---------------------------------------------------------------------------
4313 bool wxWindowMSW
::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4315 #if wxUSE_MENUS_NATIVE
4316 if ( !cmd
&& wxCurrentPopupMenu
)
4318 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4319 wxCurrentPopupMenu
= NULL
;
4321 return popupMenu
->MSWCommand(cmd
, id
);
4323 #endif // wxUSE_MENUS_NATIVE
4325 wxWindow
*win
= NULL
;
4327 // first try to find it from HWND - this works even with the broken
4328 // programs using the same ids for different controls
4331 win
= wxFindWinFromHandle(control
);
4337 // must cast to a signed type before comparing with other ids!
4338 win
= FindItem((signed short)id
);
4343 return win
->MSWCommand(cmd
, id
);
4346 // the messages sent from the in-place edit control used by the treectrl
4347 // for label editing have id == 0, but they should _not_ be treated as menu
4348 // messages (they are EN_XXX ones, in fact) so don't translate anything
4349 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4352 // If no child window, it may be an accelerator, e.g. for a popup menu
4355 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4356 event
.SetEventObject(this);
4360 return GetEventHandler()->ProcessEvent(event
);
4362 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4365 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4366 // notifications to its parent which we want to reflect back to
4368 wxSpinCtrl
*spin
= wxSpinCtrl
::GetSpinForTextCtrl(control
);
4369 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4372 #endif // wxUSE_SPINCTRL
4377 // ---------------------------------------------------------------------------
4379 // ---------------------------------------------------------------------------
4381 void wxWindowMSW
::InitMouseEvent(wxMouseEvent
& event
,
4385 // our client coords are not quite the same as Windows ones
4386 wxPoint pt
= GetClientAreaOrigin();
4387 event
.m_x
= x
- pt
.x
;
4388 event
.m_y
= y
- pt
.y
;
4390 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4391 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4392 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4393 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4394 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4395 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4396 // Returns different negative values on WinME and WinNT,
4397 // so simply test for negative value.
4398 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4401 event
.SetTimestamp(::GetMessageTime());
4404 event
.m_eventObject
= this;
4405 event
.SetId(GetId());
4407 #if wxUSE_MOUSEEVENT_HACK
4410 m_lastMouseEvent
= event
.GetEventType();
4411 #endif // wxUSE_MOUSEEVENT_HACK
4414 // Windows doesn't send the mouse events to the static controls (which are
4415 // transparent in the sense that their WM_NCHITTEST handler returns
4416 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4417 // and so we manually check if we don't have a child window under mouse and if
4418 // we do, send the event to it instead of the window Windows had sent WM_XXX
4421 // Notice that this is not done for the mouse move events because this could
4422 // (would?) be too slow, but only for clicks which means that the static texts
4423 // still don't get move, enter nor leave events.
4424 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4426 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4428 // first try to find a non transparent child: this allows us to send events
4429 // to a static text which is inside a static box, for example
4430 POINT pt
= { *x
, *y
};
4431 HWND hwnd
= GetHwndOf(win
),
4435 hwndUnderMouse
= ::ChildWindowFromPoint
4441 hwndUnderMouse
= ::ChildWindowFromPointEx
4451 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4453 // now try any child window at all
4454 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4457 // check that we have a child window which is susceptible to receive mouse
4458 // events: for this it must be shown and enabled
4459 if ( hwndUnderMouse
&&
4460 hwndUnderMouse
!= hwnd
&&
4461 ::IsWindowVisible(hwndUnderMouse
) &&
4462 ::IsWindowEnabled(hwndUnderMouse
) )
4464 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4465 if ( winUnderMouse
)
4467 // translate the mouse coords to the other window coords
4468 win
->ClientToScreen(x
, y
);
4469 winUnderMouse
->ScreenToClient(x
, y
);
4471 win
= winUnderMouse
;
4478 bool wxWindowMSW
::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4480 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4481 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4482 // from the message id and take the value in the table to get wxWin event
4484 static const wxEventType eventsMouse
[] =
4498 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4499 InitMouseEvent(event
, x
, y
, flags
);
4501 return GetEventHandler()->ProcessEvent(event
);
4504 bool wxWindowMSW
::HandleMouseMove(int x
, int y
, WXUINT flags
)
4506 if ( !m_mouseInWindow
)
4508 // it would be wrong to assume that just because we get a mouse move
4509 // event that the mouse is inside the window: although this is usually
4510 // true, it is not if we had captured the mouse, so we need to check
4511 // the mouse coordinates here
4512 if ( !HasCapture() || IsMouseInWindow() )
4514 // Generate an ENTER event
4515 m_mouseInWindow
= true;
4516 #if _WIN32_WINNT >= 0x0400
4518 TRACKMOUSEEVENT trackinfo
;
4520 trackinfo
.cbSize
= sizeof(trackinfo
);
4521 trackinfo
.dwFlags
= TME_LEAVE
;
4522 trackinfo
.hwndTrack
= GetHwnd();
4523 //Use the commctrl.h _TrackMouseEvent, which will call the
4524 // appropriate TrackMouseEvent or emulate it ( win95 )
4525 // else we need _WIN32_WINNT >= 0x0400
4526 _TrackMouseEvent(&trackinfo
);
4529 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4530 InitMouseEvent(event
, x
, y
, flags
);
4532 (void)GetEventHandler()->ProcessEvent(event
);
4536 #if wxUSE_MOUSEEVENT_HACK
4537 // Window gets a click down message followed by a mouse move message even
4538 // if position isn't changed! We want to discard the trailing move event
4539 // if x and y are the same.
4540 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4541 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4542 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4543 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4545 m_lastMouseEvent
= wxEVT_MOTION
;
4549 #endif // wxUSE_MOUSEEVENT_HACK
4551 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4555 bool wxWindowMSW
::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4557 #if wxUSE_MOUSEWHEEL
4558 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4559 InitMouseEvent(event
,
4560 GET_X_LPARAM(lParam
),
4561 GET_Y_LPARAM(lParam
),
4563 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4564 event
.m_wheelDelta
= WHEEL_DELTA
;
4566 static int s_linesPerRotation
= -1;
4567 if ( s_linesPerRotation
== -1 )
4569 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4570 &s_linesPerRotation
, 0))
4572 // this is not supposed to happen
4573 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4575 // the default is 3, so use it if SystemParametersInfo() failed
4576 s_linesPerRotation
= 3;
4580 event
.m_linesPerAction
= s_linesPerRotation
;
4581 return GetEventHandler()->ProcessEvent(event
);
4592 // ---------------------------------------------------------------------------
4593 // keyboard handling
4594 // ---------------------------------------------------------------------------
4596 // create the key event of the given type for the given key - used by
4597 // HandleChar and HandleKeyDown/Up
4598 wxKeyEvent wxWindowMSW
::CreateKeyEvent(wxEventType evType
,
4601 WXWPARAM wParam
) const
4603 wxKeyEvent
event(evType
);
4604 event
.SetId(GetId());
4605 event
.m_shiftDown
= wxIsShiftDown();
4606 event
.m_controlDown
= wxIsCtrlDown();
4607 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4609 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4610 event
.m_keyCode
= id
;
4612 event
.m_uniChar
= (wxChar
) wParam
;
4614 event
.m_rawCode
= (wxUint32
) wParam
;
4615 event
.m_rawFlags
= (wxUint32
) lParam
;
4617 event
.SetTimestamp(::GetMessageTime());
4620 // translate the position to client coords
4624 GetWindowRect(GetHwnd(),&rect
);
4634 // isASCII is true only when we're called from WM_CHAR handler and not from
4636 bool wxWindowMSW
::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4641 // If 1 -> 26, translate to either special keycode or just set
4642 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4643 // ControlDown() == true.
4645 if ( (id
> 0) && (id
< 27) )
4667 else // we're called from WM_KEYDOWN
4669 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4672 // it's ASCII and will be processed here only when called from
4673 // WM_CHAR (i.e. when isASCII = true), don't process it now
4678 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4680 // the alphanumeric keys produced by pressing AltGr+something on European
4681 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4682 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4683 // alphanumeric, so pretend that there are no modifiers at all (the
4684 // KEY_DOWN event would still have the correct modifiers if they're really
4686 if ( event
.m_controlDown
&& event
.m_altDown
&&
4687 (id
>= 32 && id
< 256) )
4689 event
.m_controlDown
=
4690 event
.m_altDown
= false;
4693 return GetEventHandler()->ProcessEvent(event
);
4696 bool wxWindowMSW
::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4698 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4702 // normal ASCII char
4706 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4708 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4709 if ( GetEventHandler()->ProcessEvent(event
) )
4718 bool wxWindowMSW
::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4720 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4724 // normal ASCII char
4728 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4730 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4731 if ( GetEventHandler()->ProcessEvent(event
) )
4738 int wxWindowMSW
::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4740 // FIXME: implement GetMenuItemCount for WinCE, possibly
4741 // in terms of GetMenuItemInfo
4743 const HMENU hmenu
= (HMENU
)lParam
;
4747 mii
.cbSize
= sizeof(MENUITEMINFO
);
4748 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4750 // find if we have this letter in any owner drawn item
4751 const int count
= ::GetMenuItemCount(hmenu
);
4752 for ( int i
= 0; i
< count
; i
++ )
4754 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4756 if ( mii
.fType
== MFT_OWNERDRAW
)
4758 // dwItemData member of the MENUITEMINFO is a
4759 // pointer to the associated wxMenuItem -- see the
4760 // menu creation code
4761 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4763 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4766 if ( *p
== _T('&') )
4768 // this is not the accel char, find the real one
4769 p
= wxStrchr(p
+ 1, _T('&'));
4771 else // got the accel char
4773 // FIXME-UNICODE: this comparison doesn't risk to work
4774 // for non ASCII accelerator characters I'm afraid, but
4776 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
4782 // this one doesn't match
4789 else // failed to get the menu text?
4791 // it's not fatal, so don't show error, but still log
4793 wxLogLastError(_T("GetMenuItemInfo"));
4797 wxUnusedVar(chAccel
);
4798 wxUnusedVar(lParam
);
4803 // ---------------------------------------------------------------------------
4805 // ---------------------------------------------------------------------------
4807 bool wxWindowMSW
::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4811 if ( flags
& JOY_BUTTON1CHG
)
4812 change
= wxJOY_BUTTON1
;
4813 if ( flags
& JOY_BUTTON2CHG
)
4814 change
= wxJOY_BUTTON2
;
4815 if ( flags
& JOY_BUTTON3CHG
)
4816 change
= wxJOY_BUTTON3
;
4817 if ( flags
& JOY_BUTTON4CHG
)
4818 change
= wxJOY_BUTTON4
;
4821 if ( flags
& JOY_BUTTON1
)
4822 buttons
|= wxJOY_BUTTON1
;
4823 if ( flags
& JOY_BUTTON2
)
4824 buttons
|= wxJOY_BUTTON2
;
4825 if ( flags
& JOY_BUTTON3
)
4826 buttons
|= wxJOY_BUTTON3
;
4827 if ( flags
& JOY_BUTTON4
)
4828 buttons
|= wxJOY_BUTTON4
;
4830 // the event ids aren't consecutive so we can't use table based lookup
4832 wxEventType eventType
;
4837 eventType
= wxEVT_JOY_MOVE
;
4842 eventType
= wxEVT_JOY_MOVE
;
4847 eventType
= wxEVT_JOY_ZMOVE
;
4852 eventType
= wxEVT_JOY_ZMOVE
;
4855 case MM_JOY1BUTTONDOWN
:
4857 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4860 case MM_JOY2BUTTONDOWN
:
4862 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4865 case MM_JOY1BUTTONUP
:
4867 eventType
= wxEVT_JOY_BUTTON_UP
;
4870 case MM_JOY2BUTTONUP
:
4872 eventType
= wxEVT_JOY_BUTTON_UP
;
4876 wxFAIL_MSG(wxT("no such joystick event"));
4881 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4882 event
.SetPosition(wxPoint(x
, y
));
4883 event
.SetEventObject(this);
4885 return GetEventHandler()->ProcessEvent(event
);
4895 // ---------------------------------------------------------------------------
4897 // ---------------------------------------------------------------------------
4899 bool wxWindowMSW
::MSWOnScroll(int orientation
, WXWORD wParam
,
4900 WXWORD pos
, WXHWND control
)
4902 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
4904 wxWindow
*child
= wxFindWinFromHandle(control
);
4906 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4909 wxScrollWinEvent event
;
4910 event
.SetPosition(pos
);
4911 event
.SetOrientation(orientation
);
4912 event
.m_eventObject
= this;
4917 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4921 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4925 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4929 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4933 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4937 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4940 case SB_THUMBPOSITION
:
4942 // under Win32, the scrollbar range and position are 32 bit integers,
4943 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4944 // explicitly query the scrollbar for the correct position (this must
4945 // be done only for these two SB_ events as they are the only one
4946 // carrying the scrollbar position)
4948 WinStruct
<SCROLLINFO
> scrollInfo
;
4949 scrollInfo
.fMask
= SIF_TRACKPOS
;
4951 if ( !::GetScrollInfo(GetHwnd(),
4952 orientation
== wxHORIZONTAL ? SB_HORZ
4956 // Not neccessarily an error, if there are no scrollbars yet.
4957 // wxLogLastError(_T("GetScrollInfo"));
4960 event
.SetPosition(scrollInfo
.nTrackPos
);
4963 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4964 ? wxEVT_SCROLLWIN_THUMBRELEASE
4965 : wxEVT_SCROLLWIN_THUMBTRACK
;
4972 return GetEventHandler()->ProcessEvent(event
);
4975 // ===========================================================================
4977 // ===========================================================================
4979 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
4982 HDC dc
= ::GetDC((HWND
) wnd
);
4985 // the_font.UseResource();
4986 // the_font.RealizeResource();
4987 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
4989 was
= (HFONT
) SelectObject(dc
,fnt
);
4991 GetTextMetrics(dc
, &tm
);
4994 SelectObject(dc
,was
);
4996 ReleaseDC((HWND
)wnd
, dc
);
4999 *x
= tm
.tmAveCharWidth
;
5001 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5003 // the_font.ReleaseResource();
5006 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5007 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5008 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
5013 case VK_CANCEL
: id
= WXK_CANCEL
; break;
5014 case VK_BACK
: id
= WXK_BACK
; break;
5015 case VK_TAB
: id
= WXK_TAB
; break;
5016 case VK_CLEAR
: id
= WXK_CLEAR
; break;
5017 case VK_SHIFT
: id
= WXK_SHIFT
; break;
5018 case VK_CONTROL
: id
= WXK_CONTROL
; break;
5019 case VK_MENU
: id
= WXK_MENU
; break;
5020 case VK_PAUSE
: id
= WXK_PAUSE
; break;
5021 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
5022 case VK_SPACE
: id
= WXK_SPACE
; break;
5023 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
5024 case VK_PRIOR
: id
= WXK_PRIOR
; break;
5025 case VK_NEXT
: id
= WXK_NEXT
; break;
5026 case VK_END
: id
= WXK_END
; break;
5027 case VK_HOME
: id
= WXK_HOME
; break;
5028 case VK_LEFT
: id
= WXK_LEFT
; break;
5029 case VK_UP
: id
= WXK_UP
; break;
5030 case VK_RIGHT
: id
= WXK_RIGHT
; break;
5031 case VK_DOWN
: id
= WXK_DOWN
; break;
5032 case VK_SELECT
: id
= WXK_SELECT
; break;
5033 case VK_PRINT
: id
= WXK_PRINT
; break;
5034 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
5035 case VK_INSERT
: id
= WXK_INSERT
; break;
5036 case VK_DELETE
: id
= WXK_DELETE
; break;
5037 case VK_HELP
: id
= WXK_HELP
; break;
5038 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
5039 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
5040 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
5041 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
5042 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
5043 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
5044 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
5045 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
5046 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
5047 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
5048 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
5049 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
5050 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
5051 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
5052 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
5053 case VK_F1
: id
= WXK_F1
; break;
5054 case VK_F2
: id
= WXK_F2
; break;
5055 case VK_F3
: id
= WXK_F3
; break;
5056 case VK_F4
: id
= WXK_F4
; break;
5057 case VK_F5
: id
= WXK_F5
; break;
5058 case VK_F6
: id
= WXK_F6
; break;
5059 case VK_F7
: id
= WXK_F7
; break;
5060 case VK_F8
: id
= WXK_F8
; break;
5061 case VK_F9
: id
= WXK_F9
; break;
5062 case VK_F10
: id
= WXK_F10
; break;
5063 case VK_F11
: id
= WXK_F11
; break;
5064 case VK_F12
: id
= WXK_F12
; break;
5065 case VK_F13
: id
= WXK_F13
; break;
5066 case VK_F14
: id
= WXK_F14
; break;
5067 case VK_F15
: id
= WXK_F15
; break;
5068 case VK_F16
: id
= WXK_F16
; break;
5069 case VK_F17
: id
= WXK_F17
; break;
5070 case VK_F18
: id
= WXK_F18
; break;
5071 case VK_F19
: id
= WXK_F19
; break;
5072 case VK_F20
: id
= WXK_F20
; break;
5073 case VK_F21
: id
= WXK_F21
; break;
5074 case VK_F22
: id
= WXK_F22
; break;
5075 case VK_F23
: id
= WXK_F23
; break;
5076 case VK_F24
: id
= WXK_F24
; break;
5077 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
5078 case VK_SCROLL
: id
= WXK_SCROLL
; break;
5080 // the mapping for these keys may be incorrect on non-US keyboards so
5081 // maybe we shouldn't map them to ASCII values at all
5082 case VK_OEM_1
: id
= ';'; break;
5083 case VK_OEM_PLUS
: id
= '+'; break;
5084 case VK_OEM_COMMA
: id
= ','; break;
5085 case VK_OEM_MINUS
: id
= '-'; break;
5086 case VK_OEM_PERIOD
: id
= '.'; break;
5087 case VK_OEM_2
: id
= '/'; break;
5088 case VK_OEM_3
: id
= '~'; break;
5089 case VK_OEM_4
: id
= '['; break;
5090 case VK_OEM_5
: id
= '\\'; break;
5091 case VK_OEM_6
: id
= ']'; break;
5092 case VK_OEM_7
: id
= '\''; break;
5095 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
5096 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
5097 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
5098 #endif // VK_APPS defined
5101 // the same key is sent for both the "return" key on the main
5102 // keyboard and the numeric keypad but we want to distinguish
5103 // between them: we do this using the "extended" bit (24) of lParam
5104 id
= lParam
& (1 << 24) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5114 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5120 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5121 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5122 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5123 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5124 case WXK_ALT
: keySym
= VK_MENU
; break;
5125 case WXK_MENU
: keySym
= VK_MENU
; break;
5126 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5127 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5128 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5129 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5130 case WXK_END
: keySym
= VK_END
; break;
5131 case WXK_HOME
: keySym
= VK_HOME
; break;
5132 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5133 case WXK_UP
: keySym
= VK_UP
; break;
5134 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5135 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5136 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5137 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5138 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5139 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5140 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5141 case WXK_HELP
: keySym
= VK_HELP
; break;
5142 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5143 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5144 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5145 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5146 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5147 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5148 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5149 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5150 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5151 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5152 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5153 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5154 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5155 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5156 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5157 case WXK_F1
: keySym
= VK_F1
; break;
5158 case WXK_F2
: keySym
= VK_F2
; break;
5159 case WXK_F3
: keySym
= VK_F3
; break;
5160 case WXK_F4
: keySym
= VK_F4
; break;
5161 case WXK_F5
: keySym
= VK_F5
; break;
5162 case WXK_F6
: keySym
= VK_F6
; break;
5163 case WXK_F7
: keySym
= VK_F7
; break;
5164 case WXK_F8
: keySym
= VK_F8
; break;
5165 case WXK_F9
: keySym
= VK_F9
; break;
5166 case WXK_F10
: keySym
= VK_F10
; break;
5167 case WXK_F11
: keySym
= VK_F11
; break;
5168 case WXK_F12
: keySym
= VK_F12
; break;
5169 case WXK_F13
: keySym
= VK_F13
; break;
5170 case WXK_F14
: keySym
= VK_F14
; break;
5171 case WXK_F15
: keySym
= VK_F15
; break;
5172 case WXK_F16
: keySym
= VK_F16
; break;
5173 case WXK_F17
: keySym
= VK_F17
; break;
5174 case WXK_F18
: keySym
= VK_F18
; break;
5175 case WXK_F19
: keySym
= VK_F19
; break;
5176 case WXK_F20
: keySym
= VK_F20
; break;
5177 case WXK_F21
: keySym
= VK_F21
; break;
5178 case WXK_F22
: keySym
= VK_F22
; break;
5179 case WXK_F23
: keySym
= VK_F23
; break;
5180 case WXK_F24
: keySym
= VK_F24
; break;
5181 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5182 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5193 bool wxGetKeyState(wxKeyCode key
)
5197 //High order with GetAsyncKeyState only available on WIN32
5199 //If the requested key is a LED key, return
5200 //true if the led is pressed
5201 if (key
== WXK_NUMLOCK
||
5202 key
== WXK_CAPITAL
||
5206 //low order bit means LED is highlighted,
5207 //high order means key is down
5208 //Here, for compat with other ports we want both
5209 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5216 //low order bit means key pressed since last call
5217 //high order means key is down
5218 //We want only the high order bit - the key may not be down if only low order
5219 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5224 wxWindow
*wxGetActiveWindow()
5226 HWND hWnd
= GetActiveWindow();
5229 return wxFindWinFromHandle((WXHWND
) hWnd
);
5234 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5236 HWND hwnd
= (HWND
)hWnd
;
5238 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5239 // by code in msw/radiobox.cpp), for all the others we just search up the
5241 wxWindow
*win
= (wxWindow
*)NULL
;
5244 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5248 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5249 // wxWindow class which overrides WM_GETDLGCODE processing to
5250 // do it as well, win would be already non NULL
5251 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5253 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5255 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5256 #endif // wxUSE_RADIOBOX
5258 // spin control text buddy window should be mapped to spin ctrl
5259 // itself so try it too
5260 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5263 win
= wxSpinCtrl
::GetSpinForTextCtrl((WXHWND
)hwnd
);
5265 #endif // wxUSE_SPINCTRL
5269 while ( hwnd
&& !win
)
5271 // this is a really ugly hack needed to avoid mistakenly returning the
5272 // parent frame wxWindow for the find/replace modeless dialog HWND -
5273 // this, in turn, is needed to call IsDialogMessage() from
5274 // wxApp::ProcessMessage() as for this we must return NULL from here
5276 // FIXME: this is clearly not the best way to do it but I think we'll
5277 // need to change HWND <-> wxWindow code more heavily than I can
5278 // do it now to fix it
5279 #ifndef __WXMICROWIN__
5280 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5282 // it's a dialog box, don't go upwards
5287 hwnd
= ::GetParent(hwnd
);
5288 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5294 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5296 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5297 // in active frames and dialogs, regardless of where the focus is.
5298 static HHOOK wxTheKeyboardHook
= 0;
5299 static FARPROC wxTheKeyboardHookProc
= 0;
5300 int APIENTRY _EXPORT
5301 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5303 void wxSetKeyboardHook(bool doIt
)
5307 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5308 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5310 GetCurrentThreadId()
5311 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5316 UnhookWindowsHookEx(wxTheKeyboardHook
);
5320 int APIENTRY _EXPORT
5321 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5323 DWORD hiWord
= HIWORD(lParam
);
5324 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5326 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5329 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5330 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5331 event
.m_altDown
= true;
5333 event
.m_eventObject
= NULL
;
5334 event
.m_keyCode
= id
;
5335 event
.m_shiftDown
= wxIsShiftDown();
5336 event
.m_controlDown
= wxIsCtrlDown();
5338 event
.SetTimestamp(::GetMessageTime());
5340 wxWindow
*win
= wxGetActiveWindow();
5341 wxEvtHandler
*handler
;
5344 handler
= win
->GetEventHandler();
5345 event
.SetId(win
->GetId());
5350 event
.SetId(wxID_ANY
);
5353 if ( handler
&& handler
->ProcessEvent(event
) )
5361 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5364 #endif // !__WXMICROWIN__
5367 const char *wxGetMessageName(int message
)
5371 case 0x0000: return "WM_NULL";
5372 case 0x0001: return "WM_CREATE";
5373 case 0x0002: return "WM_DESTROY";
5374 case 0x0003: return "WM_MOVE";
5375 case 0x0005: return "WM_SIZE";
5376 case 0x0006: return "WM_ACTIVATE";
5377 case 0x0007: return "WM_SETFOCUS";
5378 case 0x0008: return "WM_KILLFOCUS";
5379 case 0x000A: return "WM_ENABLE";
5380 case 0x000B: return "WM_SETREDRAW";
5381 case 0x000C: return "WM_SETTEXT";
5382 case 0x000D: return "WM_GETTEXT";
5383 case 0x000E: return "WM_GETTEXTLENGTH";
5384 case 0x000F: return "WM_PAINT";
5385 case 0x0010: return "WM_CLOSE";
5386 case 0x0011: return "WM_QUERYENDSESSION";
5387 case 0x0012: return "WM_QUIT";
5388 case 0x0013: return "WM_QUERYOPEN";
5389 case 0x0014: return "WM_ERASEBKGND";
5390 case 0x0015: return "WM_SYSCOLORCHANGE";
5391 case 0x0016: return "WM_ENDSESSION";
5392 case 0x0017: return "WM_SYSTEMERROR";
5393 case 0x0018: return "WM_SHOWWINDOW";
5394 case 0x0019: return "WM_CTLCOLOR";
5395 case 0x001A: return "WM_WININICHANGE";
5396 case 0x001B: return "WM_DEVMODECHANGE";
5397 case 0x001C: return "WM_ACTIVATEAPP";
5398 case 0x001D: return "WM_FONTCHANGE";
5399 case 0x001E: return "WM_TIMECHANGE";
5400 case 0x001F: return "WM_CANCELMODE";
5401 case 0x0020: return "WM_SETCURSOR";
5402 case 0x0021: return "WM_MOUSEACTIVATE";
5403 case 0x0022: return "WM_CHILDACTIVATE";
5404 case 0x0023: return "WM_QUEUESYNC";
5405 case 0x0024: return "WM_GETMINMAXINFO";
5406 case 0x0026: return "WM_PAINTICON";
5407 case 0x0027: return "WM_ICONERASEBKGND";
5408 case 0x0028: return "WM_NEXTDLGCTL";
5409 case 0x002A: return "WM_SPOOLERSTATUS";
5410 case 0x002B: return "WM_DRAWITEM";
5411 case 0x002C: return "WM_MEASUREITEM";
5412 case 0x002D: return "WM_DELETEITEM";
5413 case 0x002E: return "WM_VKEYTOITEM";
5414 case 0x002F: return "WM_CHARTOITEM";
5415 case 0x0030: return "WM_SETFONT";
5416 case 0x0031: return "WM_GETFONT";
5417 case 0x0037: return "WM_QUERYDRAGICON";
5418 case 0x0039: return "WM_COMPAREITEM";
5419 case 0x0041: return "WM_COMPACTING";
5420 case 0x0044: return "WM_COMMNOTIFY";
5421 case 0x0046: return "WM_WINDOWPOSCHANGING";
5422 case 0x0047: return "WM_WINDOWPOSCHANGED";
5423 case 0x0048: return "WM_POWER";
5425 case 0x004A: return "WM_COPYDATA";
5426 case 0x004B: return "WM_CANCELJOURNAL";
5427 case 0x004E: return "WM_NOTIFY";
5428 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5429 case 0x0051: return "WM_INPUTLANGCHANGE";
5430 case 0x0052: return "WM_TCARD";
5431 case 0x0053: return "WM_HELP";
5432 case 0x0054: return "WM_USERCHANGED";
5433 case 0x0055: return "WM_NOTIFYFORMAT";
5434 case 0x007B: return "WM_CONTEXTMENU";
5435 case 0x007C: return "WM_STYLECHANGING";
5436 case 0x007D: return "WM_STYLECHANGED";
5437 case 0x007E: return "WM_DISPLAYCHANGE";
5438 case 0x007F: return "WM_GETICON";
5439 case 0x0080: return "WM_SETICON";
5441 case 0x0081: return "WM_NCCREATE";
5442 case 0x0082: return "WM_NCDESTROY";
5443 case 0x0083: return "WM_NCCALCSIZE";
5444 case 0x0084: return "WM_NCHITTEST";
5445 case 0x0085: return "WM_NCPAINT";
5446 case 0x0086: return "WM_NCACTIVATE";
5447 case 0x0087: return "WM_GETDLGCODE";
5448 case 0x00A0: return "WM_NCMOUSEMOVE";
5449 case 0x00A1: return "WM_NCLBUTTONDOWN";
5450 case 0x00A2: return "WM_NCLBUTTONUP";
5451 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5452 case 0x00A4: return "WM_NCRBUTTONDOWN";
5453 case 0x00A5: return "WM_NCRBUTTONUP";
5454 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5455 case 0x00A7: return "WM_NCMBUTTONDOWN";
5456 case 0x00A8: return "WM_NCMBUTTONUP";
5457 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5458 case 0x0100: return "WM_KEYDOWN";
5459 case 0x0101: return "WM_KEYUP";
5460 case 0x0102: return "WM_CHAR";
5461 case 0x0103: return "WM_DEADCHAR";
5462 case 0x0104: return "WM_SYSKEYDOWN";
5463 case 0x0105: return "WM_SYSKEYUP";
5464 case 0x0106: return "WM_SYSCHAR";
5465 case 0x0107: return "WM_SYSDEADCHAR";
5466 case 0x0108: return "WM_KEYLAST";
5468 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5469 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5470 case 0x010F: return "WM_IME_COMPOSITION";
5472 case 0x0110: return "WM_INITDIALOG";
5473 case 0x0111: return "WM_COMMAND";
5474 case 0x0112: return "WM_SYSCOMMAND";
5475 case 0x0113: return "WM_TIMER";
5476 case 0x0114: return "WM_HSCROLL";
5477 case 0x0115: return "WM_VSCROLL";
5478 case 0x0116: return "WM_INITMENU";
5479 case 0x0117: return "WM_INITMENUPOPUP";
5480 case 0x011F: return "WM_MENUSELECT";
5481 case 0x0120: return "WM_MENUCHAR";
5482 case 0x0121: return "WM_ENTERIDLE";
5483 case 0x0200: return "WM_MOUSEMOVE";
5484 case 0x0201: return "WM_LBUTTONDOWN";
5485 case 0x0202: return "WM_LBUTTONUP";
5486 case 0x0203: return "WM_LBUTTONDBLCLK";
5487 case 0x0204: return "WM_RBUTTONDOWN";
5488 case 0x0205: return "WM_RBUTTONUP";
5489 case 0x0206: return "WM_RBUTTONDBLCLK";
5490 case 0x0207: return "WM_MBUTTONDOWN";
5491 case 0x0208: return "WM_MBUTTONUP";
5492 case 0x0209: return "WM_MBUTTONDBLCLK";
5493 case 0x020A: return "WM_MOUSEWHEEL";
5494 case 0x0210: return "WM_PARENTNOTIFY";
5495 case 0x0211: return "WM_ENTERMENULOOP";
5496 case 0x0212: return "WM_EXITMENULOOP";
5498 case 0x0213: return "WM_NEXTMENU";
5499 case 0x0214: return "WM_SIZING";
5500 case 0x0215: return "WM_CAPTURECHANGED";
5501 case 0x0216: return "WM_MOVING";
5502 case 0x0218: return "WM_POWERBROADCAST";
5503 case 0x0219: return "WM_DEVICECHANGE";
5505 case 0x0220: return "WM_MDICREATE";
5506 case 0x0221: return "WM_MDIDESTROY";
5507 case 0x0222: return "WM_MDIACTIVATE";
5508 case 0x0223: return "WM_MDIRESTORE";
5509 case 0x0224: return "WM_MDINEXT";
5510 case 0x0225: return "WM_MDIMAXIMIZE";
5511 case 0x0226: return "WM_MDITILE";
5512 case 0x0227: return "WM_MDICASCADE";
5513 case 0x0228: return "WM_MDIICONARRANGE";
5514 case 0x0229: return "WM_MDIGETACTIVE";
5515 case 0x0230: return "WM_MDISETMENU";
5516 case 0x0233: return "WM_DROPFILES";
5518 case 0x0281: return "WM_IME_SETCONTEXT";
5519 case 0x0282: return "WM_IME_NOTIFY";
5520 case 0x0283: return "WM_IME_CONTROL";
5521 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5522 case 0x0285: return "WM_IME_SELECT";
5523 case 0x0286: return "WM_IME_CHAR";
5524 case 0x0290: return "WM_IME_KEYDOWN";
5525 case 0x0291: return "WM_IME_KEYUP";
5527 case 0x0300: return "WM_CUT";
5528 case 0x0301: return "WM_COPY";
5529 case 0x0302: return "WM_PASTE";
5530 case 0x0303: return "WM_CLEAR";
5531 case 0x0304: return "WM_UNDO";
5532 case 0x0305: return "WM_RENDERFORMAT";
5533 case 0x0306: return "WM_RENDERALLFORMATS";
5534 case 0x0307: return "WM_DESTROYCLIPBOARD";
5535 case 0x0308: return "WM_DRAWCLIPBOARD";
5536 case 0x0309: return "WM_PAINTCLIPBOARD";
5537 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5538 case 0x030B: return "WM_SIZECLIPBOARD";
5539 case 0x030C: return "WM_ASKCBFORMATNAME";
5540 case 0x030D: return "WM_CHANGECBCHAIN";
5541 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5542 case 0x030F: return "WM_QUERYNEWPALETTE";
5543 case 0x0310: return "WM_PALETTEISCHANGING";
5544 case 0x0311: return "WM_PALETTECHANGED";
5546 case 0x0312: return "WM_HOTKEY";
5549 // common controls messages - although they're not strictly speaking
5550 // standard, it's nice to decode them nevertheless
5553 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5554 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5555 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5556 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5557 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5558 case 0x1000 + 5: return "LVM_GETITEMA";
5559 case 0x1000 + 75: return "LVM_GETITEMW";
5560 case 0x1000 + 6: return "LVM_SETITEMA";
5561 case 0x1000 + 76: return "LVM_SETITEMW";
5562 case 0x1000 + 7: return "LVM_INSERTITEMA";
5563 case 0x1000 + 77: return "LVM_INSERTITEMW";
5564 case 0x1000 + 8: return "LVM_DELETEITEM";
5565 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5566 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5567 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5568 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5569 case 0x1000 + 13: return "LVM_FINDITEMA";
5570 case 0x1000 + 83: return "LVM_FINDITEMW";
5571 case 0x1000 + 14: return "LVM_GETITEMRECT";
5572 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5573 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5574 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5575 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5576 case 0x1000 + 18: return "LVM_HITTEST";
5577 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5578 case 0x1000 + 20: return "LVM_SCROLL";
5579 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5580 case 0x1000 + 22: return "LVM_ARRANGE";
5581 case 0x1000 + 23: return "LVM_EDITLABELA";
5582 case 0x1000 + 118: return "LVM_EDITLABELW";
5583 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5584 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5585 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5586 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5587 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5588 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5589 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5590 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5591 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5592 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5593 case 0x1000 + 31: return "LVM_GETHEADER";
5594 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5595 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5596 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5597 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5598 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5599 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5600 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5601 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5602 case 0x1000 + 41: return "LVM_GETORIGIN";
5603 case 0x1000 + 42: return "LVM_UPDATE";
5604 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5605 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5606 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5607 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5608 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5609 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5610 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5611 case 0x1000 + 48: return "LVM_SORTITEMS";
5612 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5613 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5614 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5615 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5616 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5617 case 0x1000 + 53: return "LVM_SETICONSPACING";
5618 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5619 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5620 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5621 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5622 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5623 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5624 case 0x1000 + 60: return "LVM_SETHOTITEM";
5625 case 0x1000 + 61: return "LVM_GETHOTITEM";
5626 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5627 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5628 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5629 case 0x1000 + 65: return "LVM_SETWORKAREA";
5632 case 0x1100 + 0: return "TVM_INSERTITEMA";
5633 case 0x1100 + 50: return "TVM_INSERTITEMW";
5634 case 0x1100 + 1: return "TVM_DELETEITEM";
5635 case 0x1100 + 2: return "TVM_EXPAND";
5636 case 0x1100 + 4: return "TVM_GETITEMRECT";
5637 case 0x1100 + 5: return "TVM_GETCOUNT";
5638 case 0x1100 + 6: return "TVM_GETINDENT";
5639 case 0x1100 + 7: return "TVM_SETINDENT";
5640 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5641 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5642 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5643 case 0x1100 + 11: return "TVM_SELECTITEM";
5644 case 0x1100 + 12: return "TVM_GETITEMA";
5645 case 0x1100 + 62: return "TVM_GETITEMW";
5646 case 0x1100 + 13: return "TVM_SETITEMA";
5647 case 0x1100 + 63: return "TVM_SETITEMW";
5648 case 0x1100 + 14: return "TVM_EDITLABELA";
5649 case 0x1100 + 65: return "TVM_EDITLABELW";
5650 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5651 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5652 case 0x1100 + 17: return "TVM_HITTEST";
5653 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5654 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5655 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5656 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5657 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5658 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5659 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5660 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5661 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5664 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5665 case 0x1200 + 1: return "HDM_INSERTITEMA";
5666 case 0x1200 + 10: return "HDM_INSERTITEMW";
5667 case 0x1200 + 2: return "HDM_DELETEITEM";
5668 case 0x1200 + 3: return "HDM_GETITEMA";
5669 case 0x1200 + 11: return "HDM_GETITEMW";
5670 case 0x1200 + 4: return "HDM_SETITEMA";
5671 case 0x1200 + 12: return "HDM_SETITEMW";
5672 case 0x1200 + 5: return "HDM_LAYOUT";
5673 case 0x1200 + 6: return "HDM_HITTEST";
5674 case 0x1200 + 7: return "HDM_GETITEMRECT";
5675 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5676 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5677 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5678 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5679 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5680 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5681 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5684 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5685 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5686 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5687 case 0x1300 + 5: return "TCM_GETITEMA";
5688 case 0x1300 + 60: return "TCM_GETITEMW";
5689 case 0x1300 + 6: return "TCM_SETITEMA";
5690 case 0x1300 + 61: return "TCM_SETITEMW";
5691 case 0x1300 + 7: return "TCM_INSERTITEMA";
5692 case 0x1300 + 62: return "TCM_INSERTITEMW";
5693 case 0x1300 + 8: return "TCM_DELETEITEM";
5694 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5695 case 0x1300 + 10: return "TCM_GETITEMRECT";
5696 case 0x1300 + 11: return "TCM_GETCURSEL";
5697 case 0x1300 + 12: return "TCM_SETCURSEL";
5698 case 0x1300 + 13: return "TCM_HITTEST";
5699 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5700 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5701 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5702 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5703 case 0x1300 + 43: return "TCM_SETPADDING";
5704 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5705 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5706 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5707 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5708 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5709 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5710 case 0x1300 + 50: return "TCM_DESELECTALL";
5713 case WM_USER
+1: return "TB_ENABLEBUTTON";
5714 case WM_USER
+2: return "TB_CHECKBUTTON";
5715 case WM_USER
+3: return "TB_PRESSBUTTON";
5716 case WM_USER
+4: return "TB_HIDEBUTTON";
5717 case WM_USER
+5: return "TB_INDETERMINATE";
5718 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5719 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5720 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5721 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5722 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5723 case WM_USER
+17: return "TB_SETSTATE";
5724 case WM_USER
+18: return "TB_GETSTATE";
5725 case WM_USER
+19: return "TB_ADDBITMAP";
5726 case WM_USER
+20: return "TB_ADDBUTTONS";
5727 case WM_USER
+21: return "TB_INSERTBUTTON";
5728 case WM_USER
+22: return "TB_DELETEBUTTON";
5729 case WM_USER
+23: return "TB_GETBUTTON";
5730 case WM_USER
+24: return "TB_BUTTONCOUNT";
5731 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5732 case WM_USER
+26: return "TB_SAVERESTOREA";
5733 case WM_USER
+76: return "TB_SAVERESTOREW";
5734 case WM_USER
+27: return "TB_CUSTOMIZE";
5735 case WM_USER
+28: return "TB_ADDSTRINGA";
5736 case WM_USER
+77: return "TB_ADDSTRINGW";
5737 case WM_USER
+29: return "TB_GETITEMRECT";
5738 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5739 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5740 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5741 case WM_USER
+33: return "TB_AUTOSIZE";
5742 case WM_USER
+35: return "TB_GETTOOLTIPS";
5743 case WM_USER
+36: return "TB_SETTOOLTIPS";
5744 case WM_USER
+37: return "TB_SETPARENT";
5745 case WM_USER
+39: return "TB_SETROWS";
5746 case WM_USER
+40: return "TB_GETROWS";
5747 case WM_USER
+42: return "TB_SETCMDID";
5748 case WM_USER
+43: return "TB_CHANGEBITMAP";
5749 case WM_USER
+44: return "TB_GETBITMAP";
5750 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5751 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5752 case WM_USER
+46: return "TB_REPLACEBITMAP";
5753 case WM_USER
+47: return "TB_SETINDENT";
5754 case WM_USER
+48: return "TB_SETIMAGELIST";
5755 case WM_USER
+49: return "TB_GETIMAGELIST";
5756 case WM_USER
+50: return "TB_LOADIMAGES";
5757 case WM_USER
+51: return "TB_GETRECT";
5758 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5759 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5760 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5761 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5762 case WM_USER
+56: return "TB_SETSTYLE";
5763 case WM_USER
+57: return "TB_GETSTYLE";
5764 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5765 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5766 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5767 case WM_USER
+61: return "TB_GETTEXTROWS";
5768 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5771 static char s_szBuf
[128];
5772 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5776 #endif //__WXDEBUG__
5778 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5782 HWND hwnd
= GetHwndOf(win
);
5783 HDC hdc
= ::GetDC(hwnd
);
5785 #if !wxDIALOG_UNIT_COMPATIBILITY
5786 // and select the current font into it
5787 HFONT hfont
= GetHfontOf(win
->GetFont());
5790 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5794 // finally retrieve the text metrics from it
5795 GetTextMetrics(hdc
, &tm
);
5797 #if !wxDIALOG_UNIT_COMPATIBILITY
5801 (void)::SelectObject(hdc
, hfont
);
5805 ::ReleaseDC(hwnd
, hdc
);
5810 // Find the wxWindow at the current mouse position, returning the mouse
5812 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5814 pt
= wxGetMousePosition();
5815 return wxFindWindowAtPoint(pt
);
5818 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5823 HWND hWndHit
= ::WindowFromPoint(pt2
);
5825 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5826 HWND hWnd
= hWndHit
;
5828 // Try to find a window with a wxWindow associated with it
5829 while (!win
&& (hWnd
!= 0))
5831 hWnd
= ::GetParent(hWnd
);
5832 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5837 // Get the current mouse position.
5838 wxPoint
wxGetMousePosition()
5841 GetCursorPos( & pt
);
5843 return wxPoint(pt
.x
, pt
.y
);
5848 bool wxWindowMSW
::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5850 UINT win_modifiers
=0;
5851 if ( modifiers
& wxMOD_ALT
)
5852 win_modifiers
|= MOD_ALT
;
5853 if ( modifiers
& wxMOD_SHIFT
)
5854 win_modifiers
|= MOD_SHIFT
;
5855 if ( modifiers
& wxMOD_CONTROL
)
5856 win_modifiers
|= MOD_CONTROL
;
5857 if ( modifiers
& wxMOD_WIN
)
5858 win_modifiers
|= MOD_WIN
;
5860 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5862 wxLogLastError(_T("RegisterHotKey"));
5870 bool wxWindowMSW
::UnregisterHotKey(int hotkeyId
)
5872 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5874 wxLogLastError(_T("UnregisterHotKey"));
5884 bool wxWindowMSW
::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5886 int hotkeyId
= wParam
;
5887 int virtualKey
= HIWORD(lParam
);
5888 int win_modifiers
= LOWORD(lParam
);
5890 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5891 event
.SetId(hotkeyId
);
5892 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5893 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5894 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5895 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5897 return GetEventHandler()->ProcessEvent(event
);
5900 #endif // wxUSE_ACCEL
5902 #endif // wxUSE_HOTKEY
5904 // Not tested under WinCE
5907 // this class installs a message hook which really wakes up our idle processing
5908 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
5909 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
5910 // being dragged or even inside ::MessageBox()) and so don't control message
5911 // dispatching otherwise
5912 class wxIdleWakeUpModule
: public wxModule
5915 virtual bool OnInit()
5917 ms_hMsgHookProc
= ::SetWindowsHookEx
5920 &wxIdleWakeUpModule
::MsgHookProc
,
5922 GetCurrentThreadId()
5925 if ( !ms_hMsgHookProc
)
5927 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
5935 virtual void OnExit()
5937 ::UnhookWindowsHookEx(wxIdleWakeUpModule
::ms_hMsgHookProc
);
5940 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
5942 MSG
*msg
= (MSG
*)lParam
;
5944 // only process the message if it is actually going to be removed from
5945 // the message queue, this prevents that the same event from being
5946 // processed multiple times if now someone just called PeekMessage()
5947 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
5949 wxTheApp
->ProcessPendingEvents();
5952 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
5956 static HHOOK ms_hMsgHookProc
;
5958 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
5961 HHOOK wxIdleWakeUpModule
::ms_hMsgHookProc
= 0;
5963 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
5965 #endif // __WXWINCE__
5970 static void wxAdjustZOrder(wxWindow
* parent
)
5972 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
5974 // Set the z-order correctly
5975 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
5978 wxWindowList
::compatibility_iterator current
= parent
->GetChildren().GetFirst();
5981 wxWindow
*childWin
= current
->GetData();
5982 wxAdjustZOrder(childWin
);
5983 current
= current
->GetNext();
5988 // We need to adjust the z-order of static boxes in WinCE, to
5989 // make 'contained' controls visible
5990 void wxWindowMSW
::OnInitDialog( wxInitDialogEvent
& event
)
5993 wxAdjustZOrder(this);