1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/window.cpp
3 // Purpose: wxWindowMSW
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 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
28 #include "wx/msw/wrapwin.h"
29 #include "wx/window.h"
33 #include "wx/dcclient.h"
34 #include "wx/dcmemory.h"
37 #include "wx/layout.h"
38 #include "wx/dialog.h"
40 #include "wx/listbox.h"
41 #include "wx/button.h"
42 #include "wx/msgdlg.h"
43 #include "wx/settings.h"
44 #include "wx/statbox.h"
48 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
49 #include "wx/ownerdrw.h"
52 #include "wx/evtloop.h"
53 #include "wx/module.h"
54 #include "wx/sysopt.h"
56 #if wxUSE_DRAG_AND_DROP
60 #if wxUSE_ACCESSIBILITY
61 #include "wx/access.h"
65 #define WM_GETOBJECT 0x003D
68 #define OBJID_CLIENT 0xFFFFFFFC
72 #include "wx/menuitem.h"
75 #include "wx/msw/private.h"
78 #include "wx/tooltip.h"
86 #include "wx/spinctrl.h"
87 #endif // wxUSE_SPINCTRL
92 #include "wx/textctrl.h"
93 #include "wx/notebook.h"
94 #include "wx/listctrl.h"
98 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
100 #include <mmsystem.h>
104 #include <windowsx.h>
107 #include <commctrl.h>
109 #include "wx/msw/missing.h"
111 #if defined(__WXWINCE__)
112 #include "wx/msw/wince/missing.h"
115 #include <shellapi.h>
117 #include <aygshell.h>
121 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE)
122 #define HAVE_TRACKMOUSEEVENT
123 #endif // everything needed for TrackMouseEvent()
125 // if this is set to 1, we use deferred window sizing to reduce flicker when
126 // resizing complicated window hierarchies, but this can in theory result in
127 // different behaviour than the old code so we keep the possibility to use it
128 // by setting this to 0 (in the future this should be removed completely)
130 #define USE_DEFERRED_SIZING 0
132 #define USE_DEFERRED_SIZING 1
135 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
136 // when mouse position didnd't change
138 #define wxUSE_MOUSEEVENT_HACK 0
140 #define wxUSE_MOUSEEVENT_HACK 1
143 // ---------------------------------------------------------------------------
145 // ---------------------------------------------------------------------------
147 #if wxUSE_MENUS_NATIVE
148 wxMenu
*wxCurrentPopupMenu
= NULL
;
149 #endif // wxUSE_MENUS_NATIVE
152 extern wxChar
*wxCanvasClassName
;
154 extern const wxChar
*wxCanvasClassName
;
157 // true if we had already created the std colour map, used by
158 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
159 static bool gs_hasStdCmap
= false;
161 // last mouse event information we need to filter out the duplicates
162 #if wxUSE_MOUSEEVENT_HACK
163 static struct MouseEventInfoDummy
165 // mouse position (in screen coordinates)
168 // last mouse event type
171 #endif // wxUSE_MOUSEEVENT_HACK
173 // ---------------------------------------------------------------------------
175 // ---------------------------------------------------------------------------
177 // the window proc for all our windows
178 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
179 WPARAM wParam
, LPARAM lParam
);
183 const wxChar
*wxGetMessageName(int message
);
186 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
187 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
188 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
190 // get the text metrics for the current font
191 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
194 // find the window for the mouse event at the specified position
195 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
196 #endif // __WXWINCE__
198 // wrapper around BringWindowToTop() API
199 static inline void wxBringWindowToTop(HWND hwnd
)
201 #ifdef __WXMICROWIN__
202 // It seems that MicroWindows brings the _parent_ of the window to the top,
203 // which can be the wrong one.
205 // activate (set focus to) specified window
209 // raise top level parent to top of z order
210 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
212 wxLogLastError(_T("SetWindowPos"));
218 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
219 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
222 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
223 parent as well as otherwise several Win32 functions using
224 GetNextDlgTabItem() to iterate over all controls such as
225 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
226 all of them iterate over all the controls starting from the currently
227 focused one and stop iterating when they get back to the focus but
228 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
229 get back to the initial (focused) window: as we do have this style,
230 GetNextDlgTabItem() will leave this window and continue in its parent,
231 but if the parent doesn't have it, it wouldn't recurse inside it later
232 on and so wouldn't have a chance of getting back to this window either.
234 while ( parent
&& !parent
->IsTopLevel() )
236 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
237 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
239 // force the parent to have this style
240 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
241 exStyle
| WS_EX_CONTROLPARENT
);
244 parent
= parent
->GetParent();
248 #endif // !__WXWINCE__
251 // On Windows CE, GetCursorPos can return an error, so use this function
253 bool GetCursorPosWinCE(POINT
* pt
)
255 if (!GetCursorPos(pt
))
257 DWORD pos
= GetMessagePos();
265 // ---------------------------------------------------------------------------
267 // ---------------------------------------------------------------------------
269 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
271 #ifdef __WXUNIVERSAL__
272 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
274 #if wxUSE_EXTENDED_RTTI
276 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
277 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
278 // windows with negative ids never can be recreated anyway
280 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
282 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
283 if ( win
&& win
->GetId() < 0 )
288 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
290 // make wxWindowList known before the property is used
292 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
294 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
296 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
299 WX_DEFINE_FLAGS( wxWindowStyle
)
301 wxBEGIN_FLAGS( wxWindowStyle
)
302 // new style border flags, we put them first to
303 // use them for streaming out
305 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
306 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
307 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
308 wxFLAGS_MEMBER(wxBORDER_RAISED
)
309 wxFLAGS_MEMBER(wxBORDER_STATIC
)
310 wxFLAGS_MEMBER(wxBORDER_NONE
)
312 // old style border flags
313 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
314 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
315 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
316 wxFLAGS_MEMBER(wxRAISED_BORDER
)
317 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
318 wxFLAGS_MEMBER(wxBORDER
)
320 // standard window styles
321 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
322 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
323 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
324 wxFLAGS_MEMBER(wxWANTS_CHARS
)
325 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
326 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
327 wxFLAGS_MEMBER(wxVSCROLL
)
328 wxFLAGS_MEMBER(wxHSCROLL
)
330 wxEND_FLAGS( wxWindowStyle
)
332 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
333 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
334 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
335 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
336 // Always constructor Properties first
338 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
339 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
340 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
341 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
342 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
344 // Then all relations of the object graph
346 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
348 // and finally all other properties
350 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
351 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
352 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
353 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
354 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
356 // possible property candidates (not in xrc) or not valid in all subclasses
357 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
358 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
359 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
360 // MaxHeight, Width , MinHeight , Width
361 // TODO switch label to control and title to toplevels
363 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
364 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
365 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
366 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
371 wxEND_PROPERTIES_TABLE()
373 wxBEGIN_HANDLERS_TABLE(wxWindow
)
374 wxEND_HANDLERS_TABLE()
376 wxCONSTRUCTOR_DUMMY(wxWindow
)
379 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
381 #endif // __WXUNIVERSAL__/__WXMSW__
383 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
384 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
385 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
387 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
391 // ===========================================================================
393 // ===========================================================================
395 // ---------------------------------------------------------------------------
396 // wxWindow utility functions
397 // ---------------------------------------------------------------------------
399 // Find an item given the MS Windows id
400 wxWindow
*wxWindowMSW::FindItem(long id
) const
403 wxControl
*item
= wxDynamicCastThis(wxControl
);
406 // is it us or one of our "internal" children?
407 if ( item
->GetId() == id
408 #ifndef __WXUNIVERSAL__
409 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
410 #endif // __WXUNIVERSAL__
416 #endif // wxUSE_CONTROLS
418 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
421 wxWindow
*childWin
= current
->GetData();
423 wxWindow
*wnd
= childWin
->FindItem(id
);
427 current
= current
->GetNext();
433 // Find an item given the MS Windows handle
434 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
436 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
439 wxWindow
*parent
= current
->GetData();
441 // Do a recursive search.
442 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
448 || parent
->IsKindOf(CLASSINFO(wxControl
))
449 #endif // wxUSE_CONTROLS
452 wxWindow
*item
= current
->GetData();
453 if ( item
->GetHWND() == hWnd
)
457 if ( item
->ContainsHWND(hWnd
) )
462 current
= current
->GetNext();
467 // Default command handler
468 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
473 // ----------------------------------------------------------------------------
474 // constructors and such
475 // ----------------------------------------------------------------------------
477 void wxWindowMSW::Init()
480 m_isBeingDeleted
= false;
482 m_mouseInWindow
= false;
483 m_lastKeydownProcessed
= false;
485 m_childrenDisabled
= NULL
;
494 m_pendingPosition
= wxDefaultPosition
;
495 m_pendingSize
= wxDefaultSize
;
498 m_contextMenuEnabled
= false;
503 wxWindowMSW::~wxWindowMSW()
505 m_isBeingDeleted
= true;
507 #ifndef __WXUNIVERSAL__
508 // VS: make sure there's no wxFrame with last focus set to us:
509 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
511 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
514 if ( frame
->GetLastFocus() == this )
516 frame
->SetLastFocus(NULL
);
519 // apparently sometimes we can end up with our grand parent
520 // pointing to us as well: this is surely a bug in focus handling
521 // code but it's not clear where it happens so for now just try to
522 // fix it here by not breaking out of the loop
526 #endif // __WXUNIVERSAL__
528 // VS: destroy children first and _then_ detach *this from its parent.
529 // If we did it the other way around, children wouldn't be able
530 // find their parent frame (see above).
535 // VZ: test temp removed to understand what really happens here
536 //if (::IsWindow(GetHwnd()))
538 if ( !::DestroyWindow(GetHwnd()) )
539 wxLogLastError(wxT("DestroyWindow"));
542 // remove hWnd <-> wxWindow association
543 wxRemoveHandleAssociation(this);
546 delete m_childrenDisabled
;
550 // real construction (Init() must have been called before!)
551 bool wxWindowMSW::Create(wxWindow
*parent
,
556 const wxString
& name
)
558 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
560 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
563 parent
->AddChild(this);
566 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
568 #ifdef __WXUNIVERSAL__
569 // no borders, we draw them ourselves
570 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
574 msflags
&= ~WS_BORDER
;
575 #endif // wxUniversal
579 msflags
|= WS_VISIBLE
;
582 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
590 // ---------------------------------------------------------------------------
592 // ---------------------------------------------------------------------------
594 void wxWindowMSW::SetFocus()
596 HWND hWnd
= GetHwnd();
597 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
599 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
603 if ( !::SetFocus(hWnd
) )
605 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
606 // was there really an error?
607 DWORD dwRes
= ::GetLastError();
610 HWND hwndFocus
= ::GetFocus();
611 if ( hwndFocus
!= hWnd
)
613 wxLogApiError(_T("SetFocus"), dwRes
);
620 void wxWindowMSW::SetFocusFromKbd()
622 // when the focus is given to the control with DLGC_HASSETSEL style from
623 // keyboard its contents should be entirely selected: this is what
624 // ::IsDialogMessage() does and so we should do it as well to provide the
625 // same LNF as the native programs
626 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
628 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
631 // do this after (maybe) setting the selection as like this when
632 // wxEVT_SET_FOCUS handler is called, the selection would have been already
633 // set correctly -- this may be important
634 wxWindowBase::SetFocusFromKbd();
637 // Get the window with the focus
638 wxWindow
*wxWindowBase::DoFindFocus()
640 HWND hWnd
= ::GetFocus();
643 return wxGetWindowFromHWND((WXHWND
)hWnd
);
649 bool wxWindowMSW::Enable(bool enable
)
651 if ( !wxWindowBase::Enable(enable
) )
654 HWND hWnd
= GetHwnd();
656 ::EnableWindow(hWnd
, (BOOL
)enable
);
658 // the logic below doesn't apply to the top level windows -- otherwise
659 // showing a modal dialog would result in total greying out (and ungreying
660 // out later) of everything which would be really ugly
664 // when the parent is disabled, all of its children should be disabled as
665 // well but when it is enabled back, only those of the children which
666 // hadn't been already disabled in the beginning should be enabled again,
667 // so we have to keep the list of those children
668 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
670 node
= node
->GetNext() )
672 wxWindow
*child
= node
->GetData();
673 if ( child
->IsTopLevel() )
675 // the logic below doesn't apply to top level children
681 // re-enable the child unless it had been disabled before us
682 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
685 else // we're being disabled
687 if ( child
->IsEnabled() )
689 // disable it as children shouldn't stay enabled while the
693 else // child already disabled, remember it
695 // have we created the list of disabled children already?
696 if ( !m_childrenDisabled
)
697 m_childrenDisabled
= new wxWindowList
;
699 m_childrenDisabled
->Append(child
);
704 if ( enable
&& m_childrenDisabled
)
706 // we don't need this list any more, don't keep unused memory
707 delete m_childrenDisabled
;
708 m_childrenDisabled
= NULL
;
714 bool wxWindowMSW::Show(bool show
)
716 if ( !wxWindowBase::Show(show
) )
719 HWND hWnd
= GetHwnd();
721 // we could be called before the underlying window is created (this is
722 // actually useful to prevent it from being initially shown), e.g.
724 // wxFoo *foo = new wxFoo;
726 // foo->Create(parent, ...);
728 // should work without errors
731 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
737 // Raise the window to the top of the Z order
738 void wxWindowMSW::Raise()
740 wxBringWindowToTop(GetHwnd());
743 // Lower the window to the bottom of the Z order
744 void wxWindowMSW::Lower()
746 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
747 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
750 void wxWindowMSW::DoCaptureMouse()
752 HWND hWnd
= GetHwnd();
759 void wxWindowMSW::DoReleaseMouse()
761 if ( !::ReleaseCapture() )
763 wxLogLastError(_T("ReleaseCapture"));
767 /* static */ wxWindow
*wxWindowBase::GetCapture()
769 HWND hwnd
= ::GetCapture();
770 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
773 bool wxWindowMSW::SetFont(const wxFont
& font
)
775 if ( !wxWindowBase::SetFont(font
) )
781 HWND hWnd
= GetHwnd();
784 WXHANDLE hFont
= m_font
.GetResourceHandle();
786 wxASSERT_MSG( hFont
, wxT("should have valid font") );
788 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
793 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
795 if ( !wxWindowBase::SetCursor(cursor
) )
803 HWND hWnd
= GetHwnd();
805 // Change the cursor NOW if we're within the correct window
808 ::GetCursorPosWinCE(&point
);
810 ::GetCursorPos(&point
);
813 RECT rect
= wxGetWindowRect(hWnd
);
815 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
816 ::SetCursor(GetHcursorOf(m_cursor
));
822 void wxWindowMSW::WarpPointer(int x
, int y
)
824 ClientToScreen(&x
, &y
);
826 if ( !::SetCursorPos(x
, y
) )
828 wxLogLastError(_T("SetCursorPos"));
832 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
834 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
835 // to use it on older systems -- and could possibly do some harm
836 static int s_needToUpdate
= -1;
837 if ( s_needToUpdate
== -1 )
840 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxWINDOWS_NT
&&
844 if ( s_needToUpdate
)
846 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
847 // won't send WM_UPDATEUISTATE
848 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
852 // ---------------------------------------------------------------------------
854 // ---------------------------------------------------------------------------
856 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
858 #ifdef __WXMICROWIN__
859 return ::GetScrollPosWX(hWnd
, wOrient
);
861 WinStruct
<SCROLLINFO
> scrollInfo
;
862 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
863 scrollInfo
.fMask
= SIF_POS
;
864 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
866 return scrollInfo
.nPos
;
871 int wxWindowMSW::GetScrollPos(int orient
) const
873 HWND hWnd
= GetHwnd();
874 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
876 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
879 // This now returns the whole range, not just the number
880 // of positions that we can scroll.
881 int wxWindowMSW::GetScrollRange(int orient
) const
884 HWND hWnd
= GetHwnd();
888 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
891 WinStruct
<SCROLLINFO
> scrollInfo
;
892 scrollInfo
.fMask
= SIF_RANGE
;
893 if ( !::GetScrollInfo(hWnd
,
894 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
897 // Most of the time this is not really an error, since the return
898 // value can also be zero when there is no scrollbar yet.
899 // wxLogLastError(_T("GetScrollInfo"));
901 maxPos
= scrollInfo
.nMax
;
903 // undo "range - 1" done in SetScrollbar()
907 int wxWindowMSW::GetScrollThumb(int orient
) const
909 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
912 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
914 HWND hWnd
= GetHwnd();
915 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
917 WinStruct
<SCROLLINFO
> info
;
921 info
.fMask
= SIF_POS
;
922 if ( HasFlag(wxALWAYS_SHOW_SB
) )
924 // disable scrollbar instead of removing it then
925 info
.fMask
|= SIF_DISABLENOSCROLL
;
928 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
932 // New function that will replace some of the above.
933 void wxWindowMSW::SetScrollbar(int orient
,
939 WinStruct
<SCROLLINFO
> info
;
940 info
.nPage
= pageSize
;
941 info
.nMin
= 0; // range is nMax - nMin + 1
942 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
944 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
945 if ( HasFlag(wxALWAYS_SHOW_SB
) )
947 // disable scrollbar instead of removing it then
948 info
.fMask
|= SIF_DISABLENOSCROLL
;
951 HWND hWnd
= GetHwnd();
954 // We have to set the variables here to make them valid in events
955 // triggered by ::SetScrollInfo()
956 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
958 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
963 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
969 rect
.left
= prect
->x
;
971 rect
.right
= prect
->x
+ prect
->width
;
972 rect
.bottom
= prect
->y
+ prect
->height
;
982 // FIXME: is this the exact equivalent of the line below?
983 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
985 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
989 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
991 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
994 for ( int n
= 0; n
< count
; n
++ )
996 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
998 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
1001 // don't bother to continue, we're already at top/bottom
1008 return pos
!= posStart
;
1011 bool wxWindowMSW::ScrollLines(int lines
)
1013 bool down
= lines
> 0;
1015 return ScrollVertically(GetHwnd(),
1016 down
? SB_LINEDOWN
: SB_LINEUP
,
1017 down
? lines
: -lines
);
1020 bool wxWindowMSW::ScrollPages(int pages
)
1022 bool down
= pages
> 0;
1024 return ScrollVertically(GetHwnd(),
1025 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1026 down
? pages
: -pages
);
1029 // ---------------------------------------------------------------------------
1031 // ---------------------------------------------------------------------------
1033 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1035 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1037 HWND hwnd
= (HWND
)hWnd
;
1038 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1040 wxAssociateWinWithHandle(hwnd
, this);
1042 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1044 // we don't need to subclass the window of our own class (in the Windows
1045 // sense of the word)
1046 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1048 wxSetWindowProc(hwnd
, wxWndProc
);
1052 // don't bother restoring it either: this also makes it easy to
1053 // implement IsOfStandardClass() method which returns true for the
1054 // standard controls and false for the wxWidgets own windows as it can
1055 // simply check m_oldWndProc
1056 m_oldWndProc
= NULL
;
1060 void wxWindowMSW::UnsubclassWin()
1062 wxRemoveHandleAssociation(this);
1064 // Restore old Window proc
1065 HWND hwnd
= GetHwnd();
1070 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1074 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1076 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1079 m_oldWndProc
= NULL
;
1084 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1088 if ( !::DestroyWindow(GetHwnd()) )
1089 wxLogLastError(wxT("DestroyWindow"));
1092 WXHWND wxhwnd
= (WXHWND
)handle
;
1095 SubclassWin(wxhwnd
);
1098 void wxWindowMSW::DissociateHandle()
1100 // this also calls SetHWND(0) for us
1105 bool wxCheckWindowWndProc(WXHWND hWnd
,
1106 WXFARPROC
WXUNUSED(wndProc
))
1108 // TODO: This list of window class names should be factored out so they can be
1109 // managed in one place and then accessed from here and other places, such as
1110 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1113 extern wxChar
*wxCanvasClassName
;
1114 extern wxChar
*wxCanvasClassNameNR
;
1116 extern const wxChar
*wxCanvasClassName
;
1117 extern const wxChar
*wxCanvasClassNameNR
;
1119 extern const wxChar
*wxMDIFrameClassName
;
1120 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1121 extern const wxChar
*wxMDIChildFrameClassName
;
1122 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1123 wxString
str(wxGetWindowClass(hWnd
));
1124 if (str
== wxCanvasClassName
||
1125 str
== wxCanvasClassNameNR
||
1127 str
== _T("wxGLCanvasClass") ||
1128 str
== _T("wxGLCanvasClassNR") ||
1129 #endif // wxUSE_GLCANVAS
1130 str
== wxMDIFrameClassName
||
1131 str
== wxMDIFrameClassNameNoRedraw
||
1132 str
== wxMDIChildFrameClassName
||
1133 str
== wxMDIChildFrameClassNameNoRedraw
||
1134 str
== _T("wxTLWHiddenParent"))
1135 return true; // Effectively means don't subclass
1140 // ----------------------------------------------------------------------------
1142 // ----------------------------------------------------------------------------
1144 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1146 long flagsOld
= GetWindowStyleFlag();
1147 if ( flags
== flagsOld
)
1150 // update the internal variable
1151 wxWindowBase::SetWindowStyleFlag(flags
);
1153 // now update the Windows style as well if needed - and if the window had
1154 // been already created
1158 WXDWORD exstyle
, exstyleOld
;
1159 long style
= MSWGetStyle(flags
, &exstyle
),
1160 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1162 if ( style
!= styleOld
)
1164 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1165 // this function so instead of simply setting the style to the new
1166 // value we clear the bits which were set in styleOld but are set in
1167 // the new one and set the ones which were not set before
1168 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1169 styleReal
&= ~styleOld
;
1172 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1175 // and the extended style
1176 if ( exstyle
!= exstyleOld
)
1178 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1179 exstyleReal
&= ~exstyleOld
;
1180 exstyleReal
|= exstyle
;
1182 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1184 // we must call SetWindowPos() to flush the cached extended style and
1185 // also to make the change to wxSTAY_ON_TOP style take effect: just
1186 // setting the style simply doesn't work
1187 if ( !::SetWindowPos(GetHwnd(),
1188 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1191 SWP_NOMOVE
| SWP_NOSIZE
) )
1193 wxLogLastError(_T("SetWindowPos"));
1198 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1200 // translate common wxWidgets styles to Windows ones
1202 // most of windows are child ones, those which are not (such as
1203 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1204 WXDWORD style
= WS_CHILD
;
1206 // using this flag results in very significant reduction in flicker,
1207 // especially with controls inside the static boxes (as the interior of the
1208 // box is not redrawn twice), but sometimes results in redraw problems, so
1209 // optionally allow the old code to continue to use it provided a special
1210 // system option is turned on
1211 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1212 || (flags
& wxCLIP_CHILDREN
) )
1213 style
|= WS_CLIPCHILDREN
;
1215 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1216 // don't support overlapping windows and it only makes sense for them and,
1217 // presumably, gives the system some extra work (to manage more clipping
1218 // regions), so avoid it alltogether
1221 if ( flags
& wxVSCROLL
)
1222 style
|= WS_VSCROLL
;
1224 if ( flags
& wxHSCROLL
)
1225 style
|= WS_HSCROLL
;
1227 const wxBorder border
= GetBorder(flags
);
1229 // WS_BORDER is only required for wxBORDER_SIMPLE
1230 if ( border
== wxBORDER_SIMPLE
)
1233 // now deal with ext style if the caller wants it
1239 if ( flags
& wxTRANSPARENT_WINDOW
)
1240 *exstyle
|= WS_EX_TRANSPARENT
;
1246 case wxBORDER_DEFAULT
:
1247 wxFAIL_MSG( _T("unknown border style") );
1251 case wxBORDER_SIMPLE
:
1254 case wxBORDER_STATIC
:
1255 *exstyle
|= WS_EX_STATICEDGE
;
1258 case wxBORDER_RAISED
:
1259 *exstyle
|= WS_EX_DLGMODALFRAME
;
1262 case wxBORDER_SUNKEN
:
1263 *exstyle
|= WS_EX_CLIENTEDGE
;
1264 style
&= ~WS_BORDER
;
1267 case wxBORDER_DOUBLE
:
1268 *exstyle
|= WS_EX_DLGMODALFRAME
;
1272 // wxUniv doesn't use Windows dialog navigation functions at all
1273 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1274 // to make the dialog navigation work with the nested panels we must
1275 // use this style (top level windows such as dialogs don't need it)
1276 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1278 *exstyle
|= WS_EX_CONTROLPARENT
;
1280 #endif // __WXUNIVERSAL__
1286 // Setup background and foreground colours correctly
1287 void wxWindowMSW::SetupColours()
1290 SetBackgroundColour(GetParent()->GetBackgroundColour());
1293 bool wxWindowMSW::IsMouseInWindow() const
1295 // get the mouse position
1298 ::GetCursorPosWinCE(&pt
);
1300 ::GetCursorPos(&pt
);
1303 // find the window which currently has the cursor and go up the window
1304 // chain until we find this window - or exhaust it
1305 HWND hwnd
= ::WindowFromPoint(pt
);
1306 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1307 hwnd
= ::GetParent(hwnd
);
1309 return hwnd
!= NULL
;
1312 void wxWindowMSW::OnInternalIdle()
1314 #ifndef HAVE_TRACKMOUSEEVENT
1315 // Check if we need to send a LEAVE event
1316 if ( m_mouseInWindow
)
1318 // note that we should generate the leave event whether the window has
1319 // or doesn't have mouse capture
1320 if ( !IsMouseInWindow() )
1322 GenerateMouseLeave();
1325 #endif // !HAVE_TRACKMOUSEEVENT
1327 if (wxUpdateUIEvent::CanUpdate(this))
1328 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1331 // Set this window to be the child of 'parent'.
1332 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1334 if ( !wxWindowBase::Reparent(parent
) )
1337 HWND hWndChild
= GetHwnd();
1338 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1340 ::SetParent(hWndChild
, hWndParent
);
1343 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1345 EnsureParentHasControlParentStyle(GetParent());
1347 #endif // !__WXWINCE__
1352 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1354 #ifndef __WXMICROWIN__
1355 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1359 void wxWindowMSW::Freeze()
1361 if ( !m_frozenness
++ )
1364 SendSetRedraw(GetHwnd(), false);
1368 void wxWindowMSW::Thaw()
1370 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1372 if ( --m_frozenness
== 0 )
1376 SendSetRedraw(GetHwnd(), true);
1378 // we need to refresh everything or otherwise the invalidated area
1379 // is not going to be repainted
1385 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1387 HWND hWnd
= GetHwnd();
1394 mswRect
.left
= rect
->x
;
1395 mswRect
.top
= rect
->y
;
1396 mswRect
.right
= rect
->x
+ rect
->width
;
1397 mswRect
.bottom
= rect
->y
+ rect
->height
;
1406 // RedrawWindow not available on SmartPhone or eVC++ 3
1407 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1408 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1412 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1414 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1419 void wxWindowMSW::Update()
1421 if ( !::UpdateWindow(GetHwnd()) )
1423 wxLogLastError(_T("UpdateWindow"));
1426 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1427 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1428 // handler needs to be really drawn right now
1433 // ---------------------------------------------------------------------------
1435 // ---------------------------------------------------------------------------
1437 // we need to lower the sibling static boxes so controls contained within can be
1439 static inline void AdjustStaticBoxZOrder(wxWindow
*parent
)
1441 // no sibling static boxes if we have no parent (ie TLW)
1445 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1447 node
= node
->GetNext() )
1449 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1452 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1453 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1458 #if wxUSE_DRAG_AND_DROP
1459 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1461 if ( m_dropTarget
!= 0 ) {
1462 m_dropTarget
->Revoke(m_hWnd
);
1463 delete m_dropTarget
;
1466 m_dropTarget
= pDropTarget
;
1467 if ( m_dropTarget
!= 0 )
1469 AdjustStaticBoxZOrder(GetParent());
1470 m_dropTarget
->Register(m_hWnd
);
1473 #endif // wxUSE_DRAG_AND_DROP
1475 // old-style file manager drag&drop support: we retain the old-style
1476 // DragAcceptFiles in parallel with SetDropTarget.
1477 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1480 HWND hWnd
= GetHwnd();
1483 AdjustStaticBoxZOrder(GetParent());
1484 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1489 // ----------------------------------------------------------------------------
1491 // ----------------------------------------------------------------------------
1495 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1497 wxWindowBase::DoSetToolTip(tooltip
);
1500 m_tooltip
->SetWindow((wxWindow
*)this);
1503 #endif // wxUSE_TOOLTIPS
1505 // ---------------------------------------------------------------------------
1506 // moving and resizing
1507 // ---------------------------------------------------------------------------
1509 bool wxWindowMSW::IsSizeDeferred() const
1511 #if USE_DEFERRED_SIZING
1512 if ( m_pendingPosition
!= wxDefaultPosition
||
1513 m_pendingSize
!= wxDefaultSize
)
1515 #endif // USE_DEFERRED_SIZING
1521 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1523 // if SetSize() had been called at wx level but not realized at Windows
1524 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1525 // the new and not the old position to the other wx code
1526 if ( m_pendingSize
!= wxDefaultSize
)
1529 *x
= m_pendingSize
.x
;
1531 *y
= m_pendingSize
.y
;
1533 else // use current size
1535 RECT rect
= wxGetWindowRect(GetHwnd());
1538 *x
= rect
.right
- rect
.left
;
1540 *y
= rect
.bottom
- rect
.top
;
1544 // Get size *available for subwindows* i.e. excluding menu bar etc.
1545 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1547 #if USE_DEFERRED_SIZING
1548 if ( IsTopLevel() || m_pendingSize
== wxDefaultSize
)
1550 { // top level windows resizing is never deferred, so we can safely use
1551 // the current size here
1552 RECT rect
= wxGetClientRect(GetHwnd());
1559 #if USE_DEFERRED_SIZING
1560 else // non top level and using deferred sizing
1562 // we need to calculate the *pending* client size here
1564 rect
.left
= m_pendingPosition
.x
;
1565 rect
.top
= m_pendingPosition
.y
;
1566 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1567 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1569 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1572 *x
= rect
.right
- rect
.left
;
1574 *y
= rect
.bottom
- rect
.top
;
1579 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1581 wxWindow
* const parent
= GetParent();
1584 if ( m_pendingPosition
!= wxDefaultPosition
)
1586 pos
= m_pendingPosition
;
1588 else // use current position
1590 RECT rect
= wxGetWindowRect(GetHwnd());
1593 point
.x
= rect
.left
;
1596 // we do the adjustments with respect to the parent only for the "real"
1597 // children, not for the dialogs/frames
1598 if ( !IsTopLevel() )
1600 // Since we now have the absolute screen coords, if there's a
1601 // parent we must subtract its top left corner
1604 ::ScreenToClient(GetHwndOf(parent
), &point
);
1612 // we also must adjust by the client area offset: a control which is just
1613 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1614 if ( parent
&& !IsTopLevel() )
1616 const wxPoint
pt(parent
->GetClientAreaOrigin());
1627 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1635 ::ScreenToClient(GetHwnd(), &pt
);
1643 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1651 ::ClientToScreen(GetHwnd(), &pt
);
1660 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1662 #if USE_DEFERRED_SIZING
1663 // if our parent had prepared a defer window handle for us, use it (unless
1664 // we are a top level window)
1665 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1667 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1670 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1671 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1674 wxLogLastError(_T("DeferWindowPos"));
1680 // hdwp must be updated as it may have been changed
1681 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1686 // did deferred move, remember new coordinates of the window as they're
1687 // different from what Windows would return for it
1691 // otherwise (or if deferring failed) move the window in place immediately
1692 #endif // USE_DEFERRED_SIZING
1693 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1695 wxLogLastError(wxT("MoveWindow"));
1698 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1699 // ignored otherwise
1703 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1705 // TODO: is this consistent with other platforms?
1706 // Still, negative width or height shouldn't be allowed
1712 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1714 #if USE_DEFERRED_SIZING
1715 m_pendingPosition
= wxPoint(x
, y
);
1716 m_pendingSize
= wxSize(width
, height
);
1717 #endif // USE_DEFERRED_SIZING
1721 // set the size of the window: if the dimensions are positive, just use them,
1722 // but if any of them is equal to -1, it means that we must find the value for
1723 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1724 // which case -1 is a valid value for x and y)
1726 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1727 // the width/height to best suit our contents, otherwise we reuse the current
1729 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1731 // get the current size and position...
1732 int currentX
, currentY
;
1733 int currentW
, currentH
;
1735 GetPosition(¤tX
, ¤tY
);
1736 GetSize(¤tW
, ¤tH
);
1738 // ... and don't do anything (avoiding flicker) if it's already ok unless
1739 // we're forced to resize the window
1740 if ( x
== currentX
&& y
== currentY
&&
1741 width
== currentW
&& height
== currentH
&&
1742 !(sizeFlags
& wxSIZE_FORCE
) )
1747 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1749 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1752 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1754 wxSize size
= wxDefaultSize
;
1755 if ( width
== wxDefaultCoord
)
1757 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1759 size
= DoGetBestSize();
1764 // just take the current one
1769 if ( height
== wxDefaultCoord
)
1771 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1773 if ( size
.x
== wxDefaultCoord
)
1775 size
= DoGetBestSize();
1777 //else: already called DoGetBestSize() above
1783 // just take the current one
1788 DoMoveWindow(x
, y
, width
, height
);
1791 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1793 // setting the client size is less obvious than it could have been
1794 // because in the result of changing the total size the window scrollbar
1795 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
1796 // doesn't take neither into account) and so the client size will not be
1797 // correct as the difference between the total and client size changes --
1798 // so we keep changing it until we get it right
1800 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1801 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1802 // may become 3 if the window had 0 size originally and so we didn't
1803 // calculate the scrollbar correction correctly during the first iteration)
1804 // but just to be on the safe side we check for it instead of making it an
1805 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1806 for ( int i
= 0; i
< 4; i
++ )
1809 ::GetClientRect(GetHwnd(), &rectClient
);
1811 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
1812 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1813 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1818 // Find the difference between the entire window (title bar and all)
1819 // and the client area; add this to the new client size to move the
1822 ::GetWindowRect(GetHwnd(), &rectWin
);
1824 const int widthWin
= rectWin
.right
- rectWin
.left
,
1825 heightWin
= rectWin
.bottom
- rectWin
.top
;
1827 // MoveWindow positions the child windows relative to the parent, so
1828 // adjust if necessary
1829 if ( !IsTopLevel() )
1831 wxWindow
*parent
= GetParent();
1834 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
1838 // don't call DoMoveWindow() because we want to move window immediately
1839 // and not defer it here as otherwise the value returned by
1840 // GetClient/WindowRect() wouldn't change as the window wouldn't be
1842 if ( !::MoveWindow(GetHwnd(),
1845 width
+ widthWin
- rectClient
.right
,
1846 height
+ heightWin
- rectClient
.bottom
,
1849 wxLogLastError(_T("MoveWindow"));
1854 // ---------------------------------------------------------------------------
1856 // ---------------------------------------------------------------------------
1858 int wxWindowMSW::GetCharHeight() const
1860 return wxGetTextMetrics(this).tmHeight
;
1863 int wxWindowMSW::GetCharWidth() const
1865 // +1 is needed because Windows apparently adds it when calculating the
1866 // dialog units size in pixels
1867 #if wxDIALOG_UNIT_COMPATIBILITY
1868 return wxGetTextMetrics(this).tmAveCharWidth
;
1870 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1874 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1876 int *descent
, int *externalLeading
,
1877 const wxFont
*theFont
) const
1879 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1880 _T("invalid font in GetTextExtent()") );
1884 fontToUse
= *theFont
;
1886 fontToUse
= GetFont();
1888 WindowHDC
hdc(GetHwnd());
1889 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1893 ::GetTextExtentPoint32(hdc
, string
, string
.length(), &sizeRect
);
1894 GetTextMetrics(hdc
, &tm
);
1901 *descent
= tm
.tmDescent
;
1902 if ( externalLeading
)
1903 *externalLeading
= tm
.tmExternalLeading
;
1906 // ---------------------------------------------------------------------------
1908 // ---------------------------------------------------------------------------
1910 #if wxUSE_MENUS_NATIVE
1912 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1913 // immediately, without waiting for the next event loop iteration
1915 // NB: this function should probably be made public later as it can almost
1916 // surely replace wxYield() elsewhere as well
1917 static void wxYieldForCommandsOnly()
1919 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1920 // want to process it here)
1922 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1924 if ( msg
.message
== WM_QUIT
)
1926 // if we retrieved a WM_QUIT, insert back into the message queue.
1927 ::PostQuitMessage(0);
1931 // luckily (as we don't have access to wxEventLoopImpl method from here
1932 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1934 ::TranslateMessage(&msg
);
1935 ::DispatchMessage(&msg
);
1939 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1941 menu
->SetInvokingWindow(this);
1944 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1946 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1947 x
= mouse
.x
; y
= mouse
.y
;
1950 HWND hWnd
= GetHwnd();
1951 HMENU hMenu
= GetHmenuOf(menu
);
1955 ::ClientToScreen(hWnd
, &point
);
1956 wxCurrentPopupMenu
= menu
;
1957 #if defined(__WXWINCE__)
1960 UINT flags
= TPM_RIGHTBUTTON
;
1962 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1964 // we need to do it right now as otherwise the events are never going to be
1965 // sent to wxCurrentPopupMenu from HandleCommand()
1967 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1968 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1969 // destroyed as soon as we return (it can be a local variable in the caller
1970 // for example) and so we do need to process the event immediately
1971 wxYieldForCommandsOnly();
1973 wxCurrentPopupMenu
= NULL
;
1975 menu
->SetInvokingWindow(NULL
);
1980 #endif // wxUSE_MENUS_NATIVE
1982 // ===========================================================================
1983 // pre/post message processing
1984 // ===========================================================================
1986 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1989 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1991 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1994 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1996 // wxUniversal implements tab traversal itself
1997 #ifndef __WXUNIVERSAL__
1998 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2000 // intercept dialog navigation keys
2001 MSG
*msg
= (MSG
*)pMsg
;
2003 // here we try to do all the job which ::IsDialogMessage() usually does
2005 if ( msg
->message
== WM_KEYDOWN
)
2007 bool bCtrlDown
= wxIsCtrlDown();
2008 bool bShiftDown
= wxIsShiftDown();
2010 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2011 // don't process it if it's the case (except for Ctrl-Tab/Enter
2012 // combinations which are always processed)
2016 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2018 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2019 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2020 // it, of course, implies them
2021 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2023 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2027 bool bForward
= true,
2028 bWindowChange
= false,
2031 // should we process this message specially?
2032 bool bProcess
= true;
2033 switch ( msg
->wParam
)
2036 if ( lDlgCode
& DLGC_WANTTAB
) {
2040 // Ctrl-Tab cycles thru notebook pages
2041 bWindowChange
= bCtrlDown
;
2042 bForward
= !bShiftDown
;
2049 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2057 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2063 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
2065 // control wants to process Enter itself, don't
2066 // call IsDialogMessage() which would interpret
2071 // currently active button should get enter press even
2072 // if there is a default button elsewhere
2073 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2075 // let IsDialogMessage() handle this for all
2076 // buttons except the owner-drawn ones which it
2077 // just seems to ignore
2078 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2079 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2081 // emulate the button click
2083 btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2085 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2090 else // not a button itself
2093 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
2095 if ( btn
&& btn
->IsEnabled() )
2097 // if we do have a default button, do press it
2098 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2102 else // no default button
2103 #endif // wxUSE_BUTTON
2106 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2107 event
.SetEventObject(this);
2108 if(GetEventHandler()->ProcessEvent(event
))
2111 // this is a quick and dirty test for a text
2113 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
2115 // don't process Enter, the control might
2116 // need it for itself and don't let
2117 // ::IsDialogMessage() have it as it can
2118 // eat the Enter events sometimes
2121 else if (!IsTopLevel())
2123 // if not a top level window, let parent
2127 //else: treat Enter as TAB: pass to the next
2128 // control as this is the best thing to do
2129 // if the text doesn't handle Enter itself
2141 wxNavigationKeyEvent event
;
2142 event
.SetDirection(bForward
);
2143 event
.SetWindowChange(bWindowChange
);
2144 event
.SetFromTab(bFromTab
);
2145 event
.SetEventObject(this);
2147 if ( GetEventHandler()->ProcessEvent(event
) )
2149 // as we don't call IsDialogMessage(), which would take of
2150 // this by default, we need to manually send this message
2151 // so that controls can change their UI state if needed
2152 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2159 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2160 // message even when there is no cancel button and when the message is
2161 // needed by the control itself: in particular, it prevents the tree in
2162 // place edit control from being closed with Escape in a dialog
2163 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2165 // ::IsDialogMessage() is broken and may sometimes hang the
2166 // application by going into an infinite loop, so we try to detect
2167 // [some of] the situations when this may happen and not call it
2170 // assume we can call it by default
2171 bool canSafelyCallIsDlgMsg
= true;
2173 HWND hwndFocus
= ::GetFocus();
2175 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2176 // an infinite loop, because it will recursively check the child
2177 // windows but not the window itself and so if none of the children
2178 // accepts focus it loops forever (as it only stops when it gets
2179 // back to the window it started from)
2181 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2182 // style has the focus, it can happen. One such possibility is if
2183 // all windows are either toplevel, wxDialog, wxPanel or static
2184 // controls and no window can actually accept keyboard input.
2185 #if !defined(__WXWINCE__)
2186 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2188 // pessimistic by default
2189 canSafelyCallIsDlgMsg
= false;
2190 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2192 node
= node
->GetNext() )
2194 wxWindow
* const win
= node
->GetData();
2195 if ( win
->AcceptsFocus() &&
2196 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2197 WS_EX_CONTROLPARENT
) )
2199 // it shouldn't hang...
2200 canSafelyCallIsDlgMsg
= true;
2206 #endif // !__WXWINCE__
2208 if ( canSafelyCallIsDlgMsg
)
2210 // ::IsDialogMessage() can enter in an infinite loop when the
2211 // currently focused window is disabled or hidden and its
2212 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2216 if ( !::IsWindowEnabled(hwndFocus
) ||
2217 !::IsWindowVisible(hwndFocus
) )
2219 // it would enter an infinite loop if we do this!
2220 canSafelyCallIsDlgMsg
= false;
2225 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2227 // it's a top level window, don't go further -- e.g. even
2228 // if the parent of a dialog is disabled, this doesn't
2229 // break navigation inside the dialog
2233 hwndFocus
= ::GetParent(hwndFocus
);
2237 // let IsDialogMessage() have the message if it's safe to call it
2238 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2240 // IsDialogMessage() did something...
2245 #endif // __WXUNIVERSAL__
2250 // relay mouse move events to the tooltip control
2251 MSG
*msg
= (MSG
*)pMsg
;
2252 if ( msg
->message
== WM_MOUSEMOVE
)
2253 m_tooltip
->RelayEvent(pMsg
);
2255 #endif // wxUSE_TOOLTIPS
2260 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2262 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2263 return m_acceleratorTable
.Translate(this, pMsg
);
2267 #endif // wxUSE_ACCEL
2270 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2272 // preprocess all messages by default
2276 // ---------------------------------------------------------------------------
2277 // message params unpackers
2278 // ---------------------------------------------------------------------------
2280 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2281 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2283 *id
= LOWORD(wParam
);
2284 *hwnd
= (WXHWND
)lParam
;
2285 *cmd
= HIWORD(wParam
);
2288 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2289 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2291 *state
= LOWORD(wParam
);
2292 *minimized
= HIWORD(wParam
);
2293 *hwnd
= (WXHWND
)lParam
;
2296 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2297 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2299 *code
= LOWORD(wParam
);
2300 *pos
= HIWORD(wParam
);
2301 *hwnd
= (WXHWND
)lParam
;
2304 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2305 WXHDC
*hdc
, WXHWND
*hwnd
)
2307 *hwnd
= (WXHWND
)lParam
;
2308 *hdc
= (WXHDC
)wParam
;
2311 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2312 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2314 *item
= (WXWORD
)wParam
;
2315 *flags
= HIWORD(wParam
);
2316 *hmenu
= (WXHMENU
)lParam
;
2319 // ---------------------------------------------------------------------------
2320 // Main wxWidgets window proc and the window proc for wxWindow
2321 // ---------------------------------------------------------------------------
2323 // Hook for new window just as it's being created, when the window isn't yet
2324 // associated with the handle
2325 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2327 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2328 // window being created and insures that it's always unset back later
2329 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2331 gs_winBeingCreated
= winBeingCreated
;
2334 wxWindowCreationHook::~wxWindowCreationHook()
2336 gs_winBeingCreated
= NULL
;
2340 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2342 // trace all messages - useful for the debugging
2344 wxLogTrace(wxTraceMessages
,
2345 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2346 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2347 #endif // __WXDEBUG__
2349 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2351 // when we get the first message for the HWND we just created, we associate
2352 // it with wxWindow stored in gs_winBeingCreated
2353 if ( !wnd
&& gs_winBeingCreated
)
2355 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2356 wnd
= gs_winBeingCreated
;
2357 gs_winBeingCreated
= NULL
;
2358 wnd
->SetHWND((WXHWND
)hWnd
);
2363 if ( wnd
&& wxEventLoop::AllowProcessing(wnd
) )
2364 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2366 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2371 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2373 // did we process the message?
2374 bool processed
= false;
2384 // for most messages we should return 0 when we do process the message
2392 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2395 // return 0 to allow window creation
2396 rc
.result
= mayCreate
? 0 : -1;
2402 // never set processed to true and *always* pass WM_DESTROY to
2403 // DefWindowProc() as Windows may do some internal cleanup when
2404 // processing it and failing to pass the message along may cause
2405 // memory and resource leaks!
2406 (void)HandleDestroy();
2410 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2414 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2417 #if !defined(__WXWINCE__)
2420 LPRECT pRect
= (LPRECT
)lParam
;
2422 rc
.SetLeft(pRect
->left
);
2423 rc
.SetTop(pRect
->top
);
2424 rc
.SetRight(pRect
->right
);
2425 rc
.SetBottom(pRect
->bottom
);
2426 processed
= HandleMoving(rc
);
2428 pRect
->left
= rc
.GetLeft();
2429 pRect
->top
= rc
.GetTop();
2430 pRect
->right
= rc
.GetRight();
2431 pRect
->bottom
= rc
.GetBottom();
2438 LPRECT pRect
= (LPRECT
)lParam
;
2440 rc
.SetLeft(pRect
->left
);
2441 rc
.SetTop(pRect
->top
);
2442 rc
.SetRight(pRect
->right
);
2443 rc
.SetBottom(pRect
->bottom
);
2444 processed
= HandleSizing(rc
);
2446 pRect
->left
= rc
.GetLeft();
2447 pRect
->top
= rc
.GetTop();
2448 pRect
->right
= rc
.GetRight();
2449 pRect
->bottom
= rc
.GetBottom();
2453 #endif // !__WXWINCE__
2455 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2456 case WM_ACTIVATEAPP
:
2457 // This implicitly sends a wxEVT_ACTIVATE_APP event
2458 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2464 WXWORD state
, minimized
;
2466 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2468 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2473 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2477 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2480 case WM_PRINTCLIENT
:
2481 processed
= HandlePrintClient((WXHDC
)wParam
);
2487 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2489 processed
= HandlePaint();
2493 processed
= HandlePaint();
2498 #ifdef __WXUNIVERSAL__
2499 // Universal uses its own wxFrame/wxDialog, so we don't receive
2500 // close events unless we have this.
2502 #endif // __WXUNIVERSAL__
2504 // don't let the DefWindowProc() destroy our window - we'll do it
2505 // ourselves in ~wxWindow
2511 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2515 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2516 GET_Y_LPARAM(lParam
),
2520 #ifdef HAVE_TRACKMOUSEEVENT
2522 // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
2523 if ( m_mouseInWindow
)
2525 GenerateMouseLeave();
2528 // always pass processed back as false, this allows the window
2529 // manager to process the message too. This is needed to
2530 // ensure windows XP themes work properly as the mouse moves
2531 // over widgets like buttons. So don't set processed to true here.
2533 #endif // HAVE_TRACKMOUSEEVENT
2535 #if wxUSE_MOUSEWHEEL
2537 processed
= HandleMouseWheel(wParam
, lParam
);
2541 case WM_LBUTTONDOWN
:
2543 case WM_LBUTTONDBLCLK
:
2544 case WM_RBUTTONDOWN
:
2546 case WM_RBUTTONDBLCLK
:
2547 case WM_MBUTTONDOWN
:
2549 case WM_MBUTTONDBLCLK
:
2551 #ifdef __WXMICROWIN__
2552 // MicroWindows seems to ignore the fact that a window is
2553 // disabled. So catch mouse events and throw them away if
2555 wxWindowMSW
* win
= this;
2558 if (!win
->IsEnabled())
2564 win
= win
->GetParent();
2565 if ( !win
|| win
->IsTopLevel() )
2572 #endif // __WXMICROWIN__
2573 int x
= GET_X_LPARAM(lParam
),
2574 y
= GET_Y_LPARAM(lParam
);
2577 // redirect the event to a static control if necessary by
2578 // finding one under mouse because under CE the static controls
2579 // don't generate mouse events (even with SS_NOTIFY)
2581 if ( GetCapture() == this )
2583 // but don't do it if the mouse is captured by this window
2584 // because then it should really get this event itself
2589 win
= FindWindowForMouseEvent(this, &x
, &y
);
2591 // this should never happen
2592 wxCHECK_MSG( win
, 0,
2593 _T("FindWindowForMouseEvent() returned NULL") );
2596 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2598 SHRGINFO shrgi
= {0};
2600 shrgi
.cbSize
= sizeof(SHRGINFO
);
2601 shrgi
.hwndClient
= (HWND
) GetHWND();
2605 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2606 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2608 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2611 pt
= ClientToScreen(pt
);
2613 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2615 evtCtx
.SetEventObject(this);
2616 if (GetEventHandler()->ProcessEvent(evtCtx
))
2619 return MSWDefWindowProc(message
, wParam
, lParam
);
2624 #else // !__WXWINCE__
2625 wxWindowMSW
*win
= this;
2626 #endif // __WXWINCE__/!__WXWINCE__
2628 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2630 // if the app didn't eat the event, handle it in the default
2631 // way, that is by giving this window the focus
2634 // for the standard classes their WndProc sets the focus to
2635 // them anyhow and doing it from here results in some weird
2636 // problems, so don't do it for them (unnecessary anyhow)
2637 if ( !win
->IsOfStandardClass() )
2639 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2651 case MM_JOY1BUTTONDOWN
:
2652 case MM_JOY2BUTTONDOWN
:
2653 case MM_JOY1BUTTONUP
:
2654 case MM_JOY2BUTTONUP
:
2655 processed
= HandleJoystickEvent(message
,
2656 GET_X_LPARAM(lParam
),
2657 GET_Y_LPARAM(lParam
),
2660 #endif // __WXMICROWIN__
2666 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2668 processed
= HandleCommand(id
, cmd
, hwnd
);
2673 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2676 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2677 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2678 // apparently doesn't always behave properly and needs some help
2679 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2680 case WM_NOTIFYFORMAT
:
2681 if ( lParam
== NF_QUERY
)
2684 rc
.result
= NFR_UNICODE
;
2687 #endif // wxUSE_UNICODE_MSLU
2689 // for these messages we must return true if process the message
2692 case WM_MEASUREITEM
:
2694 int idCtrl
= (UINT
)wParam
;
2695 if ( message
== WM_DRAWITEM
)
2697 processed
= MSWOnDrawItem(idCtrl
,
2698 (WXDRAWITEMSTRUCT
*)lParam
);
2702 processed
= MSWOnMeasureItem(idCtrl
,
2703 (WXMEASUREITEMSTRUCT
*)lParam
);
2710 #endif // defined(WM_DRAWITEM)
2713 if ( !IsOfStandardClass() )
2715 // we always want to get the char events
2716 rc
.result
= DLGC_WANTCHARS
;
2718 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2720 // in fact, we want everything
2721 rc
.result
|= DLGC_WANTARROWS
|
2728 //else: get the dlg code from the DefWindowProc()
2733 // If this has been processed by an event handler, return 0 now
2734 // (we've handled it).
2735 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2736 if ( m_lastKeydownProcessed
)
2745 // we consider these messages "not interesting" to OnChar, so
2746 // just don't do anything more with them
2756 // avoid duplicate messages to OnChar for these ASCII keys:
2757 // they will be translated by TranslateMessage() and received
2779 // but set processed to false, not true to still pass them
2780 // to the control's default window proc - otherwise
2781 // built-in keyboard handling won't work
2786 // special case of VK_APPS: treat it the same as right mouse
2787 // click because both usually pop up a context menu
2789 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2794 // do generate a CHAR event
2795 processed
= HandleChar((WORD
)wParam
, lParam
);
2798 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2805 // special case of VK_APPS: treat it the same as right mouse button
2806 if ( wParam
== VK_APPS
)
2808 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2813 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2818 case WM_CHAR
: // Always an ASCII character
2819 if ( m_lastKeydownProcessed
)
2821 // The key was handled in the EVT_KEY_DOWN and handling
2822 // a key in an EVT_KEY_DOWN handler is meant, by
2823 // design, to prevent EVT_CHARs from happening
2824 m_lastKeydownProcessed
= false;
2829 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2835 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2837 #endif // wxUSE_HOTKEY
2844 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2846 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2852 // CTLCOLOR messages are sent by children to query the parent for their
2854 #ifndef __WXMICROWIN__
2855 case WM_CTLCOLORMSGBOX
:
2856 case WM_CTLCOLOREDIT
:
2857 case WM_CTLCOLORLISTBOX
:
2858 case WM_CTLCOLORBTN
:
2859 case WM_CTLCOLORDLG
:
2860 case WM_CTLCOLORSCROLLBAR
:
2861 case WM_CTLCOLORSTATIC
:
2865 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2867 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2870 #endif // !__WXMICROWIN__
2872 case WM_SYSCOLORCHANGE
:
2873 // the return value for this message is ignored
2874 processed
= HandleSysColorChange();
2877 #if !defined(__WXWINCE__)
2878 case WM_DISPLAYCHANGE
:
2879 processed
= HandleDisplayChange();
2883 case WM_PALETTECHANGED
:
2884 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2887 case WM_CAPTURECHANGED
:
2888 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2891 case WM_SETTINGCHANGE
:
2892 processed
= HandleSettingChange(wParam
, lParam
);
2895 case WM_QUERYNEWPALETTE
:
2896 processed
= HandleQueryNewPalette();
2900 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2903 // we processed the message, i.e. erased the background
2908 #if !defined(__WXWINCE__)
2910 processed
= HandleDropFiles(wParam
);
2915 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2919 // we never set focus from here
2924 #if !defined(__WXWINCE__)
2925 case WM_QUERYENDSESSION
:
2926 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2930 processed
= HandleEndSession(wParam
!= 0, lParam
);
2933 case WM_GETMINMAXINFO
:
2934 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2939 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2940 LOWORD(lParam
), // hit test
2941 HIWORD(lParam
)); // mouse msg
2945 // returning TRUE stops the DefWindowProc() from further
2946 // processing this message - exactly what we need because we've
2947 // just set the cursor.
2952 #if wxUSE_ACCESSIBILITY
2955 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2956 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2958 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2960 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2966 #if defined(WM_HELP)
2969 // HELPINFO doesn't seem to be supported on WinCE.
2971 HELPINFO
* info
= (HELPINFO
*) lParam
;
2972 // Don't yet process menu help events, just windows
2973 if (info
->iContextType
== HELPINFO_WINDOW
)
2976 wxWindowMSW
* subjectOfHelp
= this;
2977 bool eventProcessed
= false;
2978 while (subjectOfHelp
&& !eventProcessed
)
2980 wxHelpEvent
helpEvent(wxEVT_HELP
,
2981 subjectOfHelp
->GetId(),
2985 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2989 helpEvent
.SetEventObject(this);
2991 GetEventHandler()->ProcessEvent(helpEvent
);
2993 // Go up the window hierarchy until the event is
2995 subjectOfHelp
= subjectOfHelp
->GetParent();
2998 processed
= eventProcessed
;
3001 else if (info
->iContextType
== HELPINFO_MENUITEM
)
3003 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3004 helpEvent
.SetEventObject(this);
3005 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
3008 //else: processed is already false
3014 #if !defined(__WXWINCE__)
3015 case WM_CONTEXTMENU
:
3017 // we don't convert from screen to client coordinates as
3018 // the event may be handled by a parent window
3019 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3021 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3023 // we could have got an event from our child, reflect it back
3024 // to it if this is the case
3025 wxWindowMSW
*win
= NULL
;
3026 if ( (WXHWND
)wParam
!= m_hWnd
)
3028 win
= FindItemByHWND((WXHWND
)wParam
);
3034 evtCtx
.SetEventObject(win
);
3035 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
3041 // we're only interested in our own menus, not MF_SYSMENU
3042 if ( HIWORD(wParam
) == MF_POPUP
)
3044 // handle menu chars for ownerdrawn menu items
3045 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3046 if ( i
!= wxNOT_FOUND
)
3048 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3058 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3059 wxGetMessageName(message
));
3060 #endif // __WXDEBUG__
3061 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3067 // ----------------------------------------------------------------------------
3068 // wxWindow <-> HWND map
3069 // ----------------------------------------------------------------------------
3071 wxWinHashTable
*wxWinHandleHash
= NULL
;
3073 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3075 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3078 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3080 // adding NULL hWnd is (first) surely a result of an error and
3081 // (secondly) breaks menu command processing
3082 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3083 wxT("attempt to add a NULL hWnd to window list ignored") );
3085 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3087 if ( oldWin
&& (oldWin
!= win
) )
3089 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3090 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3093 #endif // __WXDEBUG__
3096 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3100 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3102 wxWinHandleHash
->Delete((long)win
->GetHWND());
3105 // ----------------------------------------------------------------------------
3106 // various MSW speciic class dependent functions
3107 // ----------------------------------------------------------------------------
3109 // Default destroyer - override if you destroy it in some other way
3110 // (e.g. with MDI child windows)
3111 void wxWindowMSW::MSWDestroyWindow()
3115 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3118 int& w
, int& h
) const
3120 // yes, those are just some arbitrary hardcoded numbers
3121 static const int DEFAULT_Y
= 200;
3123 bool nonDefault
= false;
3125 if ( pos
.x
== wxDefaultCoord
)
3127 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3128 // can just as well set it to CW_USEDEFAULT as well
3134 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3135 // neither because it is not handled as a special value by Windows then
3136 // and so we have to choose some default value for it
3138 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3144 NB: there used to be some code here which set the initial size of the
3145 window to the client size of the parent if no explicit size was
3146 specified. This was wrong because wxWidgets programs often assume
3147 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3148 it. To see why, you should understand that Windows sends WM_SIZE from
3149 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3150 from some base class ctor and so this WM_SIZE is not processed in the
3151 real class' OnSize() (because it's not fully constructed yet and the
3152 event goes to some base class OnSize() instead). So the WM_SIZE we
3153 rely on is the one sent when the parent frame resizes its children
3154 but here is the problem: if the child already has just the right
3155 size, nothing will happen as both wxWidgets and Windows check for
3156 this and ignore any attempts to change the window size to the size it
3157 already has - so no WM_SIZE would be sent.
3161 // we don't use CW_USEDEFAULT here for several reasons:
3163 // 1. it results in huge frames on modern screens (1000*800 is not
3164 // uncommon on my 1280*1024 screen) which is way too big for a half
3165 // empty frame of most of wxWidgets samples for example)
3167 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3168 // the default is for whatever reason 8*8 which breaks client <->
3169 // window size calculations (it would be nice if it didn't, but it
3170 // does and the simplest way to fix it seemed to change the broken
3171 // default size anyhow)
3173 // 3. there is just no advantage in doing it: with x and y it is
3174 // possible that [future versions of] Windows position the new top
3175 // level window in some smart way which we can't do, but we can
3176 // guess a reasonably good size for a new window just as well
3179 // However, on PocketPC devices, we must use the default
3180 // size if possible.
3182 if (size
.x
== wxDefaultCoord
)
3186 if (size
.y
== wxDefaultCoord
)
3191 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3195 w
= WidthDefault(size
.x
);
3196 h
= HeightDefault(size
.y
);
3199 AdjustForParentClientOrigin(x
, y
);
3204 WXHWND
wxWindowMSW::MSWGetParent() const
3206 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3209 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3210 const wxChar
*title
,
3214 WXDWORD extendedStyle
)
3216 // choose the position/size for the new window
3218 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3220 // controlId is menu handle for the top level windows, so set it to 0
3221 // unless we're creating a child window
3222 int controlId
= style
& WS_CHILD
? GetId() : 0;
3224 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3225 // which is the same but without CS_[HV]REDRAW class styles so using it
3226 // ensures that the window is not fully repainted on each resize
3227 wxString
className(wclass
);
3228 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3230 className
+= wxT("NR");
3233 // do create the window
3234 wxWindowCreationHook
hook(this);
3236 m_hWnd
= (WXHWND
)::CreateWindowEx
3240 title
? title
: m_windowName
.c_str(),
3243 (HWND
)MSWGetParent(),
3246 NULL
// no extra data
3251 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3256 SubclassWin(m_hWnd
);
3261 // ===========================================================================
3262 // MSW message handlers
3263 // ===========================================================================
3265 // ---------------------------------------------------------------------------
3267 // ---------------------------------------------------------------------------
3269 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3271 #ifndef __WXMICROWIN__
3272 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3273 HWND hWnd
= hdr
->hwndFrom
;
3274 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3276 // if the control is one of our windows, let it handle the message itself
3279 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3282 // VZ: why did we do it? normally this is unnecessary and, besides, it
3283 // breaks the message processing for the toolbars because the tooltip
3284 // notifications were being forwarded to the toolbar child controls
3285 // (if it had any) before being passed to the toolbar itself, so in my
3286 // example the tooltip for the combobox was always shown instead of the
3287 // correct button tooltips
3289 // try all our children
3290 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3293 wxWindow
*child
= node
->GetData();
3294 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3299 node
= node
->GetNext();
3303 // by default, handle it ourselves
3304 return MSWOnNotify(idCtrl
, lParam
, result
);
3305 #else // __WXMICROWIN__
3312 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3314 const wxString
& ttip
)
3316 // I don't know why it happens, but the versions of comctl32.dll starting
3317 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3318 // this message is supposed to be sent to Unicode programs only) -- hence
3319 // we need to handle it as well, otherwise no tooltips will be shown in
3322 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3325 // not a tooltip message or no tooltip to show anyhow
3330 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3332 // We don't want to use the szText buffer because it has a limit of 80
3333 // bytes and this is not enough, especially for Unicode build where it
3334 // limits the tooltip string length to only 40 characters
3336 // The best would be, of course, to not impose any length limitations at
3337 // all but then the buffer would have to be dynamic and someone would have
3338 // to free it and we don't have the tooltip owner object here any more, so
3339 // for now use our own static buffer with a higher fixed max length.
3341 // Note that using a static buffer should not be a problem as only a single
3342 // tooltip can be shown at the same time anyhow.
3344 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3346 // We need to convert tooltip from multi byte to Unicode on the fly.
3347 static wchar_t buf
[513];
3349 // Truncate tooltip length if needed as otherwise we might not have
3350 // enough space for it in the buffer and MultiByteToWideChar() would
3352 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3354 // Convert to WideChar without adding the NULL character. The NULL
3355 // character is added afterwards (this is more efficient).
3356 int len
= ::MultiByteToWideChar
3368 wxLogLastError(_T("MultiByteToWideChar()"));
3372 ttText
->lpszText
= (LPSTR
) buf
;
3374 else // TTN_NEEDTEXTA
3375 #endif // !wxUSE_UNICODE
3377 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3378 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3379 // to copy the string we have into the buffer
3380 static wxChar buf
[513];
3381 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3382 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3383 ttText
->lpszText
= buf
;
3389 #endif // wxUSE_TOOLTIPS
3391 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3393 WXLPARAM
* WXUNUSED(result
))
3398 NMHDR
* hdr
= (NMHDR
*)lParam
;
3399 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3406 wxUnusedVar(lParam
);
3407 #endif // wxUSE_TOOLTIPS
3412 // ---------------------------------------------------------------------------
3413 // end session messages
3414 // ---------------------------------------------------------------------------
3416 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3418 #ifdef ENDSESSION_LOGOFF
3419 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3420 event
.SetEventObject(wxTheApp
);
3421 event
.SetCanVeto(true);
3422 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3424 bool rc
= wxTheApp
->ProcessEvent(event
);
3428 // we may end only if the app didn't veto session closing (double
3430 *mayEnd
= !event
.GetVeto();
3435 wxUnusedVar(logOff
);
3436 wxUnusedVar(mayEnd
);
3441 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3443 #ifdef ENDSESSION_LOGOFF
3444 // do nothing if the session isn't ending
3449 if ( (this != wxTheApp
->GetTopWindow()) )
3452 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3453 event
.SetEventObject(wxTheApp
);
3454 event
.SetCanVeto(false);
3455 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3457 return wxTheApp
->ProcessEvent(event
);
3459 wxUnusedVar(endSession
);
3460 wxUnusedVar(logOff
);
3465 // ---------------------------------------------------------------------------
3466 // window creation/destruction
3467 // ---------------------------------------------------------------------------
3469 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3472 // VZ: why is this commented out for WinCE? If it doesn't support
3473 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3474 // not with multiple #ifdef's!
3476 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3477 EnsureParentHasControlParentStyle(GetParent());
3478 #endif // !__WXWINCE__
3480 // TODO: should generate this event from WM_NCCREATE
3481 wxWindowCreateEvent
event((wxWindow
*)this);
3482 (void)GetEventHandler()->ProcessEvent(event
);
3489 bool wxWindowMSW::HandleDestroy()
3493 // delete our drop target if we've got one
3494 #if wxUSE_DRAG_AND_DROP
3495 if ( m_dropTarget
!= NULL
)
3497 m_dropTarget
->Revoke(m_hWnd
);
3499 delete m_dropTarget
;
3500 m_dropTarget
= NULL
;
3502 #endif // wxUSE_DRAG_AND_DROP
3504 // WM_DESTROY handled
3508 // ---------------------------------------------------------------------------
3510 // ---------------------------------------------------------------------------
3512 bool wxWindowMSW::HandleActivate(int state
,
3513 bool WXUNUSED(minimized
),
3514 WXHWND
WXUNUSED(activate
))
3516 wxActivateEvent
event(wxEVT_ACTIVATE
,
3517 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3519 event
.SetEventObject(this);
3521 return GetEventHandler()->ProcessEvent(event
);
3524 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3526 // Strangly enough, some controls get set focus events when they are being
3527 // deleted, even if they already had focus before.
3528 if ( m_isBeingDeleted
)
3533 // notify the parent keeping track of focus for the kbd navigation
3534 // purposes that we got it
3535 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3536 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3542 m_caret
->OnSetFocus();
3544 #endif // wxUSE_CARET
3547 // If it's a wxTextCtrl don't send the event as it will be done
3548 // after the control gets to process it from EN_FOCUS handler
3549 if ( wxDynamicCastThis(wxTextCtrl
) )
3553 #endif // wxUSE_TEXTCTRL
3555 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3556 event
.SetEventObject(this);
3558 // wxFindWinFromHandle() may return NULL, it is ok
3559 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3561 return GetEventHandler()->ProcessEvent(event
);
3564 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3570 m_caret
->OnKillFocus();
3572 #endif // wxUSE_CARET
3575 // If it's a wxTextCtrl don't send the event as it will be done
3576 // after the control gets to process it.
3577 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3584 // Don't send the event when in the process of being deleted. This can
3585 // only cause problems if the event handler tries to access the object.
3586 if ( m_isBeingDeleted
)
3591 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3592 event
.SetEventObject(this);
3594 // wxFindWinFromHandle() may return NULL, it is ok
3595 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3597 return GetEventHandler()->ProcessEvent(event
);
3600 // ---------------------------------------------------------------------------
3602 // ---------------------------------------------------------------------------
3604 void wxWindowMSW::SetLabel( const wxString
& label
)
3606 SetWindowText(GetHwnd(), label
.c_str());
3609 wxString
wxWindowMSW::GetLabel() const
3611 return wxGetWindowText(GetHWND());
3614 // ---------------------------------------------------------------------------
3616 // ---------------------------------------------------------------------------
3618 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3620 wxShowEvent
event(GetId(), show
);
3621 event
.SetEventObject(this);
3623 return GetEventHandler()->ProcessEvent(event
);
3626 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3628 wxInitDialogEvent
event(GetId());
3629 event
.SetEventObject(this);
3631 return GetEventHandler()->ProcessEvent(event
);
3634 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3636 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3637 wxUnusedVar(wParam
);
3639 #else // __WXMICROWIN__
3640 HDROP hFilesInfo
= (HDROP
) wParam
;
3642 // Get the total number of files dropped
3643 UINT gwFilesDropped
= ::DragQueryFile
3651 wxString
*files
= new wxString
[gwFilesDropped
];
3652 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3654 // first get the needed buffer length (+1 for terminating NUL)
3655 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3657 // and now get the file name
3658 ::DragQueryFile(hFilesInfo
, wIndex
,
3659 wxStringBuffer(files
[wIndex
], len
), len
);
3661 DragFinish (hFilesInfo
);
3663 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3664 event
.SetEventObject(this);
3667 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3668 event
.m_pos
.x
= dropPoint
.x
;
3669 event
.m_pos
.y
= dropPoint
.y
;
3671 return GetEventHandler()->ProcessEvent(event
);
3676 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3678 int WXUNUSED(mouseMsg
))
3680 #ifndef __WXMICROWIN__
3681 // the logic is as follows:
3682 // -1. don't set cursor for non client area, including but not limited to
3683 // the title bar, scrollbars, &c
3684 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3685 // 1. if we have the cursor set it unless wxIsBusy()
3686 // 2. if we're a top level window, set some cursor anyhow
3687 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3689 if ( nHitTest
!= HTCLIENT
)
3694 HCURSOR hcursor
= 0;
3696 // first ask the user code - it may wish to set the cursor in some very
3697 // specific way (for example, depending on the current position)
3700 if ( !::GetCursorPosWinCE(&pt
))
3702 if ( !::GetCursorPos(&pt
) )
3705 wxLogLastError(wxT("GetCursorPos"));
3710 ScreenToClient(&x
, &y
);
3711 wxSetCursorEvent
event(x
, y
);
3713 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3714 if ( processedEvtSetCursor
&& event
.HasCursor() )
3716 hcursor
= GetHcursorOf(event
.GetCursor());
3721 bool isBusy
= wxIsBusy();
3723 // the test for processedEvtSetCursor is here to prevent using m_cursor
3724 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3725 // it - this is a way to say that our cursor shouldn't be used for this
3727 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3729 hcursor
= GetHcursorOf(m_cursor
);
3736 hcursor
= wxGetCurrentBusyCursor();
3738 else if ( !hcursor
)
3740 const wxCursor
*cursor
= wxGetGlobalCursor();
3741 if ( cursor
&& cursor
->Ok() )
3743 hcursor
= GetHcursorOf(*cursor
);
3751 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3753 ::SetCursor(hcursor
);
3755 // cursor set, stop here
3758 #endif // __WXMICROWIN__
3760 // pass up the window chain
3764 // ---------------------------------------------------------------------------
3765 // owner drawn stuff
3766 // ---------------------------------------------------------------------------
3768 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3769 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3770 #define WXUNUSED_UNLESS_ODRAWN(param) param
3772 #define WXUNUSED_UNLESS_ODRAWN(param)
3776 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3777 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3779 #if wxUSE_OWNER_DRAWN
3781 #if wxUSE_MENUS_NATIVE
3782 // is it a menu item?
3783 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3784 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3786 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3788 // see comment before the same test in MSWOnMeasureItem() below
3792 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3793 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3795 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3796 // the DC from being released
3797 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3798 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3799 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3800 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3802 return pMenuItem
->OnDrawItem
3806 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3807 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3810 #endif // wxUSE_MENUS_NATIVE
3812 #endif // USE_OWNER_DRAWN
3814 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3816 #if wxUSE_OWNER_DRAWN
3817 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3818 #else // !wxUSE_OWNER_DRAWN
3819 // we may still have owner-drawn buttons internally because we have to make
3820 // them owner-drawn to support colour change
3823 wxDynamicCast(FindItem(id
), wxButton
)
3828 #endif // USE_OWNER_DRAWN
3832 return item
->MSWOnDraw(itemStruct
);
3835 #endif // wxUSE_CONTROLS
3841 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3843 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3844 // is it a menu item?
3845 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3846 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3848 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3850 // according to Carsten Fuchs the pointer may be NULL under XP if an
3851 // MDI child frame is initially maximized, see this for more info:
3852 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
3854 // so silently ignore it instead of asserting
3858 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3859 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3862 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3864 pMeasureStruct
->itemWidth
= w
;
3865 pMeasureStruct
->itemHeight
= h
;
3870 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3873 return item
->MSWOnMeasure(itemStruct
);
3877 wxUnusedVar(itemStruct
);
3878 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3883 // ---------------------------------------------------------------------------
3884 // colours and palettes
3885 // ---------------------------------------------------------------------------
3887 bool wxWindowMSW::HandleSysColorChange()
3889 wxSysColourChangedEvent event
;
3890 event
.SetEventObject(this);
3892 (void)GetEventHandler()->ProcessEvent(event
);
3894 // always let the system carry on the default processing to allow the
3895 // native controls to react to the colours update
3899 bool wxWindowMSW::HandleDisplayChange()
3901 wxDisplayChangedEvent event
;
3902 event
.SetEventObject(this);
3904 return GetEventHandler()->ProcessEvent(event
);
3907 #ifndef __WXMICROWIN__
3909 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
3911 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
3915 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
3918 *brush
= item
->MSWControlColor(hDC
, hWnd
);
3920 #endif // wxUSE_CONTROLS
3923 return *brush
!= NULL
;
3926 #endif // __WXMICROWIN__
3928 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3931 // same as below except we don't respond to our own messages
3932 if ( hWndPalChange
!= GetHWND() )
3934 // check to see if we our our parents have a custom palette
3935 wxWindowMSW
*win
= this;
3936 while ( win
&& !win
->HasCustomPalette() )
3938 win
= win
->GetParent();
3941 if ( win
&& win
->HasCustomPalette() )
3943 // realize the palette to see whether redrawing is needed
3944 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3945 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3946 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3948 int result
= ::RealizePalette(hdc
);
3950 // restore the palette (before releasing the DC)
3951 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3952 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3953 ::RealizePalette(hdc
);
3954 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3956 // now check for the need to redraw
3958 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3962 #endif // wxUSE_PALETTE
3964 wxPaletteChangedEvent
event(GetId());
3965 event
.SetEventObject(this);
3966 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3968 return GetEventHandler()->ProcessEvent(event
);
3971 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3973 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3974 event
.SetEventObject(this);
3976 return GetEventHandler()->ProcessEvent(event
);
3979 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
3981 // despite MSDN saying "(This message cannot be sent directly to a window.)"
3982 // we need to send this to child windows (it is only sent to top-level
3983 // windows) so {list,tree}ctrls can adjust their font size if necessary
3984 // this is exactly how explorer does it to enable the font size changes
3986 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3989 // top-level windows already get this message from the system
3990 wxWindow
*win
= node
->GetData();
3991 if ( !win
->IsTopLevel() )
3993 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
3996 node
= node
->GetNext();
3999 // let the system handle it
4003 bool wxWindowMSW::HandleQueryNewPalette()
4007 // check to see if we our our parents have a custom palette
4008 wxWindowMSW
*win
= this;
4009 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4010 if (win
->HasCustomPalette()) {
4011 /* realize the palette to see whether redrawing is needed */
4012 HDC hdc
= ::GetDC((HWND
) GetHWND());
4013 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4014 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4016 int result
= ::RealizePalette(hdc
);
4017 /* restore the palette (before releasing the DC) */
4018 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4019 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4020 ::RealizePalette(hdc
);
4021 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4022 /* now check for the need to redraw */
4024 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4026 #endif // wxUSE_PALETTE
4028 wxQueryNewPaletteEvent
event(GetId());
4029 event
.SetEventObject(this);
4031 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
4034 // Responds to colour changes: passes event on to children.
4035 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4037 // the top level window also reset the standard colour map as it might have
4038 // changed (there is no need to do it for the non top level windows as we
4039 // only have to do it once)
4043 gs_hasStdCmap
= false;
4045 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4048 // Only propagate to non-top-level windows because Windows already
4049 // sends this event to all top-level ones
4050 wxWindow
*win
= node
->GetData();
4051 if ( !win
->IsTopLevel() )
4053 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4054 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4055 // the standard controls
4056 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4059 node
= node
->GetNext();
4063 extern wxCOLORMAP
*wxGetStdColourMap()
4065 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4066 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4068 if ( !gs_hasStdCmap
)
4070 static bool s_coloursInit
= false;
4072 if ( !s_coloursInit
)
4074 // When a bitmap is loaded, the RGB values can change (apparently
4075 // because Windows adjusts them to care for the old programs always
4076 // using 0xc0c0c0 while the transparent colour for the new Windows
4077 // versions is different). But we do this adjustment ourselves so
4078 // we want to avoid Windows' "help" and for this we need to have a
4079 // reference bitmap which can tell us what the RGB values change
4081 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4082 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4083 if ( stdColourBitmap
.Ok() )
4085 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4086 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4087 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4090 memDC
.SelectObject(stdColourBitmap
);
4093 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4095 memDC
.GetPixel(i
, 0, &colour
);
4096 s_stdColours
[i
] = wxColourToRGB(colour
);
4099 else // wxBITMAP_STD_COLOURS couldn't be loaded
4101 s_stdColours
[0] = RGB(000,000,000); // black
4102 s_stdColours
[1] = RGB(128,128,128); // dark grey
4103 s_stdColours
[2] = RGB(192,192,192); // light grey
4104 s_stdColours
[3] = RGB(255,255,255); // white
4105 //s_stdColours[4] = RGB(000,000,255); // blue
4106 //s_stdColours[5] = RGB(255,000,255); // magenta
4109 s_coloursInit
= true;
4112 gs_hasStdCmap
= true;
4114 // create the colour map
4115 #define INIT_CMAP_ENTRY(col) \
4116 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4117 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4119 INIT_CMAP_ENTRY(BTNTEXT
);
4120 INIT_CMAP_ENTRY(BTNSHADOW
);
4121 INIT_CMAP_ENTRY(BTNFACE
);
4122 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4124 #undef INIT_CMAP_ENTRY
4130 // ---------------------------------------------------------------------------
4132 // ---------------------------------------------------------------------------
4134 bool wxWindowMSW::HandlePaint()
4136 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4138 wxLogLastError(wxT("CreateRectRgn"));
4139 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4140 wxLogLastError(wxT("GetUpdateRgn"));
4142 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4144 wxPaintEvent
event(m_windowId
);
4145 event
.SetEventObject(this);
4147 bool processed
= GetEventHandler()->ProcessEvent(event
);
4149 // note that we must generate NC event after the normal one as otherwise
4150 // BeginPaint() will happily overwrite our decorations with the background
4152 wxNcPaintEvent
eventNc(m_windowId
);
4153 eventNc
.SetEventObject(this);
4154 GetEventHandler()->ProcessEvent(eventNc
);
4159 // Can be called from an application's OnPaint handler
4160 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4162 #ifdef __WXUNIVERSAL__
4165 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
4168 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4173 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4178 dc
.SetWindow((wxWindow
*)this);
4180 wxEraseEvent
event(m_windowId
, &dc
);
4181 event
.SetEventObject(this);
4182 bool rc
= GetEventHandler()->ProcessEvent(event
);
4184 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4185 dc
.SelectOldObjects(hdc
);
4190 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4192 // standard non top level controls (i.e. except the dialogs) always erase
4193 // their background themselves in HandleCtlColor() or have some control-
4194 // specific ways to set the colours (common controls)
4195 if ( IsOfStandardClass() && !IsTopLevel() )
4201 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4203 // don't skip the event here, custom background means that the app
4204 // is drawing it itself in its OnPaint(), so don't draw it at all
4205 // now to avoid flicker
4210 // do default background painting
4211 if ( !DoEraseBackground(GetHdcOf(*event
.GetDC())) )
4213 // let the system paint the background
4218 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4220 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4224 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4230 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4234 // our background colour applies to:
4235 // 1. this window itself, always
4236 // 2. all children unless the colour is "not inheritable"
4237 // 3. even if it is not inheritable, our immediate transparent
4238 // children should still inherit it -- but not any transparent
4239 // children because it would look wrong if a child of non
4240 // transparent child would show our bg colour when the child itself
4242 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4245 (win
&& win
->HasTransparentBackground() &&
4246 win
->GetParent() == this) )
4248 // draw children with the same colour as the parent
4250 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4252 return (WXHBRUSH
)GetHbrushOf(*brush
);
4259 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4262 hWndToPaint
= GetHWND();
4264 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4266 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4270 // background is not inherited beyond top level windows
4271 if ( win
->IsTopLevel() )
4278 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4280 // we receive this message when DrawThemeParentBackground() is
4281 // called from def window proc of several controls under XP and we
4282 // must draw properly themed background here
4284 // note that naively I'd expect filling the client rect with the
4285 // brush returned by MSWGetBgBrush() work -- but for some reason it
4286 // doesn't and we have to call parents MSWPrintChild() which is
4287 // supposed to call DrawThemeBackground() with appropriate params
4289 // also note that in this case lParam == PRF_CLIENT but we're
4290 // clearly expected to paint the background and nothing else!
4292 if ( IsTopLevel() || InheritsBackgroundColour() )
4295 // sometimes we don't want the parent to handle it at all, instead
4296 // return whatever value this window wants
4297 if ( !MSWShouldPropagatePrintChild() )
4298 return MSWPrintChild(hDC
, (wxWindow
*)this);
4300 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4302 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4305 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4312 // ---------------------------------------------------------------------------
4313 // moving and resizing
4314 // ---------------------------------------------------------------------------
4316 bool wxWindowMSW::HandleMinimize()
4318 wxIconizeEvent
event(m_windowId
);
4319 event
.SetEventObject(this);
4321 return GetEventHandler()->ProcessEvent(event
);
4324 bool wxWindowMSW::HandleMaximize()
4326 wxMaximizeEvent
event(m_windowId
);
4327 event
.SetEventObject(this);
4329 return GetEventHandler()->ProcessEvent(event
);
4332 bool wxWindowMSW::HandleMove(int x
, int y
)
4335 wxMoveEvent
event(point
, m_windowId
);
4336 event
.SetEventObject(this);
4338 return GetEventHandler()->ProcessEvent(event
);
4341 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4343 wxMoveEvent
event(rect
, m_windowId
);
4344 event
.SetEventObject(this);
4346 bool rc
= GetEventHandler()->ProcessEvent(event
);
4348 rect
= event
.GetRect();
4352 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4354 #if USE_DEFERRED_SIZING
4355 // when we resize this window, its children are probably going to be
4356 // repositioned as well, prepare to use DeferWindowPos() for them
4357 int numChildren
= 0;
4358 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4360 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4365 // Protect against valid m_hDWP being overwritten
4366 bool useDefer
= false;
4368 if ( numChildren
> 1 )
4372 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4375 wxLogLastError(_T("BeginDeferWindowPos"));
4381 #endif // USE_DEFERRED_SIZING
4383 // update this window size
4384 bool processed
= false;
4388 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4389 // fall through nevertheless
4393 // we're not interested in these messages at all
4396 case SIZE_MINIMIZED
:
4397 processed
= HandleMinimize();
4400 case SIZE_MAXIMIZED
:
4401 /* processed = */ HandleMaximize();
4402 // fall through to send a normal size event as well
4405 // don't use w and h parameters as they specify the client size
4406 // while according to the docs EVT_SIZE handler is supposed to
4407 // receive the total size
4408 wxSizeEvent
event(GetSize(), m_windowId
);
4409 event
.SetEventObject(this);
4411 processed
= GetEventHandler()->ProcessEvent(event
);
4414 #if USE_DEFERRED_SIZING
4415 // and finally change the positions of all child windows at once
4416 if ( useDefer
&& m_hDWP
)
4418 // reset m_hDWP to NULL so that child windows don't try to use our
4419 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4420 // happen anyhow normally but who knows what weird flow of control we
4421 // may have depending on what the users EVT_SIZE handler does...)
4422 HDWP hDWP
= (HDWP
)m_hDWP
;
4425 // do put all child controls in place at once
4426 if ( !::EndDeferWindowPos(hDWP
) )
4428 wxLogLastError(_T("EndDeferWindowPos"));
4431 // Reset our children's pending pos/size values.
4432 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4434 node
= node
->GetNext() )
4436 wxWindowMSW
*child
= node
->GetData();
4437 child
->m_pendingPosition
= wxDefaultPosition
;
4438 child
->m_pendingSize
= wxDefaultSize
;
4441 #endif // USE_DEFERRED_SIZING
4446 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4448 wxSizeEvent
event(rect
, m_windowId
);
4449 event
.SetEventObject(this);
4451 bool rc
= GetEventHandler()->ProcessEvent(event
);
4453 rect
= event
.GetRect();
4457 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4462 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4466 int minWidth
= GetMinWidth(),
4467 minHeight
= GetMinHeight(),
4468 maxWidth
= GetMaxWidth(),
4469 maxHeight
= GetMaxHeight();
4471 if ( minWidth
!= wxDefaultCoord
)
4473 info
->ptMinTrackSize
.x
= minWidth
;
4477 if ( minHeight
!= wxDefaultCoord
)
4479 info
->ptMinTrackSize
.y
= minHeight
;
4483 if ( maxWidth
!= wxDefaultCoord
)
4485 info
->ptMaxTrackSize
.x
= maxWidth
;
4489 if ( maxHeight
!= wxDefaultCoord
)
4491 info
->ptMaxTrackSize
.y
= maxHeight
;
4499 // ---------------------------------------------------------------------------
4501 // ---------------------------------------------------------------------------
4503 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4505 #if wxUSE_MENUS_NATIVE
4506 if ( !cmd
&& wxCurrentPopupMenu
)
4508 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4509 wxCurrentPopupMenu
= NULL
;
4511 return popupMenu
->MSWCommand(cmd
, id
);
4513 #endif // wxUSE_MENUS_NATIVE
4515 wxWindow
*win
= NULL
;
4517 // first try to find it from HWND - this works even with the broken
4518 // programs using the same ids for different controls
4521 win
= wxFindWinFromHandle(control
);
4527 // must cast to a signed type before comparing with other ids!
4528 win
= FindItem((signed short)id
);
4533 return win
->MSWCommand(cmd
, id
);
4536 // the messages sent from the in-place edit control used by the treectrl
4537 // for label editing have id == 0, but they should _not_ be treated as menu
4538 // messages (they are EN_XXX ones, in fact) so don't translate anything
4539 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4542 // If no child window, it may be an accelerator, e.g. for a popup menu
4545 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4546 event
.SetEventObject(this);
4550 return GetEventHandler()->ProcessEvent(event
);
4554 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4555 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4556 // notifications to its parent which we want to reflect back to
4558 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4559 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4561 #endif // wxUSE_SPINCTRL
4563 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
4564 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
4565 // notifications to its parent which we want to reflect back to
4567 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
4568 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
4576 // ---------------------------------------------------------------------------
4578 // ---------------------------------------------------------------------------
4580 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4584 // our client coords are not quite the same as Windows ones
4585 wxPoint pt
= GetClientAreaOrigin();
4586 event
.m_x
= x
- pt
.x
;
4587 event
.m_y
= y
- pt
.y
;
4589 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4590 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4591 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4592 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4593 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4594 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4597 event
.SetTimestamp(::GetMessageTime());
4600 event
.SetEventObject(this);
4601 event
.SetId(GetId());
4603 #if wxUSE_MOUSEEVENT_HACK
4604 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
4605 gs_lastMouseEvent
.type
= event
.GetEventType();
4606 #endif // wxUSE_MOUSEEVENT_HACK
4610 // Windows doesn't send the mouse events to the static controls (which are
4611 // transparent in the sense that their WM_NCHITTEST handler returns
4612 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4613 // and so we manually check if we don't have a child window under mouse and if
4614 // we do, send the event to it instead of the window Windows had sent WM_XXX
4617 // Notice that this is not done for the mouse move events because this could
4618 // (would?) be too slow, but only for clicks which means that the static texts
4619 // still don't get move, enter nor leave events.
4620 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
4622 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4624 // first try to find a non transparent child: this allows us to send events
4625 // to a static text which is inside a static box, for example
4626 POINT pt
= { *x
, *y
};
4627 HWND hwnd
= GetHwndOf(win
),
4631 hwndUnderMouse
= ::ChildWindowFromPoint
4637 hwndUnderMouse
= ::ChildWindowFromPointEx
4647 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4649 // now try any child window at all
4650 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4653 // check that we have a child window which is susceptible to receive mouse
4654 // events: for this it must be shown and enabled
4655 if ( hwndUnderMouse
&&
4656 hwndUnderMouse
!= hwnd
&&
4657 ::IsWindowVisible(hwndUnderMouse
) &&
4658 ::IsWindowEnabled(hwndUnderMouse
) )
4660 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4661 if ( winUnderMouse
)
4663 // translate the mouse coords to the other window coords
4664 win
->ClientToScreen(x
, y
);
4665 winUnderMouse
->ScreenToClient(x
, y
);
4667 win
= winUnderMouse
;
4673 #endif // __WXWINCE__
4675 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4677 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4678 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4679 // from the message id and take the value in the table to get wxWin event
4681 static const wxEventType eventsMouse
[] =
4695 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4696 InitMouseEvent(event
, x
, y
, flags
);
4698 return GetEventHandler()->ProcessEvent(event
);
4701 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4703 if ( !m_mouseInWindow
)
4705 // it would be wrong to assume that just because we get a mouse move
4706 // event that the mouse is inside the window: although this is usually
4707 // true, it is not if we had captured the mouse, so we need to check
4708 // the mouse coordinates here
4709 if ( !HasCapture() || IsMouseInWindow() )
4711 // Generate an ENTER event
4712 m_mouseInWindow
= true;
4714 #ifdef HAVE_TRACKMOUSEEVENT
4715 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
4717 trackinfo
.dwFlags
= TME_LEAVE
;
4718 trackinfo
.hwndTrack
= GetHwnd();
4720 // Use the commctrl.h _TrackMouseEvent(), which will call the real
4721 // TrackMouseEvent() if available or emulate it
4722 _TrackMouseEvent(&trackinfo
);
4723 #endif // HAVE_TRACKMOUSEEVENT
4725 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4726 InitMouseEvent(event
, x
, y
, flags
);
4728 (void)GetEventHandler()->ProcessEvent(event
);
4731 #ifdef HAVE_TRACKMOUSEEVENT
4734 // Check if we need to send a LEAVE event
4735 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
4736 // send it here if we are using native mouse leave tracking
4737 if ( HasCapture() && !IsMouseInWindow() )
4739 GenerateMouseLeave();
4742 #endif // HAVE_TRACKMOUSEEVENT
4744 #if wxUSE_MOUSEEVENT_HACK
4745 // Windows often generates mouse events even if mouse position hasn't
4746 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
4748 // Filter this out as it can result in unexpected behaviour compared to
4750 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
4751 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
4752 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
4753 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
4755 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
4757 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
4762 #endif // wxUSE_MOUSEEVENT_HACK
4764 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4768 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4770 #if wxUSE_MOUSEWHEEL
4771 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
4772 // forwarded up to the parent by DefWindowProc()) and not in the client
4773 // ones as all the other messages, translate them to the client coords for
4776 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
4777 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4778 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
4779 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4780 event
.m_wheelDelta
= WHEEL_DELTA
;
4782 static int s_linesPerRotation
= -1;
4783 if ( s_linesPerRotation
== -1 )
4785 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4786 &s_linesPerRotation
, 0))
4788 // this is not supposed to happen
4789 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4791 // the default is 3, so use it if SystemParametersInfo() failed
4792 s_linesPerRotation
= 3;
4796 event
.m_linesPerAction
= s_linesPerRotation
;
4797 return GetEventHandler()->ProcessEvent(event
);
4799 #else // !wxUSE_MOUSEWHEEL
4800 wxUnusedVar(wParam
);
4801 wxUnusedVar(lParam
);
4804 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
4807 void wxWindowMSW::GenerateMouseLeave()
4809 m_mouseInWindow
= false;
4812 if ( wxIsShiftDown() )
4814 if ( wxIsCtrlDown() )
4815 state
|= MK_CONTROL
;
4817 // Only the high-order bit should be tested
4818 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
4819 state
|= MK_LBUTTON
;
4820 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
4821 state
|= MK_MBUTTON
;
4822 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
4823 state
|= MK_RBUTTON
;
4827 if ( !::GetCursorPosWinCE(&pt
) )
4829 if ( !::GetCursorPos(&pt
) )
4832 wxLogLastError(_T("GetCursorPos"));
4835 // we need to have client coordinates here for symmetry with
4836 // wxEVT_ENTER_WINDOW
4837 RECT rect
= wxGetWindowRect(GetHwnd());
4841 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
4842 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
4844 (void)GetEventHandler()->ProcessEvent(event
);
4847 // ---------------------------------------------------------------------------
4848 // keyboard handling
4849 // ---------------------------------------------------------------------------
4851 // create the key event of the given type for the given key - used by
4852 // HandleChar and HandleKeyDown/Up
4853 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4856 WXWPARAM wParam
) const
4858 wxKeyEvent
event(evType
);
4859 event
.SetId(GetId());
4860 event
.m_shiftDown
= wxIsShiftDown();
4861 event
.m_controlDown
= wxIsCtrlDown();
4862 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4864 event
.SetEventObject((wxWindow
*)this); // const_cast
4865 event
.m_keyCode
= id
;
4867 event
.m_uniChar
= (wxChar
) wParam
;
4869 event
.m_rawCode
= (wxUint32
) wParam
;
4870 event
.m_rawFlags
= (wxUint32
) lParam
;
4872 event
.SetTimestamp(::GetMessageTime());
4875 // translate the position to client coords
4878 GetCursorPosWinCE(&pt
);
4883 GetWindowRect(GetHwnd(),&rect
);
4893 // isASCII is true only when we're called from WM_CHAR handler and not from
4895 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4900 // If 1 -> 26, translate to either special keycode or just set
4901 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4902 // ControlDown() == true.
4904 if ( (id
> 0) && (id
< 27) )
4926 else // we're called from WM_KEYDOWN
4928 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4931 // it's ASCII and will be processed here only when called from
4932 // WM_CHAR (i.e. when isASCII = true), don't process it now
4937 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4939 // the alphanumeric keys produced by pressing AltGr+something on European
4940 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4941 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4942 // alphanumeric, so pretend that there are no modifiers at all (the
4943 // KEY_DOWN event would still have the correct modifiers if they're really
4945 if ( event
.m_controlDown
&& event
.m_altDown
&&
4946 (id
>= 32 && id
< 256) )
4948 event
.m_controlDown
=
4949 event
.m_altDown
= false;
4952 return GetEventHandler()->ProcessEvent(event
);
4955 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4957 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4961 // normal ASCII char
4965 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4967 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4968 if ( GetEventHandler()->ProcessEvent(event
) )
4977 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4979 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4983 // normal ASCII char
4987 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4989 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4990 if ( GetEventHandler()->ProcessEvent(event
) )
4997 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
4998 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5000 // FIXME: implement GetMenuItemCount for WinCE, possibly
5001 // in terms of GetMenuItemInfo
5003 const HMENU hmenu
= (HMENU
)lParam
;
5007 mii
.cbSize
= sizeof(MENUITEMINFO
);
5009 // we could use MIIM_FTYPE here as we only need to know if the item is
5010 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5011 // MIIM_FTYPE is not supported under Win95
5012 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5014 // find if we have this letter in any owner drawn item
5015 const int count
= ::GetMenuItemCount(hmenu
);
5016 for ( int i
= 0; i
< count
; i
++ )
5018 // previous loop iteration could modify it, reset it back before
5019 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5022 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5024 if ( mii
.fType
== MFT_OWNERDRAW
)
5026 // dwItemData member of the MENUITEMINFO is a
5027 // pointer to the associated wxMenuItem -- see the
5028 // menu creation code
5029 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5031 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
5034 if ( *p
== _T('&') )
5036 // this is not the accel char, find the real one
5037 p
= wxStrchr(p
+ 1, _T('&'));
5039 else // got the accel char
5041 // FIXME-UNICODE: this comparison doesn't risk to work
5042 // for non ASCII accelerator characters I'm afraid, but
5044 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5050 // this one doesn't match
5057 else // failed to get the menu text?
5059 // it's not fatal, so don't show error, but still log it
5060 wxLogLastError(_T("GetMenuItemInfo"));
5067 // ---------------------------------------------------------------------------
5069 // ---------------------------------------------------------------------------
5071 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5075 if ( flags
& JOY_BUTTON1CHG
)
5076 change
= wxJOY_BUTTON1
;
5077 if ( flags
& JOY_BUTTON2CHG
)
5078 change
= wxJOY_BUTTON2
;
5079 if ( flags
& JOY_BUTTON3CHG
)
5080 change
= wxJOY_BUTTON3
;
5081 if ( flags
& JOY_BUTTON4CHG
)
5082 change
= wxJOY_BUTTON4
;
5085 if ( flags
& JOY_BUTTON1
)
5086 buttons
|= wxJOY_BUTTON1
;
5087 if ( flags
& JOY_BUTTON2
)
5088 buttons
|= wxJOY_BUTTON2
;
5089 if ( flags
& JOY_BUTTON3
)
5090 buttons
|= wxJOY_BUTTON3
;
5091 if ( flags
& JOY_BUTTON4
)
5092 buttons
|= wxJOY_BUTTON4
;
5094 // the event ids aren't consecutive so we can't use table based lookup
5096 wxEventType eventType
;
5101 eventType
= wxEVT_JOY_MOVE
;
5106 eventType
= wxEVT_JOY_MOVE
;
5111 eventType
= wxEVT_JOY_ZMOVE
;
5116 eventType
= wxEVT_JOY_ZMOVE
;
5119 case MM_JOY1BUTTONDOWN
:
5121 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5124 case MM_JOY2BUTTONDOWN
:
5126 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5129 case MM_JOY1BUTTONUP
:
5131 eventType
= wxEVT_JOY_BUTTON_UP
;
5134 case MM_JOY2BUTTONUP
:
5136 eventType
= wxEVT_JOY_BUTTON_UP
;
5140 wxFAIL_MSG(wxT("no such joystick event"));
5145 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5146 event
.SetPosition(wxPoint(x
, y
));
5147 event
.SetEventObject(this);
5149 return GetEventHandler()->ProcessEvent(event
);
5159 // ---------------------------------------------------------------------------
5161 // ---------------------------------------------------------------------------
5163 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5164 WXWORD pos
, WXHWND control
)
5166 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5168 wxWindow
*child
= wxFindWinFromHandle(control
);
5170 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5173 wxScrollWinEvent event
;
5174 event
.SetPosition(pos
);
5175 event
.SetOrientation(orientation
);
5176 event
.SetEventObject(this);
5181 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5185 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5189 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5193 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5197 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5201 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5204 case SB_THUMBPOSITION
:
5206 // under Win32, the scrollbar range and position are 32 bit integers,
5207 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5208 // explicitly query the scrollbar for the correct position (this must
5209 // be done only for these two SB_ events as they are the only one
5210 // carrying the scrollbar position)
5212 WinStruct
<SCROLLINFO
> scrollInfo
;
5213 scrollInfo
.fMask
= SIF_TRACKPOS
;
5215 if ( !::GetScrollInfo(GetHwnd(),
5216 orientation
== wxHORIZONTAL
? SB_HORZ
5220 // Not necessarily an error, if there are no scrollbars yet.
5221 // wxLogLastError(_T("GetScrollInfo"));
5224 event
.SetPosition(scrollInfo
.nTrackPos
);
5227 event
.SetEventType( wParam
== SB_THUMBPOSITION
5228 ? wxEVT_SCROLLWIN_THUMBRELEASE
5229 : wxEVT_SCROLLWIN_THUMBTRACK
);
5236 return GetEventHandler()->ProcessEvent(event
);
5239 // ===========================================================================
5241 // ===========================================================================
5243 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5246 HDC dc
= ::GetDC((HWND
) wnd
);
5249 // the_font.UseResource();
5250 // the_font.RealizeResource();
5251 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5253 was
= (HFONT
) SelectObject(dc
,fnt
);
5255 GetTextMetrics(dc
, &tm
);
5258 SelectObject(dc
,was
);
5260 ReleaseDC((HWND
)wnd
, dc
);
5263 *x
= tm
.tmAveCharWidth
;
5265 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5267 // the_font.ReleaseResource();
5270 // use the "extended" bit (24) of lParam to distinguish extended keys
5271 // from normal keys as the same key is sent
5273 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5275 // except that if lParam is 0, it means we don't have real lParam from
5276 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5277 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5278 // non-numpad (hence extended) key as this is a more common case
5279 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5282 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5283 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5284 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
5289 case VK_CANCEL
: id
= WXK_CANCEL
; break;
5290 case VK_BACK
: id
= WXK_BACK
; break;
5291 case VK_TAB
: id
= WXK_TAB
; break;
5292 case VK_CLEAR
: id
= WXK_CLEAR
; break;
5293 case VK_SHIFT
: id
= WXK_SHIFT
; break;
5294 case VK_CONTROL
: id
= WXK_CONTROL
; break;
5295 case VK_MENU
: id
= WXK_ALT
; break;
5296 case VK_PAUSE
: id
= WXK_PAUSE
; break;
5297 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
5298 case VK_SPACE
: id
= WXK_SPACE
; break;
5299 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
5300 case VK_SELECT
: id
= WXK_SELECT
; break;
5301 case VK_PRINT
: id
= WXK_PRINT
; break;
5302 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
5303 case VK_HELP
: id
= WXK_HELP
; break;
5304 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
5305 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
5306 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
5307 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
5308 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
5309 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
5310 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
5311 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
5312 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
5313 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
5314 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
5315 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
5316 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
5317 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
5318 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
5319 case VK_F1
: id
= WXK_F1
; break;
5320 case VK_F2
: id
= WXK_F2
; break;
5321 case VK_F3
: id
= WXK_F3
; break;
5322 case VK_F4
: id
= WXK_F4
; break;
5323 case VK_F5
: id
= WXK_F5
; break;
5324 case VK_F6
: id
= WXK_F6
; break;
5325 case VK_F7
: id
= WXK_F7
; break;
5326 case VK_F8
: id
= WXK_F8
; break;
5327 case VK_F9
: id
= WXK_F9
; break;
5328 case VK_F10
: id
= WXK_F10
; break;
5329 case VK_F11
: id
= WXK_F11
; break;
5330 case VK_F12
: id
= WXK_F12
; break;
5331 case VK_F13
: id
= WXK_F13
; break;
5332 case VK_F14
: id
= WXK_F14
; break;
5333 case VK_F15
: id
= WXK_F15
; break;
5334 case VK_F16
: id
= WXK_F16
; break;
5335 case VK_F17
: id
= WXK_F17
; break;
5336 case VK_F18
: id
= WXK_F18
; break;
5337 case VK_F19
: id
= WXK_F19
; break;
5338 case VK_F20
: id
= WXK_F20
; break;
5339 case VK_F21
: id
= WXK_F21
; break;
5340 case VK_F22
: id
= WXK_F22
; break;
5341 case VK_F23
: id
= WXK_F23
; break;
5342 case VK_F24
: id
= WXK_F24
; break;
5343 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
5344 case VK_SCROLL
: id
= WXK_SCROLL
; break;
5346 // the mapping for these keys may be incorrect on non-US keyboards so
5347 // maybe we shouldn't map them to ASCII values at all
5348 case VK_OEM_1
: id
= ';'; break;
5349 case VK_OEM_PLUS
: id
= '+'; break;
5350 case VK_OEM_COMMA
: id
= ','; break;
5351 case VK_OEM_MINUS
: id
= '-'; break;
5352 case VK_OEM_PERIOD
: id
= '.'; break;
5353 case VK_OEM_2
: id
= '/'; break;
5354 case VK_OEM_3
: id
= '~'; break;
5355 case VK_OEM_4
: id
= '['; break;
5356 case VK_OEM_5
: id
= '\\'; break;
5357 case VK_OEM_6
: id
= ']'; break;
5358 case VK_OEM_7
: id
= '\''; break;
5361 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
5362 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
5363 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
5364 #endif // VK_APPS defined
5366 // handle extended keys
5368 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PRIOR
, WXK_PRIOR
);
5371 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_NEXT
, WXK_NEXT
);
5374 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
5377 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
5380 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
5383 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
5386 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
5389 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
5392 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
5395 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
5398 // don't use ChooseNormalOrExtended() here as the keys are reversed
5399 // here: numpad enter is the extended one
5400 id
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5410 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5416 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5417 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5418 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5419 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5420 case WXK_ALT
: keySym
= VK_MENU
; break;
5421 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5422 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5423 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5424 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5425 case WXK_END
: keySym
= VK_END
; break;
5426 case WXK_HOME
: keySym
= VK_HOME
; break;
5427 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5428 case WXK_UP
: keySym
= VK_UP
; break;
5429 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5430 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5431 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5432 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5433 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5434 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5435 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5436 case WXK_HELP
: keySym
= VK_HELP
; break;
5437 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5438 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5439 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5440 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5441 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5442 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5443 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5444 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5445 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5446 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5447 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5448 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5449 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5450 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5451 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5452 case WXK_F1
: keySym
= VK_F1
; break;
5453 case WXK_F2
: keySym
= VK_F2
; break;
5454 case WXK_F3
: keySym
= VK_F3
; break;
5455 case WXK_F4
: keySym
= VK_F4
; break;
5456 case WXK_F5
: keySym
= VK_F5
; break;
5457 case WXK_F6
: keySym
= VK_F6
; break;
5458 case WXK_F7
: keySym
= VK_F7
; break;
5459 case WXK_F8
: keySym
= VK_F8
; break;
5460 case WXK_F9
: keySym
= VK_F9
; break;
5461 case WXK_F10
: keySym
= VK_F10
; break;
5462 case WXK_F11
: keySym
= VK_F11
; break;
5463 case WXK_F12
: keySym
= VK_F12
; break;
5464 case WXK_F13
: keySym
= VK_F13
; break;
5465 case WXK_F14
: keySym
= VK_F14
; break;
5466 case WXK_F15
: keySym
= VK_F15
; break;
5467 case WXK_F16
: keySym
= VK_F16
; break;
5468 case WXK_F17
: keySym
= VK_F17
; break;
5469 case WXK_F18
: keySym
= VK_F18
; break;
5470 case WXK_F19
: keySym
= VK_F19
; break;
5471 case WXK_F20
: keySym
= VK_F20
; break;
5472 case WXK_F21
: keySym
= VK_F21
; break;
5473 case WXK_F22
: keySym
= VK_F22
; break;
5474 case WXK_F23
: keySym
= VK_F23
; break;
5475 case WXK_F24
: keySym
= VK_F24
; break;
5476 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5477 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5488 bool wxGetKeyState(wxKeyCode key
)
5492 wxASSERT_MSG(key
!= WXK_LBUTTON
&& key
!= WXK_RBUTTON
&& key
!=
5493 WXK_MBUTTON
, wxT("can't use wxGetKeyState() for mouse buttons"));
5495 //High order with GetAsyncKeyState only available on WIN32
5497 //If the requested key is a LED key, return
5498 //true if the led is pressed
5499 if (key
== WXK_NUMLOCK
||
5500 key
== WXK_CAPITAL
||
5504 //low order bit means LED is highlighted,
5505 //high order means key is down
5506 //Here, for compat with other ports we want both
5507 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5514 //low order bit means key pressed since last call
5515 //high order means key is down
5516 //We want only the high order bit - the key may not be down if only low order
5517 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5523 wxMouseState
wxGetMouseState()
5527 GetCursorPos( &pt
);
5531 ms
.SetLeftDown( (GetAsyncKeyState(VK_LBUTTON
) & (1<<15)) != 0 );
5532 ms
.SetMiddleDown( (GetAsyncKeyState(VK_MBUTTON
) & (1<<15)) != 0 );
5533 ms
.SetRightDown( (GetAsyncKeyState(VK_RBUTTON
) & (1<<15)) != 0 );
5535 ms
.SetControlDown( (GetAsyncKeyState(VK_CONTROL
) & (1<<15)) != 0 );
5536 ms
.SetShiftDown( (GetAsyncKeyState(VK_SHIFT
) & (1<<15)) != 0 );
5537 ms
.SetAltDown( (GetAsyncKeyState(VK_MENU
) & (1<<15)) != 0 );
5538 // ms.SetMetaDown();
5544 wxWindow
*wxGetActiveWindow()
5546 HWND hWnd
= GetActiveWindow();
5549 return wxFindWinFromHandle((WXHWND
) hWnd
);
5554 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5556 HWND hwnd
= (HWND
)hWnd
;
5558 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5559 // by code in msw/radiobox.cpp), for all the others we just search up the
5561 wxWindow
*win
= (wxWindow
*)NULL
;
5564 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5568 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5569 // wxWindow class which overrides WM_GETDLGCODE processing to
5570 // do it as well, win would be already non NULL
5571 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5573 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5575 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5576 #endif // wxUSE_RADIOBOX
5578 // spin control text buddy window should be mapped to spin ctrl
5579 // itself so try it too
5580 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5583 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5585 #endif // wxUSE_SPINCTRL
5589 while ( hwnd
&& !win
)
5591 // this is a really ugly hack needed to avoid mistakenly returning the
5592 // parent frame wxWindow for the find/replace modeless dialog HWND -
5593 // this, in turn, is needed to call IsDialogMessage() from
5594 // wxApp::ProcessMessage() as for this we must return NULL from here
5596 // FIXME: this is clearly not the best way to do it but I think we'll
5597 // need to change HWND <-> wxWindow code more heavily than I can
5598 // do it now to fix it
5599 #ifndef __WXMICROWIN__
5600 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5602 // it's a dialog box, don't go upwards
5607 hwnd
= ::GetParent(hwnd
);
5608 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5614 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5616 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5617 // in active frames and dialogs, regardless of where the focus is.
5618 static HHOOK wxTheKeyboardHook
= 0;
5619 static FARPROC wxTheKeyboardHookProc
= 0;
5620 int APIENTRY _EXPORT
5621 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5623 void wxSetKeyboardHook(bool doIt
)
5627 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5628 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5630 GetCurrentThreadId()
5631 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5636 UnhookWindowsHookEx(wxTheKeyboardHook
);
5640 int APIENTRY _EXPORT
5641 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5643 DWORD hiWord
= HIWORD(lParam
);
5644 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5646 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5649 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5650 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5651 event
.m_altDown
= true;
5653 event
.SetEventObject(NULL
);
5654 event
.m_keyCode
= id
;
5655 event
.m_shiftDown
= wxIsShiftDown();
5656 event
.m_controlDown
= wxIsCtrlDown();
5658 event
.SetTimestamp(::GetMessageTime());
5660 wxWindow
*win
= wxGetActiveWindow();
5661 wxEvtHandler
*handler
;
5664 handler
= win
->GetEventHandler();
5665 event
.SetId(win
->GetId());
5670 event
.SetId(wxID_ANY
);
5673 if ( handler
&& handler
->ProcessEvent(event
) )
5681 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5684 #endif // !__WXMICROWIN__
5687 const wxChar
*wxGetMessageName(int message
)
5691 case 0x0000: return wxT("WM_NULL");
5692 case 0x0001: return wxT("WM_CREATE");
5693 case 0x0002: return wxT("WM_DESTROY");
5694 case 0x0003: return wxT("WM_MOVE");
5695 case 0x0005: return wxT("WM_SIZE");
5696 case 0x0006: return wxT("WM_ACTIVATE");
5697 case 0x0007: return wxT("WM_SETFOCUS");
5698 case 0x0008: return wxT("WM_KILLFOCUS");
5699 case 0x000A: return wxT("WM_ENABLE");
5700 case 0x000B: return wxT("WM_SETREDRAW");
5701 case 0x000C: return wxT("WM_SETTEXT");
5702 case 0x000D: return wxT("WM_GETTEXT");
5703 case 0x000E: return wxT("WM_GETTEXTLENGTH");
5704 case 0x000F: return wxT("WM_PAINT");
5705 case 0x0010: return wxT("WM_CLOSE");
5706 case 0x0011: return wxT("WM_QUERYENDSESSION");
5707 case 0x0012: return wxT("WM_QUIT");
5708 case 0x0013: return wxT("WM_QUERYOPEN");
5709 case 0x0014: return wxT("WM_ERASEBKGND");
5710 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
5711 case 0x0016: return wxT("WM_ENDSESSION");
5712 case 0x0017: return wxT("WM_SYSTEMERROR");
5713 case 0x0018: return wxT("WM_SHOWWINDOW");
5714 case 0x0019: return wxT("WM_CTLCOLOR");
5715 case 0x001A: return wxT("WM_WININICHANGE");
5716 case 0x001B: return wxT("WM_DEVMODECHANGE");
5717 case 0x001C: return wxT("WM_ACTIVATEAPP");
5718 case 0x001D: return wxT("WM_FONTCHANGE");
5719 case 0x001E: return wxT("WM_TIMECHANGE");
5720 case 0x001F: return wxT("WM_CANCELMODE");
5721 case 0x0020: return wxT("WM_SETCURSOR");
5722 case 0x0021: return wxT("WM_MOUSEACTIVATE");
5723 case 0x0022: return wxT("WM_CHILDACTIVATE");
5724 case 0x0023: return wxT("WM_QUEUESYNC");
5725 case 0x0024: return wxT("WM_GETMINMAXINFO");
5726 case 0x0026: return wxT("WM_PAINTICON");
5727 case 0x0027: return wxT("WM_ICONERASEBKGND");
5728 case 0x0028: return wxT("WM_NEXTDLGCTL");
5729 case 0x002A: return wxT("WM_SPOOLERSTATUS");
5730 case 0x002B: return wxT("WM_DRAWITEM");
5731 case 0x002C: return wxT("WM_MEASUREITEM");
5732 case 0x002D: return wxT("WM_DELETEITEM");
5733 case 0x002E: return wxT("WM_VKEYTOITEM");
5734 case 0x002F: return wxT("WM_CHARTOITEM");
5735 case 0x0030: return wxT("WM_SETFONT");
5736 case 0x0031: return wxT("WM_GETFONT");
5737 case 0x0037: return wxT("WM_QUERYDRAGICON");
5738 case 0x0039: return wxT("WM_COMPAREITEM");
5739 case 0x0041: return wxT("WM_COMPACTING");
5740 case 0x0044: return wxT("WM_COMMNOTIFY");
5741 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
5742 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
5743 case 0x0048: return wxT("WM_POWER");
5745 case 0x004A: return wxT("WM_COPYDATA");
5746 case 0x004B: return wxT("WM_CANCELJOURNAL");
5747 case 0x004E: return wxT("WM_NOTIFY");
5748 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
5749 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
5750 case 0x0052: return wxT("WM_TCARD");
5751 case 0x0053: return wxT("WM_HELP");
5752 case 0x0054: return wxT("WM_USERCHANGED");
5753 case 0x0055: return wxT("WM_NOTIFYFORMAT");
5754 case 0x007B: return wxT("WM_CONTEXTMENU");
5755 case 0x007C: return wxT("WM_STYLECHANGING");
5756 case 0x007D: return wxT("WM_STYLECHANGED");
5757 case 0x007E: return wxT("WM_DISPLAYCHANGE");
5758 case 0x007F: return wxT("WM_GETICON");
5759 case 0x0080: return wxT("WM_SETICON");
5761 case 0x0081: return wxT("WM_NCCREATE");
5762 case 0x0082: return wxT("WM_NCDESTROY");
5763 case 0x0083: return wxT("WM_NCCALCSIZE");
5764 case 0x0084: return wxT("WM_NCHITTEST");
5765 case 0x0085: return wxT("WM_NCPAINT");
5766 case 0x0086: return wxT("WM_NCACTIVATE");
5767 case 0x0087: return wxT("WM_GETDLGCODE");
5768 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
5769 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
5770 case 0x00A2: return wxT("WM_NCLBUTTONUP");
5771 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
5772 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
5773 case 0x00A5: return wxT("WM_NCRBUTTONUP");
5774 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
5775 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
5776 case 0x00A8: return wxT("WM_NCMBUTTONUP");
5777 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
5778 case 0x0100: return wxT("WM_KEYDOWN");
5779 case 0x0101: return wxT("WM_KEYUP");
5780 case 0x0102: return wxT("WM_CHAR");
5781 case 0x0103: return wxT("WM_DEADCHAR");
5782 case 0x0104: return wxT("WM_SYSKEYDOWN");
5783 case 0x0105: return wxT("WM_SYSKEYUP");
5784 case 0x0106: return wxT("WM_SYSCHAR");
5785 case 0x0107: return wxT("WM_SYSDEADCHAR");
5786 case 0x0108: return wxT("WM_KEYLAST");
5788 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
5789 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
5790 case 0x010F: return wxT("WM_IME_COMPOSITION");
5792 case 0x0110: return wxT("WM_INITDIALOG");
5793 case 0x0111: return wxT("WM_COMMAND");
5794 case 0x0112: return wxT("WM_SYSCOMMAND");
5795 case 0x0113: return wxT("WM_TIMER");
5796 case 0x0114: return wxT("WM_HSCROLL");
5797 case 0x0115: return wxT("WM_VSCROLL");
5798 case 0x0116: return wxT("WM_INITMENU");
5799 case 0x0117: return wxT("WM_INITMENUPOPUP");
5800 case 0x011F: return wxT("WM_MENUSELECT");
5801 case 0x0120: return wxT("WM_MENUCHAR");
5802 case 0x0121: return wxT("WM_ENTERIDLE");
5803 case 0x0200: return wxT("WM_MOUSEMOVE");
5804 case 0x0201: return wxT("WM_LBUTTONDOWN");
5805 case 0x0202: return wxT("WM_LBUTTONUP");
5806 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
5807 case 0x0204: return wxT("WM_RBUTTONDOWN");
5808 case 0x0205: return wxT("WM_RBUTTONUP");
5809 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
5810 case 0x0207: return wxT("WM_MBUTTONDOWN");
5811 case 0x0208: return wxT("WM_MBUTTONUP");
5812 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
5813 case 0x020A: return wxT("WM_MOUSEWHEEL");
5814 case 0x0210: return wxT("WM_PARENTNOTIFY");
5815 case 0x0211: return wxT("WM_ENTERMENULOOP");
5816 case 0x0212: return wxT("WM_EXITMENULOOP");
5818 case 0x0213: return wxT("WM_NEXTMENU");
5819 case 0x0214: return wxT("WM_SIZING");
5820 case 0x0215: return wxT("WM_CAPTURECHANGED");
5821 case 0x0216: return wxT("WM_MOVING");
5822 case 0x0218: return wxT("WM_POWERBROADCAST");
5823 case 0x0219: return wxT("WM_DEVICECHANGE");
5825 case 0x0220: return wxT("WM_MDICREATE");
5826 case 0x0221: return wxT("WM_MDIDESTROY");
5827 case 0x0222: return wxT("WM_MDIACTIVATE");
5828 case 0x0223: return wxT("WM_MDIRESTORE");
5829 case 0x0224: return wxT("WM_MDINEXT");
5830 case 0x0225: return wxT("WM_MDIMAXIMIZE");
5831 case 0x0226: return wxT("WM_MDITILE");
5832 case 0x0227: return wxT("WM_MDICASCADE");
5833 case 0x0228: return wxT("WM_MDIICONARRANGE");
5834 case 0x0229: return wxT("WM_MDIGETACTIVE");
5835 case 0x0230: return wxT("WM_MDISETMENU");
5836 case 0x0233: return wxT("WM_DROPFILES");
5838 case 0x0281: return wxT("WM_IME_SETCONTEXT");
5839 case 0x0282: return wxT("WM_IME_NOTIFY");
5840 case 0x0283: return wxT("WM_IME_CONTROL");
5841 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
5842 case 0x0285: return wxT("WM_IME_SELECT");
5843 case 0x0286: return wxT("WM_IME_CHAR");
5844 case 0x0290: return wxT("WM_IME_KEYDOWN");
5845 case 0x0291: return wxT("WM_IME_KEYUP");
5847 case 0x0300: return wxT("WM_CUT");
5848 case 0x0301: return wxT("WM_COPY");
5849 case 0x0302: return wxT("WM_PASTE");
5850 case 0x0303: return wxT("WM_CLEAR");
5851 case 0x0304: return wxT("WM_UNDO");
5852 case 0x0305: return wxT("WM_RENDERFORMAT");
5853 case 0x0306: return wxT("WM_RENDERALLFORMATS");
5854 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
5855 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
5856 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
5857 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
5858 case 0x030B: return wxT("WM_SIZECLIPBOARD");
5859 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
5860 case 0x030D: return wxT("WM_CHANGECBCHAIN");
5861 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
5862 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
5863 case 0x0310: return wxT("WM_PALETTEISCHANGING");
5864 case 0x0311: return wxT("WM_PALETTECHANGED");
5866 case 0x0312: return wxT("WM_HOTKEY");
5869 // common controls messages - although they're not strictly speaking
5870 // standard, it's nice to decode them nevertheless
5873 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
5874 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
5875 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
5876 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
5877 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
5878 case 0x1000 + 5: return wxT("LVM_GETITEMA");
5879 case 0x1000 + 75: return wxT("LVM_GETITEMW");
5880 case 0x1000 + 6: return wxT("LVM_SETITEMA");
5881 case 0x1000 + 76: return wxT("LVM_SETITEMW");
5882 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
5883 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
5884 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
5885 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
5886 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
5887 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
5888 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
5889 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
5890 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
5891 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
5892 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
5893 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
5894 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
5895 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
5896 case 0x1000 + 18: return wxT("LVM_HITTEST");
5897 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
5898 case 0x1000 + 20: return wxT("LVM_SCROLL");
5899 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
5900 case 0x1000 + 22: return wxT("LVM_ARRANGE");
5901 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
5902 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
5903 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
5904 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
5905 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
5906 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
5907 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
5908 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
5909 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
5910 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
5911 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
5912 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
5913 case 0x1000 + 31: return wxT("LVM_GETHEADER");
5914 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
5915 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
5916 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
5917 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
5918 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
5919 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
5920 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
5921 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
5922 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
5923 case 0x1000 + 42: return wxT("LVM_UPDATE");
5924 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
5925 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
5926 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
5927 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
5928 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
5929 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
5930 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
5931 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
5932 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
5933 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
5934 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
5935 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
5936 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
5937 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
5938 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
5939 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
5940 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
5941 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
5942 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
5943 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
5944 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
5945 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
5946 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
5947 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
5948 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
5949 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
5952 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
5953 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
5954 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
5955 case 0x1100 + 2: return wxT("TVM_EXPAND");
5956 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
5957 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
5958 case 0x1100 + 6: return wxT("TVM_GETINDENT");
5959 case 0x1100 + 7: return wxT("TVM_SETINDENT");
5960 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
5961 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
5962 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
5963 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
5964 case 0x1100 + 12: return wxT("TVM_GETITEMA");
5965 case 0x1100 + 62: return wxT("TVM_GETITEMW");
5966 case 0x1100 + 13: return wxT("TVM_SETITEMA");
5967 case 0x1100 + 63: return wxT("TVM_SETITEMW");
5968 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
5969 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
5970 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
5971 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
5972 case 0x1100 + 17: return wxT("TVM_HITTEST");
5973 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
5974 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
5975 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
5976 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
5977 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
5978 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
5979 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
5980 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
5981 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
5984 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
5985 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
5986 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
5987 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
5988 case 0x1200 + 3: return wxT("HDM_GETITEMA");
5989 case 0x1200 + 11: return wxT("HDM_GETITEMW");
5990 case 0x1200 + 4: return wxT("HDM_SETITEMA");
5991 case 0x1200 + 12: return wxT("HDM_SETITEMW");
5992 case 0x1200 + 5: return wxT("HDM_LAYOUT");
5993 case 0x1200 + 6: return wxT("HDM_HITTEST");
5994 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
5995 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
5996 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
5997 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
5998 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
5999 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6000 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6001 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6004 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6005 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6006 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6007 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6008 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6009 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6010 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6011 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6012 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6013 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6014 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6015 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6016 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6017 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6018 case 0x1300 + 13: return wxT("TCM_HITTEST");
6019 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6020 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6021 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6022 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6023 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6024 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6025 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6026 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6027 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6028 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6029 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6030 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6033 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6034 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6035 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6036 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6037 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6038 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6039 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6040 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6041 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6042 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6043 case WM_USER
+17: return wxT("TB_SETSTATE");
6044 case WM_USER
+18: return wxT("TB_GETSTATE");
6045 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6046 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6047 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6048 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6049 case WM_USER
+23: return wxT("TB_GETBUTTON");
6050 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6051 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6052 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6053 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6054 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6055 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6056 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6057 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6058 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6059 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6060 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6061 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6062 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6063 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6064 case WM_USER
+37: return wxT("TB_SETPARENT");
6065 case WM_USER
+39: return wxT("TB_SETROWS");
6066 case WM_USER
+40: return wxT("TB_GETROWS");
6067 case WM_USER
+42: return wxT("TB_SETCMDID");
6068 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6069 case WM_USER
+44: return wxT("TB_GETBITMAP");
6070 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6071 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6072 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6073 case WM_USER
+47: return wxT("TB_SETINDENT");
6074 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6075 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6076 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6077 case WM_USER
+51: return wxT("TB_GETRECT");
6078 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6079 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6080 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6081 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6082 case WM_USER
+56: return wxT("TB_SETSTYLE");
6083 case WM_USER
+57: return wxT("TB_GETSTYLE");
6084 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6085 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6086 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6087 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6088 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6091 static wxString s_szBuf
;
6092 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6093 return s_szBuf
.c_str();
6096 #endif //__WXDEBUG__
6098 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6102 HWND hwnd
= GetHwndOf(win
);
6103 HDC hdc
= ::GetDC(hwnd
);
6105 #if !wxDIALOG_UNIT_COMPATIBILITY
6106 // and select the current font into it
6107 HFONT hfont
= GetHfontOf(win
->GetFont());
6110 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6114 // finally retrieve the text metrics from it
6115 GetTextMetrics(hdc
, &tm
);
6117 #if !wxDIALOG_UNIT_COMPATIBILITY
6121 (void)::SelectObject(hdc
, hfont
);
6125 ::ReleaseDC(hwnd
, hdc
);
6130 // Find the wxWindow at the current mouse position, returning the mouse
6132 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6134 pt
= wxGetMousePosition();
6135 return wxFindWindowAtPoint(pt
);
6138 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6143 HWND hWndHit
= ::WindowFromPoint(pt2
);
6145 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
6146 HWND hWnd
= hWndHit
;
6148 // Try to find a window with a wxWindow associated with it
6149 while (!win
&& (hWnd
!= 0))
6151 hWnd
= ::GetParent(hWnd
);
6152 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
6157 // Get the current mouse position.
6158 wxPoint
wxGetMousePosition()
6162 GetCursorPosWinCE(&pt
);
6164 GetCursorPos( & pt
);
6167 return wxPoint(pt
.x
, pt
.y
);
6172 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6173 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6175 // Register hotkeys for the hardware buttons
6177 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6179 UnregisterFunc1Proc procUnregisterFunc
;
6180 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6183 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6184 if (procUnregisterFunc
)
6185 procUnregisterFunc(modifiers
, id
);
6186 FreeLibrary(hCoreDll
);
6191 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6193 UINT win_modifiers
=0;
6194 if ( modifiers
& wxMOD_ALT
)
6195 win_modifiers
|= MOD_ALT
;
6196 if ( modifiers
& wxMOD_SHIFT
)
6197 win_modifiers
|= MOD_SHIFT
;
6198 if ( modifiers
& wxMOD_CONTROL
)
6199 win_modifiers
|= MOD_CONTROL
;
6200 if ( modifiers
& wxMOD_WIN
)
6201 win_modifiers
|= MOD_WIN
;
6203 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6204 // Required for PPC and Smartphone hardware buttons
6205 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6206 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6209 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6211 wxLogLastError(_T("RegisterHotKey"));
6219 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6221 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6222 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6225 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6227 wxLogLastError(_T("UnregisterHotKey"));
6237 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6239 int hotkeyId
= wParam
;
6240 int virtualKey
= HIWORD(lParam
);
6241 int win_modifiers
= LOWORD(lParam
);
6243 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6244 event
.SetId(hotkeyId
);
6245 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6246 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6247 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6248 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6250 return GetEventHandler()->ProcessEvent(event
);
6253 #endif // wxUSE_ACCEL
6255 #endif // wxUSE_HOTKEY
6257 // Not tested under WinCE
6260 // this class installs a message hook which really wakes up our idle processing
6261 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6262 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6263 // being dragged or even inside ::MessageBox()) and so don't control message
6264 // dispatching otherwise
6265 class wxIdleWakeUpModule
: public wxModule
6268 virtual bool OnInit()
6270 ms_hMsgHookProc
= ::SetWindowsHookEx
6273 &wxIdleWakeUpModule::MsgHookProc
,
6275 GetCurrentThreadId()
6278 if ( !ms_hMsgHookProc
)
6280 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6288 virtual void OnExit()
6290 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
6293 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6295 MSG
*msg
= (MSG
*)lParam
;
6297 // only process the message if it is actually going to be removed from
6298 // the message queue, this prevents that the same event from being
6299 // processed multiple times if now someone just called PeekMessage()
6300 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
6302 wxTheApp
->ProcessPendingEvents();
6305 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
6309 static HHOOK ms_hMsgHookProc
;
6311 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
6314 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
6316 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
6318 #endif // __WXWINCE__
6323 static void wxAdjustZOrder(wxWindow
* parent
)
6325 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
6327 // Set the z-order correctly
6328 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
6331 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
6334 wxWindow
*childWin
= current
->GetData();
6335 wxAdjustZOrder(childWin
);
6336 current
= current
->GetNext();
6341 // We need to adjust the z-order of static boxes in WinCE, to
6342 // make 'contained' controls visible
6343 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
6346 wxAdjustZOrder(this);