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"
27 #include "wx/window.h"
30 #include "wx/msw/wrapwin.h"
34 #include "wx/dcclient.h"
35 #include "wx/dcmemory.h"
38 #include "wx/layout.h"
39 #include "wx/dialog.h"
41 #include "wx/listbox.h"
42 #include "wx/button.h"
43 #include "wx/msgdlg.h"
44 #include "wx/settings.h"
45 #include "wx/statbox.h"
51 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
52 #include "wx/ownerdrw.h"
55 #include "wx/evtloop.h"
56 #include "wx/module.h"
58 #include "wx/sysopt.h"
60 #if wxUSE_DRAG_AND_DROP
64 #if wxUSE_ACCESSIBILITY
65 #include "wx/access.h"
69 #define WM_GETOBJECT 0x003D
72 #define OBJID_CLIENT 0xFFFFFFFC
76 #include "wx/menuitem.h"
78 #include "wx/msw/private.h"
81 #include "wx/tooltip.h"
89 #include "wx/spinctrl.h"
90 #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
) )
801 // don't "overwrite" busy cursor
802 if ( m_cursor
.Ok() && !wxIsBusy() )
804 ::SetCursor(GetHcursorOf(m_cursor
));
810 void wxWindowMSW::WarpPointer(int x
, int y
)
812 ClientToScreen(&x
, &y
);
814 if ( !::SetCursorPos(x
, y
) )
816 wxLogLastError(_T("SetCursorPos"));
820 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
822 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
823 // to use it on older systems -- and could possibly do some harm
824 static int s_needToUpdate
= -1;
825 if ( s_needToUpdate
== -1 )
828 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxWINDOWS_NT
&&
832 if ( s_needToUpdate
)
834 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
835 // won't send WM_UPDATEUISTATE
836 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
840 // ---------------------------------------------------------------------------
842 // ---------------------------------------------------------------------------
844 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
846 #ifdef __WXMICROWIN__
847 return ::GetScrollPosWX(hWnd
, wOrient
);
849 WinStruct
<SCROLLINFO
> scrollInfo
;
850 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
851 scrollInfo
.fMask
= SIF_POS
;
852 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
854 return scrollInfo
.nPos
;
859 int wxWindowMSW::GetScrollPos(int orient
) const
861 HWND hWnd
= GetHwnd();
862 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
864 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
867 // This now returns the whole range, not just the number
868 // of positions that we can scroll.
869 int wxWindowMSW::GetScrollRange(int orient
) const
872 HWND hWnd
= GetHwnd();
876 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
879 WinStruct
<SCROLLINFO
> scrollInfo
;
880 scrollInfo
.fMask
= SIF_RANGE
;
881 if ( !::GetScrollInfo(hWnd
,
882 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
885 // Most of the time this is not really an error, since the return
886 // value can also be zero when there is no scrollbar yet.
887 // wxLogLastError(_T("GetScrollInfo"));
889 maxPos
= scrollInfo
.nMax
;
891 // undo "range - 1" done in SetScrollbar()
895 int wxWindowMSW::GetScrollThumb(int orient
) const
897 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
900 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
902 HWND hWnd
= GetHwnd();
903 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
905 WinStruct
<SCROLLINFO
> info
;
909 info
.fMask
= SIF_POS
;
910 if ( HasFlag(wxALWAYS_SHOW_SB
) )
912 // disable scrollbar instead of removing it then
913 info
.fMask
|= SIF_DISABLENOSCROLL
;
916 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
920 // New function that will replace some of the above.
921 void wxWindowMSW::SetScrollbar(int orient
,
927 WinStruct
<SCROLLINFO
> info
;
928 info
.nPage
= pageSize
;
929 info
.nMin
= 0; // range is nMax - nMin + 1
930 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
932 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
933 if ( HasFlag(wxALWAYS_SHOW_SB
) )
935 // disable scrollbar instead of removing it then
936 info
.fMask
|= SIF_DISABLENOSCROLL
;
939 HWND hWnd
= GetHwnd();
942 // We have to set the variables here to make them valid in events
943 // triggered by ::SetScrollInfo()
944 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
946 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
951 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
957 rect
.left
= prect
->x
;
959 rect
.right
= prect
->x
+ prect
->width
;
960 rect
.bottom
= prect
->y
+ prect
->height
;
970 // FIXME: is this the exact equivalent of the line below?
971 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
973 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
977 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
979 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
982 for ( int n
= 0; n
< count
; n
++ )
984 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
986 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
989 // don't bother to continue, we're already at top/bottom
996 return pos
!= posStart
;
999 bool wxWindowMSW::ScrollLines(int lines
)
1001 bool down
= lines
> 0;
1003 return ScrollVertically(GetHwnd(),
1004 down
? SB_LINEDOWN
: SB_LINEUP
,
1005 down
? lines
: -lines
);
1008 bool wxWindowMSW::ScrollPages(int pages
)
1010 bool down
= pages
> 0;
1012 return ScrollVertically(GetHwnd(),
1013 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1014 down
? pages
: -pages
);
1017 // ---------------------------------------------------------------------------
1019 // ---------------------------------------------------------------------------
1021 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1023 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1025 HWND hwnd
= (HWND
)hWnd
;
1026 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1028 wxAssociateWinWithHandle(hwnd
, this);
1030 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1032 // we don't need to subclass the window of our own class (in the Windows
1033 // sense of the word)
1034 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1036 wxSetWindowProc(hwnd
, wxWndProc
);
1040 // don't bother restoring it either: this also makes it easy to
1041 // implement IsOfStandardClass() method which returns true for the
1042 // standard controls and false for the wxWidgets own windows as it can
1043 // simply check m_oldWndProc
1044 m_oldWndProc
= NULL
;
1047 // we're officially created now, send the event
1048 wxWindowCreateEvent
event((wxWindow
*)this);
1049 (void)GetEventHandler()->ProcessEvent(event
);
1052 void wxWindowMSW::UnsubclassWin()
1054 wxRemoveHandleAssociation(this);
1056 // Restore old Window proc
1057 HWND hwnd
= GetHwnd();
1062 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1066 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1068 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1071 m_oldWndProc
= NULL
;
1076 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1080 if ( !::DestroyWindow(GetHwnd()) )
1081 wxLogLastError(wxT("DestroyWindow"));
1084 WXHWND wxhwnd
= (WXHWND
)handle
;
1087 SubclassWin(wxhwnd
);
1090 void wxWindowMSW::DissociateHandle()
1092 // this also calls SetHWND(0) for us
1097 bool wxCheckWindowWndProc(WXHWND hWnd
,
1098 WXFARPROC
WXUNUSED(wndProc
))
1100 // TODO: This list of window class names should be factored out so they can be
1101 // managed in one place and then accessed from here and other places, such as
1102 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1105 extern wxChar
*wxCanvasClassName
;
1106 extern wxChar
*wxCanvasClassNameNR
;
1108 extern const wxChar
*wxCanvasClassName
;
1109 extern const wxChar
*wxCanvasClassNameNR
;
1111 extern const wxChar
*wxMDIFrameClassName
;
1112 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1113 extern const wxChar
*wxMDIChildFrameClassName
;
1114 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1115 wxString
str(wxGetWindowClass(hWnd
));
1116 if (str
== wxCanvasClassName
||
1117 str
== wxCanvasClassNameNR
||
1119 str
== _T("wxGLCanvasClass") ||
1120 str
== _T("wxGLCanvasClassNR") ||
1121 #endif // wxUSE_GLCANVAS
1122 str
== wxMDIFrameClassName
||
1123 str
== wxMDIFrameClassNameNoRedraw
||
1124 str
== wxMDIChildFrameClassName
||
1125 str
== wxMDIChildFrameClassNameNoRedraw
||
1126 str
== _T("wxTLWHiddenParent"))
1127 return true; // Effectively means don't subclass
1132 // ----------------------------------------------------------------------------
1134 // ----------------------------------------------------------------------------
1136 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1138 long flagsOld
= GetWindowStyleFlag();
1139 if ( flags
== flagsOld
)
1142 // update the internal variable
1143 wxWindowBase::SetWindowStyleFlag(flags
);
1145 // now update the Windows style as well if needed - and if the window had
1146 // been already created
1150 // we may need to call SetWindowPos() when we change some styles
1151 bool callSWP
= false;
1153 WXDWORD exstyle
, exstyleOld
;
1154 long style
= MSWGetStyle(flags
, &exstyle
),
1155 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1157 if ( style
!= styleOld
)
1159 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1160 // this function so instead of simply setting the style to the new
1161 // value we clear the bits which were set in styleOld but are set in
1162 // the new one and set the ones which were not set before
1163 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1164 styleReal
&= ~styleOld
;
1167 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1169 // If any of the style changes changed any of the frame styles:
1170 // MSDN: SetWindowLong:
1171 // Certain window data is cached, so changes you make using
1172 // SetWindowLong will not take effect until you call the
1173 // SetWindowPos function. Specifically, if you change any of
1174 // the frame styles, you must call SetWindowPos with the
1175 // SWP_FRAMECHANGED flag for the cache to be updated properly.
1177 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1186 // and the extended style
1187 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1189 if ( exstyle
!= exstyleOld
)
1191 exstyleReal
&= ~exstyleOld
;
1192 exstyleReal
|= exstyle
;
1194 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1196 // ex style changes don't take effect without calling SetWindowPos
1202 // we must call SetWindowPos() to flush the cached extended style and
1203 // also to make the change to wxSTAY_ON_TOP style take effect: just
1204 // setting the style simply doesn't work
1205 if ( !::SetWindowPos(GetHwnd(),
1206 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1209 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1211 wxLogLastError(_T("SetWindowPos"));
1216 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1218 // translate common wxWidgets styles to Windows ones
1220 // most of windows are child ones, those which are not (such as
1221 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1222 WXDWORD style
= WS_CHILD
;
1224 // using this flag results in very significant reduction in flicker,
1225 // especially with controls inside the static boxes (as the interior of the
1226 // box is not redrawn twice), but sometimes results in redraw problems, so
1227 // optionally allow the old code to continue to use it provided a special
1228 // system option is turned on
1229 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1230 || (flags
& wxCLIP_CHILDREN
) )
1231 style
|= WS_CLIPCHILDREN
;
1233 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1234 // don't support overlapping windows and it only makes sense for them and,
1235 // presumably, gives the system some extra work (to manage more clipping
1236 // regions), so avoid it alltogether
1239 if ( flags
& wxVSCROLL
)
1240 style
|= WS_VSCROLL
;
1242 if ( flags
& wxHSCROLL
)
1243 style
|= WS_HSCROLL
;
1245 const wxBorder border
= GetBorder(flags
);
1247 // WS_BORDER is only required for wxBORDER_SIMPLE
1248 if ( border
== wxBORDER_SIMPLE
)
1251 // now deal with ext style if the caller wants it
1257 if ( flags
& wxTRANSPARENT_WINDOW
)
1258 *exstyle
|= WS_EX_TRANSPARENT
;
1264 case wxBORDER_DEFAULT
:
1265 wxFAIL_MSG( _T("unknown border style") );
1269 case wxBORDER_SIMPLE
:
1272 case wxBORDER_STATIC
:
1273 *exstyle
|= WS_EX_STATICEDGE
;
1276 case wxBORDER_RAISED
:
1277 *exstyle
|= WS_EX_DLGMODALFRAME
;
1280 case wxBORDER_SUNKEN
:
1281 *exstyle
|= WS_EX_CLIENTEDGE
;
1282 style
&= ~WS_BORDER
;
1285 case wxBORDER_DOUBLE
:
1286 *exstyle
|= WS_EX_DLGMODALFRAME
;
1290 // wxUniv doesn't use Windows dialog navigation functions at all
1291 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1292 // to make the dialog navigation work with the nested panels we must
1293 // use this style (top level windows such as dialogs don't need it)
1294 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1296 *exstyle
|= WS_EX_CONTROLPARENT
;
1298 #endif // __WXUNIVERSAL__
1304 // Setup background and foreground colours correctly
1305 void wxWindowMSW::SetupColours()
1308 SetBackgroundColour(GetParent()->GetBackgroundColour());
1311 bool wxWindowMSW::IsMouseInWindow() const
1313 // get the mouse position
1316 ::GetCursorPosWinCE(&pt
);
1318 ::GetCursorPos(&pt
);
1321 // find the window which currently has the cursor and go up the window
1322 // chain until we find this window - or exhaust it
1323 HWND hwnd
= ::WindowFromPoint(pt
);
1324 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1325 hwnd
= ::GetParent(hwnd
);
1327 return hwnd
!= NULL
;
1330 void wxWindowMSW::OnInternalIdle()
1332 #ifndef HAVE_TRACKMOUSEEVENT
1333 // Check if we need to send a LEAVE event
1334 if ( m_mouseInWindow
)
1336 // note that we should generate the leave event whether the window has
1337 // or doesn't have mouse capture
1338 if ( !IsMouseInWindow() )
1340 GenerateMouseLeave();
1343 #endif // !HAVE_TRACKMOUSEEVENT
1345 if (wxUpdateUIEvent::CanUpdate(this))
1346 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1349 // Set this window to be the child of 'parent'.
1350 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1352 if ( !wxWindowBase::Reparent(parent
) )
1355 HWND hWndChild
= GetHwnd();
1356 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1358 ::SetParent(hWndChild
, hWndParent
);
1361 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1363 EnsureParentHasControlParentStyle(GetParent());
1365 #endif // !__WXWINCE__
1370 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1372 #ifndef __WXMICROWIN__
1373 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1377 void wxWindowMSW::Freeze()
1379 if ( !m_frozenness
++ )
1382 SendSetRedraw(GetHwnd(), false);
1386 void wxWindowMSW::Thaw()
1388 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1390 if ( --m_frozenness
== 0 )
1394 SendSetRedraw(GetHwnd(), true);
1396 // we need to refresh everything or otherwise the invalidated area
1397 // is not going to be repainted
1403 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1405 HWND hWnd
= GetHwnd();
1412 mswRect
.left
= rect
->x
;
1413 mswRect
.top
= rect
->y
;
1414 mswRect
.right
= rect
->x
+ rect
->width
;
1415 mswRect
.bottom
= rect
->y
+ rect
->height
;
1424 // RedrawWindow not available on SmartPhone or eVC++ 3
1425 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1426 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1430 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1432 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1437 void wxWindowMSW::Update()
1439 if ( !::UpdateWindow(GetHwnd()) )
1441 wxLogLastError(_T("UpdateWindow"));
1444 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1445 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1446 // handler needs to be really drawn right now
1451 // ---------------------------------------------------------------------------
1453 // ---------------------------------------------------------------------------
1455 // we need to lower the sibling static boxes so controls contained within can be
1457 static inline void AdjustStaticBoxZOrder(wxWindow
*parent
)
1459 // no sibling static boxes if we have no parent (ie TLW)
1463 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1465 node
= node
->GetNext() )
1467 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1470 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1471 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1476 #if wxUSE_DRAG_AND_DROP
1477 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1479 if ( m_dropTarget
!= 0 ) {
1480 m_dropTarget
->Revoke(m_hWnd
);
1481 delete m_dropTarget
;
1484 m_dropTarget
= pDropTarget
;
1485 if ( m_dropTarget
!= 0 )
1487 AdjustStaticBoxZOrder(GetParent());
1488 m_dropTarget
->Register(m_hWnd
);
1491 #endif // wxUSE_DRAG_AND_DROP
1493 // old-style file manager drag&drop support: we retain the old-style
1494 // DragAcceptFiles in parallel with SetDropTarget.
1495 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1498 HWND hWnd
= GetHwnd();
1501 AdjustStaticBoxZOrder(GetParent());
1502 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1507 // ----------------------------------------------------------------------------
1509 // ----------------------------------------------------------------------------
1513 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1515 wxWindowBase::DoSetToolTip(tooltip
);
1518 m_tooltip
->SetWindow((wxWindow
*)this);
1521 #endif // wxUSE_TOOLTIPS
1523 // ---------------------------------------------------------------------------
1524 // moving and resizing
1525 // ---------------------------------------------------------------------------
1527 bool wxWindowMSW::IsSizeDeferred() const
1529 #if USE_DEFERRED_SIZING
1530 if ( m_pendingPosition
!= wxDefaultPosition
||
1531 m_pendingSize
!= wxDefaultSize
)
1533 #endif // USE_DEFERRED_SIZING
1539 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1541 // if SetSize() had been called at wx level but not realized at Windows
1542 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1543 // the new and not the old position to the other wx code
1544 if ( m_pendingSize
!= wxDefaultSize
)
1547 *x
= m_pendingSize
.x
;
1549 *y
= m_pendingSize
.y
;
1551 else // use current size
1553 RECT rect
= wxGetWindowRect(GetHwnd());
1556 *x
= rect
.right
- rect
.left
;
1558 *y
= rect
.bottom
- rect
.top
;
1562 // Get size *available for subwindows* i.e. excluding menu bar etc.
1563 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1565 #if USE_DEFERRED_SIZING
1566 if ( IsTopLevel() || m_pendingSize
== wxDefaultSize
)
1568 { // top level windows resizing is never deferred, so we can safely use
1569 // the current size here
1570 RECT rect
= wxGetClientRect(GetHwnd());
1577 #if USE_DEFERRED_SIZING
1578 else // non top level and using deferred sizing
1580 // we need to calculate the *pending* client size here
1582 rect
.left
= m_pendingPosition
.x
;
1583 rect
.top
= m_pendingPosition
.y
;
1584 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1585 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1587 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1590 *x
= rect
.right
- rect
.left
;
1592 *y
= rect
.bottom
- rect
.top
;
1597 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1599 wxWindow
* const parent
= GetParent();
1602 if ( m_pendingPosition
!= wxDefaultPosition
)
1604 pos
= m_pendingPosition
;
1606 else // use current position
1608 RECT rect
= wxGetWindowRect(GetHwnd());
1611 point
.x
= rect
.left
;
1614 // we do the adjustments with respect to the parent only for the "real"
1615 // children, not for the dialogs/frames
1616 if ( !IsTopLevel() )
1618 // Since we now have the absolute screen coords, if there's a
1619 // parent we must subtract its top left corner
1622 ::ScreenToClient(GetHwndOf(parent
), &point
);
1630 // we also must adjust by the client area offset: a control which is just
1631 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1632 if ( parent
&& !IsTopLevel() )
1634 const wxPoint
pt(parent
->GetClientAreaOrigin());
1645 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1653 ::ScreenToClient(GetHwnd(), &pt
);
1661 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1669 ::ClientToScreen(GetHwnd(), &pt
);
1678 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1680 #if USE_DEFERRED_SIZING
1681 // if our parent had prepared a defer window handle for us, use it (unless
1682 // we are a top level window)
1683 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1685 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1688 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1689 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1692 wxLogLastError(_T("DeferWindowPos"));
1698 // hdwp must be updated as it may have been changed
1699 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1704 // did deferred move, remember new coordinates of the window as they're
1705 // different from what Windows would return for it
1709 // otherwise (or if deferring failed) move the window in place immediately
1710 #endif // USE_DEFERRED_SIZING
1711 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1713 wxLogLastError(wxT("MoveWindow"));
1716 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1717 // ignored otherwise
1721 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1723 // TODO: is this consistent with other platforms?
1724 // Still, negative width or height shouldn't be allowed
1730 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1732 #if USE_DEFERRED_SIZING
1733 m_pendingPosition
= wxPoint(x
, y
);
1734 m_pendingSize
= wxSize(width
, height
);
1735 #endif // USE_DEFERRED_SIZING
1739 // set the size of the window: if the dimensions are positive, just use them,
1740 // but if any of them is equal to -1, it means that we must find the value for
1741 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1742 // which case -1 is a valid value for x and y)
1744 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1745 // the width/height to best suit our contents, otherwise we reuse the current
1747 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1749 // get the current size and position...
1750 int currentX
, currentY
;
1751 int currentW
, currentH
;
1753 GetPosition(¤tX
, ¤tY
);
1754 GetSize(¤tW
, ¤tH
);
1756 // ... and don't do anything (avoiding flicker) if it's already ok unless
1757 // we're forced to resize the window
1758 if ( x
== currentX
&& y
== currentY
&&
1759 width
== currentW
&& height
== currentH
&&
1760 !(sizeFlags
& wxSIZE_FORCE
) )
1765 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1767 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1770 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1772 wxSize size
= wxDefaultSize
;
1773 if ( width
== wxDefaultCoord
)
1775 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1777 size
= DoGetBestSize();
1782 // just take the current one
1787 if ( height
== wxDefaultCoord
)
1789 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1791 if ( size
.x
== wxDefaultCoord
)
1793 size
= DoGetBestSize();
1795 //else: already called DoGetBestSize() above
1801 // just take the current one
1806 DoMoveWindow(x
, y
, width
, height
);
1809 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1811 // setting the client size is less obvious than it could have been
1812 // because in the result of changing the total size the window scrollbar
1813 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
1814 // doesn't take neither into account) and so the client size will not be
1815 // correct as the difference between the total and client size changes --
1816 // so we keep changing it until we get it right
1818 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1819 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1820 // may become 3 if the window had 0 size originally and so we didn't
1821 // calculate the scrollbar correction correctly during the first iteration)
1822 // but just to be on the safe side we check for it instead of making it an
1823 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1824 for ( int i
= 0; i
< 4; i
++ )
1827 ::GetClientRect(GetHwnd(), &rectClient
);
1829 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
1830 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1831 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1836 // Find the difference between the entire window (title bar and all)
1837 // and the client area; add this to the new client size to move the
1840 ::GetWindowRect(GetHwnd(), &rectWin
);
1842 const int widthWin
= rectWin
.right
- rectWin
.left
,
1843 heightWin
= rectWin
.bottom
- rectWin
.top
;
1845 // MoveWindow positions the child windows relative to the parent, so
1846 // adjust if necessary
1847 if ( !IsTopLevel() )
1849 wxWindow
*parent
= GetParent();
1852 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
1856 // don't call DoMoveWindow() because we want to move window immediately
1857 // and not defer it here as otherwise the value returned by
1858 // GetClient/WindowRect() wouldn't change as the window wouldn't be
1860 if ( !::MoveWindow(GetHwnd(),
1863 width
+ widthWin
- rectClient
.right
,
1864 height
+ heightWin
- rectClient
.bottom
,
1867 wxLogLastError(_T("MoveWindow"));
1872 // ---------------------------------------------------------------------------
1874 // ---------------------------------------------------------------------------
1876 int wxWindowMSW::GetCharHeight() const
1878 return wxGetTextMetrics(this).tmHeight
;
1881 int wxWindowMSW::GetCharWidth() const
1883 // +1 is needed because Windows apparently adds it when calculating the
1884 // dialog units size in pixels
1885 #if wxDIALOG_UNIT_COMPATIBILITY
1886 return wxGetTextMetrics(this).tmAveCharWidth
;
1888 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1892 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1894 int *descent
, int *externalLeading
,
1895 const wxFont
*theFont
) const
1897 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1898 _T("invalid font in GetTextExtent()") );
1902 fontToUse
= *theFont
;
1904 fontToUse
= GetFont();
1906 WindowHDC
hdc(GetHwnd());
1907 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1911 ::GetTextExtentPoint32(hdc
, string
, string
.length(), &sizeRect
);
1912 GetTextMetrics(hdc
, &tm
);
1919 *descent
= tm
.tmDescent
;
1920 if ( externalLeading
)
1921 *externalLeading
= tm
.tmExternalLeading
;
1924 // ---------------------------------------------------------------------------
1926 // ---------------------------------------------------------------------------
1928 #if wxUSE_MENUS_NATIVE
1930 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1931 // immediately, without waiting for the next event loop iteration
1933 // NB: this function should probably be made public later as it can almost
1934 // surely replace wxYield() elsewhere as well
1935 static void wxYieldForCommandsOnly()
1937 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1938 // want to process it here)
1940 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1942 if ( msg
.message
== WM_QUIT
)
1944 // if we retrieved a WM_QUIT, insert back into the message queue.
1945 ::PostQuitMessage(0);
1949 // luckily (as we don't have access to wxEventLoopImpl method from here
1950 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1952 ::TranslateMessage(&msg
);
1953 ::DispatchMessage(&msg
);
1957 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1959 menu
->SetInvokingWindow(this);
1962 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1964 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1965 x
= mouse
.x
; y
= mouse
.y
;
1968 HWND hWnd
= GetHwnd();
1969 HMENU hMenu
= GetHmenuOf(menu
);
1973 ::ClientToScreen(hWnd
, &point
);
1974 wxCurrentPopupMenu
= menu
;
1975 #if defined(__WXWINCE__)
1978 UINT flags
= TPM_RIGHTBUTTON
| TPM_RECURSE
;
1980 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1982 // we need to do it right now as otherwise the events are never going to be
1983 // sent to wxCurrentPopupMenu from HandleCommand()
1985 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1986 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1987 // destroyed as soon as we return (it can be a local variable in the caller
1988 // for example) and so we do need to process the event immediately
1989 wxYieldForCommandsOnly();
1991 wxCurrentPopupMenu
= NULL
;
1993 menu
->SetInvokingWindow(NULL
);
1998 #endif // wxUSE_MENUS_NATIVE
2000 // ===========================================================================
2001 // pre/post message processing
2002 // ===========================================================================
2004 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2007 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2009 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2012 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2014 // wxUniversal implements tab traversal itself
2015 #ifndef __WXUNIVERSAL__
2016 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2018 // intercept dialog navigation keys
2019 MSG
*msg
= (MSG
*)pMsg
;
2021 // here we try to do all the job which ::IsDialogMessage() usually does
2023 if ( msg
->message
== WM_KEYDOWN
)
2025 bool bCtrlDown
= wxIsCtrlDown();
2026 bool bShiftDown
= wxIsShiftDown();
2028 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2029 // don't process it if it's the case (except for Ctrl-Tab/Enter
2030 // combinations which are always processed)
2034 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2036 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2037 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2038 // it, of course, implies them
2039 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2041 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2045 bool bForward
= true,
2046 bWindowChange
= false,
2049 // should we process this message specially?
2050 bool bProcess
= true;
2051 switch ( msg
->wParam
)
2054 if ( lDlgCode
& DLGC_WANTTAB
) {
2058 // Ctrl-Tab cycles thru notebook pages
2059 bWindowChange
= bCtrlDown
;
2060 bForward
= !bShiftDown
;
2067 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2075 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2081 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
2083 // control wants to process Enter itself, don't
2084 // call IsDialogMessage() which would interpret
2089 // currently active button should get enter press even
2090 // if there is a default button elsewhere
2091 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2093 // let IsDialogMessage() handle this for all
2094 // buttons except the owner-drawn ones which it
2095 // just seems to ignore
2096 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2097 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2099 // emulate the button click
2101 btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2103 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2108 else // not a button itself
2111 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
2113 if ( btn
&& btn
->IsEnabled() )
2115 // if we do have a default button, do press it
2116 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2120 else // no default button
2121 #endif // wxUSE_BUTTON
2124 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2125 event
.SetEventObject(this);
2126 if(GetEventHandler()->ProcessEvent(event
))
2129 // this is a quick and dirty test for a text
2131 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
2133 // don't process Enter, the control might
2134 // need it for itself and don't let
2135 // ::IsDialogMessage() have it as it can
2136 // eat the Enter events sometimes
2139 else if (!IsTopLevel())
2141 // if not a top level window, let parent
2145 //else: treat Enter as TAB: pass to the next
2146 // control as this is the best thing to do
2147 // if the text doesn't handle Enter itself
2159 wxNavigationKeyEvent event
;
2160 event
.SetDirection(bForward
);
2161 event
.SetWindowChange(bWindowChange
);
2162 event
.SetFromTab(bFromTab
);
2163 event
.SetEventObject(this);
2165 if ( GetEventHandler()->ProcessEvent(event
) )
2167 // as we don't call IsDialogMessage(), which would take of
2168 // this by default, we need to manually send this message
2169 // so that controls can change their UI state if needed
2170 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2177 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2178 // message even when there is no cancel button and when the message is
2179 // needed by the control itself: in particular, it prevents the tree in
2180 // place edit control from being closed with Escape in a dialog
2181 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2183 // ::IsDialogMessage() is broken and may sometimes hang the
2184 // application by going into an infinite loop, so we try to detect
2185 // [some of] the situations when this may happen and not call it
2188 // assume we can call it by default
2189 bool canSafelyCallIsDlgMsg
= true;
2191 HWND hwndFocus
= ::GetFocus();
2193 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2194 // an infinite loop, because it will recursively check the child
2195 // windows but not the window itself and so if none of the children
2196 // accepts focus it loops forever (as it only stops when it gets
2197 // back to the window it started from)
2199 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2200 // style has the focus, it can happen. One such possibility is if
2201 // all windows are either toplevel, wxDialog, wxPanel or static
2202 // controls and no window can actually accept keyboard input.
2203 #if !defined(__WXWINCE__)
2204 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2206 // pessimistic by default
2207 canSafelyCallIsDlgMsg
= false;
2208 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2210 node
= node
->GetNext() )
2212 wxWindow
* const win
= node
->GetData();
2213 if ( win
->AcceptsFocus() &&
2214 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2215 WS_EX_CONTROLPARENT
) )
2217 // it shouldn't hang...
2218 canSafelyCallIsDlgMsg
= true;
2224 #endif // !__WXWINCE__
2226 if ( canSafelyCallIsDlgMsg
)
2228 // ::IsDialogMessage() can enter in an infinite loop when the
2229 // currently focused window is disabled or hidden and its
2230 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2234 if ( !::IsWindowEnabled(hwndFocus
) ||
2235 !::IsWindowVisible(hwndFocus
) )
2237 // it would enter an infinite loop if we do this!
2238 canSafelyCallIsDlgMsg
= false;
2243 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2245 // it's a top level window, don't go further -- e.g. even
2246 // if the parent of a dialog is disabled, this doesn't
2247 // break navigation inside the dialog
2251 hwndFocus
= ::GetParent(hwndFocus
);
2255 // let IsDialogMessage() have the message if it's safe to call it
2256 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2258 // IsDialogMessage() did something...
2263 #endif // __WXUNIVERSAL__
2268 // relay mouse move events to the tooltip control
2269 MSG
*msg
= (MSG
*)pMsg
;
2270 if ( msg
->message
== WM_MOUSEMOVE
)
2271 wxToolTip::RelayEvent(pMsg
);
2273 #endif // wxUSE_TOOLTIPS
2278 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2280 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2281 return m_acceleratorTable
.Translate(this, pMsg
);
2285 #endif // wxUSE_ACCEL
2288 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2290 // preprocess all messages by default
2294 // ---------------------------------------------------------------------------
2295 // message params unpackers
2296 // ---------------------------------------------------------------------------
2298 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2299 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2301 *id
= LOWORD(wParam
);
2302 *hwnd
= (WXHWND
)lParam
;
2303 *cmd
= HIWORD(wParam
);
2306 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2307 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2309 *state
= LOWORD(wParam
);
2310 *minimized
= HIWORD(wParam
);
2311 *hwnd
= (WXHWND
)lParam
;
2314 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2315 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2317 *code
= LOWORD(wParam
);
2318 *pos
= HIWORD(wParam
);
2319 *hwnd
= (WXHWND
)lParam
;
2322 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2323 WXHDC
*hdc
, WXHWND
*hwnd
)
2325 *hwnd
= (WXHWND
)lParam
;
2326 *hdc
= (WXHDC
)wParam
;
2329 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2330 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2332 *item
= (WXWORD
)wParam
;
2333 *flags
= HIWORD(wParam
);
2334 *hmenu
= (WXHMENU
)lParam
;
2337 // ---------------------------------------------------------------------------
2338 // Main wxWidgets window proc and the window proc for wxWindow
2339 // ---------------------------------------------------------------------------
2341 // Hook for new window just as it's being created, when the window isn't yet
2342 // associated with the handle
2343 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2345 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2346 // window being created and insures that it's always unset back later
2347 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2349 gs_winBeingCreated
= winBeingCreated
;
2352 wxWindowCreationHook::~wxWindowCreationHook()
2354 gs_winBeingCreated
= NULL
;
2358 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2360 // trace all messages - useful for the debugging
2362 wxLogTrace(wxTraceMessages
,
2363 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2364 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2365 #endif // __WXDEBUG__
2367 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2369 // when we get the first message for the HWND we just created, we associate
2370 // it with wxWindow stored in gs_winBeingCreated
2371 if ( !wnd
&& gs_winBeingCreated
)
2373 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2374 wnd
= gs_winBeingCreated
;
2375 gs_winBeingCreated
= NULL
;
2376 wnd
->SetHWND((WXHWND
)hWnd
);
2381 if ( wnd
&& wxEventLoop::AllowProcessing(wnd
) )
2382 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2384 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2389 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2391 // did we process the message?
2392 bool processed
= false;
2402 // for most messages we should return 0 when we do process the message
2410 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2413 // return 0 to allow window creation
2414 rc
.result
= mayCreate
? 0 : -1;
2420 // never set processed to true and *always* pass WM_DESTROY to
2421 // DefWindowProc() as Windows may do some internal cleanup when
2422 // processing it and failing to pass the message along may cause
2423 // memory and resource leaks!
2424 (void)HandleDestroy();
2428 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2432 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2435 #if !defined(__WXWINCE__)
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
= HandleMoving(rc
);
2446 pRect
->left
= rc
.GetLeft();
2447 pRect
->top
= rc
.GetTop();
2448 pRect
->right
= rc
.GetRight();
2449 pRect
->bottom
= rc
.GetBottom();
2456 LPRECT pRect
= (LPRECT
)lParam
;
2458 rc
.SetLeft(pRect
->left
);
2459 rc
.SetTop(pRect
->top
);
2460 rc
.SetRight(pRect
->right
);
2461 rc
.SetBottom(pRect
->bottom
);
2462 processed
= HandleSizing(rc
);
2464 pRect
->left
= rc
.GetLeft();
2465 pRect
->top
= rc
.GetTop();
2466 pRect
->right
= rc
.GetRight();
2467 pRect
->bottom
= rc
.GetBottom();
2471 #endif // !__WXWINCE__
2473 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2474 case WM_ACTIVATEAPP
:
2475 // This implicitly sends a wxEVT_ACTIVATE_APP event
2476 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2482 WXWORD state
, minimized
;
2484 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2486 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2491 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2495 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2498 case WM_PRINTCLIENT
:
2499 processed
= HandlePrintClient((WXHDC
)wParam
);
2505 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2507 processed
= HandlePaint();
2511 processed
= HandlePaint();
2516 #ifdef __WXUNIVERSAL__
2517 // Universal uses its own wxFrame/wxDialog, so we don't receive
2518 // close events unless we have this.
2520 #endif // __WXUNIVERSAL__
2522 // don't let the DefWindowProc() destroy our window - we'll do it
2523 // ourselves in ~wxWindow
2529 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2533 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2534 GET_Y_LPARAM(lParam
),
2538 #ifdef HAVE_TRACKMOUSEEVENT
2540 // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
2541 if ( m_mouseInWindow
)
2543 GenerateMouseLeave();
2546 // always pass processed back as false, this allows the window
2547 // manager to process the message too. This is needed to
2548 // ensure windows XP themes work properly as the mouse moves
2549 // over widgets like buttons. So don't set processed to true here.
2551 #endif // HAVE_TRACKMOUSEEVENT
2553 #if wxUSE_MOUSEWHEEL
2555 processed
= HandleMouseWheel(wParam
, lParam
);
2559 case WM_LBUTTONDOWN
:
2561 case WM_LBUTTONDBLCLK
:
2562 case WM_RBUTTONDOWN
:
2564 case WM_RBUTTONDBLCLK
:
2565 case WM_MBUTTONDOWN
:
2567 case WM_MBUTTONDBLCLK
:
2569 #ifdef __WXMICROWIN__
2570 // MicroWindows seems to ignore the fact that a window is
2571 // disabled. So catch mouse events and throw them away if
2573 wxWindowMSW
* win
= this;
2576 if (!win
->IsEnabled())
2582 win
= win
->GetParent();
2583 if ( !win
|| win
->IsTopLevel() )
2590 #endif // __WXMICROWIN__
2591 int x
= GET_X_LPARAM(lParam
),
2592 y
= GET_Y_LPARAM(lParam
);
2595 // redirect the event to a static control if necessary by
2596 // finding one under mouse because under CE the static controls
2597 // don't generate mouse events (even with SS_NOTIFY)
2599 if ( GetCapture() == this )
2601 // but don't do it if the mouse is captured by this window
2602 // because then it should really get this event itself
2607 win
= FindWindowForMouseEvent(this, &x
, &y
);
2609 // this should never happen
2610 wxCHECK_MSG( win
, 0,
2611 _T("FindWindowForMouseEvent() returned NULL") );
2614 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2616 SHRGINFO shrgi
= {0};
2618 shrgi
.cbSize
= sizeof(SHRGINFO
);
2619 shrgi
.hwndClient
= (HWND
) GetHWND();
2623 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2624 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2626 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2629 pt
= ClientToScreen(pt
);
2631 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2633 evtCtx
.SetEventObject(this);
2634 if (GetEventHandler()->ProcessEvent(evtCtx
))
2643 #else // !__WXWINCE__
2644 wxWindowMSW
*win
= this;
2645 #endif // __WXWINCE__/!__WXWINCE__
2647 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2649 // if the app didn't eat the event, handle it in the default
2650 // way, that is by giving this window the focus
2653 // for the standard classes their WndProc sets the focus to
2654 // them anyhow and doing it from here results in some weird
2655 // problems, so don't do it for them (unnecessary anyhow)
2656 if ( !win
->IsOfStandardClass() )
2658 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2670 case MM_JOY1BUTTONDOWN
:
2671 case MM_JOY2BUTTONDOWN
:
2672 case MM_JOY1BUTTONUP
:
2673 case MM_JOY2BUTTONUP
:
2674 processed
= HandleJoystickEvent(message
,
2675 GET_X_LPARAM(lParam
),
2676 GET_Y_LPARAM(lParam
),
2679 #endif // __WXMICROWIN__
2685 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2687 processed
= HandleCommand(id
, cmd
, hwnd
);
2692 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2695 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2696 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2697 // apparently doesn't always behave properly and needs some help
2698 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2699 case WM_NOTIFYFORMAT
:
2700 if ( lParam
== NF_QUERY
)
2703 rc
.result
= NFR_UNICODE
;
2706 #endif // wxUSE_UNICODE_MSLU
2708 // for these messages we must return true if process the message
2711 case WM_MEASUREITEM
:
2713 int idCtrl
= (UINT
)wParam
;
2714 if ( message
== WM_DRAWITEM
)
2716 processed
= MSWOnDrawItem(idCtrl
,
2717 (WXDRAWITEMSTRUCT
*)lParam
);
2721 processed
= MSWOnMeasureItem(idCtrl
,
2722 (WXMEASUREITEMSTRUCT
*)lParam
);
2729 #endif // defined(WM_DRAWITEM)
2732 if ( !IsOfStandardClass() )
2734 // we always want to get the char events
2735 rc
.result
= DLGC_WANTCHARS
;
2737 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2739 // in fact, we want everything
2740 rc
.result
|= DLGC_WANTARROWS
|
2747 //else: get the dlg code from the DefWindowProc()
2752 // If this has been processed by an event handler, return 0 now
2753 // (we've handled it).
2754 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2755 if ( m_lastKeydownProcessed
)
2764 // we consider these messages "not interesting" to OnChar, so
2765 // just don't do anything more with them
2775 // avoid duplicate messages to OnChar for these ASCII keys:
2776 // they will be translated by TranslateMessage() and received
2808 // but set processed to false, not true to still pass them
2809 // to the control's default window proc - otherwise
2810 // built-in keyboard handling won't work
2815 // special case of VK_APPS: treat it the same as right mouse
2816 // click because both usually pop up a context menu
2818 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2823 // do generate a CHAR event
2824 processed
= HandleChar((WORD
)wParam
, lParam
);
2827 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2834 // special case of VK_APPS: treat it the same as right mouse button
2835 if ( wParam
== VK_APPS
)
2837 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2842 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2847 case WM_CHAR
: // Always an ASCII character
2848 if ( m_lastKeydownProcessed
)
2850 // The key was handled in the EVT_KEY_DOWN and handling
2851 // a key in an EVT_KEY_DOWN handler is meant, by
2852 // design, to prevent EVT_CHARs from happening
2853 m_lastKeydownProcessed
= false;
2858 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2864 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2866 #endif // wxUSE_HOTKEY
2873 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2875 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2881 // CTLCOLOR messages are sent by children to query the parent for their
2883 #ifndef __WXMICROWIN__
2884 case WM_CTLCOLORMSGBOX
:
2885 case WM_CTLCOLOREDIT
:
2886 case WM_CTLCOLORLISTBOX
:
2887 case WM_CTLCOLORBTN
:
2888 case WM_CTLCOLORDLG
:
2889 case WM_CTLCOLORSCROLLBAR
:
2890 case WM_CTLCOLORSTATIC
:
2894 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2896 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2899 #endif // !__WXMICROWIN__
2901 case WM_SYSCOLORCHANGE
:
2902 // the return value for this message is ignored
2903 processed
= HandleSysColorChange();
2906 #if !defined(__WXWINCE__)
2907 case WM_DISPLAYCHANGE
:
2908 processed
= HandleDisplayChange();
2912 case WM_PALETTECHANGED
:
2913 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2916 case WM_CAPTURECHANGED
:
2917 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2920 case WM_SETTINGCHANGE
:
2921 processed
= HandleSettingChange(wParam
, lParam
);
2924 case WM_QUERYNEWPALETTE
:
2925 processed
= HandleQueryNewPalette();
2929 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2932 // we processed the message, i.e. erased the background
2937 #if !defined(__WXWINCE__)
2939 processed
= HandleDropFiles(wParam
);
2944 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2948 // we never set focus from here
2953 #if !defined(__WXWINCE__)
2954 case WM_QUERYENDSESSION
:
2955 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2959 processed
= HandleEndSession(wParam
!= 0, lParam
);
2962 case WM_GETMINMAXINFO
:
2963 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2968 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2969 LOWORD(lParam
), // hit test
2970 HIWORD(lParam
)); // mouse msg
2974 // returning TRUE stops the DefWindowProc() from further
2975 // processing this message - exactly what we need because we've
2976 // just set the cursor.
2981 #if wxUSE_ACCESSIBILITY
2984 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2985 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2987 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2989 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2995 #if defined(WM_HELP)
2998 // HELPINFO doesn't seem to be supported on WinCE.
3000 HELPINFO
* info
= (HELPINFO
*) lParam
;
3001 // Don't yet process menu help events, just windows
3002 if (info
->iContextType
== HELPINFO_WINDOW
)
3005 wxWindowMSW
* subjectOfHelp
= this;
3006 bool eventProcessed
= false;
3007 while (subjectOfHelp
&& !eventProcessed
)
3009 wxHelpEvent
helpEvent(wxEVT_HELP
,
3010 subjectOfHelp
->GetId(),
3014 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3018 helpEvent
.SetEventObject(this);
3020 GetEventHandler()->ProcessEvent(helpEvent
);
3022 // Go up the window hierarchy until the event is
3024 subjectOfHelp
= subjectOfHelp
->GetParent();
3027 processed
= eventProcessed
;
3030 else if (info
->iContextType
== HELPINFO_MENUITEM
)
3032 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3033 helpEvent
.SetEventObject(this);
3034 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
3037 //else: processed is already false
3043 #if !defined(__WXWINCE__)
3044 case WM_CONTEXTMENU
:
3046 // we don't convert from screen to client coordinates as
3047 // the event may be handled by a parent window
3048 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3050 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3052 // we could have got an event from our child, reflect it back
3053 // to it if this is the case
3054 wxWindowMSW
*win
= NULL
;
3055 if ( (WXHWND
)wParam
!= m_hWnd
)
3057 win
= FindItemByHWND((WXHWND
)wParam
);
3063 evtCtx
.SetEventObject(win
);
3064 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
3070 // we're only interested in our own menus, not MF_SYSMENU
3071 if ( HIWORD(wParam
) == MF_POPUP
)
3073 // handle menu chars for ownerdrawn menu items
3074 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3075 if ( i
!= wxNOT_FOUND
)
3077 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3083 case WM_POWERBROADCAST
:
3086 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3087 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3095 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3096 wxGetMessageName(message
));
3097 #endif // __WXDEBUG__
3098 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3104 // ----------------------------------------------------------------------------
3105 // wxWindow <-> HWND map
3106 // ----------------------------------------------------------------------------
3108 wxWinHashTable
*wxWinHandleHash
= NULL
;
3110 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3112 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3115 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3117 // adding NULL hWnd is (first) surely a result of an error and
3118 // (secondly) breaks menu command processing
3119 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3120 wxT("attempt to add a NULL hWnd to window list ignored") );
3122 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3124 if ( oldWin
&& (oldWin
!= win
) )
3126 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3127 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3130 #endif // __WXDEBUG__
3133 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3137 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3139 wxWinHandleHash
->Delete((long)win
->GetHWND());
3142 // ----------------------------------------------------------------------------
3143 // various MSW speciic class dependent functions
3144 // ----------------------------------------------------------------------------
3146 // Default destroyer - override if you destroy it in some other way
3147 // (e.g. with MDI child windows)
3148 void wxWindowMSW::MSWDestroyWindow()
3152 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3155 int& w
, int& h
) const
3157 // yes, those are just some arbitrary hardcoded numbers
3158 static const int DEFAULT_Y
= 200;
3160 bool nonDefault
= false;
3162 if ( pos
.x
== wxDefaultCoord
)
3164 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3165 // can just as well set it to CW_USEDEFAULT as well
3171 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3172 // neither because it is not handled as a special value by Windows then
3173 // and so we have to choose some default value for it
3175 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3181 NB: there used to be some code here which set the initial size of the
3182 window to the client size of the parent if no explicit size was
3183 specified. This was wrong because wxWidgets programs often assume
3184 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3185 it. To see why, you should understand that Windows sends WM_SIZE from
3186 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3187 from some base class ctor and so this WM_SIZE is not processed in the
3188 real class' OnSize() (because it's not fully constructed yet and the
3189 event goes to some base class OnSize() instead). So the WM_SIZE we
3190 rely on is the one sent when the parent frame resizes its children
3191 but here is the problem: if the child already has just the right
3192 size, nothing will happen as both wxWidgets and Windows check for
3193 this and ignore any attempts to change the window size to the size it
3194 already has - so no WM_SIZE would be sent.
3198 // we don't use CW_USEDEFAULT here for several reasons:
3200 // 1. it results in huge frames on modern screens (1000*800 is not
3201 // uncommon on my 1280*1024 screen) which is way too big for a half
3202 // empty frame of most of wxWidgets samples for example)
3204 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3205 // the default is for whatever reason 8*8 which breaks client <->
3206 // window size calculations (it would be nice if it didn't, but it
3207 // does and the simplest way to fix it seemed to change the broken
3208 // default size anyhow)
3210 // 3. there is just no advantage in doing it: with x and y it is
3211 // possible that [future versions of] Windows position the new top
3212 // level window in some smart way which we can't do, but we can
3213 // guess a reasonably good size for a new window just as well
3216 // However, on PocketPC devices, we must use the default
3217 // size if possible.
3219 if (size
.x
== wxDefaultCoord
)
3223 if (size
.y
== wxDefaultCoord
)
3228 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3232 w
= WidthDefault(size
.x
);
3233 h
= HeightDefault(size
.y
);
3236 AdjustForParentClientOrigin(x
, y
);
3241 WXHWND
wxWindowMSW::MSWGetParent() const
3243 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3246 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3247 const wxChar
*title
,
3251 WXDWORD extendedStyle
)
3253 // choose the position/size for the new window
3255 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3257 // controlId is menu handle for the top level windows, so set it to 0
3258 // unless we're creating a child window
3259 int controlId
= style
& WS_CHILD
? GetId() : 0;
3261 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3262 // which is the same but without CS_[HV]REDRAW class styles so using it
3263 // ensures that the window is not fully repainted on each resize
3264 wxString
className(wclass
);
3265 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3267 className
+= wxT("NR");
3270 // do create the window
3271 wxWindowCreationHook
hook(this);
3273 m_hWnd
= (WXHWND
)::CreateWindowEx
3277 title
? title
: m_windowName
.c_str(),
3280 (HWND
)MSWGetParent(),
3283 NULL
// no extra data
3288 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3293 SubclassWin(m_hWnd
);
3298 // ===========================================================================
3299 // MSW message handlers
3300 // ===========================================================================
3302 // ---------------------------------------------------------------------------
3304 // ---------------------------------------------------------------------------
3306 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3308 #ifndef __WXMICROWIN__
3309 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3310 HWND hWnd
= hdr
->hwndFrom
;
3311 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3313 // if the control is one of our windows, let it handle the message itself
3316 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3319 // VZ: why did we do it? normally this is unnecessary and, besides, it
3320 // breaks the message processing for the toolbars because the tooltip
3321 // notifications were being forwarded to the toolbar child controls
3322 // (if it had any) before being passed to the toolbar itself, so in my
3323 // example the tooltip for the combobox was always shown instead of the
3324 // correct button tooltips
3326 // try all our children
3327 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3330 wxWindow
*child
= node
->GetData();
3331 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3336 node
= node
->GetNext();
3340 // by default, handle it ourselves
3341 return MSWOnNotify(idCtrl
, lParam
, result
);
3342 #else // __WXMICROWIN__
3349 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3351 const wxString
& ttip
)
3353 // I don't know why it happens, but the versions of comctl32.dll starting
3354 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3355 // this message is supposed to be sent to Unicode programs only) -- hence
3356 // we need to handle it as well, otherwise no tooltips will be shown in
3359 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3362 // not a tooltip message or no tooltip to show anyhow
3367 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3369 // We don't want to use the szText buffer because it has a limit of 80
3370 // bytes and this is not enough, especially for Unicode build where it
3371 // limits the tooltip string length to only 40 characters
3373 // The best would be, of course, to not impose any length limitations at
3374 // all but then the buffer would have to be dynamic and someone would have
3375 // to free it and we don't have the tooltip owner object here any more, so
3376 // for now use our own static buffer with a higher fixed max length.
3378 // Note that using a static buffer should not be a problem as only a single
3379 // tooltip can be shown at the same time anyhow.
3381 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3383 // We need to convert tooltip from multi byte to Unicode on the fly.
3384 static wchar_t buf
[513];
3386 // Truncate tooltip length if needed as otherwise we might not have
3387 // enough space for it in the buffer and MultiByteToWideChar() would
3389 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3391 // Convert to WideChar without adding the NULL character. The NULL
3392 // character is added afterwards (this is more efficient).
3393 int len
= ::MultiByteToWideChar
3405 wxLogLastError(_T("MultiByteToWideChar()"));
3409 ttText
->lpszText
= (LPSTR
) buf
;
3411 else // TTN_NEEDTEXTA
3412 #endif // !wxUSE_UNICODE
3414 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3415 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3416 // to copy the string we have into the buffer
3417 static wxChar buf
[513];
3418 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3419 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3420 ttText
->lpszText
= buf
;
3426 #endif // wxUSE_TOOLTIPS
3428 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3430 WXLPARAM
* WXUNUSED(result
))
3435 NMHDR
* hdr
= (NMHDR
*)lParam
;
3436 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3443 wxUnusedVar(lParam
);
3444 #endif // wxUSE_TOOLTIPS
3449 // ---------------------------------------------------------------------------
3450 // end session messages
3451 // ---------------------------------------------------------------------------
3453 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3455 #ifdef ENDSESSION_LOGOFF
3456 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3457 event
.SetEventObject(wxTheApp
);
3458 event
.SetCanVeto(true);
3459 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3461 bool rc
= wxTheApp
->ProcessEvent(event
);
3465 // we may end only if the app didn't veto session closing (double
3467 *mayEnd
= !event
.GetVeto();
3472 wxUnusedVar(logOff
);
3473 wxUnusedVar(mayEnd
);
3478 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3480 #ifdef ENDSESSION_LOGOFF
3481 // do nothing if the session isn't ending
3486 if ( (this != wxTheApp
->GetTopWindow()) )
3489 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3490 event
.SetEventObject(wxTheApp
);
3491 event
.SetCanVeto(false);
3492 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3494 return wxTheApp
->ProcessEvent(event
);
3496 wxUnusedVar(endSession
);
3497 wxUnusedVar(logOff
);
3502 // ---------------------------------------------------------------------------
3503 // window creation/destruction
3504 // ---------------------------------------------------------------------------
3506 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3509 // VZ: why is this commented out for WinCE? If it doesn't support
3510 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3511 // not with multiple #ifdef's!
3513 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3514 EnsureParentHasControlParentStyle(GetParent());
3515 #endif // !__WXWINCE__
3522 bool wxWindowMSW::HandleDestroy()
3526 // delete our drop target if we've got one
3527 #if wxUSE_DRAG_AND_DROP
3528 if ( m_dropTarget
!= NULL
)
3530 m_dropTarget
->Revoke(m_hWnd
);
3532 delete m_dropTarget
;
3533 m_dropTarget
= NULL
;
3535 #endif // wxUSE_DRAG_AND_DROP
3537 // WM_DESTROY handled
3541 // ---------------------------------------------------------------------------
3543 // ---------------------------------------------------------------------------
3545 bool wxWindowMSW::HandleActivate(int state
,
3546 bool WXUNUSED(minimized
),
3547 WXHWND
WXUNUSED(activate
))
3549 wxActivateEvent
event(wxEVT_ACTIVATE
,
3550 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3552 event
.SetEventObject(this);
3554 return GetEventHandler()->ProcessEvent(event
);
3557 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3559 // Strangly enough, some controls get set focus events when they are being
3560 // deleted, even if they already had focus before.
3561 if ( m_isBeingDeleted
)
3566 // notify the parent keeping track of focus for the kbd navigation
3567 // purposes that we got it
3568 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3569 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3575 m_caret
->OnSetFocus();
3577 #endif // wxUSE_CARET
3580 // If it's a wxTextCtrl don't send the event as it will be done
3581 // after the control gets to process it from EN_FOCUS handler
3582 if ( wxDynamicCastThis(wxTextCtrl
) )
3586 #endif // wxUSE_TEXTCTRL
3588 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3589 event
.SetEventObject(this);
3591 // wxFindWinFromHandle() may return NULL, it is ok
3592 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3594 return GetEventHandler()->ProcessEvent(event
);
3597 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3603 m_caret
->OnKillFocus();
3605 #endif // wxUSE_CARET
3608 // If it's a wxTextCtrl don't send the event as it will be done
3609 // after the control gets to process it.
3610 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3617 // Don't send the event when in the process of being deleted. This can
3618 // only cause problems if the event handler tries to access the object.
3619 if ( m_isBeingDeleted
)
3624 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3625 event
.SetEventObject(this);
3627 // wxFindWinFromHandle() may return NULL, it is ok
3628 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3630 return GetEventHandler()->ProcessEvent(event
);
3633 // ---------------------------------------------------------------------------
3635 // ---------------------------------------------------------------------------
3637 void wxWindowMSW::SetLabel( const wxString
& label
)
3639 SetWindowText(GetHwnd(), label
.c_str());
3642 wxString
wxWindowMSW::GetLabel() const
3644 return wxGetWindowText(GetHWND());
3647 // ---------------------------------------------------------------------------
3649 // ---------------------------------------------------------------------------
3651 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3653 wxShowEvent
event(GetId(), show
);
3654 event
.SetEventObject(this);
3656 return GetEventHandler()->ProcessEvent(event
);
3659 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3661 wxInitDialogEvent
event(GetId());
3662 event
.SetEventObject(this);
3664 return GetEventHandler()->ProcessEvent(event
);
3667 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3669 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3670 wxUnusedVar(wParam
);
3672 #else // __WXMICROWIN__
3673 HDROP hFilesInfo
= (HDROP
) wParam
;
3675 // Get the total number of files dropped
3676 UINT gwFilesDropped
= ::DragQueryFile
3684 wxString
*files
= new wxString
[gwFilesDropped
];
3685 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3687 // first get the needed buffer length (+1 for terminating NUL)
3688 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3690 // and now get the file name
3691 ::DragQueryFile(hFilesInfo
, wIndex
,
3692 wxStringBuffer(files
[wIndex
], len
), len
);
3694 DragFinish (hFilesInfo
);
3696 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3697 event
.SetEventObject(this);
3700 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3701 event
.m_pos
.x
= dropPoint
.x
;
3702 event
.m_pos
.y
= dropPoint
.y
;
3704 return GetEventHandler()->ProcessEvent(event
);
3709 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3711 int WXUNUSED(mouseMsg
))
3713 #ifndef __WXMICROWIN__
3714 // the logic is as follows:
3715 // -1. don't set cursor for non client area, including but not limited to
3716 // the title bar, scrollbars, &c
3717 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3718 // 1. if we have the cursor set it unless wxIsBusy()
3719 // 2. if we're a top level window, set some cursor anyhow
3720 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3722 if ( nHitTest
!= HTCLIENT
)
3727 HCURSOR hcursor
= 0;
3729 // first ask the user code - it may wish to set the cursor in some very
3730 // specific way (for example, depending on the current position)
3733 if ( !::GetCursorPosWinCE(&pt
))
3735 if ( !::GetCursorPos(&pt
) )
3738 wxLogLastError(wxT("GetCursorPos"));
3743 ScreenToClient(&x
, &y
);
3744 wxSetCursorEvent
event(x
, y
);
3746 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3747 if ( processedEvtSetCursor
&& event
.HasCursor() )
3749 hcursor
= GetHcursorOf(event
.GetCursor());
3754 bool isBusy
= wxIsBusy();
3756 // the test for processedEvtSetCursor is here to prevent using m_cursor
3757 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3758 // it - this is a way to say that our cursor shouldn't be used for this
3760 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3762 hcursor
= GetHcursorOf(m_cursor
);
3769 hcursor
= wxGetCurrentBusyCursor();
3771 else if ( !hcursor
)
3773 const wxCursor
*cursor
= wxGetGlobalCursor();
3774 if ( cursor
&& cursor
->Ok() )
3776 hcursor
= GetHcursorOf(*cursor
);
3784 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3786 ::SetCursor(hcursor
);
3788 // cursor set, stop here
3791 #endif // __WXMICROWIN__
3793 // pass up the window chain
3797 bool wxWindowMSW::HandlePower(WXWPARAM wParam
,
3798 WXLPARAM
WXUNUSED(lParam
),
3801 wxEventType evtType
;
3804 case PBT_APMQUERYSUSPEND
:
3805 evtType
= wxEVT_POWER_SUSPENDING
;
3808 case PBT_APMQUERYSUSPENDFAILED
:
3809 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
3812 case PBT_APMSUSPEND
:
3813 evtType
= wxEVT_POWER_SUSPENDED
;
3816 case PBT_APMRESUMESUSPEND
:
3817 evtType
= wxEVT_POWER_RESUME
;
3821 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
3824 // these messages are currently not mapped to wx events
3825 case PBT_APMQUERYSTANDBY
:
3826 case PBT_APMQUERYSTANDBYFAILED
:
3827 case PBT_APMSTANDBY
:
3828 case PBT_APMRESUMESTANDBY
:
3829 case PBT_APMBATTERYLOW
:
3830 case PBT_APMPOWERSTATUSCHANGE
:
3831 case PBT_APMOEMEVENT
:
3832 case PBT_APMRESUMEAUTOMATIC
:
3833 case PBT_APMRESUMECRITICAL
:
3834 evtType
= wxEVT_NULL
;
3838 // don't handle unknown messages
3839 if ( evtType
== wxEVT_NULL
)
3842 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
3844 wxPowerEvent
event(evtType
);
3845 if ( !GetEventHandler()->ProcessEvent(event
) )
3848 *vetoed
= event
.IsVetoed();
3853 // ---------------------------------------------------------------------------
3854 // owner drawn stuff
3855 // ---------------------------------------------------------------------------
3857 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3858 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3859 #define WXUNUSED_UNLESS_ODRAWN(param) param
3861 #define WXUNUSED_UNLESS_ODRAWN(param)
3865 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3866 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3868 #if wxUSE_OWNER_DRAWN
3870 #if wxUSE_MENUS_NATIVE
3871 // is it a menu item?
3872 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3873 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3875 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3877 // see comment before the same test in MSWOnMeasureItem() below
3881 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3882 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3884 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3885 // the DC from being released
3886 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3887 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3888 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3889 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3891 return pMenuItem
->OnDrawItem
3895 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3896 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3899 #endif // wxUSE_MENUS_NATIVE
3901 #endif // USE_OWNER_DRAWN
3903 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3905 #if wxUSE_OWNER_DRAWN
3906 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3907 #else // !wxUSE_OWNER_DRAWN
3908 // we may still have owner-drawn buttons internally because we have to make
3909 // them owner-drawn to support colour change
3912 wxDynamicCast(FindItem(id
), wxButton
)
3917 #endif // USE_OWNER_DRAWN
3921 return item
->MSWOnDraw(itemStruct
);
3924 #endif // wxUSE_CONTROLS
3930 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3932 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3933 // is it a menu item?
3934 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3935 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3937 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3939 // according to Carsten Fuchs the pointer may be NULL under XP if an
3940 // MDI child frame is initially maximized, see this for more info:
3941 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
3943 // so silently ignore it instead of asserting
3947 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3948 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3951 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3953 pMeasureStruct
->itemWidth
= w
;
3954 pMeasureStruct
->itemHeight
= h
;
3959 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3962 return item
->MSWOnMeasure(itemStruct
);
3966 wxUnusedVar(itemStruct
);
3967 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3972 // ---------------------------------------------------------------------------
3973 // colours and palettes
3974 // ---------------------------------------------------------------------------
3976 bool wxWindowMSW::HandleSysColorChange()
3978 wxSysColourChangedEvent event
;
3979 event
.SetEventObject(this);
3981 (void)GetEventHandler()->ProcessEvent(event
);
3983 // always let the system carry on the default processing to allow the
3984 // native controls to react to the colours update
3988 bool wxWindowMSW::HandleDisplayChange()
3990 wxDisplayChangedEvent event
;
3991 event
.SetEventObject(this);
3993 return GetEventHandler()->ProcessEvent(event
);
3996 #ifndef __WXMICROWIN__
3998 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4000 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4004 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4007 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4009 #endif // wxUSE_CONTROLS
4012 return *brush
!= NULL
;
4015 #endif // __WXMICROWIN__
4017 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4020 // same as below except we don't respond to our own messages
4021 if ( hWndPalChange
!= GetHWND() )
4023 // check to see if we our our parents have a custom palette
4024 wxWindowMSW
*win
= this;
4025 while ( win
&& !win
->HasCustomPalette() )
4027 win
= win
->GetParent();
4030 if ( win
&& win
->HasCustomPalette() )
4032 // realize the palette to see whether redrawing is needed
4033 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4034 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4035 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4037 int result
= ::RealizePalette(hdc
);
4039 // restore the palette (before releasing the DC)
4040 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4041 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4042 ::RealizePalette(hdc
);
4043 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4045 // now check for the need to redraw
4047 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4051 #endif // wxUSE_PALETTE
4053 wxPaletteChangedEvent
event(GetId());
4054 event
.SetEventObject(this);
4055 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4057 return GetEventHandler()->ProcessEvent(event
);
4060 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4062 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
4063 event
.SetEventObject(this);
4065 return GetEventHandler()->ProcessEvent(event
);
4068 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4070 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4071 // we need to send this to child windows (it is only sent to top-level
4072 // windows) so {list,tree}ctrls can adjust their font size if necessary
4073 // this is exactly how explorer does it to enable the font size changes
4075 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4078 // top-level windows already get this message from the system
4079 wxWindow
*win
= node
->GetData();
4080 if ( !win
->IsTopLevel() )
4082 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4085 node
= node
->GetNext();
4088 // let the system handle it
4092 bool wxWindowMSW::HandleQueryNewPalette()
4096 // check to see if we our our parents have a custom palette
4097 wxWindowMSW
*win
= this;
4098 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4099 if (win
->HasCustomPalette()) {
4100 /* realize the palette to see whether redrawing is needed */
4101 HDC hdc
= ::GetDC((HWND
) GetHWND());
4102 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4103 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4105 int result
= ::RealizePalette(hdc
);
4106 /* restore the palette (before releasing the DC) */
4107 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4108 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4109 ::RealizePalette(hdc
);
4110 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4111 /* now check for the need to redraw */
4113 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4115 #endif // wxUSE_PALETTE
4117 wxQueryNewPaletteEvent
event(GetId());
4118 event
.SetEventObject(this);
4120 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
4123 // Responds to colour changes: passes event on to children.
4124 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4126 // the top level window also reset the standard colour map as it might have
4127 // changed (there is no need to do it for the non top level windows as we
4128 // only have to do it once)
4132 gs_hasStdCmap
= false;
4134 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4137 // Only propagate to non-top-level windows because Windows already
4138 // sends this event to all top-level ones
4139 wxWindow
*win
= node
->GetData();
4140 if ( !win
->IsTopLevel() )
4142 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4143 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4144 // the standard controls
4145 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4148 node
= node
->GetNext();
4152 extern wxCOLORMAP
*wxGetStdColourMap()
4154 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4155 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4157 if ( !gs_hasStdCmap
)
4159 static bool s_coloursInit
= false;
4161 if ( !s_coloursInit
)
4163 // When a bitmap is loaded, the RGB values can change (apparently
4164 // because Windows adjusts them to care for the old programs always
4165 // using 0xc0c0c0 while the transparent colour for the new Windows
4166 // versions is different). But we do this adjustment ourselves so
4167 // we want to avoid Windows' "help" and for this we need to have a
4168 // reference bitmap which can tell us what the RGB values change
4170 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4171 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4172 if ( stdColourBitmap
.Ok() )
4174 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4175 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4176 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4179 memDC
.SelectObject(stdColourBitmap
);
4182 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4184 memDC
.GetPixel(i
, 0, &colour
);
4185 s_stdColours
[i
] = wxColourToRGB(colour
);
4188 else // wxBITMAP_STD_COLOURS couldn't be loaded
4190 s_stdColours
[0] = RGB(000,000,000); // black
4191 s_stdColours
[1] = RGB(128,128,128); // dark grey
4192 s_stdColours
[2] = RGB(192,192,192); // light grey
4193 s_stdColours
[3] = RGB(255,255,255); // white
4194 //s_stdColours[4] = RGB(000,000,255); // blue
4195 //s_stdColours[5] = RGB(255,000,255); // magenta
4198 s_coloursInit
= true;
4201 gs_hasStdCmap
= true;
4203 // create the colour map
4204 #define INIT_CMAP_ENTRY(col) \
4205 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4206 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4208 INIT_CMAP_ENTRY(BTNTEXT
);
4209 INIT_CMAP_ENTRY(BTNSHADOW
);
4210 INIT_CMAP_ENTRY(BTNFACE
);
4211 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4213 #undef INIT_CMAP_ENTRY
4219 // ---------------------------------------------------------------------------
4221 // ---------------------------------------------------------------------------
4223 bool wxWindowMSW::HandlePaint()
4225 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4227 wxLogLastError(wxT("CreateRectRgn"));
4228 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4229 wxLogLastError(wxT("GetUpdateRgn"));
4231 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4233 wxPaintEvent
event(m_windowId
);
4234 event
.SetEventObject(this);
4236 bool processed
= GetEventHandler()->ProcessEvent(event
);
4238 // note that we must generate NC event after the normal one as otherwise
4239 // BeginPaint() will happily overwrite our decorations with the background
4241 wxNcPaintEvent
eventNc(m_windowId
);
4242 eventNc
.SetEventObject(this);
4243 GetEventHandler()->ProcessEvent(eventNc
);
4248 // Can be called from an application's OnPaint handler
4249 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4251 #ifdef __WXUNIVERSAL__
4254 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
4257 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4262 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4267 dc
.SetWindow((wxWindow
*)this);
4269 wxEraseEvent
event(m_windowId
, &dc
);
4270 event
.SetEventObject(this);
4271 bool rc
= GetEventHandler()->ProcessEvent(event
);
4273 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4274 dc
.SelectOldObjects(hdc
);
4279 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4281 // standard non top level controls (i.e. except the dialogs) always erase
4282 // their background themselves in HandleCtlColor() or have some control-
4283 // specific ways to set the colours (common controls)
4284 if ( IsOfStandardClass() && !IsTopLevel() )
4290 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4292 // don't skip the event here, custom background means that the app
4293 // is drawing it itself in its OnPaint(), so don't draw it at all
4294 // now to avoid flicker
4299 // do default background painting
4300 if ( !DoEraseBackground(GetHdcOf(*event
.GetDC())) )
4302 // let the system paint the background
4307 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4309 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4313 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4319 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4323 // our background colour applies to:
4324 // 1. this window itself, always
4325 // 2. all children unless the colour is "not inheritable"
4326 // 3. even if it is not inheritable, our immediate transparent
4327 // children should still inherit it -- but not any transparent
4328 // children because it would look wrong if a child of non
4329 // transparent child would show our bg colour when the child itself
4331 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4334 (win
&& win
->HasTransparentBackground() &&
4335 win
->GetParent() == this) )
4337 // draw children with the same colour as the parent
4339 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4341 return (WXHBRUSH
)GetHbrushOf(*brush
);
4348 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4351 hWndToPaint
= GetHWND();
4353 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4355 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4359 // background is not inherited beyond top level windows
4360 if ( win
->IsTopLevel() )
4367 bool wxWindowMSW::HandlePrintClient(WXHDC hDC
)
4369 // we receive this message when DrawThemeParentBackground() is
4370 // called from def window proc of several controls under XP and we
4371 // must draw properly themed background here
4373 // note that naively I'd expect filling the client rect with the
4374 // brush returned by MSWGetBgBrush() work -- but for some reason it
4375 // doesn't and we have to call parents MSWPrintChild() which is
4376 // supposed to call DrawThemeBackground() with appropriate params
4378 // also note that in this case lParam == PRF_CLIENT but we're
4379 // clearly expected to paint the background and nothing else!
4381 if ( IsTopLevel() || InheritsBackgroundColour() )
4384 // sometimes we don't want the parent to handle it at all, instead
4385 // return whatever value this window wants
4386 if ( !MSWShouldPropagatePrintChild() )
4387 return MSWPrintChild(hDC
, (wxWindow
*)this);
4389 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4391 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4394 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4401 // ---------------------------------------------------------------------------
4402 // moving and resizing
4403 // ---------------------------------------------------------------------------
4405 bool wxWindowMSW::HandleMinimize()
4407 wxIconizeEvent
event(m_windowId
);
4408 event
.SetEventObject(this);
4410 return GetEventHandler()->ProcessEvent(event
);
4413 bool wxWindowMSW::HandleMaximize()
4415 wxMaximizeEvent
event(m_windowId
);
4416 event
.SetEventObject(this);
4418 return GetEventHandler()->ProcessEvent(event
);
4421 bool wxWindowMSW::HandleMove(int x
, int y
)
4424 wxMoveEvent
event(point
, m_windowId
);
4425 event
.SetEventObject(this);
4427 return GetEventHandler()->ProcessEvent(event
);
4430 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4432 wxMoveEvent
event(rect
, m_windowId
);
4433 event
.SetEventObject(this);
4435 bool rc
= GetEventHandler()->ProcessEvent(event
);
4437 rect
= event
.GetRect();
4441 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4443 #if USE_DEFERRED_SIZING
4444 // when we resize this window, its children are probably going to be
4445 // repositioned as well, prepare to use DeferWindowPos() for them
4446 int numChildren
= 0;
4447 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4449 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4454 // Protect against valid m_hDWP being overwritten
4455 bool useDefer
= false;
4457 if ( numChildren
> 1 )
4461 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4464 wxLogLastError(_T("BeginDeferWindowPos"));
4470 #endif // USE_DEFERRED_SIZING
4472 // update this window size
4473 bool processed
= false;
4477 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4478 // fall through nevertheless
4482 // we're not interested in these messages at all
4485 case SIZE_MINIMIZED
:
4486 processed
= HandleMinimize();
4489 case SIZE_MAXIMIZED
:
4490 /* processed = */ HandleMaximize();
4491 // fall through to send a normal size event as well
4494 // don't use w and h parameters as they specify the client size
4495 // while according to the docs EVT_SIZE handler is supposed to
4496 // receive the total size
4497 wxSizeEvent
event(GetSize(), m_windowId
);
4498 event
.SetEventObject(this);
4500 processed
= GetEventHandler()->ProcessEvent(event
);
4503 #if USE_DEFERRED_SIZING
4504 // and finally change the positions of all child windows at once
4505 if ( useDefer
&& m_hDWP
)
4507 // reset m_hDWP to NULL so that child windows don't try to use our
4508 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4509 // happen anyhow normally but who knows what weird flow of control we
4510 // may have depending on what the users EVT_SIZE handler does...)
4511 HDWP hDWP
= (HDWP
)m_hDWP
;
4514 // do put all child controls in place at once
4515 if ( !::EndDeferWindowPos(hDWP
) )
4517 wxLogLastError(_T("EndDeferWindowPos"));
4520 // Reset our children's pending pos/size values.
4521 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4523 node
= node
->GetNext() )
4525 wxWindowMSW
*child
= node
->GetData();
4526 child
->m_pendingPosition
= wxDefaultPosition
;
4527 child
->m_pendingSize
= wxDefaultSize
;
4530 #endif // USE_DEFERRED_SIZING
4535 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4537 wxSizeEvent
event(rect
, m_windowId
);
4538 event
.SetEventObject(this);
4540 bool rc
= GetEventHandler()->ProcessEvent(event
);
4542 rect
= event
.GetRect();
4546 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4551 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4555 int minWidth
= GetMinWidth(),
4556 minHeight
= GetMinHeight(),
4557 maxWidth
= GetMaxWidth(),
4558 maxHeight
= GetMaxHeight();
4560 if ( minWidth
!= wxDefaultCoord
)
4562 info
->ptMinTrackSize
.x
= minWidth
;
4566 if ( minHeight
!= wxDefaultCoord
)
4568 info
->ptMinTrackSize
.y
= minHeight
;
4572 if ( maxWidth
!= wxDefaultCoord
)
4574 info
->ptMaxTrackSize
.x
= maxWidth
;
4578 if ( maxHeight
!= wxDefaultCoord
)
4580 info
->ptMaxTrackSize
.y
= maxHeight
;
4588 // ---------------------------------------------------------------------------
4590 // ---------------------------------------------------------------------------
4592 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4594 #if wxUSE_MENUS_NATIVE
4595 if ( !cmd
&& wxCurrentPopupMenu
)
4597 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4598 wxCurrentPopupMenu
= NULL
;
4600 return popupMenu
->MSWCommand(cmd
, id
);
4602 #endif // wxUSE_MENUS_NATIVE
4604 wxWindow
*win
= NULL
;
4606 // first try to find it from HWND - this works even with the broken
4607 // programs using the same ids for different controls
4610 win
= wxFindWinFromHandle(control
);
4616 // must cast to a signed type before comparing with other ids!
4617 win
= FindItem((signed short)id
);
4622 return win
->MSWCommand(cmd
, id
);
4625 // the messages sent from the in-place edit control used by the treectrl
4626 // for label editing have id == 0, but they should _not_ be treated as menu
4627 // messages (they are EN_XXX ones, in fact) so don't translate anything
4628 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4631 // If no child window, it may be an accelerator, e.g. for a popup menu
4634 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4635 event
.SetEventObject(this);
4639 return GetEventHandler()->ProcessEvent(event
);
4643 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4644 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4645 // notifications to its parent which we want to reflect back to
4647 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4648 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4650 #endif // wxUSE_SPINCTRL
4652 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
4653 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
4654 // notifications to its parent which we want to reflect back to
4656 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
4657 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
4665 // ---------------------------------------------------------------------------
4667 // ---------------------------------------------------------------------------
4669 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4673 // our client coords are not quite the same as Windows ones
4674 wxPoint pt
= GetClientAreaOrigin();
4675 event
.m_x
= x
- pt
.x
;
4676 event
.m_y
= y
- pt
.y
;
4678 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4679 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4680 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4681 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4682 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4683 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4686 event
.SetTimestamp(::GetMessageTime());
4689 event
.SetEventObject(this);
4690 event
.SetId(GetId());
4692 #if wxUSE_MOUSEEVENT_HACK
4693 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
4694 gs_lastMouseEvent
.type
= event
.GetEventType();
4695 #endif // wxUSE_MOUSEEVENT_HACK
4699 // Windows doesn't send the mouse events to the static controls (which are
4700 // transparent in the sense that their WM_NCHITTEST handler returns
4701 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4702 // and so we manually check if we don't have a child window under mouse and if
4703 // we do, send the event to it instead of the window Windows had sent WM_XXX
4706 // Notice that this is not done for the mouse move events because this could
4707 // (would?) be too slow, but only for clicks which means that the static texts
4708 // still don't get move, enter nor leave events.
4709 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
4711 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4713 // first try to find a non transparent child: this allows us to send events
4714 // to a static text which is inside a static box, for example
4715 POINT pt
= { *x
, *y
};
4716 HWND hwnd
= GetHwndOf(win
),
4720 hwndUnderMouse
= ::ChildWindowFromPoint
4726 hwndUnderMouse
= ::ChildWindowFromPointEx
4736 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4738 // now try any child window at all
4739 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4742 // check that we have a child window which is susceptible to receive mouse
4743 // events: for this it must be shown and enabled
4744 if ( hwndUnderMouse
&&
4745 hwndUnderMouse
!= hwnd
&&
4746 ::IsWindowVisible(hwndUnderMouse
) &&
4747 ::IsWindowEnabled(hwndUnderMouse
) )
4749 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4750 if ( winUnderMouse
)
4752 // translate the mouse coords to the other window coords
4753 win
->ClientToScreen(x
, y
);
4754 winUnderMouse
->ScreenToClient(x
, y
);
4756 win
= winUnderMouse
;
4762 #endif // __WXWINCE__
4764 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4766 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4767 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4768 // from the message id and take the value in the table to get wxWin event
4770 static const wxEventType eventsMouse
[] =
4784 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4785 InitMouseEvent(event
, x
, y
, flags
);
4787 return GetEventHandler()->ProcessEvent(event
);
4790 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4792 if ( !m_mouseInWindow
)
4794 // it would be wrong to assume that just because we get a mouse move
4795 // event that the mouse is inside the window: although this is usually
4796 // true, it is not if we had captured the mouse, so we need to check
4797 // the mouse coordinates here
4798 if ( !HasCapture() || IsMouseInWindow() )
4800 // Generate an ENTER event
4801 m_mouseInWindow
= true;
4803 #ifdef HAVE_TRACKMOUSEEVENT
4804 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
4806 trackinfo
.dwFlags
= TME_LEAVE
;
4807 trackinfo
.hwndTrack
= GetHwnd();
4809 // Use the commctrl.h _TrackMouseEvent(), which will call the real
4810 // TrackMouseEvent() if available or emulate it
4811 _TrackMouseEvent(&trackinfo
);
4812 #endif // HAVE_TRACKMOUSEEVENT
4814 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4815 InitMouseEvent(event
, x
, y
, flags
);
4817 (void)GetEventHandler()->ProcessEvent(event
);
4820 #ifdef HAVE_TRACKMOUSEEVENT
4823 // Check if we need to send a LEAVE event
4824 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
4825 // send it here if we are using native mouse leave tracking
4826 if ( HasCapture() && !IsMouseInWindow() )
4828 GenerateMouseLeave();
4831 #endif // HAVE_TRACKMOUSEEVENT
4833 #if wxUSE_MOUSEEVENT_HACK
4834 // Windows often generates mouse events even if mouse position hasn't
4835 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
4837 // Filter this out as it can result in unexpected behaviour compared to
4839 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
4840 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
4841 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
4842 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
4844 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
4846 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
4851 #endif // wxUSE_MOUSEEVENT_HACK
4853 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4857 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4859 #if wxUSE_MOUSEWHEEL
4860 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
4861 // forwarded up to the parent by DefWindowProc()) and not in the client
4862 // ones as all the other messages, translate them to the client coords for
4865 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
4866 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4867 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
4868 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4869 event
.m_wheelDelta
= WHEEL_DELTA
;
4871 static int s_linesPerRotation
= -1;
4872 if ( s_linesPerRotation
== -1 )
4874 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4875 &s_linesPerRotation
, 0))
4877 // this is not supposed to happen
4878 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4880 // the default is 3, so use it if SystemParametersInfo() failed
4881 s_linesPerRotation
= 3;
4885 event
.m_linesPerAction
= s_linesPerRotation
;
4886 return GetEventHandler()->ProcessEvent(event
);
4888 #else // !wxUSE_MOUSEWHEEL
4889 wxUnusedVar(wParam
);
4890 wxUnusedVar(lParam
);
4893 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
4896 void wxWindowMSW::GenerateMouseLeave()
4898 m_mouseInWindow
= false;
4901 if ( wxIsShiftDown() )
4903 if ( wxIsCtrlDown() )
4904 state
|= MK_CONTROL
;
4906 // Only the high-order bit should be tested
4907 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
4908 state
|= MK_LBUTTON
;
4909 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
4910 state
|= MK_MBUTTON
;
4911 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
4912 state
|= MK_RBUTTON
;
4916 if ( !::GetCursorPosWinCE(&pt
) )
4918 if ( !::GetCursorPos(&pt
) )
4921 wxLogLastError(_T("GetCursorPos"));
4924 // we need to have client coordinates here for symmetry with
4925 // wxEVT_ENTER_WINDOW
4926 RECT rect
= wxGetWindowRect(GetHwnd());
4930 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
4931 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
4933 (void)GetEventHandler()->ProcessEvent(event
);
4936 // ---------------------------------------------------------------------------
4937 // keyboard handling
4938 // ---------------------------------------------------------------------------
4940 // create the key event of the given type for the given key - used by
4941 // HandleChar and HandleKeyDown/Up
4942 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4945 WXWPARAM wParam
) const
4947 wxKeyEvent
event(evType
);
4948 event
.SetId(GetId());
4949 event
.m_shiftDown
= wxIsShiftDown();
4950 event
.m_controlDown
= wxIsCtrlDown();
4951 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4953 event
.SetEventObject((wxWindow
*)this); // const_cast
4954 event
.m_keyCode
= id
;
4956 event
.m_uniChar
= (wxChar
) wParam
;
4958 event
.m_rawCode
= (wxUint32
) wParam
;
4959 event
.m_rawFlags
= (wxUint32
) lParam
;
4961 event
.SetTimestamp(::GetMessageTime());
4964 // translate the position to client coords
4967 GetCursorPosWinCE(&pt
);
4972 GetWindowRect(GetHwnd(),&rect
);
4982 // isASCII is true only when we're called from WM_CHAR handler and not from
4984 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4991 else // we're called from WM_KEYDOWN
4993 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
4994 // to get numpad key codes: CHAR events should use the logical keys
4995 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
4996 id
= wxCharCodeMSWToWX(wParam
);
4999 // it's ASCII and will be processed here only when called from
5000 // WM_CHAR (i.e. when isASCII = true), don't process it now
5005 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5007 // the alphanumeric keys produced by pressing AltGr+something on European
5008 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5009 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5010 // alphanumeric, so pretend that there are no modifiers at all (the
5011 // KEY_DOWN event would still have the correct modifiers if they're really
5013 if ( event
.m_controlDown
&& event
.m_altDown
&&
5014 (id
>= 32 && id
< 256) )
5016 event
.m_controlDown
=
5017 event
.m_altDown
= false;
5020 return GetEventHandler()->ProcessEvent(event
);
5023 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5025 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5029 // normal ASCII char
5033 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5034 return GetEventHandler()->ProcessEvent(event
);
5037 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5039 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5043 // normal ASCII char
5047 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5048 return GetEventHandler()->ProcessEvent(event
);
5051 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5052 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5054 // FIXME: implement GetMenuItemCount for WinCE, possibly
5055 // in terms of GetMenuItemInfo
5057 const HMENU hmenu
= (HMENU
)lParam
;
5061 mii
.cbSize
= sizeof(MENUITEMINFO
);
5063 // we could use MIIM_FTYPE here as we only need to know if the item is
5064 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5065 // MIIM_FTYPE is not supported under Win95
5066 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5068 // find if we have this letter in any owner drawn item
5069 const int count
= ::GetMenuItemCount(hmenu
);
5070 for ( int i
= 0; i
< count
; i
++ )
5072 // previous loop iteration could modify it, reset it back before
5073 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5076 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5078 if ( mii
.fType
== MFT_OWNERDRAW
)
5080 // dwItemData member of the MENUITEMINFO is a
5081 // pointer to the associated wxMenuItem -- see the
5082 // menu creation code
5083 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5085 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
5088 if ( *p
== _T('&') )
5090 // this is not the accel char, find the real one
5091 p
= wxStrchr(p
+ 1, _T('&'));
5093 else // got the accel char
5095 // FIXME-UNICODE: this comparison doesn't risk to work
5096 // for non ASCII accelerator characters I'm afraid, but
5098 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5104 // this one doesn't match
5111 else // failed to get the menu text?
5113 // it's not fatal, so don't show error, but still log it
5114 wxLogLastError(_T("GetMenuItemInfo"));
5121 bool wxWindowMSW::HandleClipboardEvent( WXUINT nMsg
)
5123 const wxEventType type
= ( nMsg
== WM_CUT
) ? wxEVT_COMMAND_TEXT_CUT
:
5124 ( nMsg
== WM_COPY
) ? wxEVT_COMMAND_TEXT_COPY
:
5125 /*( nMsg == WM_PASTE ) ? */ wxEVT_COMMAND_TEXT_PASTE
;
5126 wxClipboardTextEvent
evt(type
, GetId());
5128 evt
.SetEventObject(this);
5130 return GetEventHandler()->ProcessEvent(evt
);
5133 // ---------------------------------------------------------------------------
5135 // ---------------------------------------------------------------------------
5137 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5141 if ( flags
& JOY_BUTTON1CHG
)
5142 change
= wxJOY_BUTTON1
;
5143 if ( flags
& JOY_BUTTON2CHG
)
5144 change
= wxJOY_BUTTON2
;
5145 if ( flags
& JOY_BUTTON3CHG
)
5146 change
= wxJOY_BUTTON3
;
5147 if ( flags
& JOY_BUTTON4CHG
)
5148 change
= wxJOY_BUTTON4
;
5151 if ( flags
& JOY_BUTTON1
)
5152 buttons
|= wxJOY_BUTTON1
;
5153 if ( flags
& JOY_BUTTON2
)
5154 buttons
|= wxJOY_BUTTON2
;
5155 if ( flags
& JOY_BUTTON3
)
5156 buttons
|= wxJOY_BUTTON3
;
5157 if ( flags
& JOY_BUTTON4
)
5158 buttons
|= wxJOY_BUTTON4
;
5160 // the event ids aren't consecutive so we can't use table based lookup
5162 wxEventType eventType
;
5167 eventType
= wxEVT_JOY_MOVE
;
5172 eventType
= wxEVT_JOY_MOVE
;
5177 eventType
= wxEVT_JOY_ZMOVE
;
5182 eventType
= wxEVT_JOY_ZMOVE
;
5185 case MM_JOY1BUTTONDOWN
:
5187 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5190 case MM_JOY2BUTTONDOWN
:
5192 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5195 case MM_JOY1BUTTONUP
:
5197 eventType
= wxEVT_JOY_BUTTON_UP
;
5200 case MM_JOY2BUTTONUP
:
5202 eventType
= wxEVT_JOY_BUTTON_UP
;
5206 wxFAIL_MSG(wxT("no such joystick event"));
5211 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5212 event
.SetPosition(wxPoint(x
, y
));
5213 event
.SetEventObject(this);
5215 return GetEventHandler()->ProcessEvent(event
);
5225 // ---------------------------------------------------------------------------
5227 // ---------------------------------------------------------------------------
5229 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5230 WXWORD pos
, WXHWND control
)
5232 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5234 wxWindow
*child
= wxFindWinFromHandle(control
);
5236 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5239 wxScrollWinEvent event
;
5240 event
.SetPosition(pos
);
5241 event
.SetOrientation(orientation
);
5242 event
.SetEventObject(this);
5247 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5251 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5255 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5259 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5263 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5267 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5270 case SB_THUMBPOSITION
:
5272 // under Win32, the scrollbar range and position are 32 bit integers,
5273 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5274 // explicitly query the scrollbar for the correct position (this must
5275 // be done only for these two SB_ events as they are the only one
5276 // carrying the scrollbar position)
5278 WinStruct
<SCROLLINFO
> scrollInfo
;
5279 scrollInfo
.fMask
= SIF_TRACKPOS
;
5281 if ( !::GetScrollInfo(GetHwnd(),
5282 orientation
== wxHORIZONTAL
? SB_HORZ
5286 // Not necessarily an error, if there are no scrollbars yet.
5287 // wxLogLastError(_T("GetScrollInfo"));
5290 event
.SetPosition(scrollInfo
.nTrackPos
);
5293 event
.SetEventType( wParam
== SB_THUMBPOSITION
5294 ? wxEVT_SCROLLWIN_THUMBRELEASE
5295 : wxEVT_SCROLLWIN_THUMBTRACK
);
5302 return GetEventHandler()->ProcessEvent(event
);
5305 // ===========================================================================
5307 // ===========================================================================
5309 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5312 HDC dc
= ::GetDC((HWND
) wnd
);
5315 // the_font.UseResource();
5316 // the_font.RealizeResource();
5317 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5319 was
= (HFONT
) SelectObject(dc
,fnt
);
5321 GetTextMetrics(dc
, &tm
);
5324 SelectObject(dc
,was
);
5326 ReleaseDC((HWND
)wnd
, dc
);
5329 *x
= tm
.tmAveCharWidth
;
5331 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5333 // the_font.ReleaseResource();
5336 // use the "extended" bit (24) of lParam to distinguish extended keys
5337 // from normal keys as the same key is sent
5339 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5341 // except that if lParam is 0, it means we don't have real lParam from
5342 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5343 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5344 // non-numpad (hence extended) key as this is a more common case
5345 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5348 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5349 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5350 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
5355 case VK_CANCEL
: id
= WXK_CANCEL
; break;
5356 case VK_BACK
: id
= WXK_BACK
; break;
5357 case VK_TAB
: id
= WXK_TAB
; break;
5358 case VK_CLEAR
: id
= WXK_CLEAR
; break;
5359 case VK_SHIFT
: id
= WXK_SHIFT
; break;
5360 case VK_CONTROL
: id
= WXK_CONTROL
; break;
5361 case VK_MENU
: id
= WXK_ALT
; break;
5362 case VK_PAUSE
: id
= WXK_PAUSE
; break;
5363 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
5364 case VK_SPACE
: id
= WXK_SPACE
; break;
5365 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
5366 case VK_SELECT
: id
= WXK_SELECT
; break;
5367 case VK_PRINT
: id
= WXK_PRINT
; break;
5368 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
5369 case VK_HELP
: id
= WXK_HELP
; break;
5370 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
5371 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
5372 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
5373 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
5374 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
5375 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
5376 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
5377 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
5378 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
5379 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
5380 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
5381 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
5382 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
5383 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
5384 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
5385 case VK_F1
: id
= WXK_F1
; break;
5386 case VK_F2
: id
= WXK_F2
; break;
5387 case VK_F3
: id
= WXK_F3
; break;
5388 case VK_F4
: id
= WXK_F4
; break;
5389 case VK_F5
: id
= WXK_F5
; break;
5390 case VK_F6
: id
= WXK_F6
; break;
5391 case VK_F7
: id
= WXK_F7
; break;
5392 case VK_F8
: id
= WXK_F8
; break;
5393 case VK_F9
: id
= WXK_F9
; break;
5394 case VK_F10
: id
= WXK_F10
; break;
5395 case VK_F11
: id
= WXK_F11
; break;
5396 case VK_F12
: id
= WXK_F12
; break;
5397 case VK_F13
: id
= WXK_F13
; break;
5398 case VK_F14
: id
= WXK_F14
; break;
5399 case VK_F15
: id
= WXK_F15
; break;
5400 case VK_F16
: id
= WXK_F16
; break;
5401 case VK_F17
: id
= WXK_F17
; break;
5402 case VK_F18
: id
= WXK_F18
; break;
5403 case VK_F19
: id
= WXK_F19
; break;
5404 case VK_F20
: id
= WXK_F20
; break;
5405 case VK_F21
: id
= WXK_F21
; break;
5406 case VK_F22
: id
= WXK_F22
; break;
5407 case VK_F23
: id
= WXK_F23
; break;
5408 case VK_F24
: id
= WXK_F24
; break;
5409 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
5410 case VK_SCROLL
: id
= WXK_SCROLL
; break;
5412 // the mapping for these keys may be incorrect on non-US keyboards so
5413 // maybe we shouldn't map them to ASCII values at all
5414 case VK_OEM_1
: id
= ';'; break;
5415 case VK_OEM_PLUS
: id
= '+'; break;
5416 case VK_OEM_COMMA
: id
= ','; break;
5417 case VK_OEM_MINUS
: id
= '-'; break;
5418 case VK_OEM_PERIOD
: id
= '.'; break;
5419 case VK_OEM_2
: id
= '/'; break;
5420 case VK_OEM_3
: id
= '~'; break;
5421 case VK_OEM_4
: id
= '['; break;
5422 case VK_OEM_5
: id
= '\\'; break;
5423 case VK_OEM_6
: id
= ']'; break;
5424 case VK_OEM_7
: id
= '\''; break;
5427 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
5428 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
5429 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
5430 #endif // VK_APPS defined
5432 // handle extended keys
5434 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5437 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
5440 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
5443 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
5446 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
5449 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
5452 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
5455 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
5458 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
5461 id
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
5464 // don't use ChooseNormalOrExtended() here as the keys are reversed
5465 // here: numpad enter is the extended one
5466 id
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5476 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5482 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5483 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5484 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5485 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5486 case WXK_ALT
: keySym
= VK_MENU
; break;
5487 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5488 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5489 case WXK_PAGEUP
: keySym
= VK_PRIOR
; break;
5490 case WXK_PAGEDOWN
: keySym
= VK_NEXT
; break;
5491 case WXK_END
: keySym
= VK_END
; break;
5492 case WXK_HOME
: keySym
= VK_HOME
; break;
5493 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5494 case WXK_UP
: keySym
= VK_UP
; break;
5495 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5496 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5497 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5498 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5499 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5500 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5501 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5502 case WXK_HELP
: keySym
= VK_HELP
; break;
5503 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5504 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5505 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5506 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5507 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5508 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5509 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5510 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5511 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5512 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5513 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5514 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5515 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5516 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5517 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5518 case WXK_F1
: keySym
= VK_F1
; break;
5519 case WXK_F2
: keySym
= VK_F2
; break;
5520 case WXK_F3
: keySym
= VK_F3
; break;
5521 case WXK_F4
: keySym
= VK_F4
; break;
5522 case WXK_F5
: keySym
= VK_F5
; break;
5523 case WXK_F6
: keySym
= VK_F6
; break;
5524 case WXK_F7
: keySym
= VK_F7
; break;
5525 case WXK_F8
: keySym
= VK_F8
; break;
5526 case WXK_F9
: keySym
= VK_F9
; break;
5527 case WXK_F10
: keySym
= VK_F10
; break;
5528 case WXK_F11
: keySym
= VK_F11
; break;
5529 case WXK_F12
: keySym
= VK_F12
; break;
5530 case WXK_F13
: keySym
= VK_F13
; break;
5531 case WXK_F14
: keySym
= VK_F14
; break;
5532 case WXK_F15
: keySym
= VK_F15
; break;
5533 case WXK_F16
: keySym
= VK_F16
; break;
5534 case WXK_F17
: keySym
= VK_F17
; break;
5535 case WXK_F18
: keySym
= VK_F18
; break;
5536 case WXK_F19
: keySym
= VK_F19
; break;
5537 case WXK_F20
: keySym
= VK_F20
; break;
5538 case WXK_F21
: keySym
= VK_F21
; break;
5539 case WXK_F22
: keySym
= VK_F22
; break;
5540 case WXK_F23
: keySym
= VK_F23
; break;
5541 case WXK_F24
: keySym
= VK_F24
; break;
5542 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5543 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5554 bool wxGetKeyState(wxKeyCode key
)
5558 wxASSERT_MSG(key
!= WXK_LBUTTON
&& key
!= WXK_RBUTTON
&& key
!=
5559 WXK_MBUTTON
, wxT("can't use wxGetKeyState() for mouse buttons"));
5561 //High order with GetAsyncKeyState only available on WIN32
5563 //If the requested key is a LED key, return
5564 //true if the led is pressed
5565 if (key
== WXK_NUMLOCK
||
5566 key
== WXK_CAPITAL
||
5570 //low order bit means LED is highlighted,
5571 //high order means key is down
5572 //Here, for compat with other ports we want both
5573 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5580 //low order bit means key pressed since last call
5581 //high order means key is down
5582 //We want only the high order bit - the key may not be down if only low order
5583 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5589 wxMouseState
wxGetMouseState()
5593 GetCursorPos( &pt
);
5597 ms
.SetLeftDown( (GetAsyncKeyState(VK_LBUTTON
) & (1<<15)) != 0 );
5598 ms
.SetMiddleDown( (GetAsyncKeyState(VK_MBUTTON
) & (1<<15)) != 0 );
5599 ms
.SetRightDown( (GetAsyncKeyState(VK_RBUTTON
) & (1<<15)) != 0 );
5601 ms
.SetControlDown( (GetAsyncKeyState(VK_CONTROL
) & (1<<15)) != 0 );
5602 ms
.SetShiftDown( (GetAsyncKeyState(VK_SHIFT
) & (1<<15)) != 0 );
5603 ms
.SetAltDown( (GetAsyncKeyState(VK_MENU
) & (1<<15)) != 0 );
5604 // ms.SetMetaDown();
5610 wxWindow
*wxGetActiveWindow()
5612 HWND hWnd
= GetActiveWindow();
5615 return wxFindWinFromHandle((WXHWND
) hWnd
);
5620 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5622 HWND hwnd
= (HWND
)hWnd
;
5624 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5625 // by code in msw/radiobox.cpp), for all the others we just search up the
5627 wxWindow
*win
= (wxWindow
*)NULL
;
5630 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5634 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5635 // wxWindow class which overrides WM_GETDLGCODE processing to
5636 // do it as well, win would be already non NULL
5637 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5639 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5641 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5642 #endif // wxUSE_RADIOBOX
5644 // spin control text buddy window should be mapped to spin ctrl
5645 // itself so try it too
5646 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5649 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5651 #endif // wxUSE_SPINCTRL
5655 while ( hwnd
&& !win
)
5657 // this is a really ugly hack needed to avoid mistakenly returning the
5658 // parent frame wxWindow for the find/replace modeless dialog HWND -
5659 // this, in turn, is needed to call IsDialogMessage() from
5660 // wxApp::ProcessMessage() as for this we must return NULL from here
5662 // FIXME: this is clearly not the best way to do it but I think we'll
5663 // need to change HWND <-> wxWindow code more heavily than I can
5664 // do it now to fix it
5665 #ifndef __WXMICROWIN__
5666 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5668 // it's a dialog box, don't go upwards
5673 hwnd
= ::GetParent(hwnd
);
5674 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5680 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5682 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5683 // in active frames and dialogs, regardless of where the focus is.
5684 static HHOOK wxTheKeyboardHook
= 0;
5685 static FARPROC wxTheKeyboardHookProc
= 0;
5686 int APIENTRY _EXPORT
5687 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5689 void wxSetKeyboardHook(bool doIt
)
5693 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5694 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5696 GetCurrentThreadId()
5697 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5702 UnhookWindowsHookEx(wxTheKeyboardHook
);
5706 int APIENTRY _EXPORT
5707 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5709 DWORD hiWord
= HIWORD(lParam
);
5710 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5712 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5715 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5716 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5717 event
.m_altDown
= true;
5719 event
.SetEventObject(NULL
);
5720 event
.m_keyCode
= id
;
5721 event
.m_shiftDown
= wxIsShiftDown();
5722 event
.m_controlDown
= wxIsCtrlDown();
5724 event
.SetTimestamp(::GetMessageTime());
5726 wxWindow
*win
= wxGetActiveWindow();
5727 wxEvtHandler
*handler
;
5730 handler
= win
->GetEventHandler();
5731 event
.SetId(win
->GetId());
5736 event
.SetId(wxID_ANY
);
5739 if ( handler
&& handler
->ProcessEvent(event
) )
5747 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5750 #endif // !__WXMICROWIN__
5753 const wxChar
*wxGetMessageName(int message
)
5757 case 0x0000: return wxT("WM_NULL");
5758 case 0x0001: return wxT("WM_CREATE");
5759 case 0x0002: return wxT("WM_DESTROY");
5760 case 0x0003: return wxT("WM_MOVE");
5761 case 0x0005: return wxT("WM_SIZE");
5762 case 0x0006: return wxT("WM_ACTIVATE");
5763 case 0x0007: return wxT("WM_SETFOCUS");
5764 case 0x0008: return wxT("WM_KILLFOCUS");
5765 case 0x000A: return wxT("WM_ENABLE");
5766 case 0x000B: return wxT("WM_SETREDRAW");
5767 case 0x000C: return wxT("WM_SETTEXT");
5768 case 0x000D: return wxT("WM_GETTEXT");
5769 case 0x000E: return wxT("WM_GETTEXTLENGTH");
5770 case 0x000F: return wxT("WM_PAINT");
5771 case 0x0010: return wxT("WM_CLOSE");
5772 case 0x0011: return wxT("WM_QUERYENDSESSION");
5773 case 0x0012: return wxT("WM_QUIT");
5774 case 0x0013: return wxT("WM_QUERYOPEN");
5775 case 0x0014: return wxT("WM_ERASEBKGND");
5776 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
5777 case 0x0016: return wxT("WM_ENDSESSION");
5778 case 0x0017: return wxT("WM_SYSTEMERROR");
5779 case 0x0018: return wxT("WM_SHOWWINDOW");
5780 case 0x0019: return wxT("WM_CTLCOLOR");
5781 case 0x001A: return wxT("WM_WININICHANGE");
5782 case 0x001B: return wxT("WM_DEVMODECHANGE");
5783 case 0x001C: return wxT("WM_ACTIVATEAPP");
5784 case 0x001D: return wxT("WM_FONTCHANGE");
5785 case 0x001E: return wxT("WM_TIMECHANGE");
5786 case 0x001F: return wxT("WM_CANCELMODE");
5787 case 0x0020: return wxT("WM_SETCURSOR");
5788 case 0x0021: return wxT("WM_MOUSEACTIVATE");
5789 case 0x0022: return wxT("WM_CHILDACTIVATE");
5790 case 0x0023: return wxT("WM_QUEUESYNC");
5791 case 0x0024: return wxT("WM_GETMINMAXINFO");
5792 case 0x0026: return wxT("WM_PAINTICON");
5793 case 0x0027: return wxT("WM_ICONERASEBKGND");
5794 case 0x0028: return wxT("WM_NEXTDLGCTL");
5795 case 0x002A: return wxT("WM_SPOOLERSTATUS");
5796 case 0x002B: return wxT("WM_DRAWITEM");
5797 case 0x002C: return wxT("WM_MEASUREITEM");
5798 case 0x002D: return wxT("WM_DELETEITEM");
5799 case 0x002E: return wxT("WM_VKEYTOITEM");
5800 case 0x002F: return wxT("WM_CHARTOITEM");
5801 case 0x0030: return wxT("WM_SETFONT");
5802 case 0x0031: return wxT("WM_GETFONT");
5803 case 0x0037: return wxT("WM_QUERYDRAGICON");
5804 case 0x0039: return wxT("WM_COMPAREITEM");
5805 case 0x0041: return wxT("WM_COMPACTING");
5806 case 0x0044: return wxT("WM_COMMNOTIFY");
5807 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
5808 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
5809 case 0x0048: return wxT("WM_POWER");
5811 case 0x004A: return wxT("WM_COPYDATA");
5812 case 0x004B: return wxT("WM_CANCELJOURNAL");
5813 case 0x004E: return wxT("WM_NOTIFY");
5814 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
5815 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
5816 case 0x0052: return wxT("WM_TCARD");
5817 case 0x0053: return wxT("WM_HELP");
5818 case 0x0054: return wxT("WM_USERCHANGED");
5819 case 0x0055: return wxT("WM_NOTIFYFORMAT");
5820 case 0x007B: return wxT("WM_CONTEXTMENU");
5821 case 0x007C: return wxT("WM_STYLECHANGING");
5822 case 0x007D: return wxT("WM_STYLECHANGED");
5823 case 0x007E: return wxT("WM_DISPLAYCHANGE");
5824 case 0x007F: return wxT("WM_GETICON");
5825 case 0x0080: return wxT("WM_SETICON");
5827 case 0x0081: return wxT("WM_NCCREATE");
5828 case 0x0082: return wxT("WM_NCDESTROY");
5829 case 0x0083: return wxT("WM_NCCALCSIZE");
5830 case 0x0084: return wxT("WM_NCHITTEST");
5831 case 0x0085: return wxT("WM_NCPAINT");
5832 case 0x0086: return wxT("WM_NCACTIVATE");
5833 case 0x0087: return wxT("WM_GETDLGCODE");
5834 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
5835 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
5836 case 0x00A2: return wxT("WM_NCLBUTTONUP");
5837 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
5838 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
5839 case 0x00A5: return wxT("WM_NCRBUTTONUP");
5840 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
5841 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
5842 case 0x00A8: return wxT("WM_NCMBUTTONUP");
5843 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
5844 case 0x0100: return wxT("WM_KEYDOWN");
5845 case 0x0101: return wxT("WM_KEYUP");
5846 case 0x0102: return wxT("WM_CHAR");
5847 case 0x0103: return wxT("WM_DEADCHAR");
5848 case 0x0104: return wxT("WM_SYSKEYDOWN");
5849 case 0x0105: return wxT("WM_SYSKEYUP");
5850 case 0x0106: return wxT("WM_SYSCHAR");
5851 case 0x0107: return wxT("WM_SYSDEADCHAR");
5852 case 0x0108: return wxT("WM_KEYLAST");
5854 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
5855 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
5856 case 0x010F: return wxT("WM_IME_COMPOSITION");
5858 case 0x0110: return wxT("WM_INITDIALOG");
5859 case 0x0111: return wxT("WM_COMMAND");
5860 case 0x0112: return wxT("WM_SYSCOMMAND");
5861 case 0x0113: return wxT("WM_TIMER");
5862 case 0x0114: return wxT("WM_HSCROLL");
5863 case 0x0115: return wxT("WM_VSCROLL");
5864 case 0x0116: return wxT("WM_INITMENU");
5865 case 0x0117: return wxT("WM_INITMENUPOPUP");
5866 case 0x011F: return wxT("WM_MENUSELECT");
5867 case 0x0120: return wxT("WM_MENUCHAR");
5868 case 0x0121: return wxT("WM_ENTERIDLE");
5869 case 0x0200: return wxT("WM_MOUSEMOVE");
5870 case 0x0201: return wxT("WM_LBUTTONDOWN");
5871 case 0x0202: return wxT("WM_LBUTTONUP");
5872 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
5873 case 0x0204: return wxT("WM_RBUTTONDOWN");
5874 case 0x0205: return wxT("WM_RBUTTONUP");
5875 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
5876 case 0x0207: return wxT("WM_MBUTTONDOWN");
5877 case 0x0208: return wxT("WM_MBUTTONUP");
5878 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
5879 case 0x020A: return wxT("WM_MOUSEWHEEL");
5880 case 0x0210: return wxT("WM_PARENTNOTIFY");
5881 case 0x0211: return wxT("WM_ENTERMENULOOP");
5882 case 0x0212: return wxT("WM_EXITMENULOOP");
5884 case 0x0213: return wxT("WM_NEXTMENU");
5885 case 0x0214: return wxT("WM_SIZING");
5886 case 0x0215: return wxT("WM_CAPTURECHANGED");
5887 case 0x0216: return wxT("WM_MOVING");
5888 case 0x0218: return wxT("WM_POWERBROADCAST");
5889 case 0x0219: return wxT("WM_DEVICECHANGE");
5891 case 0x0220: return wxT("WM_MDICREATE");
5892 case 0x0221: return wxT("WM_MDIDESTROY");
5893 case 0x0222: return wxT("WM_MDIACTIVATE");
5894 case 0x0223: return wxT("WM_MDIRESTORE");
5895 case 0x0224: return wxT("WM_MDINEXT");
5896 case 0x0225: return wxT("WM_MDIMAXIMIZE");
5897 case 0x0226: return wxT("WM_MDITILE");
5898 case 0x0227: return wxT("WM_MDICASCADE");
5899 case 0x0228: return wxT("WM_MDIICONARRANGE");
5900 case 0x0229: return wxT("WM_MDIGETACTIVE");
5901 case 0x0230: return wxT("WM_MDISETMENU");
5902 case 0x0233: return wxT("WM_DROPFILES");
5904 case 0x0281: return wxT("WM_IME_SETCONTEXT");
5905 case 0x0282: return wxT("WM_IME_NOTIFY");
5906 case 0x0283: return wxT("WM_IME_CONTROL");
5907 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
5908 case 0x0285: return wxT("WM_IME_SELECT");
5909 case 0x0286: return wxT("WM_IME_CHAR");
5910 case 0x0290: return wxT("WM_IME_KEYDOWN");
5911 case 0x0291: return wxT("WM_IME_KEYUP");
5913 case 0x0300: return wxT("WM_CUT");
5914 case 0x0301: return wxT("WM_COPY");
5915 case 0x0302: return wxT("WM_PASTE");
5916 case 0x0303: return wxT("WM_CLEAR");
5917 case 0x0304: return wxT("WM_UNDO");
5918 case 0x0305: return wxT("WM_RENDERFORMAT");
5919 case 0x0306: return wxT("WM_RENDERALLFORMATS");
5920 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
5921 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
5922 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
5923 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
5924 case 0x030B: return wxT("WM_SIZECLIPBOARD");
5925 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
5926 case 0x030D: return wxT("WM_CHANGECBCHAIN");
5927 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
5928 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
5929 case 0x0310: return wxT("WM_PALETTEISCHANGING");
5930 case 0x0311: return wxT("WM_PALETTECHANGED");
5932 case 0x0312: return wxT("WM_HOTKEY");
5935 // common controls messages - although they're not strictly speaking
5936 // standard, it's nice to decode them nevertheless
5939 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
5940 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
5941 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
5942 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
5943 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
5944 case 0x1000 + 5: return wxT("LVM_GETITEMA");
5945 case 0x1000 + 75: return wxT("LVM_GETITEMW");
5946 case 0x1000 + 6: return wxT("LVM_SETITEMA");
5947 case 0x1000 + 76: return wxT("LVM_SETITEMW");
5948 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
5949 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
5950 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
5951 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
5952 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
5953 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
5954 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
5955 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
5956 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
5957 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
5958 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
5959 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
5960 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
5961 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
5962 case 0x1000 + 18: return wxT("LVM_HITTEST");
5963 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
5964 case 0x1000 + 20: return wxT("LVM_SCROLL");
5965 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
5966 case 0x1000 + 22: return wxT("LVM_ARRANGE");
5967 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
5968 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
5969 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
5970 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
5971 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
5972 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
5973 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
5974 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
5975 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
5976 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
5977 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
5978 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
5979 case 0x1000 + 31: return wxT("LVM_GETHEADER");
5980 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
5981 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
5982 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
5983 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
5984 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
5985 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
5986 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
5987 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
5988 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
5989 case 0x1000 + 42: return wxT("LVM_UPDATE");
5990 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
5991 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
5992 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
5993 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
5994 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
5995 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
5996 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
5997 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
5998 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
5999 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6000 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6001 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6002 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6003 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6004 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6005 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6006 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6007 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6008 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6009 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6010 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6011 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6012 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6013 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6014 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6015 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6018 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6019 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6020 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6021 case 0x1100 + 2: return wxT("TVM_EXPAND");
6022 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6023 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6024 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6025 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6026 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6027 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6028 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6029 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6030 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6031 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6032 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6033 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6034 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6035 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6036 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6037 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6038 case 0x1100 + 17: return wxT("TVM_HITTEST");
6039 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6040 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6041 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6042 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6043 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6044 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6045 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6046 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6047 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6050 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6051 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6052 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6053 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6054 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6055 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6056 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6057 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6058 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6059 case 0x1200 + 6: return wxT("HDM_HITTEST");
6060 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6061 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6062 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6063 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6064 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6065 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6066 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6067 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6070 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6071 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6072 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6073 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6074 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6075 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6076 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6077 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6078 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6079 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6080 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6081 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6082 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6083 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6084 case 0x1300 + 13: return wxT("TCM_HITTEST");
6085 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6086 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6087 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6088 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6089 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6090 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6091 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6092 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6093 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6094 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6095 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6096 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6099 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6100 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6101 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6102 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6103 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6104 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6105 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6106 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6107 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6108 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6109 case WM_USER
+17: return wxT("TB_SETSTATE");
6110 case WM_USER
+18: return wxT("TB_GETSTATE");
6111 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6112 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6113 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6114 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6115 case WM_USER
+23: return wxT("TB_GETBUTTON");
6116 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6117 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6118 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6119 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6120 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6121 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6122 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6123 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6124 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6125 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6126 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6127 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6128 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6129 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6130 case WM_USER
+37: return wxT("TB_SETPARENT");
6131 case WM_USER
+39: return wxT("TB_SETROWS");
6132 case WM_USER
+40: return wxT("TB_GETROWS");
6133 case WM_USER
+42: return wxT("TB_SETCMDID");
6134 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6135 case WM_USER
+44: return wxT("TB_GETBITMAP");
6136 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6137 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6138 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6139 case WM_USER
+47: return wxT("TB_SETINDENT");
6140 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6141 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6142 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6143 case WM_USER
+51: return wxT("TB_GETRECT");
6144 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6145 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6146 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6147 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6148 case WM_USER
+56: return wxT("TB_SETSTYLE");
6149 case WM_USER
+57: return wxT("TB_GETSTYLE");
6150 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6151 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6152 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6153 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6154 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6157 static wxString s_szBuf
;
6158 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6159 return s_szBuf
.c_str();
6162 #endif //__WXDEBUG__
6164 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6168 HWND hwnd
= GetHwndOf(win
);
6169 HDC hdc
= ::GetDC(hwnd
);
6171 #if !wxDIALOG_UNIT_COMPATIBILITY
6172 // and select the current font into it
6173 HFONT hfont
= GetHfontOf(win
->GetFont());
6176 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6180 // finally retrieve the text metrics from it
6181 GetTextMetrics(hdc
, &tm
);
6183 #if !wxDIALOG_UNIT_COMPATIBILITY
6187 (void)::SelectObject(hdc
, hfont
);
6191 ::ReleaseDC(hwnd
, hdc
);
6196 // Find the wxWindow at the current mouse position, returning the mouse
6198 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6200 pt
= wxGetMousePosition();
6201 return wxFindWindowAtPoint(pt
);
6204 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6209 HWND hWndHit
= ::WindowFromPoint(pt2
);
6211 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
6212 HWND hWnd
= hWndHit
;
6214 // Try to find a window with a wxWindow associated with it
6215 while (!win
&& (hWnd
!= 0))
6217 hWnd
= ::GetParent(hWnd
);
6218 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
6223 // Get the current mouse position.
6224 wxPoint
wxGetMousePosition()
6228 GetCursorPosWinCE(&pt
);
6230 GetCursorPos( & pt
);
6233 return wxPoint(pt
.x
, pt
.y
);
6238 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6239 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6241 // Register hotkeys for the hardware buttons
6243 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6245 UnregisterFunc1Proc procUnregisterFunc
;
6246 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6249 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6250 if (procUnregisterFunc
)
6251 procUnregisterFunc(modifiers
, id
);
6252 FreeLibrary(hCoreDll
);
6257 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6259 UINT win_modifiers
=0;
6260 if ( modifiers
& wxMOD_ALT
)
6261 win_modifiers
|= MOD_ALT
;
6262 if ( modifiers
& wxMOD_SHIFT
)
6263 win_modifiers
|= MOD_SHIFT
;
6264 if ( modifiers
& wxMOD_CONTROL
)
6265 win_modifiers
|= MOD_CONTROL
;
6266 if ( modifiers
& wxMOD_WIN
)
6267 win_modifiers
|= MOD_WIN
;
6269 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6270 // Required for PPC and Smartphone hardware buttons
6271 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6272 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6275 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6277 wxLogLastError(_T("RegisterHotKey"));
6285 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6287 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6288 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6291 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6293 wxLogLastError(_T("UnregisterHotKey"));
6303 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6305 int hotkeyId
= wParam
;
6306 int virtualKey
= HIWORD(lParam
);
6307 int win_modifiers
= LOWORD(lParam
);
6309 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6310 event
.SetId(hotkeyId
);
6311 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6312 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6313 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6314 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6316 return GetEventHandler()->ProcessEvent(event
);
6319 #endif // wxUSE_ACCEL
6321 #endif // wxUSE_HOTKEY
6323 // Not tested under WinCE
6326 // this class installs a message hook which really wakes up our idle processing
6327 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6328 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6329 // being dragged or even inside ::MessageBox()) and so don't control message
6330 // dispatching otherwise
6331 class wxIdleWakeUpModule
: public wxModule
6334 virtual bool OnInit()
6336 ms_hMsgHookProc
= ::SetWindowsHookEx
6339 &wxIdleWakeUpModule::MsgHookProc
,
6341 GetCurrentThreadId()
6344 if ( !ms_hMsgHookProc
)
6346 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6354 virtual void OnExit()
6356 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
6359 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6361 MSG
*msg
= (MSG
*)lParam
;
6363 // only process the message if it is actually going to be removed from
6364 // the message queue, this prevents that the same event from being
6365 // processed multiple times if now someone just called PeekMessage()
6366 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
6368 wxTheApp
->ProcessPendingEvents();
6371 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
6375 static HHOOK ms_hMsgHookProc
;
6377 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
6380 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
6382 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
6384 #endif // __WXWINCE__
6389 static void wxAdjustZOrder(wxWindow
* parent
)
6391 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
6393 // Set the z-order correctly
6394 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
6397 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
6400 wxWindow
*childWin
= current
->GetData();
6401 wxAdjustZOrder(childWin
);
6402 current
= current
->GetNext();
6407 // We need to adjust the z-order of static boxes in WinCE, to
6408 // make 'contained' controls visible
6409 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
6412 wxAdjustZOrder(this);