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"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
56 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
60 #include "wx/evtloop.h"
62 #include "wx/sysopt.h"
64 #if wxUSE_DRAG_AND_DROP
68 #if wxUSE_ACCESSIBILITY
69 #include "wx/access.h"
73 #define WM_GETOBJECT 0x003D
76 #define OBJID_CLIENT 0xFFFFFFFC
80 #include "wx/msw/private.h"
83 #include "wx/tooltip.h"
91 #include "wx/spinctrl.h"
92 #endif // wxUSE_SPINCTRL
94 #include "wx/notebook.h"
95 #include "wx/listctrl.h"
99 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
100 #include <shellapi.h>
101 #include <mmsystem.h>
105 #include <windowsx.h>
108 #if !defined __WXWINCE__ && !defined NEED_PBT_H
112 #if defined(__WXWINCE__)
113 #include "wx/msw/wince/missing.h"
116 #include <shellapi.h>
118 #include <aygshell.h>
122 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE)
123 #define HAVE_TRACKMOUSEEVENT
124 #endif // everything needed for TrackMouseEvent()
126 // if this is set to 1, we use deferred window sizing to reduce flicker when
127 // resizing complicated window hierarchies, but this can in theory result in
128 // different behaviour than the old code so we keep the possibility to use it
129 // by setting this to 0 (in the future this should be removed completely)
131 #define USE_DEFERRED_SIZING 0
133 #define USE_DEFERRED_SIZING 1
136 // set this to 1 to filter out duplicate mouse events, e.g. mouse move events
137 // when mouse position didnd't change
139 #define wxUSE_MOUSEEVENT_HACK 0
141 #define wxUSE_MOUSEEVENT_HACK 1
144 // ---------------------------------------------------------------------------
146 // ---------------------------------------------------------------------------
148 #if wxUSE_MENUS_NATIVE
149 wxMenu
*wxCurrentPopupMenu
= NULL
;
150 #endif // wxUSE_MENUS_NATIVE
153 extern wxChar
*wxCanvasClassName
;
155 extern const wxChar
*wxCanvasClassName
;
158 // true if we had already created the std colour map, used by
159 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
160 static bool gs_hasStdCmap
= false;
162 // last mouse event information we need to filter out the duplicates
163 #if wxUSE_MOUSEEVENT_HACK
164 static struct MouseEventInfoDummy
166 // mouse position (in screen coordinates)
169 // last mouse event type
172 #endif // wxUSE_MOUSEEVENT_HACK
174 // ---------------------------------------------------------------------------
176 // ---------------------------------------------------------------------------
178 // the window proc for all our windows
179 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
180 WPARAM wParam
, LPARAM lParam
);
184 const wxChar
*wxGetMessageName(int message
);
187 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
188 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
189 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
191 // get the text metrics for the current font
192 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
195 // find the window for the mouse event at the specified position
196 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
);
197 #endif // __WXWINCE__
199 // wrapper around BringWindowToTop() API
200 static inline void wxBringWindowToTop(HWND hwnd
)
202 #ifdef __WXMICROWIN__
203 // It seems that MicroWindows brings the _parent_ of the window to the top,
204 // which can be the wrong one.
206 // activate (set focus to) specified window
210 // raise top level parent to top of z order
211 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
213 wxLogLastError(_T("SetWindowPos"));
219 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
220 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
223 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
224 parent as well as otherwise several Win32 functions using
225 GetNextDlgTabItem() to iterate over all controls such as
226 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
227 all of them iterate over all the controls starting from the currently
228 focused one and stop iterating when they get back to the focus but
229 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
230 get back to the initial (focused) window: as we do have this style,
231 GetNextDlgTabItem() will leave this window and continue in its parent,
232 but if the parent doesn't have it, it wouldn't recurse inside it later
233 on and so wouldn't have a chance of getting back to this window either.
235 while ( parent
&& !parent
->IsTopLevel() )
237 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
238 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
240 // force the parent to have this style
241 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
242 exStyle
| WS_EX_CONTROLPARENT
);
245 parent
= parent
->GetParent();
249 #endif // !__WXWINCE__
252 // On Windows CE, GetCursorPos can return an error, so use this function
254 bool GetCursorPosWinCE(POINT
* pt
)
256 if (!GetCursorPos(pt
))
258 DWORD pos
= GetMessagePos();
266 // ---------------------------------------------------------------------------
268 // ---------------------------------------------------------------------------
270 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
272 #ifdef __WXUNIVERSAL__
273 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
275 #if wxUSE_EXTENDED_RTTI
277 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
278 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
279 // windows with negative ids never can be recreated anyway
281 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
283 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
284 if ( win
&& win
->GetId() < 0 )
289 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
291 // make wxWindowList known before the property is used
293 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
295 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
297 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
300 WX_DEFINE_FLAGS( wxWindowStyle
)
302 wxBEGIN_FLAGS( wxWindowStyle
)
303 // new style border flags, we put them first to
304 // use them for streaming out
306 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
307 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
308 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
309 wxFLAGS_MEMBER(wxBORDER_RAISED
)
310 wxFLAGS_MEMBER(wxBORDER_STATIC
)
311 wxFLAGS_MEMBER(wxBORDER_NONE
)
313 // old style border flags
314 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
315 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
316 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
317 wxFLAGS_MEMBER(wxRAISED_BORDER
)
318 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
319 wxFLAGS_MEMBER(wxBORDER
)
321 // standard window styles
322 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
323 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
324 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
325 wxFLAGS_MEMBER(wxWANTS_CHARS
)
326 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
327 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
328 wxFLAGS_MEMBER(wxVSCROLL
)
329 wxFLAGS_MEMBER(wxHSCROLL
)
331 wxEND_FLAGS( wxWindowStyle
)
333 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
334 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
335 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
336 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
337 // Always constructor Properties first
339 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
340 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
341 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
342 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
343 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
345 // Then all relations of the object graph
347 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
349 // and finally all other properties
351 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
352 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
353 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
354 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
355 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
357 // possible property candidates (not in xrc) or not valid in all subclasses
358 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
359 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
360 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
361 // MaxHeight, Width , MinHeight , Width
362 // TODO switch label to control and title to toplevels
364 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
365 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
366 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
367 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
372 wxEND_PROPERTIES_TABLE()
374 wxBEGIN_HANDLERS_TABLE(wxWindow
)
375 wxEND_HANDLERS_TABLE()
377 wxCONSTRUCTOR_DUMMY(wxWindow
)
380 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
382 #endif // __WXUNIVERSAL__/__WXMSW__
384 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
385 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
386 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
388 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
392 // ===========================================================================
394 // ===========================================================================
396 // ---------------------------------------------------------------------------
397 // wxWindow utility functions
398 // ---------------------------------------------------------------------------
400 // Find an item given the MS Windows id
401 wxWindow
*wxWindowMSW::FindItem(long id
) const
404 wxControl
*item
= wxDynamicCastThis(wxControl
);
407 // is it us or one of our "internal" children?
408 if ( item
->GetId() == id
409 #ifndef __WXUNIVERSAL__
410 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
411 #endif // __WXUNIVERSAL__
417 #endif // wxUSE_CONTROLS
419 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
422 wxWindow
*childWin
= current
->GetData();
424 wxWindow
*wnd
= childWin
->FindItem(id
);
428 current
= current
->GetNext();
434 // Find an item given the MS Windows handle
435 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
437 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
440 wxWindow
*parent
= current
->GetData();
442 // Do a recursive search.
443 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
449 || parent
->IsKindOf(CLASSINFO(wxControl
))
450 #endif // wxUSE_CONTROLS
453 wxWindow
*item
= current
->GetData();
454 if ( item
->GetHWND() == hWnd
)
458 if ( item
->ContainsHWND(hWnd
) )
463 current
= current
->GetNext();
468 // Default command handler
469 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
474 // ----------------------------------------------------------------------------
475 // constructors and such
476 // ----------------------------------------------------------------------------
478 void wxWindowMSW::Init()
481 m_isBeingDeleted
= false;
483 m_mouseInWindow
= false;
484 m_lastKeydownProcessed
= false;
486 m_childrenDisabled
= NULL
;
495 m_pendingPosition
= wxDefaultPosition
;
496 m_pendingSize
= wxDefaultSize
;
499 m_contextMenuEnabled
= false;
504 wxWindowMSW::~wxWindowMSW()
506 m_isBeingDeleted
= true;
508 #ifndef __WXUNIVERSAL__
509 // VS: make sure there's no wxFrame with last focus set to us:
510 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
512 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
515 if ( frame
->GetLastFocus() == this )
517 frame
->SetLastFocus(NULL
);
520 // apparently sometimes we can end up with our grand parent
521 // pointing to us as well: this is surely a bug in focus handling
522 // code but it's not clear where it happens so for now just try to
523 // fix it here by not breaking out of the loop
527 #endif // __WXUNIVERSAL__
529 // VS: destroy children first and _then_ detach *this from its parent.
530 // If we did it the other way around, children wouldn't be able
531 // find their parent frame (see above).
536 // VZ: test temp removed to understand what really happens here
537 //if (::IsWindow(GetHwnd()))
539 if ( !::DestroyWindow(GetHwnd()) )
540 wxLogLastError(wxT("DestroyWindow"));
543 // remove hWnd <-> wxWindow association
544 wxRemoveHandleAssociation(this);
547 delete m_childrenDisabled
;
551 // real construction (Init() must have been called before!)
552 bool wxWindowMSW::Create(wxWindow
*parent
,
557 const wxString
& name
)
559 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
561 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
564 parent
->AddChild(this);
567 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
569 #ifdef __WXUNIVERSAL__
570 // no borders, we draw them ourselves
571 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
575 msflags
&= ~WS_BORDER
;
576 #endif // wxUniversal
580 msflags
|= WS_VISIBLE
;
583 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
591 // ---------------------------------------------------------------------------
593 // ---------------------------------------------------------------------------
595 void wxWindowMSW::SetFocus()
597 HWND hWnd
= GetHwnd();
598 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
600 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
604 if ( !::SetFocus(hWnd
) )
606 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
607 // was there really an error?
608 DWORD dwRes
= ::GetLastError();
611 HWND hwndFocus
= ::GetFocus();
612 if ( hwndFocus
!= hWnd
)
614 wxLogApiError(_T("SetFocus"), dwRes
);
621 void wxWindowMSW::SetFocusFromKbd()
623 // when the focus is given to the control with DLGC_HASSETSEL style from
624 // keyboard its contents should be entirely selected: this is what
625 // ::IsDialogMessage() does and so we should do it as well to provide the
626 // same LNF as the native programs
627 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
629 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
632 // do this after (maybe) setting the selection as like this when
633 // wxEVT_SET_FOCUS handler is called, the selection would have been already
634 // set correctly -- this may be important
635 wxWindowBase::SetFocusFromKbd();
638 // Get the window with the focus
639 wxWindow
*wxWindowBase::DoFindFocus()
641 HWND hWnd
= ::GetFocus();
644 return wxGetWindowFromHWND((WXHWND
)hWnd
);
650 bool wxWindowMSW::Enable(bool enable
)
652 if ( !wxWindowBase::Enable(enable
) )
655 HWND hWnd
= GetHwnd();
657 ::EnableWindow(hWnd
, (BOOL
)enable
);
659 // the logic below doesn't apply to the top level windows -- otherwise
660 // showing a modal dialog would result in total greying out (and ungreying
661 // out later) of everything which would be really ugly
665 // when the parent is disabled, all of its children should be disabled as
666 // well but when it is enabled back, only those of the children which
667 // hadn't been already disabled in the beginning should be enabled again,
668 // so we have to keep the list of those children
669 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
671 node
= node
->GetNext() )
673 wxWindow
*child
= node
->GetData();
674 if ( child
->IsTopLevel() )
676 // the logic below doesn't apply to top level children
682 // re-enable the child unless it had been disabled before us
683 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
686 else // we're being disabled
688 if ( child
->IsEnabled() )
690 // disable it as children shouldn't stay enabled while the
694 else // child already disabled, remember it
696 // have we created the list of disabled children already?
697 if ( !m_childrenDisabled
)
698 m_childrenDisabled
= new wxWindowList
;
700 m_childrenDisabled
->Append(child
);
705 if ( enable
&& m_childrenDisabled
)
707 // we don't need this list any more, don't keep unused memory
708 delete m_childrenDisabled
;
709 m_childrenDisabled
= NULL
;
715 bool wxWindowMSW::Show(bool show
)
717 if ( !wxWindowBase::Show(show
) )
720 HWND hWnd
= GetHwnd();
722 // we could be called before the underlying window is created (this is
723 // actually useful to prevent it from being initially shown), e.g.
725 // wxFoo *foo = new wxFoo;
727 // foo->Create(parent, ...);
729 // should work without errors
732 ::ShowWindow(hWnd
, show
? SW_SHOW
: SW_HIDE
);
738 // Raise the window to the top of the Z order
739 void wxWindowMSW::Raise()
741 wxBringWindowToTop(GetHwnd());
744 // Lower the window to the bottom of the Z order
745 void wxWindowMSW::Lower()
747 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
748 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
751 void wxWindowMSW::DoCaptureMouse()
753 HWND hWnd
= GetHwnd();
760 void wxWindowMSW::DoReleaseMouse()
762 if ( !::ReleaseCapture() )
764 wxLogLastError(_T("ReleaseCapture"));
768 /* static */ wxWindow
*wxWindowBase::GetCapture()
770 HWND hwnd
= ::GetCapture();
771 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
774 bool wxWindowMSW::SetFont(const wxFont
& font
)
776 if ( !wxWindowBase::SetFont(font
) )
782 HWND hWnd
= GetHwnd();
785 WXHANDLE hFont
= m_font
.GetResourceHandle();
787 wxASSERT_MSG( hFont
, wxT("should have valid font") );
789 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
794 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
796 if ( !wxWindowBase::SetCursor(cursor
) )
802 // don't "overwrite" busy cursor
803 if ( m_cursor
.Ok() && !wxIsBusy() )
805 ::SetCursor(GetHcursorOf(m_cursor
));
811 void wxWindowMSW::WarpPointer(int x
, int y
)
813 ClientToScreen(&x
, &y
);
815 if ( !::SetCursorPos(x
, y
) )
817 wxLogLastError(_T("SetCursorPos"));
821 void wxWindowMSW::MSWUpdateUIState(int action
, int state
)
823 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
824 // to use it on older systems -- and could possibly do some harm
825 static int s_needToUpdate
= -1;
826 if ( s_needToUpdate
== -1 )
829 s_needToUpdate
= wxGetOsVersion(&verMaj
, &verMin
) == wxOS_WINDOWS_NT
&&
833 if ( s_needToUpdate
)
835 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
836 // won't send WM_UPDATEUISTATE
837 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE
, MAKEWPARAM(action
, state
), 0);
841 // ---------------------------------------------------------------------------
843 // ---------------------------------------------------------------------------
845 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
847 #ifdef __WXMICROWIN__
848 return ::GetScrollPosWX(hWnd
, wOrient
);
850 WinStruct
<SCROLLINFO
> scrollInfo
;
851 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
852 scrollInfo
.fMask
= SIF_POS
;
853 ::GetScrollInfo(hWnd
, wOrient
, &scrollInfo
);
855 return scrollInfo
.nPos
;
860 int wxWindowMSW::GetScrollPos(int orient
) const
862 HWND hWnd
= GetHwnd();
863 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
865 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
868 // This now returns the whole range, not just the number
869 // of positions that we can scroll.
870 int wxWindowMSW::GetScrollRange(int orient
) const
873 HWND hWnd
= GetHwnd();
877 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
880 WinStruct
<SCROLLINFO
> scrollInfo
;
881 scrollInfo
.fMask
= SIF_RANGE
;
882 if ( !::GetScrollInfo(hWnd
,
883 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
886 // Most of the time this is not really an error, since the return
887 // value can also be zero when there is no scrollbar yet.
888 // wxLogLastError(_T("GetScrollInfo"));
890 maxPos
= scrollInfo
.nMax
;
892 // undo "range - 1" done in SetScrollbar()
896 int wxWindowMSW::GetScrollThumb(int orient
) const
898 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
901 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
903 HWND hWnd
= GetHwnd();
904 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
906 WinStruct
<SCROLLINFO
> info
;
910 info
.fMask
= SIF_POS
;
911 if ( HasFlag(wxALWAYS_SHOW_SB
) )
913 // disable scrollbar instead of removing it then
914 info
.fMask
|= SIF_DISABLENOSCROLL
;
917 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
921 // New function that will replace some of the above.
922 void wxWindowMSW::SetScrollbar(int orient
,
928 WinStruct
<SCROLLINFO
> info
;
929 info
.nPage
= pageSize
;
930 info
.nMin
= 0; // range is nMax - nMin + 1
931 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
933 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
934 if ( HasFlag(wxALWAYS_SHOW_SB
) )
936 // disable scrollbar instead of removing it then
937 info
.fMask
|= SIF_DISABLENOSCROLL
;
940 HWND hWnd
= GetHwnd();
943 // We have to set the variables here to make them valid in events
944 // triggered by ::SetScrollInfo()
945 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
947 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
952 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
958 rect
.left
= prect
->x
;
960 rect
.right
= prect
->x
+ prect
->width
;
961 rect
.bottom
= prect
->y
+ prect
->height
;
971 // FIXME: is this the exact equivalent of the line below?
972 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
974 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
978 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
980 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
983 for ( int n
= 0; n
< count
; n
++ )
985 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
987 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
990 // don't bother to continue, we're already at top/bottom
997 return pos
!= posStart
;
1000 bool wxWindowMSW::ScrollLines(int lines
)
1002 bool down
= lines
> 0;
1004 return ScrollVertically(GetHwnd(),
1005 down
? SB_LINEDOWN
: SB_LINEUP
,
1006 down
? lines
: -lines
);
1009 bool wxWindowMSW::ScrollPages(int pages
)
1011 bool down
= pages
> 0;
1013 return ScrollVertically(GetHwnd(),
1014 down
? SB_PAGEDOWN
: SB_PAGEUP
,
1015 down
? pages
: -pages
);
1018 // ----------------------------------------------------------------------------
1020 // ----------------------------------------------------------------------------
1022 void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir
)
1027 const HWND hwnd
= GetHwnd();
1028 wxCHECK_RET( hwnd
, _T("layout direction must be set after window creation") );
1030 LONG styleOld
= ::GetWindowLong(hwnd
, GWL_EXSTYLE
);
1032 LONG styleNew
= styleOld
;
1035 case wxLayout_LeftToRight
:
1036 styleNew
&= ~WS_EX_LAYOUTRTL
;
1039 case wxLayout_RightToLeft
:
1040 styleNew
|= WS_EX_LAYOUTRTL
;
1044 wxFAIL_MSG(_T("unsupported layout direction"));
1048 if ( styleNew
!= styleOld
)
1050 ::SetWindowLong(hwnd
, GWL_EXSTYLE
, styleNew
);
1055 wxLayoutDirection
wxWindowMSW::GetLayoutDirection() const
1058 return wxLayout_Default
;
1060 const HWND hwnd
= GetHwnd();
1061 wxCHECK_MSG( hwnd
, wxLayout_Default
, _T("invalid window") );
1063 return ::GetWindowLong(hwnd
, GWL_EXSTYLE
) & WS_EX_LAYOUTRTL
1064 ? wxLayout_RightToLeft
1065 : wxLayout_LeftToRight
;
1070 wxWindowMSW::AdjustForLayoutDirection(wxCoord x
,
1071 wxCoord
WXUNUSED(width
),
1072 wxCoord
WXUNUSED(widthTotal
)) const
1074 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1075 // redo it ourselves
1079 // ---------------------------------------------------------------------------
1081 // ---------------------------------------------------------------------------
1083 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
1085 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
1087 HWND hwnd
= (HWND
)hWnd
;
1088 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1090 wxAssociateWinWithHandle(hwnd
, this);
1092 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1094 // we don't need to subclass the window of our own class (in the Windows
1095 // sense of the word)
1096 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1098 wxSetWindowProc(hwnd
, wxWndProc
);
1102 // don't bother restoring it either: this also makes it easy to
1103 // implement IsOfStandardClass() method which returns true for the
1104 // standard controls and false for the wxWidgets own windows as it can
1105 // simply check m_oldWndProc
1106 m_oldWndProc
= NULL
;
1109 // we're officially created now, send the event
1110 wxWindowCreateEvent
event((wxWindow
*)this);
1111 (void)GetEventHandler()->ProcessEvent(event
);
1114 void wxWindowMSW::UnsubclassWin()
1116 wxRemoveHandleAssociation(this);
1118 // Restore old Window proc
1119 HWND hwnd
= GetHwnd();
1124 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1128 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1130 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1133 m_oldWndProc
= NULL
;
1138 void wxWindowMSW::AssociateHandle(WXWidget handle
)
1142 if ( !::DestroyWindow(GetHwnd()) )
1143 wxLogLastError(wxT("DestroyWindow"));
1146 WXHWND wxhwnd
= (WXHWND
)handle
;
1149 SubclassWin(wxhwnd
);
1152 void wxWindowMSW::DissociateHandle()
1154 // this also calls SetHWND(0) for us
1159 bool wxCheckWindowWndProc(WXHWND hWnd
,
1160 WXFARPROC
WXUNUSED(wndProc
))
1162 // TODO: This list of window class names should be factored out so they can be
1163 // managed in one place and then accessed from here and other places, such as
1164 // wxApp::RegisterWindowClasses() and wxApp::UnregisterWindowClasses()
1167 extern wxChar
*wxCanvasClassName
;
1168 extern wxChar
*wxCanvasClassNameNR
;
1170 extern const wxChar
*wxCanvasClassName
;
1171 extern const wxChar
*wxCanvasClassNameNR
;
1173 extern const wxChar
*wxMDIFrameClassName
;
1174 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1175 extern const wxChar
*wxMDIChildFrameClassName
;
1176 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1177 wxString
str(wxGetWindowClass(hWnd
));
1178 if (str
== wxCanvasClassName
||
1179 str
== wxCanvasClassNameNR
||
1181 str
== _T("wxGLCanvasClass") ||
1182 str
== _T("wxGLCanvasClassNR") ||
1183 #endif // wxUSE_GLCANVAS
1184 str
== wxMDIFrameClassName
||
1185 str
== wxMDIFrameClassNameNoRedraw
||
1186 str
== wxMDIChildFrameClassName
||
1187 str
== wxMDIChildFrameClassNameNoRedraw
||
1188 str
== _T("wxTLWHiddenParent"))
1189 return true; // Effectively means don't subclass
1194 // ----------------------------------------------------------------------------
1196 // ----------------------------------------------------------------------------
1198 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1200 long flagsOld
= GetWindowStyleFlag();
1201 if ( flags
== flagsOld
)
1204 // update the internal variable
1205 wxWindowBase::SetWindowStyleFlag(flags
);
1207 // and the real window flags
1208 MSWUpdateStyle(flagsOld
, GetExtraStyle());
1211 void wxWindowMSW::SetExtraStyle(long exflags
)
1213 long exflagsOld
= GetExtraStyle();
1214 if ( exflags
== exflagsOld
)
1217 // update the internal variable
1218 wxWindowBase::SetExtraStyle(exflags
);
1220 // and the real window flags
1221 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld
);
1224 void wxWindowMSW::MSWUpdateStyle(long flagsOld
, long exflagsOld
)
1226 // now update the Windows style as well if needed - and if the window had
1227 // been already created
1231 // we may need to call SetWindowPos() when we change some styles
1232 bool callSWP
= false;
1235 long style
= MSWGetStyle(GetWindowStyleFlag(), &exstyle
);
1237 // this is quite a horrible hack but we need it because MSWGetStyle()
1238 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1239 // and so we have to modify the window exflags temporarily to get the
1240 // correct exstyleOld
1241 long exflagsNew
= GetExtraStyle();
1242 wxWindowBase::SetExtraStyle(exflagsOld
);
1245 long styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1247 wxWindowBase::SetExtraStyle(exflagsNew
);
1250 if ( style
!= styleOld
)
1252 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1253 // this function so instead of simply setting the style to the new
1254 // value we clear the bits which were set in styleOld but are set in
1255 // the new one and set the ones which were not set before
1256 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1257 styleReal
&= ~styleOld
;
1260 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1262 // we need to call SetWindowPos() if any of the styles affecting the
1263 // frame appearance have changed
1264 callSWP
= ((styleOld
^ style
) & (WS_BORDER
|
1273 // and the extended style
1274 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1276 if ( exstyle
!= exstyleOld
)
1278 exstyleReal
&= ~exstyleOld
;
1279 exstyleReal
|= exstyle
;
1281 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1283 // ex style changes don't take effect without calling SetWindowPos
1289 // we must call SetWindowPos() to flush the cached extended style and
1290 // also to make the change to wxSTAY_ON_TOP style take effect: just
1291 // setting the style simply doesn't work
1292 if ( !::SetWindowPos(GetHwnd(),
1293 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1296 SWP_NOMOVE
| SWP_NOSIZE
| SWP_FRAMECHANGED
) )
1298 wxLogLastError(_T("SetWindowPos"));
1303 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1305 // translate common wxWidgets styles to Windows ones
1307 // most of windows are child ones, those which are not (such as
1308 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1309 WXDWORD style
= WS_CHILD
;
1311 // using this flag results in very significant reduction in flicker,
1312 // especially with controls inside the static boxes (as the interior of the
1313 // box is not redrawn twice), but sometimes results in redraw problems, so
1314 // optionally allow the old code to continue to use it provided a special
1315 // system option is turned on
1316 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1317 || (flags
& wxCLIP_CHILDREN
) )
1318 style
|= WS_CLIPCHILDREN
;
1320 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1321 // don't support overlapping windows and it only makes sense for them and,
1322 // presumably, gives the system some extra work (to manage more clipping
1323 // regions), so avoid it alltogether
1326 if ( flags
& wxVSCROLL
)
1327 style
|= WS_VSCROLL
;
1329 if ( flags
& wxHSCROLL
)
1330 style
|= WS_HSCROLL
;
1332 const wxBorder border
= GetBorder(flags
);
1334 // WS_BORDER is only required for wxBORDER_SIMPLE
1335 if ( border
== wxBORDER_SIMPLE
)
1338 // now deal with ext style if the caller wants it
1344 if ( flags
& wxTRANSPARENT_WINDOW
)
1345 *exstyle
|= WS_EX_TRANSPARENT
;
1351 case wxBORDER_DEFAULT
:
1352 wxFAIL_MSG( _T("unknown border style") );
1356 case wxBORDER_SIMPLE
:
1359 case wxBORDER_STATIC
:
1360 *exstyle
|= WS_EX_STATICEDGE
;
1363 case wxBORDER_RAISED
:
1364 *exstyle
|= WS_EX_DLGMODALFRAME
;
1367 case wxBORDER_SUNKEN
:
1368 *exstyle
|= WS_EX_CLIENTEDGE
;
1369 style
&= ~WS_BORDER
;
1372 case wxBORDER_DOUBLE
:
1373 *exstyle
|= WS_EX_DLGMODALFRAME
;
1377 // wxUniv doesn't use Windows dialog navigation functions at all
1378 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1379 // to make the dialog navigation work with the nested panels we must
1380 // use this style (top level windows such as dialogs don't need it)
1381 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1383 *exstyle
|= WS_EX_CONTROLPARENT
;
1385 #endif // __WXUNIVERSAL__
1391 // Setup background and foreground colours correctly
1392 void wxWindowMSW::SetupColours()
1395 SetBackgroundColour(GetParent()->GetBackgroundColour());
1398 bool wxWindowMSW::IsMouseInWindow() const
1400 // get the mouse position
1403 ::GetCursorPosWinCE(&pt
);
1405 ::GetCursorPos(&pt
);
1408 // find the window which currently has the cursor and go up the window
1409 // chain until we find this window - or exhaust it
1410 HWND hwnd
= ::WindowFromPoint(pt
);
1411 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1412 hwnd
= ::GetParent(hwnd
);
1414 return hwnd
!= NULL
;
1417 void wxWindowMSW::OnInternalIdle()
1419 #ifndef HAVE_TRACKMOUSEEVENT
1420 // Check if we need to send a LEAVE event
1421 if ( m_mouseInWindow
)
1423 // note that we should generate the leave event whether the window has
1424 // or doesn't have mouse capture
1425 if ( !IsMouseInWindow() )
1427 GenerateMouseLeave();
1430 #endif // !HAVE_TRACKMOUSEEVENT
1432 if (wxUpdateUIEvent::CanUpdate(this))
1433 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1436 // Set this window to be the child of 'parent'.
1437 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1439 if ( !wxWindowBase::Reparent(parent
) )
1442 HWND hWndChild
= GetHwnd();
1443 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1445 ::SetParent(hWndChild
, hWndParent
);
1448 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1450 EnsureParentHasControlParentStyle(GetParent());
1452 #endif // !__WXWINCE__
1457 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1459 #ifndef __WXMICROWIN__
1460 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1464 void wxWindowMSW::Freeze()
1466 if ( !m_frozenness
++ )
1469 SendSetRedraw(GetHwnd(), false);
1473 void wxWindowMSW::Thaw()
1475 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1477 if ( --m_frozenness
== 0 )
1481 SendSetRedraw(GetHwnd(), true);
1483 // we need to refresh everything or otherwise the invalidated area
1484 // is not going to be repainted
1490 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1492 HWND hWnd
= GetHwnd();
1499 mswRect
.left
= rect
->x
;
1500 mswRect
.top
= rect
->y
;
1501 mswRect
.right
= rect
->x
+ rect
->width
;
1502 mswRect
.bottom
= rect
->y
+ rect
->height
;
1511 // RedrawWindow not available on SmartPhone or eVC++ 3
1512 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1513 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1517 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1519 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1524 void wxWindowMSW::Update()
1526 if ( !::UpdateWindow(GetHwnd()) )
1528 wxLogLastError(_T("UpdateWindow"));
1531 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1532 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1533 // handler needs to be really drawn right now
1538 // ---------------------------------------------------------------------------
1540 // ---------------------------------------------------------------------------
1542 // we need to lower the sibling static boxes so controls contained within can be
1544 static inline void AdjustStaticBoxZOrder(wxWindow
*parent
)
1546 // no sibling static boxes if we have no parent (ie TLW)
1550 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1552 node
= node
->GetNext() )
1554 wxStaticBox
*statbox
= wxDynamicCast(node
->GetData(), wxStaticBox
);
1557 ::SetWindowPos(GetHwndOf(statbox
), HWND_BOTTOM
, 0, 0, 0, 0,
1558 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
1563 #if wxUSE_DRAG_AND_DROP
1564 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1566 if ( m_dropTarget
!= 0 ) {
1567 m_dropTarget
->Revoke(m_hWnd
);
1568 delete m_dropTarget
;
1571 m_dropTarget
= pDropTarget
;
1572 if ( m_dropTarget
!= 0 )
1574 AdjustStaticBoxZOrder(GetParent());
1575 m_dropTarget
->Register(m_hWnd
);
1578 #endif // wxUSE_DRAG_AND_DROP
1580 // old-style file manager drag&drop support: we retain the old-style
1581 // DragAcceptFiles in parallel with SetDropTarget.
1582 void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1585 HWND hWnd
= GetHwnd();
1588 AdjustStaticBoxZOrder(GetParent());
1589 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1594 // ----------------------------------------------------------------------------
1596 // ----------------------------------------------------------------------------
1600 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1602 wxWindowBase::DoSetToolTip(tooltip
);
1605 m_tooltip
->SetWindow((wxWindow
*)this);
1608 #endif // wxUSE_TOOLTIPS
1610 // ---------------------------------------------------------------------------
1611 // moving and resizing
1612 // ---------------------------------------------------------------------------
1614 bool wxWindowMSW::IsSizeDeferred() const
1616 #if USE_DEFERRED_SIZING
1617 if ( m_pendingPosition
!= wxDefaultPosition
||
1618 m_pendingSize
!= wxDefaultSize
)
1620 #endif // USE_DEFERRED_SIZING
1626 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1628 #if USE_DEFERRED_SIZING
1629 // if SetSize() had been called at wx level but not realized at Windows
1630 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1631 // the new and not the old position to the other wx code
1632 if ( m_pendingSize
!= wxDefaultSize
)
1635 *x
= m_pendingSize
.x
;
1637 *y
= m_pendingSize
.y
;
1639 else // use current size
1640 #endif // USE_DEFERRED_SIZING
1642 RECT rect
= wxGetWindowRect(GetHwnd());
1645 *x
= rect
.right
- rect
.left
;
1647 *y
= rect
.bottom
- rect
.top
;
1651 // Get size *available for subwindows* i.e. excluding menu bar etc.
1652 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1654 #if USE_DEFERRED_SIZING
1655 if ( m_pendingSize
!= wxDefaultSize
)
1657 // we need to calculate the client size corresponding to pending size
1659 rect
.left
= m_pendingPosition
.x
;
1660 rect
.top
= m_pendingPosition
.y
;
1661 rect
.right
= rect
.left
+ m_pendingSize
.x
;
1662 rect
.bottom
= rect
.top
+ m_pendingSize
.y
;
1664 ::SendMessage(GetHwnd(), WM_NCCALCSIZE
, FALSE
, (LPARAM
)&rect
);
1667 *x
= rect
.right
- rect
.left
;
1669 *y
= rect
.bottom
- rect
.top
;
1672 #endif // USE_DEFERRED_SIZING
1674 RECT rect
= wxGetClientRect(GetHwnd());
1683 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1685 wxWindow
* const parent
= GetParent();
1688 if ( m_pendingPosition
!= wxDefaultPosition
)
1690 pos
= m_pendingPosition
;
1692 else // use current position
1694 RECT rect
= wxGetWindowRect(GetHwnd());
1697 point
.x
= rect
.left
;
1700 // we do the adjustments with respect to the parent only for the "real"
1701 // children, not for the dialogs/frames
1702 if ( !IsTopLevel() )
1704 // Since we now have the absolute screen coords, if there's a
1705 // parent we must subtract its top left corner
1708 ::ScreenToClient(GetHwndOf(parent
), &point
);
1716 // we also must adjust by the client area offset: a control which is just
1717 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1718 if ( parent
&& !IsTopLevel() )
1720 const wxPoint
pt(parent
->GetClientAreaOrigin());
1731 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1739 ::ScreenToClient(GetHwnd(), &pt
);
1747 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1755 ::ClientToScreen(GetHwnd(), &pt
);
1764 wxWindowMSW::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1766 #if USE_DEFERRED_SIZING
1767 // if our parent had prepared a defer window handle for us, use it (unless
1768 // we are a top level window)
1769 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1771 HDWP hdwp
= parent
? (HDWP
)parent
->m_hDWP
: NULL
;
1774 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1775 SWP_NOZORDER
| SWP_NOOWNERZORDER
| SWP_NOACTIVATE
);
1778 wxLogLastError(_T("DeferWindowPos"));
1784 // hdwp must be updated as it may have been changed
1785 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1790 // did deferred move, remember new coordinates of the window as they're
1791 // different from what Windows would return for it
1795 // otherwise (or if deferring failed) move the window in place immediately
1796 #endif // USE_DEFERRED_SIZING
1797 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1799 wxLogLastError(wxT("MoveWindow"));
1802 // if USE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1803 // ignored otherwise
1807 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1809 // TODO: is this consistent with other platforms?
1810 // Still, negative width or height shouldn't be allowed
1816 if ( DoMoveSibling(m_hWnd
, x
, y
, width
, height
) )
1818 #if USE_DEFERRED_SIZING
1819 m_pendingPosition
= wxPoint(x
, y
);
1820 m_pendingSize
= wxSize(width
, height
);
1821 #endif // USE_DEFERRED_SIZING
1825 // set the size of the window: if the dimensions are positive, just use them,
1826 // but if any of them is equal to -1, it means that we must find the value for
1827 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1828 // which case -1 is a valid value for x and y)
1830 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1831 // the width/height to best suit our contents, otherwise we reuse the current
1833 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1835 // get the current size and position...
1836 int currentX
, currentY
;
1837 int currentW
, currentH
;
1839 GetPosition(¤tX
, ¤tY
);
1840 GetSize(¤tW
, ¤tH
);
1842 // ... and don't do anything (avoiding flicker) if it's already ok unless
1843 // we're forced to resize the window
1844 if ( x
== currentX
&& y
== currentY
&&
1845 width
== currentW
&& height
== currentH
&&
1846 !(sizeFlags
& wxSIZE_FORCE
) )
1851 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1853 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1856 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1858 wxSize size
= wxDefaultSize
;
1859 if ( width
== wxDefaultCoord
)
1861 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1863 size
= DoGetBestSize();
1868 // just take the current one
1873 if ( height
== wxDefaultCoord
)
1875 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1877 if ( size
.x
== wxDefaultCoord
)
1879 size
= DoGetBestSize();
1881 //else: already called DoGetBestSize() above
1887 // just take the current one
1892 DoMoveWindow(x
, y
, width
, height
);
1895 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1897 // setting the client size is less obvious than it could have been
1898 // because in the result of changing the total size the window scrollbar
1899 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
1900 // doesn't take neither into account) and so the client size will not be
1901 // correct as the difference between the total and client size changes --
1902 // so we keep changing it until we get it right
1904 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1905 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1906 // may become 3 if the window had 0 size originally and so we didn't
1907 // calculate the scrollbar correction correctly during the first iteration)
1908 // but just to be on the safe side we check for it instead of making it an
1909 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1910 for ( int i
= 0; i
< 4; i
++ )
1913 ::GetClientRect(GetHwnd(), &rectClient
);
1915 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
1916 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1917 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1922 // Find the difference between the entire window (title bar and all)
1923 // and the client area; add this to the new client size to move the
1926 ::GetWindowRect(GetHwnd(), &rectWin
);
1928 const int widthWin
= rectWin
.right
- rectWin
.left
,
1929 heightWin
= rectWin
.bottom
- rectWin
.top
;
1931 // MoveWindow positions the child windows relative to the parent, so
1932 // adjust if necessary
1933 if ( !IsTopLevel() )
1935 wxWindow
*parent
= GetParent();
1938 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
1942 // don't call DoMoveWindow() because we want to move window immediately
1943 // and not defer it here as otherwise the value returned by
1944 // GetClient/WindowRect() wouldn't change as the window wouldn't be
1946 if ( !::MoveWindow(GetHwnd(),
1949 width
+ widthWin
- rectClient
.right
,
1950 height
+ heightWin
- rectClient
.bottom
,
1953 wxLogLastError(_T("MoveWindow"));
1958 // ---------------------------------------------------------------------------
1960 // ---------------------------------------------------------------------------
1962 int wxWindowMSW::GetCharHeight() const
1964 return wxGetTextMetrics(this).tmHeight
;
1967 int wxWindowMSW::GetCharWidth() const
1969 // +1 is needed because Windows apparently adds it when calculating the
1970 // dialog units size in pixels
1971 #if wxDIALOG_UNIT_COMPATIBILITY
1972 return wxGetTextMetrics(this).tmAveCharWidth
;
1974 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1978 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1980 int *descent
, int *externalLeading
,
1981 const wxFont
*theFont
) const
1983 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1984 _T("invalid font in GetTextExtent()") );
1988 fontToUse
= *theFont
;
1990 fontToUse
= GetFont();
1992 WindowHDC
hdc(GetHwnd());
1993 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1997 ::GetTextExtentPoint32(hdc
, string
, string
.length(), &sizeRect
);
1998 GetTextMetrics(hdc
, &tm
);
2005 *descent
= tm
.tmDescent
;
2006 if ( externalLeading
)
2007 *externalLeading
= tm
.tmExternalLeading
;
2010 // ---------------------------------------------------------------------------
2012 // ---------------------------------------------------------------------------
2014 #if wxUSE_MENUS_NATIVE
2016 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2017 // immediately, without waiting for the next event loop iteration
2019 // NB: this function should probably be made public later as it can almost
2020 // surely replace wxYield() elsewhere as well
2021 static void wxYieldForCommandsOnly()
2023 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2024 // want to process it here)
2026 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
2028 if ( msg
.message
== WM_QUIT
)
2030 // if we retrieved a WM_QUIT, insert back into the message queue.
2031 ::PostQuitMessage(0);
2035 // luckily (as we don't have access to wxEventLoopImpl method from here
2036 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2038 ::TranslateMessage(&msg
);
2039 ::DispatchMessage(&msg
);
2043 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
2045 menu
->SetInvokingWindow(this);
2048 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
2050 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
2051 x
= mouse
.x
; y
= mouse
.y
;
2054 HWND hWnd
= GetHwnd();
2055 HMENU hMenu
= GetHmenuOf(menu
);
2059 ::ClientToScreen(hWnd
, &point
);
2060 wxCurrentPopupMenu
= menu
;
2061 #if defined(__WXWINCE__)
2064 UINT flags
= TPM_RIGHTBUTTON
| TPM_RECURSE
;
2066 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
2068 // we need to do it right now as otherwise the events are never going to be
2069 // sent to wxCurrentPopupMenu from HandleCommand()
2071 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2072 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2073 // destroyed as soon as we return (it can be a local variable in the caller
2074 // for example) and so we do need to process the event immediately
2075 wxYieldForCommandsOnly();
2077 wxCurrentPopupMenu
= NULL
;
2079 menu
->SetInvokingWindow(NULL
);
2084 #endif // wxUSE_MENUS_NATIVE
2086 // ===========================================================================
2087 // pre/post message processing
2088 // ===========================================================================
2090 WXLRESULT
wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2093 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
2095 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
2098 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
2100 // wxUniversal implements tab traversal itself
2101 #ifndef __WXUNIVERSAL__
2102 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
2104 // intercept dialog navigation keys
2105 MSG
*msg
= (MSG
*)pMsg
;
2107 // here we try to do all the job which ::IsDialogMessage() usually does
2109 if ( msg
->message
== WM_KEYDOWN
)
2111 bool bCtrlDown
= wxIsCtrlDown();
2112 bool bShiftDown
= wxIsShiftDown();
2114 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2115 // don't process it if it's the case (except for Ctrl-Tab/Enter
2116 // combinations which are always processed)
2117 LONG lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
2119 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2120 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2121 // it, of course, implies them
2122 if ( lDlgCode
& DLGC_WANTALLKEYS
)
2124 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
2127 bool bForward
= true,
2128 bWindowChange
= false,
2131 // should we process this message specially?
2132 bool bProcess
= true;
2133 switch ( msg
->wParam
)
2136 if ( lDlgCode
& DLGC_WANTTAB
) {
2140 // Ctrl-Tab cycles thru notebook pages
2141 bWindowChange
= bCtrlDown
;
2142 bForward
= !bShiftDown
;
2149 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2157 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
2166 // we treat PageUp/Dn as arrows because chances are that
2167 // a control which needs arrows also needs them for
2168 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2169 if ( (lDlgCode
& DLGC_WANTARROWS
) || !bCtrlDown
)
2172 bWindowChange
= true;
2177 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
2179 // control wants to process Enter itself, don't
2180 // call IsDialogMessage() which would consume it
2185 // currently active button should get enter press even
2186 // if there is a default button elsewhere so check if
2187 // this window is a button first
2188 wxWindow
*btn
= NULL
;
2189 if ( lDlgCode
& DLGC_DEFPUSHBUTTON
)
2191 // let IsDialogMessage() handle this for all
2192 // buttons except the owner-drawn ones which it
2193 // just seems to ignore
2194 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
2195 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
2197 // emulate the button click
2198 btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
2203 else // not a button itself, do we have default button?
2206 tlw
= wxDynamicCast(wxGetTopLevelParent(this),
2210 btn
= wxDynamicCast(tlw
->GetDefaultItem(),
2215 if ( btn
&& btn
->IsEnabled() )
2217 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
2221 #endif // wxUSE_BUTTON
2224 // map Enter presses into button presses on PDAs
2225 wxJoystickEvent
event(wxEVT_JOY_BUTTON_DOWN
);
2226 event
.SetEventObject(this);
2227 if ( GetEventHandler()->ProcessEvent(event
) )
2229 #endif // __WXWINCE__
2239 wxNavigationKeyEvent event
;
2240 event
.SetDirection(bForward
);
2241 event
.SetWindowChange(bWindowChange
);
2242 event
.SetFromTab(bFromTab
);
2243 event
.SetEventObject(this);
2245 if ( GetEventHandler()->ProcessEvent(event
) )
2247 // as we don't call IsDialogMessage(), which would take of
2248 // this by default, we need to manually send this message
2249 // so that controls can change their UI state if needed
2250 MSWUpdateUIState(UIS_CLEAR
, UISF_HIDEFOCUS
);
2257 if ( ::IsDialogMessage(GetHwnd(), msg
) )
2259 // 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
* msg
)
2290 // all tests below have to deal with various bugs/misfeatures of
2291 // IsDialogMessage(): we have to prevent it from being called from our
2292 // MSWProcessMessage() in some situations
2294 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2295 // message even when there is no cancel button and when the message is
2296 // needed by the control itself: in particular, it prevents the tree in
2297 // place edit control from being closed with Escape in a dialog
2298 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_ESCAPE
)
2303 // ::IsDialogMessage() is broken and may sometimes hang the application by
2304 // going into an infinite loop when it tries to find the control to give
2305 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2306 // situations when this may happen and not call it then
2307 if ( msg
->message
!= WM_SYSCHAR
)
2310 // assume we can call it by default
2311 bool canSafelyCallIsDlgMsg
= true;
2313 HWND hwndFocus
= ::GetFocus();
2315 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2316 // ::IsDialogMessage() will also enter an infinite loop, because it will
2317 // recursively check the child windows but not the window itself and so if
2318 // none of the children accepts focus it loops forever (as it only stops
2319 // when it gets back to the window it started from)
2321 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2322 // style has the focus, it can happen. One such possibility is if
2323 // all windows are either toplevel, wxDialog, wxPanel or static
2324 // controls and no window can actually accept keyboard input.
2325 #if !defined(__WXWINCE__)
2326 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2328 // pessimistic by default
2329 canSafelyCallIsDlgMsg
= false;
2330 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2332 node
= node
->GetNext() )
2334 wxWindow
* const win
= node
->GetData();
2335 if ( win
->AcceptsFocus() &&
2336 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2337 WS_EX_CONTROLPARENT
) )
2339 // it shouldn't hang...
2340 canSafelyCallIsDlgMsg
= true;
2346 #endif // !__WXWINCE__
2348 if ( canSafelyCallIsDlgMsg
)
2350 // ::IsDialogMessage() can enter in an infinite loop when the
2351 // currently focused window is disabled or hidden and its
2352 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2356 if ( !::IsWindowEnabled(hwndFocus
) ||
2357 !::IsWindowVisible(hwndFocus
) )
2359 // it would enter an infinite loop if we do this!
2360 canSafelyCallIsDlgMsg
= false;
2365 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2367 // it's a top level window, don't go further -- e.g. even
2368 // if the parent of a dialog is disabled, this doesn't
2369 // break navigation inside the dialog
2373 hwndFocus
= ::GetParent(hwndFocus
);
2377 return canSafelyCallIsDlgMsg
;
2380 // ---------------------------------------------------------------------------
2381 // message params unpackers
2382 // ---------------------------------------------------------------------------
2384 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2385 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2387 *id
= LOWORD(wParam
);
2388 *hwnd
= (WXHWND
)lParam
;
2389 *cmd
= HIWORD(wParam
);
2392 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2393 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2395 *state
= LOWORD(wParam
);
2396 *minimized
= HIWORD(wParam
);
2397 *hwnd
= (WXHWND
)lParam
;
2400 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2401 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2403 *code
= LOWORD(wParam
);
2404 *pos
= HIWORD(wParam
);
2405 *hwnd
= (WXHWND
)lParam
;
2408 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2409 WXHDC
*hdc
, WXHWND
*hwnd
)
2411 *hwnd
= (WXHWND
)lParam
;
2412 *hdc
= (WXHDC
)wParam
;
2415 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2416 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2418 *item
= (WXWORD
)wParam
;
2419 *flags
= HIWORD(wParam
);
2420 *hmenu
= (WXHMENU
)lParam
;
2423 // ---------------------------------------------------------------------------
2424 // Main wxWidgets window proc and the window proc for wxWindow
2425 // ---------------------------------------------------------------------------
2427 // Hook for new window just as it's being created, when the window isn't yet
2428 // associated with the handle
2429 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2431 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2432 // window being created and insures that it's always unset back later
2433 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2435 gs_winBeingCreated
= winBeingCreated
;
2438 wxWindowCreationHook::~wxWindowCreationHook()
2440 gs_winBeingCreated
= NULL
;
2444 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2446 // trace all messages - useful for the debugging
2448 wxLogTrace(wxTraceMessages
,
2449 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2450 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2451 #endif // __WXDEBUG__
2453 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2455 // when we get the first message for the HWND we just created, we associate
2456 // it with wxWindow stored in gs_winBeingCreated
2457 if ( !wnd
&& gs_winBeingCreated
)
2459 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2460 wnd
= gs_winBeingCreated
;
2461 gs_winBeingCreated
= NULL
;
2462 wnd
->SetHWND((WXHWND
)hWnd
);
2467 if ( wnd
&& wxEventLoop::AllowProcessing(wnd
) )
2468 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2470 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2475 WXLRESULT
wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2477 // did we process the message?
2478 bool processed
= false;
2488 // for most messages we should return 0 when we do process the message
2496 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2499 // return 0 to allow window creation
2500 rc
.result
= mayCreate
? 0 : -1;
2506 // never set processed to true and *always* pass WM_DESTROY to
2507 // DefWindowProc() as Windows may do some internal cleanup when
2508 // processing it and failing to pass the message along may cause
2509 // memory and resource leaks!
2510 (void)HandleDestroy();
2514 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2518 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2521 #if !defined(__WXWINCE__)
2524 LPRECT pRect
= (LPRECT
)lParam
;
2526 rc
.SetLeft(pRect
->left
);
2527 rc
.SetTop(pRect
->top
);
2528 rc
.SetRight(pRect
->right
);
2529 rc
.SetBottom(pRect
->bottom
);
2530 processed
= HandleMoving(rc
);
2532 pRect
->left
= rc
.GetLeft();
2533 pRect
->top
= rc
.GetTop();
2534 pRect
->right
= rc
.GetRight();
2535 pRect
->bottom
= rc
.GetBottom();
2542 LPRECT pRect
= (LPRECT
)lParam
;
2544 rc
.SetLeft(pRect
->left
);
2545 rc
.SetTop(pRect
->top
);
2546 rc
.SetRight(pRect
->right
);
2547 rc
.SetBottom(pRect
->bottom
);
2548 processed
= HandleSizing(rc
);
2550 pRect
->left
= rc
.GetLeft();
2551 pRect
->top
= rc
.GetTop();
2552 pRect
->right
= rc
.GetRight();
2553 pRect
->bottom
= rc
.GetBottom();
2557 #endif // !__WXWINCE__
2559 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2560 case WM_ACTIVATEAPP
:
2561 // This implicitly sends a wxEVT_ACTIVATE_APP event
2562 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2568 WXWORD state
, minimized
;
2570 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2572 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2577 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2581 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2584 case WM_PRINTCLIENT
:
2585 processed
= HandlePrintClient((WXHDC
)wParam
);
2591 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2593 processed
= HandlePaint();
2597 processed
= HandlePaint();
2602 #ifdef __WXUNIVERSAL__
2603 // Universal uses its own wxFrame/wxDialog, so we don't receive
2604 // close events unless we have this.
2606 #endif // __WXUNIVERSAL__
2608 // don't let the DefWindowProc() destroy our window - we'll do it
2609 // ourselves in ~wxWindow
2615 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2619 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2620 GET_Y_LPARAM(lParam
),
2624 #ifdef HAVE_TRACKMOUSEEVENT
2626 // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
2627 if ( m_mouseInWindow
)
2629 GenerateMouseLeave();
2632 // always pass processed back as false, this allows the window
2633 // manager to process the message too. This is needed to
2634 // ensure windows XP themes work properly as the mouse moves
2635 // over widgets like buttons. So don't set processed to true here.
2637 #endif // HAVE_TRACKMOUSEEVENT
2639 #if wxUSE_MOUSEWHEEL
2641 processed
= HandleMouseWheel(wParam
, lParam
);
2645 case WM_LBUTTONDOWN
:
2647 case WM_LBUTTONDBLCLK
:
2648 case WM_RBUTTONDOWN
:
2650 case WM_RBUTTONDBLCLK
:
2651 case WM_MBUTTONDOWN
:
2653 case WM_MBUTTONDBLCLK
:
2655 #ifdef __WXMICROWIN__
2656 // MicroWindows seems to ignore the fact that a window is
2657 // disabled. So catch mouse events and throw them away if
2659 wxWindowMSW
* win
= this;
2662 if (!win
->IsEnabled())
2668 win
= win
->GetParent();
2669 if ( !win
|| win
->IsTopLevel() )
2676 #endif // __WXMICROWIN__
2677 int x
= GET_X_LPARAM(lParam
),
2678 y
= GET_Y_LPARAM(lParam
);
2681 // redirect the event to a static control if necessary by
2682 // finding one under mouse because under CE the static controls
2683 // don't generate mouse events (even with SS_NOTIFY)
2685 if ( GetCapture() == this )
2687 // but don't do it if the mouse is captured by this window
2688 // because then it should really get this event itself
2693 win
= FindWindowForMouseEvent(this, &x
, &y
);
2695 // this should never happen
2696 wxCHECK_MSG( win
, 0,
2697 _T("FindWindowForMouseEvent() returned NULL") );
2700 if (IsContextMenuEnabled() && message
== WM_LBUTTONDOWN
)
2702 SHRGINFO shrgi
= {0};
2704 shrgi
.cbSize
= sizeof(SHRGINFO
);
2705 shrgi
.hwndClient
= (HWND
) GetHWND();
2709 shrgi
.dwFlags
= SHRG_RETURNCMD
;
2710 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2712 if (GN_CONTEXTMENU
== ::SHRecognizeGesture(&shrgi
))
2715 pt
= ClientToScreen(pt
);
2717 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2719 evtCtx
.SetEventObject(this);
2720 if (GetEventHandler()->ProcessEvent(evtCtx
))
2729 #else // !__WXWINCE__
2730 wxWindowMSW
*win
= this;
2731 #endif // __WXWINCE__/!__WXWINCE__
2733 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2735 // if the app didn't eat the event, handle it in the default
2736 // way, that is by giving this window the focus
2739 // for the standard classes their WndProc sets the focus to
2740 // them anyhow and doing it from here results in some weird
2741 // problems, so don't do it for them (unnecessary anyhow)
2742 if ( !win
->IsOfStandardClass() )
2744 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2756 case MM_JOY1BUTTONDOWN
:
2757 case MM_JOY2BUTTONDOWN
:
2758 case MM_JOY1BUTTONUP
:
2759 case MM_JOY2BUTTONUP
:
2760 processed
= HandleJoystickEvent(message
,
2761 GET_X_LPARAM(lParam
),
2762 GET_Y_LPARAM(lParam
),
2765 #endif // __WXMICROWIN__
2771 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2773 processed
= HandleCommand(id
, cmd
, hwnd
);
2778 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2781 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2782 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2783 // apparently doesn't always behave properly and needs some help
2784 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2785 case WM_NOTIFYFORMAT
:
2786 if ( lParam
== NF_QUERY
)
2789 rc
.result
= NFR_UNICODE
;
2792 #endif // wxUSE_UNICODE_MSLU
2794 // for these messages we must return true if process the message
2797 case WM_MEASUREITEM
:
2799 int idCtrl
= (UINT
)wParam
;
2800 if ( message
== WM_DRAWITEM
)
2802 processed
= MSWOnDrawItem(idCtrl
,
2803 (WXDRAWITEMSTRUCT
*)lParam
);
2807 processed
= MSWOnMeasureItem(idCtrl
,
2808 (WXMEASUREITEMSTRUCT
*)lParam
);
2815 #endif // defined(WM_DRAWITEM)
2818 if ( !IsOfStandardClass() )
2820 // we always want to get the char events
2821 rc
.result
= DLGC_WANTCHARS
;
2823 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2825 // in fact, we want everything
2826 rc
.result
|= DLGC_WANTARROWS
|
2833 //else: get the dlg code from the DefWindowProc()
2838 // If this has been processed by an event handler, return 0 now
2839 // (we've handled it).
2840 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2841 if ( m_lastKeydownProcessed
)
2850 // we consider these messages "not interesting" to OnChar, so
2851 // just don't do anything more with them
2861 // avoid duplicate messages to OnChar for these ASCII keys:
2862 // they will be translated by TranslateMessage() and received
2894 // but set processed to false, not true to still pass them
2895 // to the control's default window proc - otherwise
2896 // built-in keyboard handling won't work
2901 // special case of VK_APPS: treat it the same as right mouse
2902 // click because both usually pop up a context menu
2904 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2909 // do generate a CHAR event
2910 processed
= HandleChar((WORD
)wParam
, lParam
);
2913 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2920 // special case of VK_APPS: treat it the same as right mouse button
2921 if ( wParam
== VK_APPS
)
2923 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2928 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2933 case WM_CHAR
: // Always an ASCII character
2934 if ( m_lastKeydownProcessed
)
2936 // The key was handled in the EVT_KEY_DOWN and handling
2937 // a key in an EVT_KEY_DOWN handler is meant, by
2938 // design, to prevent EVT_CHARs from happening
2939 m_lastKeydownProcessed
= false;
2944 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2950 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2952 #endif // wxUSE_HOTKEY
2959 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2961 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2967 // CTLCOLOR messages are sent by children to query the parent for their
2969 #ifndef __WXMICROWIN__
2970 case WM_CTLCOLORMSGBOX
:
2971 case WM_CTLCOLOREDIT
:
2972 case WM_CTLCOLORLISTBOX
:
2973 case WM_CTLCOLORBTN
:
2974 case WM_CTLCOLORDLG
:
2975 case WM_CTLCOLORSCROLLBAR
:
2976 case WM_CTLCOLORSTATIC
:
2980 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2982 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2985 #endif // !__WXMICROWIN__
2987 case WM_SYSCOLORCHANGE
:
2988 // the return value for this message is ignored
2989 processed
= HandleSysColorChange();
2992 #if !defined(__WXWINCE__)
2993 case WM_DISPLAYCHANGE
:
2994 processed
= HandleDisplayChange();
2998 case WM_PALETTECHANGED
:
2999 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
3002 case WM_CAPTURECHANGED
:
3003 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
3006 case WM_SETTINGCHANGE
:
3007 processed
= HandleSettingChange(wParam
, lParam
);
3010 case WM_QUERYNEWPALETTE
:
3011 processed
= HandleQueryNewPalette();
3015 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
3018 // we processed the message, i.e. erased the background
3023 #if !defined(__WXWINCE__)
3025 processed
= HandleDropFiles(wParam
);
3030 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
3034 // we never set focus from here
3039 #if !defined(__WXWINCE__)
3040 case WM_QUERYENDSESSION
:
3041 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
3045 processed
= HandleEndSession(wParam
!= 0, lParam
);
3048 case WM_GETMINMAXINFO
:
3049 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
3054 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
3055 LOWORD(lParam
), // hit test
3056 HIWORD(lParam
)); // mouse msg
3060 // returning TRUE stops the DefWindowProc() from further
3061 // processing this message - exactly what we need because we've
3062 // just set the cursor.
3067 #if wxUSE_ACCESSIBILITY
3070 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3071 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
3073 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
3075 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
3081 #if defined(WM_HELP)
3084 // by default, WM_HELP is propagated by DefWindowProc() upwards
3085 // to the window parent but as we do it ourselves already
3086 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3087 // to get the other events if we process this message at all
3090 // WM_HELP doesn't use lParam under CE
3092 HELPINFO
* info
= (HELPINFO
*) lParam
;
3093 if ( info
->iContextType
== HELPINFO_WINDOW
)
3095 #endif // !__WXWINCE__
3096 wxHelpEvent helpEvent
3101 wxGetMousePosition() // what else?
3103 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
3107 helpEvent
.SetEventObject(this);
3108 GetEventHandler()->ProcessEvent(helpEvent
);
3111 else if ( info
->iContextType
== HELPINFO_MENUITEM
)
3113 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
3114 helpEvent
.SetEventObject(this);
3115 GetEventHandler()->ProcessEvent(helpEvent
);
3118 else // unknown help event?
3122 #endif // !__WXWINCE__
3127 #if !defined(__WXWINCE__)
3128 case WM_CONTEXTMENU
:
3130 // we don't convert from screen to client coordinates as
3131 // the event may be handled by a parent window
3132 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
3134 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
3136 // we could have got an event from our child, reflect it back
3137 // to it if this is the case
3138 wxWindowMSW
*win
= NULL
;
3139 if ( (WXHWND
)wParam
!= m_hWnd
)
3141 win
= FindItemByHWND((WXHWND
)wParam
);
3147 evtCtx
.SetEventObject(win
);
3148 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
3154 // we're only interested in our own menus, not MF_SYSMENU
3155 if ( HIWORD(wParam
) == MF_POPUP
)
3157 // handle menu chars for ownerdrawn menu items
3158 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
3159 if ( i
!= wxNOT_FOUND
)
3161 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
3168 case WM_POWERBROADCAST
:
3171 processed
= HandlePower(wParam
, lParam
, &vetoed
);
3172 rc
.result
= processed
&& vetoed
? BROADCAST_QUERY_DENY
: TRUE
;
3175 #endif // __WXWINCE__
3181 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
3182 wxGetMessageName(message
));
3183 #endif // __WXDEBUG__
3184 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
3190 // ----------------------------------------------------------------------------
3191 // wxWindow <-> HWND map
3192 // ----------------------------------------------------------------------------
3194 wxWinHashTable
*wxWinHandleHash
= NULL
;
3196 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
3198 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
3201 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
3203 // adding NULL hWnd is (first) surely a result of an error and
3204 // (secondly) breaks menu command processing
3205 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
3206 wxT("attempt to add a NULL hWnd to window list ignored") );
3208 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
3210 if ( oldWin
&& (oldWin
!= win
) )
3212 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
3213 (int) hWnd
, win
->GetClassInfo()->GetClassName());
3216 #endif // __WXDEBUG__
3219 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
3223 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
3225 wxWinHandleHash
->Delete((long)win
->GetHWND());
3228 // ----------------------------------------------------------------------------
3229 // various MSW speciic class dependent functions
3230 // ----------------------------------------------------------------------------
3232 // Default destroyer - override if you destroy it in some other way
3233 // (e.g. with MDI child windows)
3234 void wxWindowMSW::MSWDestroyWindow()
3238 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
3241 int& w
, int& h
) const
3243 // yes, those are just some arbitrary hardcoded numbers
3244 static const int DEFAULT_Y
= 200;
3246 bool nonDefault
= false;
3248 if ( pos
.x
== wxDefaultCoord
)
3250 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
3251 // can just as well set it to CW_USEDEFAULT as well
3257 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
3258 // neither because it is not handled as a special value by Windows then
3259 // and so we have to choose some default value for it
3261 y
= pos
.y
== wxDefaultCoord
? DEFAULT_Y
: pos
.y
;
3267 NB: there used to be some code here which set the initial size of the
3268 window to the client size of the parent if no explicit size was
3269 specified. This was wrong because wxWidgets programs often assume
3270 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3271 it. To see why, you should understand that Windows sends WM_SIZE from
3272 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3273 from some base class ctor and so this WM_SIZE is not processed in the
3274 real class' OnSize() (because it's not fully constructed yet and the
3275 event goes to some base class OnSize() instead). So the WM_SIZE we
3276 rely on is the one sent when the parent frame resizes its children
3277 but here is the problem: if the child already has just the right
3278 size, nothing will happen as both wxWidgets and Windows check for
3279 this and ignore any attempts to change the window size to the size it
3280 already has - so no WM_SIZE would be sent.
3284 // we don't use CW_USEDEFAULT here for several reasons:
3286 // 1. it results in huge frames on modern screens (1000*800 is not
3287 // uncommon on my 1280*1024 screen) which is way too big for a half
3288 // empty frame of most of wxWidgets samples for example)
3290 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3291 // the default is for whatever reason 8*8 which breaks client <->
3292 // window size calculations (it would be nice if it didn't, but it
3293 // does and the simplest way to fix it seemed to change the broken
3294 // default size anyhow)
3296 // 3. there is just no advantage in doing it: with x and y it is
3297 // possible that [future versions of] Windows position the new top
3298 // level window in some smart way which we can't do, but we can
3299 // guess a reasonably good size for a new window just as well
3302 // However, on PocketPC devices, we must use the default
3303 // size if possible.
3305 if (size
.x
== wxDefaultCoord
)
3309 if (size
.y
== wxDefaultCoord
)
3314 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3318 w
= WidthDefault(size
.x
);
3319 h
= HeightDefault(size
.y
);
3322 AdjustForParentClientOrigin(x
, y
);
3327 WXHWND
wxWindowMSW::MSWGetParent() const
3329 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3332 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3333 const wxChar
*title
,
3337 WXDWORD extendedStyle
)
3339 // choose the position/size for the new window
3341 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3343 // controlId is menu handle for the top level windows, so set it to 0
3344 // unless we're creating a child window
3345 int controlId
= style
& WS_CHILD
? GetId() : 0;
3347 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3348 // which is the same but without CS_[HV]REDRAW class styles so using it
3349 // ensures that the window is not fully repainted on each resize
3350 wxString
className(wclass
);
3351 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3353 className
+= wxT("NR");
3356 // do create the window
3357 wxWindowCreationHook
hook(this);
3359 m_hWnd
= (WXHWND
)::CreateWindowEx
3363 title
? title
: m_windowName
.c_str(),
3366 (HWND
)MSWGetParent(),
3369 NULL
// no extra data
3374 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3379 SubclassWin(m_hWnd
);
3384 // ===========================================================================
3385 // MSW message handlers
3386 // ===========================================================================
3388 // ---------------------------------------------------------------------------
3390 // ---------------------------------------------------------------------------
3392 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3394 #ifndef __WXMICROWIN__
3395 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3396 HWND hWnd
= hdr
->hwndFrom
;
3397 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3399 // if the control is one of our windows, let it handle the message itself
3402 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3405 // VZ: why did we do it? normally this is unnecessary and, besides, it
3406 // breaks the message processing for the toolbars because the tooltip
3407 // notifications were being forwarded to the toolbar child controls
3408 // (if it had any) before being passed to the toolbar itself, so in my
3409 // example the tooltip for the combobox was always shown instead of the
3410 // correct button tooltips
3412 // try all our children
3413 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3416 wxWindow
*child
= node
->GetData();
3417 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3422 node
= node
->GetNext();
3426 // by default, handle it ourselves
3427 return MSWOnNotify(idCtrl
, lParam
, result
);
3428 #else // __WXMICROWIN__
3435 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3437 const wxString
& ttip
)
3439 // I don't know why it happens, but the versions of comctl32.dll starting
3440 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3441 // this message is supposed to be sent to Unicode programs only) -- hence
3442 // we need to handle it as well, otherwise no tooltips will be shown in
3445 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3448 // not a tooltip message or no tooltip to show anyhow
3453 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3455 // We don't want to use the szText buffer because it has a limit of 80
3456 // bytes and this is not enough, especially for Unicode build where it
3457 // limits the tooltip string length to only 40 characters
3459 // The best would be, of course, to not impose any length limitations at
3460 // all but then the buffer would have to be dynamic and someone would have
3461 // to free it and we don't have the tooltip owner object here any more, so
3462 // for now use our own static buffer with a higher fixed max length.
3464 // Note that using a static buffer should not be a problem as only a single
3465 // tooltip can be shown at the same time anyhow.
3467 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3469 // We need to convert tooltip from multi byte to Unicode on the fly.
3470 static wchar_t buf
[513];
3472 // Truncate tooltip length if needed as otherwise we might not have
3473 // enough space for it in the buffer and MultiByteToWideChar() would
3475 size_t tipLength
= wxMin(ttip
.length(), WXSIZEOF(buf
) - 1);
3477 // Convert to WideChar without adding the NULL character. The NULL
3478 // character is added afterwards (this is more efficient).
3479 int len
= ::MultiByteToWideChar
3491 wxLogLastError(_T("MultiByteToWideChar()"));
3495 ttText
->lpszText
= (LPSTR
) buf
;
3497 else // TTN_NEEDTEXTA
3498 #endif // !wxUSE_UNICODE
3500 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3501 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3502 // to copy the string we have into the buffer
3503 static wxChar buf
[513];
3504 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3505 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3506 ttText
->lpszText
= buf
;
3512 #endif // wxUSE_TOOLTIPS
3514 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3516 WXLPARAM
* WXUNUSED(result
))
3521 NMHDR
* hdr
= (NMHDR
*)lParam
;
3522 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3529 wxUnusedVar(lParam
);
3530 #endif // wxUSE_TOOLTIPS
3535 // ---------------------------------------------------------------------------
3536 // end session messages
3537 // ---------------------------------------------------------------------------
3539 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3541 #ifdef ENDSESSION_LOGOFF
3542 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3543 event
.SetEventObject(wxTheApp
);
3544 event
.SetCanVeto(true);
3545 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3547 bool rc
= wxTheApp
->ProcessEvent(event
);
3551 // we may end only if the app didn't veto session closing (double
3553 *mayEnd
= !event
.GetVeto();
3558 wxUnusedVar(logOff
);
3559 wxUnusedVar(mayEnd
);
3564 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3566 #ifdef ENDSESSION_LOGOFF
3567 // do nothing if the session isn't ending
3572 if ( (this != wxTheApp
->GetTopWindow()) )
3575 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3576 event
.SetEventObject(wxTheApp
);
3577 event
.SetCanVeto(false);
3578 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3580 return wxTheApp
->ProcessEvent(event
);
3582 wxUnusedVar(endSession
);
3583 wxUnusedVar(logOff
);
3588 // ---------------------------------------------------------------------------
3589 // window creation/destruction
3590 // ---------------------------------------------------------------------------
3592 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3595 // VZ: why is this commented out for WinCE? If it doesn't support
3596 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3597 // not with multiple #ifdef's!
3599 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3600 EnsureParentHasControlParentStyle(GetParent());
3601 #endif // !__WXWINCE__
3608 bool wxWindowMSW::HandleDestroy()
3612 // delete our drop target if we've got one
3613 #if wxUSE_DRAG_AND_DROP
3614 if ( m_dropTarget
!= NULL
)
3616 m_dropTarget
->Revoke(m_hWnd
);
3618 delete m_dropTarget
;
3619 m_dropTarget
= NULL
;
3621 #endif // wxUSE_DRAG_AND_DROP
3623 // WM_DESTROY handled
3627 // ---------------------------------------------------------------------------
3629 // ---------------------------------------------------------------------------
3631 bool wxWindowMSW::HandleActivate(int state
,
3632 bool WXUNUSED(minimized
),
3633 WXHWND
WXUNUSED(activate
))
3635 wxActivateEvent
event(wxEVT_ACTIVATE
,
3636 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3638 event
.SetEventObject(this);
3640 return GetEventHandler()->ProcessEvent(event
);
3643 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3645 // Strangly enough, some controls get set focus events when they are being
3646 // deleted, even if they already had focus before.
3647 if ( m_isBeingDeleted
)
3652 // notify the parent keeping track of focus for the kbd navigation
3653 // purposes that we got it
3654 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3655 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3661 m_caret
->OnSetFocus();
3663 #endif // wxUSE_CARET
3666 // If it's a wxTextCtrl don't send the event as it will be done
3667 // after the control gets to process it from EN_FOCUS handler
3668 if ( wxDynamicCastThis(wxTextCtrl
) )
3672 #endif // wxUSE_TEXTCTRL
3674 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3675 event
.SetEventObject(this);
3677 // wxFindWinFromHandle() may return NULL, it is ok
3678 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3680 return GetEventHandler()->ProcessEvent(event
);
3683 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3689 m_caret
->OnKillFocus();
3691 #endif // wxUSE_CARET
3694 // If it's a wxTextCtrl don't send the event as it will be done
3695 // after the control gets to process it.
3696 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3703 // Don't send the event when in the process of being deleted. This can
3704 // only cause problems if the event handler tries to access the object.
3705 if ( m_isBeingDeleted
)
3710 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3711 event
.SetEventObject(this);
3713 // wxFindWinFromHandle() may return NULL, it is ok
3714 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3716 return GetEventHandler()->ProcessEvent(event
);
3719 // ---------------------------------------------------------------------------
3721 // ---------------------------------------------------------------------------
3723 void wxWindowMSW::SetLabel( const wxString
& label
)
3725 SetWindowText(GetHwnd(), label
.c_str());
3728 wxString
wxWindowMSW::GetLabel() const
3730 return wxGetWindowText(GetHWND());
3733 // ---------------------------------------------------------------------------
3735 // ---------------------------------------------------------------------------
3737 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3739 wxShowEvent
event(GetId(), show
);
3740 event
.SetEventObject(this);
3742 return GetEventHandler()->ProcessEvent(event
);
3745 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3747 wxInitDialogEvent
event(GetId());
3748 event
.SetEventObject(this);
3750 return GetEventHandler()->ProcessEvent(event
);
3753 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3755 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3756 wxUnusedVar(wParam
);
3758 #else // __WXMICROWIN__
3759 HDROP hFilesInfo
= (HDROP
) wParam
;
3761 // Get the total number of files dropped
3762 UINT gwFilesDropped
= ::DragQueryFile
3770 wxString
*files
= new wxString
[gwFilesDropped
];
3771 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3773 // first get the needed buffer length (+1 for terminating NUL)
3774 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3776 // and now get the file name
3777 ::DragQueryFile(hFilesInfo
, wIndex
,
3778 wxStringBuffer(files
[wIndex
], len
), len
);
3780 DragFinish (hFilesInfo
);
3782 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3783 event
.SetEventObject(this);
3786 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3787 event
.m_pos
.x
= dropPoint
.x
;
3788 event
.m_pos
.y
= dropPoint
.y
;
3790 return GetEventHandler()->ProcessEvent(event
);
3795 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3797 int WXUNUSED(mouseMsg
))
3799 #ifndef __WXMICROWIN__
3800 // the logic is as follows:
3801 // -1. don't set cursor for non client area, including but not limited to
3802 // the title bar, scrollbars, &c
3803 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3804 // 1. if we have the cursor set it unless wxIsBusy()
3805 // 2. if we're a top level window, set some cursor anyhow
3806 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3808 if ( nHitTest
!= HTCLIENT
)
3813 HCURSOR hcursor
= 0;
3815 // first ask the user code - it may wish to set the cursor in some very
3816 // specific way (for example, depending on the current position)
3819 if ( !::GetCursorPosWinCE(&pt
))
3821 if ( !::GetCursorPos(&pt
) )
3824 wxLogLastError(wxT("GetCursorPos"));
3829 ScreenToClient(&x
, &y
);
3830 wxSetCursorEvent
event(x
, y
);
3832 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3833 if ( processedEvtSetCursor
&& event
.HasCursor() )
3835 hcursor
= GetHcursorOf(event
.GetCursor());
3840 bool isBusy
= wxIsBusy();
3842 // the test for processedEvtSetCursor is here to prevent using m_cursor
3843 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3844 // it - this is a way to say that our cursor shouldn't be used for this
3846 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3848 hcursor
= GetHcursorOf(m_cursor
);
3855 hcursor
= wxGetCurrentBusyCursor();
3857 else if ( !hcursor
)
3859 const wxCursor
*cursor
= wxGetGlobalCursor();
3860 if ( cursor
&& cursor
->Ok() )
3862 hcursor
= GetHcursorOf(*cursor
);
3870 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3872 ::SetCursor(hcursor
);
3874 // cursor set, stop here
3877 #endif // __WXMICROWIN__
3879 // pass up the window chain
3883 bool wxWindowMSW::HandlePower(WXWPARAM
WXUNUSED_IN_WINCE(wParam
),
3884 WXLPARAM
WXUNUSED(lParam
),
3885 bool *WXUNUSED_IN_WINCE(vetoed
))
3891 wxEventType evtType
;
3894 case PBT_APMQUERYSUSPEND
:
3895 evtType
= wxEVT_POWER_SUSPENDING
;
3898 case PBT_APMQUERYSUSPENDFAILED
:
3899 evtType
= wxEVT_POWER_SUSPEND_CANCEL
;
3902 case PBT_APMSUSPEND
:
3903 evtType
= wxEVT_POWER_SUSPENDED
;
3906 case PBT_APMRESUMESUSPEND
:
3907 #ifdef PBT_APMRESUMEAUTOMATIC
3908 case PBT_APMRESUMEAUTOMATIC
:
3910 evtType
= wxEVT_POWER_RESUME
;
3914 wxLogDebug(_T("Unknown WM_POWERBROADCAST(%d) event"), wParam
);
3917 // these messages are currently not mapped to wx events
3918 case PBT_APMQUERYSTANDBY
:
3919 case PBT_APMQUERYSTANDBYFAILED
:
3920 case PBT_APMSTANDBY
:
3921 case PBT_APMRESUMESTANDBY
:
3922 case PBT_APMBATTERYLOW
:
3923 case PBT_APMPOWERSTATUSCHANGE
:
3924 case PBT_APMOEMEVENT
:
3925 case PBT_APMRESUMECRITICAL
:
3926 evtType
= wxEVT_NULL
;
3930 // don't handle unknown messages
3931 if ( evtType
== wxEVT_NULL
)
3934 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
3936 wxPowerEvent
event(evtType
);
3937 if ( !GetEventHandler()->ProcessEvent(event
) )
3940 *vetoed
= event
.IsVetoed();
3946 // ---------------------------------------------------------------------------
3947 // owner drawn stuff
3948 // ---------------------------------------------------------------------------
3950 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3951 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3952 #define WXUNUSED_UNLESS_ODRAWN(param) param
3954 #define WXUNUSED_UNLESS_ODRAWN(param)
3958 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3959 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3961 #if wxUSE_OWNER_DRAWN
3963 #if wxUSE_MENUS_NATIVE
3964 // is it a menu item?
3965 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3966 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3968 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3970 // see comment before the same test in MSWOnMeasureItem() below
3974 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3975 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3977 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3978 // the DC from being released
3979 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3980 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3981 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3982 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3984 return pMenuItem
->OnDrawItem
3988 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3989 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3992 #endif // wxUSE_MENUS_NATIVE
3994 #endif // USE_OWNER_DRAWN
3996 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3998 #if wxUSE_OWNER_DRAWN
3999 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4000 #else // !wxUSE_OWNER_DRAWN
4001 // we may still have owner-drawn buttons internally because we have to make
4002 // them owner-drawn to support colour change
4005 wxDynamicCast(FindItem(id
), wxButton
)
4010 #endif // USE_OWNER_DRAWN
4014 return item
->MSWOnDraw(itemStruct
);
4017 #endif // wxUSE_CONTROLS
4023 wxWindowMSW::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
4025 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4026 // is it a menu item?
4027 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
4028 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
4030 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
4032 // according to Carsten Fuchs the pointer may be NULL under XP if an
4033 // MDI child frame is initially maximized, see this for more info:
4034 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4036 // so silently ignore it instead of asserting
4040 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
4041 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
4044 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
4046 pMeasureStruct
->itemWidth
= w
;
4047 pMeasureStruct
->itemHeight
= h
;
4052 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
4055 return item
->MSWOnMeasure(itemStruct
);
4059 wxUnusedVar(itemStruct
);
4060 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4065 // ---------------------------------------------------------------------------
4066 // colours and palettes
4067 // ---------------------------------------------------------------------------
4069 bool wxWindowMSW::HandleSysColorChange()
4071 wxSysColourChangedEvent event
;
4072 event
.SetEventObject(this);
4074 (void)GetEventHandler()->ProcessEvent(event
);
4076 // always let the system carry on the default processing to allow the
4077 // native controls to react to the colours update
4081 bool wxWindowMSW::HandleDisplayChange()
4083 wxDisplayChangedEvent event
;
4084 event
.SetEventObject(this);
4086 return GetEventHandler()->ProcessEvent(event
);
4089 #ifndef __WXMICROWIN__
4091 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
4093 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4097 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
4100 *brush
= item
->MSWControlColor(hDC
, hWnd
);
4102 #endif // wxUSE_CONTROLS
4105 return *brush
!= NULL
;
4108 #endif // __WXMICROWIN__
4110 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
4113 // same as below except we don't respond to our own messages
4114 if ( hWndPalChange
!= GetHWND() )
4116 // check to see if we our our parents have a custom palette
4117 wxWindowMSW
*win
= this;
4118 while ( win
&& !win
->HasCustomPalette() )
4120 win
= win
->GetParent();
4123 if ( win
&& win
->HasCustomPalette() )
4125 // realize the palette to see whether redrawing is needed
4126 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
4127 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4128 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4130 int result
= ::RealizePalette(hdc
);
4132 // restore the palette (before releasing the DC)
4133 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
4134 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
4135 ::RealizePalette(hdc
);
4136 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
4138 // now check for the need to redraw
4140 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
4144 #endif // wxUSE_PALETTE
4146 wxPaletteChangedEvent
event(GetId());
4147 event
.SetEventObject(this);
4148 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
4150 return GetEventHandler()->ProcessEvent(event
);
4153 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
4155 // notify windows on the capture stack about lost capture
4156 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4157 wxWindowBase::NotifyCaptureLost();
4159 wxWindow
*win
= wxFindWinFromHandle(hWndGainedCapture
);
4160 wxMouseCaptureChangedEvent
event(GetId(), win
);
4161 event
.SetEventObject(this);
4162 return GetEventHandler()->ProcessEvent(event
);
4165 bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam
, WXLPARAM lParam
)
4167 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4168 // we need to send this to child windows (it is only sent to top-level
4169 // windows) so {list,tree}ctrls can adjust their font size if necessary
4170 // this is exactly how explorer does it to enable the font size changes
4172 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4175 // top-level windows already get this message from the system
4176 wxWindow
*win
= node
->GetData();
4177 if ( !win
->IsTopLevel() )
4179 ::SendMessage(GetHwndOf(win
), WM_SETTINGCHANGE
, wParam
, lParam
);
4182 node
= node
->GetNext();
4185 // let the system handle it
4189 bool wxWindowMSW::HandleQueryNewPalette()
4193 // check to see if we our our parents have a custom palette
4194 wxWindowMSW
*win
= this;
4195 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
4196 if (win
->HasCustomPalette()) {
4197 /* realize the palette to see whether redrawing is needed */
4198 HDC hdc
= ::GetDC((HWND
) GetHWND());
4199 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4200 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
4202 int result
= ::RealizePalette(hdc
);
4203 /* restore the palette (before releasing the DC) */
4204 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
4205 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
4206 ::RealizePalette(hdc
);
4207 ::ReleaseDC((HWND
) GetHWND(), hdc
);
4208 /* now check for the need to redraw */
4210 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
4212 #endif // wxUSE_PALETTE
4214 wxQueryNewPaletteEvent
event(GetId());
4215 event
.SetEventObject(this);
4217 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
4220 // Responds to colour changes: passes event on to children.
4221 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
4223 // the top level window also reset the standard colour map as it might have
4224 // changed (there is no need to do it for the non top level windows as we
4225 // only have to do it once)
4229 gs_hasStdCmap
= false;
4231 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4234 // Only propagate to non-top-level windows because Windows already
4235 // sends this event to all top-level ones
4236 wxWindow
*win
= node
->GetData();
4237 if ( !win
->IsTopLevel() )
4239 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4240 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4241 // the standard controls
4242 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
4245 node
= node
->GetNext();
4249 extern wxCOLORMAP
*wxGetStdColourMap()
4251 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
4252 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
4254 if ( !gs_hasStdCmap
)
4256 static bool s_coloursInit
= false;
4258 if ( !s_coloursInit
)
4260 // When a bitmap is loaded, the RGB values can change (apparently
4261 // because Windows adjusts them to care for the old programs always
4262 // using 0xc0c0c0 while the transparent colour for the new Windows
4263 // versions is different). But we do this adjustment ourselves so
4264 // we want to avoid Windows' "help" and for this we need to have a
4265 // reference bitmap which can tell us what the RGB values change
4267 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
4268 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
4269 if ( stdColourBitmap
.Ok() )
4271 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4272 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
4273 _T("forgot to update wxBITMAP_STD_COLOURS!") );
4276 memDC
.SelectObject(stdColourBitmap
);
4279 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
4281 memDC
.GetPixel(i
, 0, &colour
);
4282 s_stdColours
[i
] = wxColourToRGB(colour
);
4285 else // wxBITMAP_STD_COLOURS couldn't be loaded
4287 s_stdColours
[0] = RGB(000,000,000); // black
4288 s_stdColours
[1] = RGB(128,128,128); // dark grey
4289 s_stdColours
[2] = RGB(192,192,192); // light grey
4290 s_stdColours
[3] = RGB(255,255,255); // white
4291 //s_stdColours[4] = RGB(000,000,255); // blue
4292 //s_stdColours[5] = RGB(255,000,255); // magenta
4295 s_coloursInit
= true;
4298 gs_hasStdCmap
= true;
4300 // create the colour map
4301 #define INIT_CMAP_ENTRY(col) \
4302 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4303 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4305 INIT_CMAP_ENTRY(BTNTEXT
);
4306 INIT_CMAP_ENTRY(BTNSHADOW
);
4307 INIT_CMAP_ENTRY(BTNFACE
);
4308 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
4310 #undef INIT_CMAP_ENTRY
4316 // ---------------------------------------------------------------------------
4318 // ---------------------------------------------------------------------------
4320 bool wxWindowMSW::HandlePaint()
4322 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4324 wxLogLastError(wxT("CreateRectRgn"));
4325 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
4326 wxLogLastError(wxT("GetUpdateRgn"));
4328 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
4330 wxPaintEvent
event(m_windowId
);
4331 event
.SetEventObject(this);
4333 bool processed
= GetEventHandler()->ProcessEvent(event
);
4335 // note that we must generate NC event after the normal one as otherwise
4336 // BeginPaint() will happily overwrite our decorations with the background
4338 wxNcPaintEvent
eventNc(m_windowId
);
4339 eventNc
.SetEventObject(this);
4340 GetEventHandler()->ProcessEvent(eventNc
);
4345 // Can be called from an application's OnPaint handler
4346 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
4348 #ifdef __WXUNIVERSAL__
4351 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
4354 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
4359 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
4364 dc
.SetWindow((wxWindow
*)this);
4366 wxEraseEvent
event(m_windowId
, &dc
);
4367 event
.SetEventObject(this);
4368 bool rc
= GetEventHandler()->ProcessEvent(event
);
4370 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4371 dc
.SelectOldObjects(hdc
);
4376 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4378 // standard non top level controls (i.e. except the dialogs) always erase
4379 // their background themselves in HandleCtlColor() or have some control-
4380 // specific ways to set the colours (common controls)
4381 if ( IsOfStandardClass() && !IsTopLevel() )
4387 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4389 // don't skip the event here, custom background means that the app
4390 // is drawing it itself in its OnPaint(), so don't draw it at all
4391 // now to avoid flicker
4396 // do default background painting
4397 if ( !DoEraseBackground(GetHdcOf(*event
.GetDC())) )
4399 // let the system paint the background
4404 bool wxWindowMSW::DoEraseBackground(WXHDC hDC
)
4406 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4410 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4416 wxWindowMSW::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4420 // our background colour applies to:
4421 // 1. this window itself, always
4422 // 2. all children unless the colour is "not inheritable"
4423 // 3. even if it is not inheritable, our immediate transparent
4424 // children should still inherit it -- but not any transparent
4425 // children because it would look wrong if a child of non
4426 // transparent child would show our bg colour when the child itself
4428 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4431 (win
&& win
->HasTransparentBackground() &&
4432 win
->GetParent() == this) )
4434 // draw children with the same colour as the parent
4436 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4438 return (WXHBRUSH
)GetHbrushOf(*brush
);
4445 WXHBRUSH
wxWindowMSW::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4448 hWndToPaint
= GetHWND();
4450 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4452 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4456 // background is not inherited beyond top level windows
4457 if ( win
->IsTopLevel() )
4464 bool wxWindowMSW::HandlePrintClient(WXHDC
WXUNUSED(hDC
))
4466 // TODO: handle wxBG_STYLE_CUSTOM and/or wxBG_STYLE_COLOUR here so when
4467 // DrawParentThemeBackground() from uxtheme.dll is called we don't get
4468 // the default background e.g. the border when custom drawing buttons
4472 // ---------------------------------------------------------------------------
4473 // moving and resizing
4474 // ---------------------------------------------------------------------------
4476 bool wxWindowMSW::HandleMinimize()
4478 wxIconizeEvent
event(m_windowId
);
4479 event
.SetEventObject(this);
4481 return GetEventHandler()->ProcessEvent(event
);
4484 bool wxWindowMSW::HandleMaximize()
4486 wxMaximizeEvent
event(m_windowId
);
4487 event
.SetEventObject(this);
4489 return GetEventHandler()->ProcessEvent(event
);
4492 bool wxWindowMSW::HandleMove(int x
, int y
)
4495 wxMoveEvent
event(point
, m_windowId
);
4496 event
.SetEventObject(this);
4498 return GetEventHandler()->ProcessEvent(event
);
4501 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4503 wxMoveEvent
event(rect
, m_windowId
);
4504 event
.SetEventObject(this);
4506 bool rc
= GetEventHandler()->ProcessEvent(event
);
4508 rect
= event
.GetRect();
4512 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4514 #if USE_DEFERRED_SIZING
4515 // when we resize this window, its children are probably going to be
4516 // repositioned as well, prepare to use DeferWindowPos() for them
4517 int numChildren
= 0;
4518 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4520 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4525 // Protect against valid m_hDWP being overwritten
4526 bool useDefer
= false;
4528 if ( numChildren
> 1 )
4532 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4535 wxLogLastError(_T("BeginDeferWindowPos"));
4541 #endif // USE_DEFERRED_SIZING
4543 // update this window size
4544 bool processed
= false;
4548 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4549 // fall through nevertheless
4553 // we're not interested in these messages at all
4556 case SIZE_MINIMIZED
:
4557 processed
= HandleMinimize();
4560 case SIZE_MAXIMIZED
:
4561 /* processed = */ HandleMaximize();
4562 // fall through to send a normal size event as well
4565 // don't use w and h parameters as they specify the client size
4566 // while according to the docs EVT_SIZE handler is supposed to
4567 // receive the total size
4568 wxSizeEvent
event(GetSize(), m_windowId
);
4569 event
.SetEventObject(this);
4571 processed
= GetEventHandler()->ProcessEvent(event
);
4574 #if USE_DEFERRED_SIZING
4575 // and finally change the positions of all child windows at once
4576 if ( useDefer
&& m_hDWP
)
4578 // reset m_hDWP to NULL so that child windows don't try to use our
4579 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4580 // happen anyhow normally but who knows what weird flow of control we
4581 // may have depending on what the users EVT_SIZE handler does...)
4582 HDWP hDWP
= (HDWP
)m_hDWP
;
4585 // do put all child controls in place at once
4586 if ( !::EndDeferWindowPos(hDWP
) )
4588 wxLogLastError(_T("EndDeferWindowPos"));
4591 // Reset our children's pending pos/size values.
4592 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
4594 node
= node
->GetNext() )
4596 wxWindowMSW
*child
= node
->GetData();
4597 child
->m_pendingPosition
= wxDefaultPosition
;
4598 child
->m_pendingSize
= wxDefaultSize
;
4601 #endif // USE_DEFERRED_SIZING
4606 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4608 wxSizeEvent
event(rect
, m_windowId
);
4609 event
.SetEventObject(this);
4611 bool rc
= GetEventHandler()->ProcessEvent(event
);
4613 rect
= event
.GetRect();
4617 bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4622 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4626 int minWidth
= GetMinWidth(),
4627 minHeight
= GetMinHeight(),
4628 maxWidth
= GetMaxWidth(),
4629 maxHeight
= GetMaxHeight();
4631 if ( minWidth
!= wxDefaultCoord
)
4633 info
->ptMinTrackSize
.x
= minWidth
;
4637 if ( minHeight
!= wxDefaultCoord
)
4639 info
->ptMinTrackSize
.y
= minHeight
;
4643 if ( maxWidth
!= wxDefaultCoord
)
4645 info
->ptMaxTrackSize
.x
= maxWidth
;
4649 if ( maxHeight
!= wxDefaultCoord
)
4651 info
->ptMaxTrackSize
.y
= maxHeight
;
4659 // ---------------------------------------------------------------------------
4661 // ---------------------------------------------------------------------------
4663 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4665 #if wxUSE_MENUS_NATIVE
4666 if ( !cmd
&& wxCurrentPopupMenu
)
4668 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4669 wxCurrentPopupMenu
= NULL
;
4671 return popupMenu
->MSWCommand(cmd
, id
);
4673 #endif // wxUSE_MENUS_NATIVE
4675 wxWindow
*win
= NULL
;
4677 // first try to find it from HWND - this works even with the broken
4678 // programs using the same ids for different controls
4681 win
= wxFindWinFromHandle(control
);
4687 // must cast to a signed type before comparing with other ids!
4688 win
= FindItem((signed short)id
);
4693 return win
->MSWCommand(cmd
, id
);
4696 // the messages sent from the in-place edit control used by the treectrl
4697 // for label editing have id == 0, but they should _not_ be treated as menu
4698 // messages (they are EN_XXX ones, in fact) so don't translate anything
4699 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4702 // If no child window, it may be an accelerator, e.g. for a popup menu
4705 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4706 event
.SetEventObject(this);
4710 return GetEventHandler()->ProcessEvent(event
);
4714 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4715 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4716 // notifications to its parent which we want to reflect back to
4718 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4719 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4721 #endif // wxUSE_SPINCTRL
4723 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
4724 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
4725 // notifications to its parent which we want to reflect back to
4727 wxChoice
*choice
= wxChoice::GetChoiceForListBox(control
);
4728 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
4736 // ---------------------------------------------------------------------------
4738 // ---------------------------------------------------------------------------
4740 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4744 // our client coords are not quite the same as Windows ones
4745 wxPoint pt
= GetClientAreaOrigin();
4746 event
.m_x
= x
- pt
.x
;
4747 event
.m_y
= y
- pt
.y
;
4749 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4750 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4751 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4752 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4753 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4754 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4757 event
.SetTimestamp(::GetMessageTime());
4760 event
.SetEventObject(this);
4761 event
.SetId(GetId());
4763 #if wxUSE_MOUSEEVENT_HACK
4764 gs_lastMouseEvent
.pos
= ClientToScreen(wxPoint(x
, y
));
4765 gs_lastMouseEvent
.type
= event
.GetEventType();
4766 #endif // wxUSE_MOUSEEVENT_HACK
4770 // Windows doesn't send the mouse events to the static controls (which are
4771 // transparent in the sense that their WM_NCHITTEST handler returns
4772 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4773 // and so we manually check if we don't have a child window under mouse and if
4774 // we do, send the event to it instead of the window Windows had sent WM_XXX
4777 // Notice that this is not done for the mouse move events because this could
4778 // (would?) be too slow, but only for clicks which means that the static texts
4779 // still don't get move, enter nor leave events.
4780 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
)
4782 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4784 // first try to find a non transparent child: this allows us to send events
4785 // to a static text which is inside a static box, for example
4786 POINT pt
= { *x
, *y
};
4787 HWND hwnd
= GetHwndOf(win
),
4791 hwndUnderMouse
= ::ChildWindowFromPoint
4797 hwndUnderMouse
= ::ChildWindowFromPointEx
4807 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4809 // now try any child window at all
4810 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4813 // check that we have a child window which is susceptible to receive mouse
4814 // events: for this it must be shown and enabled
4815 if ( hwndUnderMouse
&&
4816 hwndUnderMouse
!= hwnd
&&
4817 ::IsWindowVisible(hwndUnderMouse
) &&
4818 ::IsWindowEnabled(hwndUnderMouse
) )
4820 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4821 if ( winUnderMouse
)
4823 // translate the mouse coords to the other window coords
4824 win
->ClientToScreen(x
, y
);
4825 winUnderMouse
->ScreenToClient(x
, y
);
4827 win
= winUnderMouse
;
4833 #endif // __WXWINCE__
4835 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4837 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4838 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4839 // from the message id and take the value in the table to get wxWin event
4841 static const wxEventType eventsMouse
[] =
4855 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4856 InitMouseEvent(event
, x
, y
, flags
);
4858 return GetEventHandler()->ProcessEvent(event
);
4861 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4863 if ( !m_mouseInWindow
)
4865 // it would be wrong to assume that just because we get a mouse move
4866 // event that the mouse is inside the window: although this is usually
4867 // true, it is not if we had captured the mouse, so we need to check
4868 // the mouse coordinates here
4869 if ( !HasCapture() || IsMouseInWindow() )
4871 // Generate an ENTER event
4872 m_mouseInWindow
= true;
4874 #ifdef HAVE_TRACKMOUSEEVENT
4875 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
4877 trackinfo
.dwFlags
= TME_LEAVE
;
4878 trackinfo
.hwndTrack
= GetHwnd();
4880 // Use the commctrl.h _TrackMouseEvent(), which will call the real
4881 // TrackMouseEvent() if available or emulate it
4882 _TrackMouseEvent(&trackinfo
);
4883 #endif // HAVE_TRACKMOUSEEVENT
4885 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4886 InitMouseEvent(event
, x
, y
, flags
);
4888 (void)GetEventHandler()->ProcessEvent(event
);
4891 #ifdef HAVE_TRACKMOUSEEVENT
4894 // Check if we need to send a LEAVE event
4895 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
4896 // send it here if we are using native mouse leave tracking
4897 if ( HasCapture() && !IsMouseInWindow() )
4899 GenerateMouseLeave();
4902 #endif // HAVE_TRACKMOUSEEVENT
4904 #if wxUSE_MOUSEEVENT_HACK
4905 // Windows often generates mouse events even if mouse position hasn't
4906 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
4908 // Filter this out as it can result in unexpected behaviour compared to
4910 if ( gs_lastMouseEvent
.type
== wxEVT_RIGHT_DOWN
||
4911 gs_lastMouseEvent
.type
== wxEVT_LEFT_DOWN
||
4912 gs_lastMouseEvent
.type
== wxEVT_MIDDLE_DOWN
||
4913 gs_lastMouseEvent
.type
== wxEVT_MOTION
)
4915 if ( ClientToScreen(wxPoint(x
, y
)) == gs_lastMouseEvent
.pos
)
4917 gs_lastMouseEvent
.type
= wxEVT_MOTION
;
4922 #endif // wxUSE_MOUSEEVENT_HACK
4924 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4928 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4930 #if wxUSE_MOUSEWHEEL
4931 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
4932 // forwarded up to the parent by DefWindowProc()) and not in the client
4933 // ones as all the other messages, translate them to the client coords for
4936 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
4937 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4938 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
4939 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4940 event
.m_wheelDelta
= WHEEL_DELTA
;
4942 static int s_linesPerRotation
= -1;
4943 if ( s_linesPerRotation
== -1 )
4945 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4946 &s_linesPerRotation
, 0))
4948 // this is not supposed to happen
4949 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4951 // the default is 3, so use it if SystemParametersInfo() failed
4952 s_linesPerRotation
= 3;
4956 event
.m_linesPerAction
= s_linesPerRotation
;
4957 return GetEventHandler()->ProcessEvent(event
);
4959 #else // !wxUSE_MOUSEWHEEL
4960 wxUnusedVar(wParam
);
4961 wxUnusedVar(lParam
);
4964 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
4967 void wxWindowMSW::GenerateMouseLeave()
4969 m_mouseInWindow
= false;
4972 if ( wxIsShiftDown() )
4974 if ( wxIsCtrlDown() )
4975 state
|= MK_CONTROL
;
4977 // Only the high-order bit should be tested
4978 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
4979 state
|= MK_LBUTTON
;
4980 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
4981 state
|= MK_MBUTTON
;
4982 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
4983 state
|= MK_RBUTTON
;
4987 if ( !::GetCursorPosWinCE(&pt
) )
4989 if ( !::GetCursorPos(&pt
) )
4992 wxLogLastError(_T("GetCursorPos"));
4995 // we need to have client coordinates here for symmetry with
4996 // wxEVT_ENTER_WINDOW
4997 RECT rect
= wxGetWindowRect(GetHwnd());
5001 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
5002 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
5004 (void)GetEventHandler()->ProcessEvent(event
);
5007 // ---------------------------------------------------------------------------
5008 // keyboard handling
5009 // ---------------------------------------------------------------------------
5011 // create the key event of the given type for the given key - used by
5012 // HandleChar and HandleKeyDown/Up
5013 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
5016 WXWPARAM wParam
) const
5018 wxKeyEvent
event(evType
);
5019 event
.SetId(GetId());
5020 event
.m_shiftDown
= wxIsShiftDown();
5021 event
.m_controlDown
= wxIsCtrlDown();
5022 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
5024 event
.SetEventObject((wxWindow
*)this); // const_cast
5025 event
.m_keyCode
= id
;
5027 event
.m_uniChar
= (wxChar
) wParam
;
5029 event
.m_rawCode
= (wxUint32
) wParam
;
5030 event
.m_rawFlags
= (wxUint32
) lParam
;
5032 event
.SetTimestamp(::GetMessageTime());
5035 // translate the position to client coords
5038 GetCursorPosWinCE(&pt
);
5043 GetWindowRect(GetHwnd(),&rect
);
5053 // isASCII is true only when we're called from WM_CHAR handler and not from
5055 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
5062 else // we're called from WM_KEYDOWN
5064 // don't pass lParam to wxCharCodeMSWToWX() here because we don't want
5065 // to get numpad key codes: CHAR events should use the logical keys
5066 // such as WXK_HOME instead of WXK_NUMPAD_HOME which is for KEY events
5067 id
= wxCharCodeMSWToWX(wParam
);
5070 // it's ASCII and will be processed here only when called from
5071 // WM_CHAR (i.e. when isASCII = true), don't process it now
5076 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
5078 // the alphanumeric keys produced by pressing AltGr+something on European
5079 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5080 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5081 // alphanumeric, so pretend that there are no modifiers at all (the
5082 // KEY_DOWN event would still have the correct modifiers if they're really
5084 if ( event
.m_controlDown
&& event
.m_altDown
&&
5085 (id
>= 32 && id
< 256) )
5087 event
.m_controlDown
=
5088 event
.m_altDown
= false;
5091 return GetEventHandler()->ProcessEvent(event
);
5094 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
5096 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5100 // normal ASCII char
5104 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
5105 return GetEventHandler()->ProcessEvent(event
);
5108 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
5110 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5114 // normal ASCII char
5118 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
5119 return GetEventHandler()->ProcessEvent(event
);
5122 int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
5123 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
5125 // FIXME: implement GetMenuItemCount for WinCE, possibly
5126 // in terms of GetMenuItemInfo
5128 const HMENU hmenu
= (HMENU
)lParam
;
5132 mii
.cbSize
= sizeof(MENUITEMINFO
);
5134 // we could use MIIM_FTYPE here as we only need to know if the item is
5135 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5136 // MIIM_FTYPE is not supported under Win95
5137 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
5139 // find if we have this letter in any owner drawn item
5140 const int count
= ::GetMenuItemCount(hmenu
);
5141 for ( int i
= 0; i
< count
; i
++ )
5143 // previous loop iteration could modify it, reset it back before
5144 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5147 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
5149 if ( mii
.fType
== MFT_OWNERDRAW
)
5151 // dwItemData member of the MENUITEMINFO is a
5152 // pointer to the associated wxMenuItem -- see the
5153 // menu creation code
5154 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
5156 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
5159 if ( *p
== _T('&') )
5161 // this is not the accel char, find the real one
5162 p
= wxStrchr(p
+ 1, _T('&'));
5164 else // got the accel char
5166 // FIXME-UNICODE: this comparison doesn't risk to work
5167 // for non ASCII accelerator characters I'm afraid, but
5169 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
5175 // this one doesn't match
5182 else // failed to get the menu text?
5184 // it's not fatal, so don't show error, but still log it
5185 wxLogLastError(_T("GetMenuItemInfo"));
5192 bool wxWindowMSW::HandleClipboardEvent( WXUINT nMsg
)
5194 const wxEventType type
= ( nMsg
== WM_CUT
) ? wxEVT_COMMAND_TEXT_CUT
:
5195 ( nMsg
== WM_COPY
) ? wxEVT_COMMAND_TEXT_COPY
:
5196 /*( nMsg == WM_PASTE ) ? */ wxEVT_COMMAND_TEXT_PASTE
;
5197 wxClipboardTextEvent
evt(type
, GetId());
5199 evt
.SetEventObject(this);
5201 return GetEventHandler()->ProcessEvent(evt
);
5204 // ---------------------------------------------------------------------------
5206 // ---------------------------------------------------------------------------
5208 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
5212 if ( flags
& JOY_BUTTON1CHG
)
5213 change
= wxJOY_BUTTON1
;
5214 if ( flags
& JOY_BUTTON2CHG
)
5215 change
= wxJOY_BUTTON2
;
5216 if ( flags
& JOY_BUTTON3CHG
)
5217 change
= wxJOY_BUTTON3
;
5218 if ( flags
& JOY_BUTTON4CHG
)
5219 change
= wxJOY_BUTTON4
;
5222 if ( flags
& JOY_BUTTON1
)
5223 buttons
|= wxJOY_BUTTON1
;
5224 if ( flags
& JOY_BUTTON2
)
5225 buttons
|= wxJOY_BUTTON2
;
5226 if ( flags
& JOY_BUTTON3
)
5227 buttons
|= wxJOY_BUTTON3
;
5228 if ( flags
& JOY_BUTTON4
)
5229 buttons
|= wxJOY_BUTTON4
;
5231 // the event ids aren't consecutive so we can't use table based lookup
5233 wxEventType eventType
;
5238 eventType
= wxEVT_JOY_MOVE
;
5243 eventType
= wxEVT_JOY_MOVE
;
5248 eventType
= wxEVT_JOY_ZMOVE
;
5253 eventType
= wxEVT_JOY_ZMOVE
;
5256 case MM_JOY1BUTTONDOWN
:
5258 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5261 case MM_JOY2BUTTONDOWN
:
5263 eventType
= wxEVT_JOY_BUTTON_DOWN
;
5266 case MM_JOY1BUTTONUP
:
5268 eventType
= wxEVT_JOY_BUTTON_UP
;
5271 case MM_JOY2BUTTONUP
:
5273 eventType
= wxEVT_JOY_BUTTON_UP
;
5277 wxFAIL_MSG(wxT("no such joystick event"));
5282 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
5283 event
.SetPosition(wxPoint(x
, y
));
5284 event
.SetEventObject(this);
5286 return GetEventHandler()->ProcessEvent(event
);
5296 // ---------------------------------------------------------------------------
5298 // ---------------------------------------------------------------------------
5300 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
5301 WXWORD pos
, WXHWND control
)
5303 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
5305 wxWindow
*child
= wxFindWinFromHandle(control
);
5307 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
5310 wxScrollWinEvent event
;
5311 event
.SetPosition(pos
);
5312 event
.SetOrientation(orientation
);
5313 event
.SetEventObject(this);
5318 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
5322 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
5326 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
5330 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
5334 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
5338 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5341 case SB_THUMBPOSITION
:
5343 // under Win32, the scrollbar range and position are 32 bit integers,
5344 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5345 // explicitly query the scrollbar for the correct position (this must
5346 // be done only for these two SB_ events as they are the only one
5347 // carrying the scrollbar position)
5349 WinStruct
<SCROLLINFO
> scrollInfo
;
5350 scrollInfo
.fMask
= SIF_TRACKPOS
;
5352 if ( !::GetScrollInfo(GetHwnd(),
5353 orientation
== wxHORIZONTAL
? SB_HORZ
5357 // Not necessarily an error, if there are no scrollbars yet.
5358 // wxLogLastError(_T("GetScrollInfo"));
5361 event
.SetPosition(scrollInfo
.nTrackPos
);
5364 event
.SetEventType( wParam
== SB_THUMBPOSITION
5365 ? wxEVT_SCROLLWIN_THUMBRELEASE
5366 : wxEVT_SCROLLWIN_THUMBTRACK
);
5373 return GetEventHandler()->ProcessEvent(event
);
5376 // ===========================================================================
5378 // ===========================================================================
5380 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5383 HDC dc
= ::GetDC((HWND
) wnd
);
5386 // the_font.UseResource();
5387 // the_font.RealizeResource();
5388 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5390 was
= (HFONT
) SelectObject(dc
,fnt
);
5392 GetTextMetrics(dc
, &tm
);
5395 SelectObject(dc
,was
);
5397 ReleaseDC((HWND
)wnd
, dc
);
5400 *x
= tm
.tmAveCharWidth
;
5402 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5404 // the_font.ReleaseResource();
5407 // use the "extended" bit (24) of lParam to distinguish extended keys
5408 // from normal keys as the same key is sent
5410 int ChooseNormalOrExtended(int lParam
, int keyNormal
, int keyExtended
)
5412 // except that if lParam is 0, it means we don't have real lParam from
5413 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
5414 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
5415 // non-numpad (hence extended) key as this is a more common case
5416 return !lParam
|| (lParam
& (1 << 24)) ? keyExtended
: keyNormal
;
5419 // this array contains the Windows virtual key codes which map one to one to
5420 // WXK_xxx constants and is used in wxCharCodeMSWToWX/WXToMSW() below
5422 // note that keys having a normal and numpad version (e.g. WXK_HOME and
5423 // WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
5424 static const struct wxKeyMapping
5428 } gs_specialKeys
[] =
5430 { VK_CANCEL
, WXK_CANCEL
},
5431 { VK_BACK
, WXK_BACK
},
5432 { VK_TAB
, WXK_TAB
},
5433 { VK_CLEAR
, WXK_CLEAR
},
5434 { VK_SHIFT
, WXK_SHIFT
},
5435 { VK_CONTROL
, WXK_CONTROL
},
5436 { VK_MENU
, WXK_ALT
},
5437 { VK_PAUSE
, WXK_PAUSE
},
5438 { VK_CAPITAL
, WXK_CAPITAL
},
5439 { VK_SPACE
, WXK_SPACE
},
5440 { VK_ESCAPE
, WXK_ESCAPE
},
5441 { VK_SELECT
, WXK_SELECT
},
5442 { VK_PRINT
, WXK_PRINT
},
5443 { VK_EXECUTE
, WXK_EXECUTE
},
5444 { VK_SNAPSHOT
, WXK_SNAPSHOT
},
5445 { VK_HELP
, WXK_HELP
},
5447 { VK_NUMPAD0
, WXK_NUMPAD0
},
5448 { VK_NUMPAD1
, WXK_NUMPAD1
},
5449 { VK_NUMPAD2
, WXK_NUMPAD2
},
5450 { VK_NUMPAD3
, WXK_NUMPAD3
},
5451 { VK_NUMPAD4
, WXK_NUMPAD4
},
5452 { VK_NUMPAD5
, WXK_NUMPAD5
},
5453 { VK_NUMPAD6
, WXK_NUMPAD6
},
5454 { VK_NUMPAD7
, WXK_NUMPAD7
},
5455 { VK_NUMPAD8
, WXK_NUMPAD8
},
5456 { VK_NUMPAD9
, WXK_NUMPAD9
},
5457 { VK_MULTIPLY
, WXK_NUMPAD_MULTIPLY
},
5458 { VK_ADD
, WXK_NUMPAD_ADD
},
5459 { VK_SUBTRACT
, WXK_NUMPAD_SUBTRACT
},
5460 { VK_DECIMAL
, WXK_NUMPAD_DECIMAL
},
5461 { VK_DIVIDE
, WXK_NUMPAD_DIVIDE
},
5472 { VK_F10
, WXK_F10
},
5473 { VK_F11
, WXK_F11
},
5474 { VK_F12
, WXK_F12
},
5475 { VK_F13
, WXK_F13
},
5476 { VK_F14
, WXK_F14
},
5477 { VK_F15
, WXK_F15
},
5478 { VK_F16
, WXK_F16
},
5479 { VK_F17
, WXK_F17
},
5480 { VK_F18
, WXK_F18
},
5481 { VK_F19
, WXK_F19
},
5482 { VK_F20
, WXK_F20
},
5483 { VK_F21
, WXK_F21
},
5484 { VK_F22
, WXK_F22
},
5485 { VK_F23
, WXK_F23
},
5486 { VK_F24
, WXK_F24
},
5488 { VK_NUMLOCK
, WXK_NUMLOCK
},
5489 { VK_SCROLL
, WXK_SCROLL
},
5492 { VK_LWIN
, WXK_WINDOWS_LEFT
},
5493 { VK_RWIN
, WXK_WINDOWS_RIGHT
},
5494 { VK_APPS
, WXK_WINDOWS_MENU
},
5495 #endif // VK_APPS defined
5498 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5499 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5500 int wxCharCodeMSWToWX(int vk
, WXLPARAM lParam
)
5502 // check the table first
5503 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5505 if ( gs_specialKeys
[n
].vk
== vk
)
5506 return gs_specialKeys
[n
].wxk
;
5509 // keys requiring special handling
5513 // the mapping for these keys may be incorrect on non-US keyboards so
5514 // maybe we shouldn't map them to ASCII values at all
5515 case VK_OEM_1
: wxk
= ';'; break;
5516 case VK_OEM_PLUS
: wxk
= '+'; break;
5517 case VK_OEM_COMMA
: wxk
= ','; break;
5518 case VK_OEM_MINUS
: wxk
= '-'; break;
5519 case VK_OEM_PERIOD
: wxk
= '.'; break;
5520 case VK_OEM_2
: wxk
= '/'; break;
5521 case VK_OEM_3
: wxk
= '~'; break;
5522 case VK_OEM_4
: wxk
= '['; break;
5523 case VK_OEM_5
: wxk
= '\\'; break;
5524 case VK_OEM_6
: wxk
= ']'; break;
5525 case VK_OEM_7
: wxk
= '\''; break;
5527 // handle extended keys
5529 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEUP
, WXK_PAGEUP
);
5533 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_PAGEDOWN
, WXK_PAGEDOWN
);
5537 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_END
, WXK_END
);
5541 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_HOME
, WXK_HOME
);
5545 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_LEFT
, WXK_LEFT
);
5549 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_UP
, WXK_UP
);
5553 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_RIGHT
, WXK_RIGHT
);
5557 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DOWN
, WXK_DOWN
);
5561 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_INSERT
, WXK_INSERT
);
5565 wxk
= ChooseNormalOrExtended(lParam
, WXK_NUMPAD_DELETE
, WXK_DELETE
);
5569 // don't use ChooseNormalOrExtended() here as the keys are reversed
5570 // here: numpad enter is the extended one
5571 wxk
= lParam
&& (lParam
& (1 << 24)) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5581 WXWORD
wxCharCodeWXToMSW(int wxk
, bool *isVirtual
)
5586 // check the table first
5587 for ( size_t n
= 0; n
< WXSIZEOF(gs_specialKeys
); n
++ )
5589 if ( gs_specialKeys
[n
].wxk
== wxk
)
5590 return gs_specialKeys
[n
].vk
;
5593 // and then check for special keys not included in the table
5598 case WXK_NUMPAD_PAGEUP
:
5603 case WXK_NUMPAD_PAGEDOWN
:
5608 case WXK_NUMPAD_END
:
5613 case WXK_NUMPAD_HOME
:
5618 case WXK_NUMPAD_LEFT
:
5628 case WXK_NUMPAD_RIGHT
:
5633 case WXK_NUMPAD_DOWN
:
5638 case WXK_NUMPAD_INSERT
:
5643 case WXK_NUMPAD_DELETE
:
5657 // small helper for wxGetKeyState() and wxGetMouseState()
5658 static inline bool wxIsKeyDown(WXWORD vk
)
5660 // the low order bit indicates whether the key was pressed since the last
5661 // call and the high order one indicates whether it is down right now and
5662 // we only want that one
5663 return (::GetAsyncKeyState(vk
) & (1<<15)) != 0;
5666 bool wxGetKeyState(wxKeyCode key
)
5668 // although this does work under Windows, it is not supported under other
5669 // platforms so don't allow it, you must use wxGetMouseState() instead
5670 wxASSERT_MSG( key
!= VK_LBUTTON
&&
5671 key
!= VK_RBUTTON
&&
5673 wxT("can't use wxGetKeyState() for mouse buttons") );
5675 const WXWORD vk
= wxCharCodeWXToMSW(key
);
5677 // if the requested key is a LED key, return true if the led is pressed
5678 if ( key
== WXK_NUMLOCK
|| key
== WXK_CAPITAL
|| key
== WXK_SCROLL
)
5680 // low order bit means LED is highlighted and high order one means the
5681 // key is down; for compatibility with the other ports return true if
5682 // either one is set
5683 return ::GetKeyState(vk
) != 0;
5688 return wxIsKeyDown(vk
);
5693 wxMouseState
wxGetMouseState()
5697 GetCursorPos( &pt
);
5701 ms
.SetLeftDown(wxIsKeyDown(VK_LBUTTON
));
5702 ms
.SetMiddleDown(wxIsKeyDown(VK_MBUTTON
));
5703 ms
.SetRightDown(wxIsKeyDown(VK_RBUTTON
));
5705 ms
.SetControlDown(wxIsKeyDown(VK_CONTROL
));
5706 ms
.SetShiftDown(wxIsKeyDown(VK_SHIFT
));
5707 ms
.SetAltDown(wxIsKeyDown(VK_MENU
));
5708 // ms.SetMetaDown();
5714 wxWindow
*wxGetActiveWindow()
5716 HWND hWnd
= GetActiveWindow();
5719 return wxFindWinFromHandle((WXHWND
) hWnd
);
5724 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5726 HWND hwnd
= (HWND
)hWnd
;
5728 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5729 // by code in msw/radiobox.cpp), for all the others we just search up the
5731 wxWindow
*win
= (wxWindow
*)NULL
;
5734 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5738 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5739 // wxWindow class which overrides WM_GETDLGCODE processing to
5740 // do it as well, win would be already non NULL
5741 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5743 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5745 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5746 #endif // wxUSE_RADIOBOX
5748 // spin control text buddy window should be mapped to spin ctrl
5749 // itself so try it too
5750 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5753 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5755 #endif // wxUSE_SPINCTRL
5759 while ( hwnd
&& !win
)
5761 // this is a really ugly hack needed to avoid mistakenly returning the
5762 // parent frame wxWindow for the find/replace modeless dialog HWND -
5763 // this, in turn, is needed to call IsDialogMessage() from
5764 // wxApp::ProcessMessage() as for this we must return NULL from here
5766 // FIXME: this is clearly not the best way to do it but I think we'll
5767 // need to change HWND <-> wxWindow code more heavily than I can
5768 // do it now to fix it
5769 #ifndef __WXMICROWIN__
5770 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5772 // it's a dialog box, don't go upwards
5777 hwnd
= ::GetParent(hwnd
);
5778 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5784 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5786 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5787 // in active frames and dialogs, regardless of where the focus is.
5788 static HHOOK wxTheKeyboardHook
= 0;
5789 static FARPROC wxTheKeyboardHookProc
= 0;
5790 int APIENTRY _EXPORT
5791 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5793 void wxSetKeyboardHook(bool doIt
)
5797 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5798 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5800 GetCurrentThreadId()
5801 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5806 UnhookWindowsHookEx(wxTheKeyboardHook
);
5810 int APIENTRY _EXPORT
5811 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5813 DWORD hiWord
= HIWORD(lParam
);
5814 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5816 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5819 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5820 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5821 event
.m_altDown
= true;
5823 event
.SetEventObject(NULL
);
5824 event
.m_keyCode
= id
;
5825 event
.m_shiftDown
= wxIsShiftDown();
5826 event
.m_controlDown
= wxIsCtrlDown();
5828 event
.SetTimestamp(::GetMessageTime());
5830 wxWindow
*win
= wxGetActiveWindow();
5831 wxEvtHandler
*handler
;
5834 handler
= win
->GetEventHandler();
5835 event
.SetId(win
->GetId());
5840 event
.SetId(wxID_ANY
);
5843 if ( handler
&& handler
->ProcessEvent(event
) )
5851 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5854 #endif // !__WXMICROWIN__
5857 const wxChar
*wxGetMessageName(int message
)
5861 case 0x0000: return wxT("WM_NULL");
5862 case 0x0001: return wxT("WM_CREATE");
5863 case 0x0002: return wxT("WM_DESTROY");
5864 case 0x0003: return wxT("WM_MOVE");
5865 case 0x0005: return wxT("WM_SIZE");
5866 case 0x0006: return wxT("WM_ACTIVATE");
5867 case 0x0007: return wxT("WM_SETFOCUS");
5868 case 0x0008: return wxT("WM_KILLFOCUS");
5869 case 0x000A: return wxT("WM_ENABLE");
5870 case 0x000B: return wxT("WM_SETREDRAW");
5871 case 0x000C: return wxT("WM_SETTEXT");
5872 case 0x000D: return wxT("WM_GETTEXT");
5873 case 0x000E: return wxT("WM_GETTEXTLENGTH");
5874 case 0x000F: return wxT("WM_PAINT");
5875 case 0x0010: return wxT("WM_CLOSE");
5876 case 0x0011: return wxT("WM_QUERYENDSESSION");
5877 case 0x0012: return wxT("WM_QUIT");
5878 case 0x0013: return wxT("WM_QUERYOPEN");
5879 case 0x0014: return wxT("WM_ERASEBKGND");
5880 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
5881 case 0x0016: return wxT("WM_ENDSESSION");
5882 case 0x0017: return wxT("WM_SYSTEMERROR");
5883 case 0x0018: return wxT("WM_SHOWWINDOW");
5884 case 0x0019: return wxT("WM_CTLCOLOR");
5885 case 0x001A: return wxT("WM_WININICHANGE");
5886 case 0x001B: return wxT("WM_DEVMODECHANGE");
5887 case 0x001C: return wxT("WM_ACTIVATEAPP");
5888 case 0x001D: return wxT("WM_FONTCHANGE");
5889 case 0x001E: return wxT("WM_TIMECHANGE");
5890 case 0x001F: return wxT("WM_CANCELMODE");
5891 case 0x0020: return wxT("WM_SETCURSOR");
5892 case 0x0021: return wxT("WM_MOUSEACTIVATE");
5893 case 0x0022: return wxT("WM_CHILDACTIVATE");
5894 case 0x0023: return wxT("WM_QUEUESYNC");
5895 case 0x0024: return wxT("WM_GETMINMAXINFO");
5896 case 0x0026: return wxT("WM_PAINTICON");
5897 case 0x0027: return wxT("WM_ICONERASEBKGND");
5898 case 0x0028: return wxT("WM_NEXTDLGCTL");
5899 case 0x002A: return wxT("WM_SPOOLERSTATUS");
5900 case 0x002B: return wxT("WM_DRAWITEM");
5901 case 0x002C: return wxT("WM_MEASUREITEM");
5902 case 0x002D: return wxT("WM_DELETEITEM");
5903 case 0x002E: return wxT("WM_VKEYTOITEM");
5904 case 0x002F: return wxT("WM_CHARTOITEM");
5905 case 0x0030: return wxT("WM_SETFONT");
5906 case 0x0031: return wxT("WM_GETFONT");
5907 case 0x0037: return wxT("WM_QUERYDRAGICON");
5908 case 0x0039: return wxT("WM_COMPAREITEM");
5909 case 0x0041: return wxT("WM_COMPACTING");
5910 case 0x0044: return wxT("WM_COMMNOTIFY");
5911 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
5912 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
5913 case 0x0048: return wxT("WM_POWER");
5915 case 0x004A: return wxT("WM_COPYDATA");
5916 case 0x004B: return wxT("WM_CANCELJOURNAL");
5917 case 0x004E: return wxT("WM_NOTIFY");
5918 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
5919 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
5920 case 0x0052: return wxT("WM_TCARD");
5921 case 0x0053: return wxT("WM_HELP");
5922 case 0x0054: return wxT("WM_USERCHANGED");
5923 case 0x0055: return wxT("WM_NOTIFYFORMAT");
5924 case 0x007B: return wxT("WM_CONTEXTMENU");
5925 case 0x007C: return wxT("WM_STYLECHANGING");
5926 case 0x007D: return wxT("WM_STYLECHANGED");
5927 case 0x007E: return wxT("WM_DISPLAYCHANGE");
5928 case 0x007F: return wxT("WM_GETICON");
5929 case 0x0080: return wxT("WM_SETICON");
5931 case 0x0081: return wxT("WM_NCCREATE");
5932 case 0x0082: return wxT("WM_NCDESTROY");
5933 case 0x0083: return wxT("WM_NCCALCSIZE");
5934 case 0x0084: return wxT("WM_NCHITTEST");
5935 case 0x0085: return wxT("WM_NCPAINT");
5936 case 0x0086: return wxT("WM_NCACTIVATE");
5937 case 0x0087: return wxT("WM_GETDLGCODE");
5938 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
5939 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
5940 case 0x00A2: return wxT("WM_NCLBUTTONUP");
5941 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
5942 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
5943 case 0x00A5: return wxT("WM_NCRBUTTONUP");
5944 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
5945 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
5946 case 0x00A8: return wxT("WM_NCMBUTTONUP");
5947 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
5948 case 0x0100: return wxT("WM_KEYDOWN");
5949 case 0x0101: return wxT("WM_KEYUP");
5950 case 0x0102: return wxT("WM_CHAR");
5951 case 0x0103: return wxT("WM_DEADCHAR");
5952 case 0x0104: return wxT("WM_SYSKEYDOWN");
5953 case 0x0105: return wxT("WM_SYSKEYUP");
5954 case 0x0106: return wxT("WM_SYSCHAR");
5955 case 0x0107: return wxT("WM_SYSDEADCHAR");
5956 case 0x0108: return wxT("WM_KEYLAST");
5958 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
5959 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
5960 case 0x010F: return wxT("WM_IME_COMPOSITION");
5962 case 0x0110: return wxT("WM_INITDIALOG");
5963 case 0x0111: return wxT("WM_COMMAND");
5964 case 0x0112: return wxT("WM_SYSCOMMAND");
5965 case 0x0113: return wxT("WM_TIMER");
5966 case 0x0114: return wxT("WM_HSCROLL");
5967 case 0x0115: return wxT("WM_VSCROLL");
5968 case 0x0116: return wxT("WM_INITMENU");
5969 case 0x0117: return wxT("WM_INITMENUPOPUP");
5970 case 0x011F: return wxT("WM_MENUSELECT");
5971 case 0x0120: return wxT("WM_MENUCHAR");
5972 case 0x0121: return wxT("WM_ENTERIDLE");
5973 case 0x0200: return wxT("WM_MOUSEMOVE");
5974 case 0x0201: return wxT("WM_LBUTTONDOWN");
5975 case 0x0202: return wxT("WM_LBUTTONUP");
5976 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
5977 case 0x0204: return wxT("WM_RBUTTONDOWN");
5978 case 0x0205: return wxT("WM_RBUTTONUP");
5979 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
5980 case 0x0207: return wxT("WM_MBUTTONDOWN");
5981 case 0x0208: return wxT("WM_MBUTTONUP");
5982 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
5983 case 0x020A: return wxT("WM_MOUSEWHEEL");
5984 case 0x0210: return wxT("WM_PARENTNOTIFY");
5985 case 0x0211: return wxT("WM_ENTERMENULOOP");
5986 case 0x0212: return wxT("WM_EXITMENULOOP");
5988 case 0x0213: return wxT("WM_NEXTMENU");
5989 case 0x0214: return wxT("WM_SIZING");
5990 case 0x0215: return wxT("WM_CAPTURECHANGED");
5991 case 0x0216: return wxT("WM_MOVING");
5992 case 0x0218: return wxT("WM_POWERBROADCAST");
5993 case 0x0219: return wxT("WM_DEVICECHANGE");
5995 case 0x0220: return wxT("WM_MDICREATE");
5996 case 0x0221: return wxT("WM_MDIDESTROY");
5997 case 0x0222: return wxT("WM_MDIACTIVATE");
5998 case 0x0223: return wxT("WM_MDIRESTORE");
5999 case 0x0224: return wxT("WM_MDINEXT");
6000 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6001 case 0x0226: return wxT("WM_MDITILE");
6002 case 0x0227: return wxT("WM_MDICASCADE");
6003 case 0x0228: return wxT("WM_MDIICONARRANGE");
6004 case 0x0229: return wxT("WM_MDIGETACTIVE");
6005 case 0x0230: return wxT("WM_MDISETMENU");
6006 case 0x0233: return wxT("WM_DROPFILES");
6008 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6009 case 0x0282: return wxT("WM_IME_NOTIFY");
6010 case 0x0283: return wxT("WM_IME_CONTROL");
6011 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6012 case 0x0285: return wxT("WM_IME_SELECT");
6013 case 0x0286: return wxT("WM_IME_CHAR");
6014 case 0x0290: return wxT("WM_IME_KEYDOWN");
6015 case 0x0291: return wxT("WM_IME_KEYUP");
6017 case 0x0300: return wxT("WM_CUT");
6018 case 0x0301: return wxT("WM_COPY");
6019 case 0x0302: return wxT("WM_PASTE");
6020 case 0x0303: return wxT("WM_CLEAR");
6021 case 0x0304: return wxT("WM_UNDO");
6022 case 0x0305: return wxT("WM_RENDERFORMAT");
6023 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6024 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6025 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6026 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6027 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6028 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6029 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6030 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6031 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6032 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6033 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6034 case 0x0311: return wxT("WM_PALETTECHANGED");
6036 case 0x0312: return wxT("WM_HOTKEY");
6039 // common controls messages - although they're not strictly speaking
6040 // standard, it's nice to decode them nevertheless
6043 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6044 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6045 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6046 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6047 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6048 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6049 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6050 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6051 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6052 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6053 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6054 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6055 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6056 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6057 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6058 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6059 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6060 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6061 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6062 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6063 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6064 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6065 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6066 case 0x1000 + 18: return wxT("LVM_HITTEST");
6067 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6068 case 0x1000 + 20: return wxT("LVM_SCROLL");
6069 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6070 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6071 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6072 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6073 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6074 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6075 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6076 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6077 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6078 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6079 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6080 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6081 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6082 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6083 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6084 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6085 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6086 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6087 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6088 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6089 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6090 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6091 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6092 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6093 case 0x1000 + 42: return wxT("LVM_UPDATE");
6094 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6095 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6096 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6097 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6098 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6099 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6100 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6101 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6102 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6103 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6104 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6105 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6106 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
6107 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
6108 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
6109 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
6110 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
6111 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
6112 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
6113 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
6114 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
6115 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
6116 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
6117 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
6118 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
6119 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
6122 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
6123 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
6124 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
6125 case 0x1100 + 2: return wxT("TVM_EXPAND");
6126 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
6127 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
6128 case 0x1100 + 6: return wxT("TVM_GETINDENT");
6129 case 0x1100 + 7: return wxT("TVM_SETINDENT");
6130 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
6131 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
6132 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
6133 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
6134 case 0x1100 + 12: return wxT("TVM_GETITEMA");
6135 case 0x1100 + 62: return wxT("TVM_GETITEMW");
6136 case 0x1100 + 13: return wxT("TVM_SETITEMA");
6137 case 0x1100 + 63: return wxT("TVM_SETITEMW");
6138 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
6139 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
6140 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
6141 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
6142 case 0x1100 + 17: return wxT("TVM_HITTEST");
6143 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
6144 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
6145 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
6146 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
6147 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
6148 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
6149 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
6150 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
6151 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
6154 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
6155 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
6156 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
6157 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
6158 case 0x1200 + 3: return wxT("HDM_GETITEMA");
6159 case 0x1200 + 11: return wxT("HDM_GETITEMW");
6160 case 0x1200 + 4: return wxT("HDM_SETITEMA");
6161 case 0x1200 + 12: return wxT("HDM_SETITEMW");
6162 case 0x1200 + 5: return wxT("HDM_LAYOUT");
6163 case 0x1200 + 6: return wxT("HDM_HITTEST");
6164 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
6165 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
6166 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
6167 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
6168 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
6169 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
6170 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
6171 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
6174 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
6175 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
6176 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
6177 case 0x1300 + 5: return wxT("TCM_GETITEMA");
6178 case 0x1300 + 60: return wxT("TCM_GETITEMW");
6179 case 0x1300 + 6: return wxT("TCM_SETITEMA");
6180 case 0x1300 + 61: return wxT("TCM_SETITEMW");
6181 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
6182 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
6183 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
6184 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
6185 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
6186 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
6187 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
6188 case 0x1300 + 13: return wxT("TCM_HITTEST");
6189 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
6190 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
6191 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
6192 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
6193 case 0x1300 + 43: return wxT("TCM_SETPADDING");
6194 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
6195 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
6196 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
6197 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
6198 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
6199 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
6200 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
6203 case WM_USER
+1: return wxT("TB_ENABLEBUTTON");
6204 case WM_USER
+2: return wxT("TB_CHECKBUTTON");
6205 case WM_USER
+3: return wxT("TB_PRESSBUTTON");
6206 case WM_USER
+4: return wxT("TB_HIDEBUTTON");
6207 case WM_USER
+5: return wxT("TB_INDETERMINATE");
6208 case WM_USER
+9: return wxT("TB_ISBUTTONENABLED");
6209 case WM_USER
+10: return wxT("TB_ISBUTTONCHECKED");
6210 case WM_USER
+11: return wxT("TB_ISBUTTONPRESSED");
6211 case WM_USER
+12: return wxT("TB_ISBUTTONHIDDEN");
6212 case WM_USER
+13: return wxT("TB_ISBUTTONINDETERMINATE");
6213 case WM_USER
+17: return wxT("TB_SETSTATE");
6214 case WM_USER
+18: return wxT("TB_GETSTATE");
6215 case WM_USER
+19: return wxT("TB_ADDBITMAP");
6216 case WM_USER
+20: return wxT("TB_ADDBUTTONS");
6217 case WM_USER
+21: return wxT("TB_INSERTBUTTON");
6218 case WM_USER
+22: return wxT("TB_DELETEBUTTON");
6219 case WM_USER
+23: return wxT("TB_GETBUTTON");
6220 case WM_USER
+24: return wxT("TB_BUTTONCOUNT");
6221 case WM_USER
+25: return wxT("TB_COMMANDTOINDEX");
6222 case WM_USER
+26: return wxT("TB_SAVERESTOREA");
6223 case WM_USER
+76: return wxT("TB_SAVERESTOREW");
6224 case WM_USER
+27: return wxT("TB_CUSTOMIZE");
6225 case WM_USER
+28: return wxT("TB_ADDSTRINGA");
6226 case WM_USER
+77: return wxT("TB_ADDSTRINGW");
6227 case WM_USER
+29: return wxT("TB_GETITEMRECT");
6228 case WM_USER
+30: return wxT("TB_BUTTONSTRUCTSIZE");
6229 case WM_USER
+31: return wxT("TB_SETBUTTONSIZE");
6230 case WM_USER
+32: return wxT("TB_SETBITMAPSIZE");
6231 case WM_USER
+33: return wxT("TB_AUTOSIZE");
6232 case WM_USER
+35: return wxT("TB_GETTOOLTIPS");
6233 case WM_USER
+36: return wxT("TB_SETTOOLTIPS");
6234 case WM_USER
+37: return wxT("TB_SETPARENT");
6235 case WM_USER
+39: return wxT("TB_SETROWS");
6236 case WM_USER
+40: return wxT("TB_GETROWS");
6237 case WM_USER
+42: return wxT("TB_SETCMDID");
6238 case WM_USER
+43: return wxT("TB_CHANGEBITMAP");
6239 case WM_USER
+44: return wxT("TB_GETBITMAP");
6240 case WM_USER
+45: return wxT("TB_GETBUTTONTEXTA");
6241 case WM_USER
+75: return wxT("TB_GETBUTTONTEXTW");
6242 case WM_USER
+46: return wxT("TB_REPLACEBITMAP");
6243 case WM_USER
+47: return wxT("TB_SETINDENT");
6244 case WM_USER
+48: return wxT("TB_SETIMAGELIST");
6245 case WM_USER
+49: return wxT("TB_GETIMAGELIST");
6246 case WM_USER
+50: return wxT("TB_LOADIMAGES");
6247 case WM_USER
+51: return wxT("TB_GETRECT");
6248 case WM_USER
+52: return wxT("TB_SETHOTIMAGELIST");
6249 case WM_USER
+53: return wxT("TB_GETHOTIMAGELIST");
6250 case WM_USER
+54: return wxT("TB_SETDISABLEDIMAGELIST");
6251 case WM_USER
+55: return wxT("TB_GETDISABLEDIMAGELIST");
6252 case WM_USER
+56: return wxT("TB_SETSTYLE");
6253 case WM_USER
+57: return wxT("TB_GETSTYLE");
6254 case WM_USER
+58: return wxT("TB_GETBUTTONSIZE");
6255 case WM_USER
+59: return wxT("TB_SETBUTTONWIDTH");
6256 case WM_USER
+60: return wxT("TB_SETMAXTEXTROWS");
6257 case WM_USER
+61: return wxT("TB_GETTEXTROWS");
6258 case WM_USER
+41: return wxT("TB_GETBITMAPFLAGS");
6261 static wxString s_szBuf
;
6262 s_szBuf
.Printf(wxT("<unknown message = %d>"), message
);
6263 return s_szBuf
.c_str();
6266 #endif //__WXDEBUG__
6268 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
6272 HWND hwnd
= GetHwndOf(win
);
6273 HDC hdc
= ::GetDC(hwnd
);
6275 #if !wxDIALOG_UNIT_COMPATIBILITY
6276 // and select the current font into it
6277 HFONT hfont
= GetHfontOf(win
->GetFont());
6280 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
6284 // finally retrieve the text metrics from it
6285 GetTextMetrics(hdc
, &tm
);
6287 #if !wxDIALOG_UNIT_COMPATIBILITY
6291 (void)::SelectObject(hdc
, hfont
);
6295 ::ReleaseDC(hwnd
, hdc
);
6300 // Find the wxWindow at the current mouse position, returning the mouse
6302 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
6304 pt
= wxGetMousePosition();
6305 return wxFindWindowAtPoint(pt
);
6308 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
6314 HWND hWnd
= ::WindowFromPoint(pt2
);
6316 return wxGetWindowFromHWND((WXHWND
)hWnd
);
6319 // Get the current mouse position.
6320 wxPoint
wxGetMousePosition()
6324 GetCursorPosWinCE(&pt
);
6326 GetCursorPos( & pt
);
6329 return wxPoint(pt
.x
, pt
.y
);
6334 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6335 static void WinCEUnregisterHotKey(int modifiers
, int id
)
6337 // Register hotkeys for the hardware buttons
6339 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
6341 UnregisterFunc1Proc procUnregisterFunc
;
6342 hCoreDll
= LoadLibrary(_T("coredll.dll"));
6345 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
6346 if (procUnregisterFunc
)
6347 procUnregisterFunc(modifiers
, id
);
6348 FreeLibrary(hCoreDll
);
6353 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
6355 UINT win_modifiers
=0;
6356 if ( modifiers
& wxMOD_ALT
)
6357 win_modifiers
|= MOD_ALT
;
6358 if ( modifiers
& wxMOD_SHIFT
)
6359 win_modifiers
|= MOD_SHIFT
;
6360 if ( modifiers
& wxMOD_CONTROL
)
6361 win_modifiers
|= MOD_CONTROL
;
6362 if ( modifiers
& wxMOD_WIN
)
6363 win_modifiers
|= MOD_WIN
;
6365 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6366 // Required for PPC and Smartphone hardware buttons
6367 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
6368 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
6371 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
6373 wxLogLastError(_T("RegisterHotKey"));
6381 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
6383 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
6384 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
6387 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
6389 wxLogLastError(_T("UnregisterHotKey"));
6399 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
6401 int hotkeyId
= wParam
;
6402 int virtualKey
= HIWORD(lParam
);
6403 int win_modifiers
= LOWORD(lParam
);
6405 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
6406 event
.SetId(hotkeyId
);
6407 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
6408 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
6409 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
6410 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
6412 return GetEventHandler()->ProcessEvent(event
);
6415 #endif // wxUSE_ACCEL
6417 #endif // wxUSE_HOTKEY
6419 // Not tested under WinCE
6422 // this class installs a message hook which really wakes up our idle processing
6423 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6424 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6425 // being dragged or even inside ::MessageBox()) and so don't control message
6426 // dispatching otherwise
6427 class wxIdleWakeUpModule
: public wxModule
6430 virtual bool OnInit()
6432 ms_hMsgHookProc
= ::SetWindowsHookEx
6435 &wxIdleWakeUpModule::MsgHookProc
,
6437 GetCurrentThreadId()
6440 if ( !ms_hMsgHookProc
)
6442 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6450 virtual void OnExit()
6452 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc
);
6455 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6457 MSG
*msg
= (MSG
*)lParam
;
6459 // only process the message if it is actually going to be removed from
6460 // the message queue, this prevents that the same event from being
6461 // processed multiple times if now someone just called PeekMessage()
6462 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
6464 wxTheApp
->ProcessPendingEvents();
6467 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
6471 static HHOOK ms_hMsgHookProc
;
6473 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
6476 HHOOK
wxIdleWakeUpModule::ms_hMsgHookProc
= 0;
6478 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
6480 #endif // __WXWINCE__
6485 static void wxAdjustZOrder(wxWindow
* parent
)
6487 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
6489 // Set the z-order correctly
6490 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
6493 wxWindowList::compatibility_iterator current
= parent
->GetChildren().GetFirst();
6496 wxWindow
*childWin
= current
->GetData();
6497 wxAdjustZOrder(childWin
);
6498 current
= current
->GetNext();
6503 // We need to adjust the z-order of static boxes in WinCE, to
6504 // make 'contained' controls visible
6505 void wxWindowMSW::OnInitDialog( wxInitDialogEvent
& event
)
6508 wxAdjustZOrder(this);