1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
38 #include "wx/dcclient.h"
39 #include "wx/dcmemory.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
47 #include "wx/msgdlg.h"
48 #include "wx/settings.h"
49 #include "wx/statbox.h"
52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
53 #include "wx/ownerdrw.h"
56 #include "wx/module.h"
57 #include "wx/sysopt.h"
59 #if wxUSE_DRAG_AND_DROP
63 #if wxUSE_ACCESSIBILITY
64 #include "wx/access.h"
68 #define WM_GETOBJECT 0x003D
71 #define OBJID_CLIENT 0xFFFFFFFC
75 #include "wx/menuitem.h"
78 #include "wx/msw/private.h"
81 #include "wx/tooltip.h"
89 #include "wx/spinctrl.h"
90 #endif // wxUSE_SPINCTRL
95 #include "wx/textctrl.h"
96 #include "wx/notebook.h"
97 #include "wx/listctrl.h"
101 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
102 #include <shellapi.h>
103 #include <mmsystem.h>
107 #include <windowsx.h>
110 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
112 #include <commctrl.h>
114 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
115 #include "wx/msw/gnuwin32/extra.h"
118 #include "wx/msw/missing.h"
120 #if defined(__WXWINCE__)
121 #include "wx/msw/wince/missing.h"
124 // ---------------------------------------------------------------------------
126 // ---------------------------------------------------------------------------
128 #if wxUSE_MENUS_NATIVE
129 wxMenu
*wxCurrentPopupMenu
= NULL
;
130 #endif // wxUSE_MENUS_NATIVE
133 extern wxChar
*wxCanvasClassName
;
135 extern const wxChar
*wxCanvasClassName
;
138 // true if we had already created the std colour map, used by
139 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
140 static bool gs_hasStdCmap
= false;
142 // ---------------------------------------------------------------------------
144 // ---------------------------------------------------------------------------
146 // the window proc for all our windows
147 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
148 WPARAM wParam
, LPARAM lParam
);
152 const char *wxGetMessageName(int message
);
155 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
156 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
157 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
159 // get the text metrics for the current font
160 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
162 // find the window for the mouse event at the specified position
163 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
165 // wrapper around BringWindowToTop() API
166 static inline void wxBringWindowToTop(HWND hwnd
)
168 #ifdef __WXMICROWIN__
169 // It seems that MicroWindows brings the _parent_ of the window to the top,
170 // which can be the wrong one.
172 // activate (set focus to) specified window
176 // raise top level parent to top of z order
177 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
179 wxLogLastError(_T("SetWindowPos"));
185 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
186 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
189 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
190 parent as well as otherwise several Win32 functions using
191 GetNextDlgTabItem() to iterate over all controls such as
192 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
193 all of them iterate over all the controls starting from the currently
194 focused one and stop iterating when they get back to the focus but
195 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
196 get back to the initial (focused) window: as we do have this style,
197 GetNextDlgTabItem() will leave this window and continue in its parent,
198 but if the parent doesn't have it, it wouldn't recurse inside it later
199 on and so wouldn't have a chance of getting back to this window neither.
201 while ( parent
&& !parent
->IsTopLevel() )
203 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
204 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
206 // force the parent to have this style
207 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
208 exStyle
| WS_EX_CONTROLPARENT
);
211 parent
= parent
->GetParent();
215 #endif // !__WXWINCE__
217 // ---------------------------------------------------------------------------
219 // ---------------------------------------------------------------------------
221 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
223 #ifdef __WXUNIVERSAL__
224 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
226 #if wxUSE_EXTENDED_RTTI
228 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
229 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
230 // windows with negative ids never can be recreated anyway
232 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
234 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
235 if ( win
&& win
->GetId() < 0 )
240 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
242 // make wxWindowList known before the property is used
244 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
246 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
248 wxListCollectionToVariantArray
<wxWindowList
::compatibility_iterator
>( theList
, value
) ;
251 WX_DEFINE_FLAGS( wxWindowStyle
)
253 wxBEGIN_FLAGS( wxWindowStyle
)
254 // new style border flags, we put them first to
255 // use them for streaming out
257 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
258 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
259 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
260 wxFLAGS_MEMBER(wxBORDER_RAISED
)
261 wxFLAGS_MEMBER(wxBORDER_STATIC
)
262 wxFLAGS_MEMBER(wxBORDER_NONE
)
264 // old style border flags
265 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
266 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
267 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
268 wxFLAGS_MEMBER(wxRAISED_BORDER
)
269 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
270 wxFLAGS_MEMBER(wxBORDER
)
272 // standard window styles
273 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
274 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
275 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
276 wxFLAGS_MEMBER(wxWANTS_CHARS
)
277 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
278 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
279 wxFLAGS_MEMBER(wxVSCROLL
)
280 wxFLAGS_MEMBER(wxHSCROLL
)
282 wxEND_FLAGS( wxWindowStyle
)
284 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
285 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
286 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
287 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
288 // Always constructor Properties first
290 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
291 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, wxID_ANY
, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
292 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
293 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
294 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
296 // Then all relations of the object graph
298 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
300 // and finally all other properties
302 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
303 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
304 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
305 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
306 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
308 // possible property candidates (not in xrc) or not valid in all subclasses
309 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
310 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
311 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
312 // MaxHeight, Width , MinHeight , Width
313 // TODO switch label to control and title to toplevels
315 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
316 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
317 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
318 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
323 wxEND_PROPERTIES_TABLE()
325 wxBEGIN_HANDLERS_TABLE(wxWindow
)
326 wxEND_HANDLERS_TABLE()
328 wxCONSTRUCTOR_DUMMY(wxWindow
)
331 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
333 #endif // __WXUNIVERSAL__/__WXMSW__
335 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
336 EVT_SYS_COLOUR_CHANGED(wxWindowMSW
::OnSysColourChanged
)
337 EVT_ERASE_BACKGROUND(wxWindowMSW
::OnEraseBackground
)
339 EVT_INIT_DIALOG(wxWindowMSW
::OnInitDialog
)
343 // ===========================================================================
345 // ===========================================================================
347 // ---------------------------------------------------------------------------
348 // wxWindow utility functions
349 // ---------------------------------------------------------------------------
351 // Find an item given the MS Windows id
352 wxWindow
*wxWindowMSW
::FindItem(long id
) const
355 wxControl
*item
= wxDynamicCastThis(wxControl
);
358 // is it we or one of our "internal" children?
359 if ( item
->GetId() == id
360 #ifndef __WXUNIVERSAL__
361 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
362 #endif // __WXUNIVERSAL__
368 #endif // wxUSE_CONTROLS
370 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
373 wxWindow
*childWin
= current
->GetData();
375 wxWindow
*wnd
= childWin
->FindItem(id
);
379 current
= current
->GetNext();
385 // Find an item given the MS Windows handle
386 wxWindow
*wxWindowMSW
::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
388 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
391 wxWindow
*parent
= current
->GetData();
393 // Do a recursive search.
394 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
400 || parent
->IsKindOf(CLASSINFO(wxControl
))
401 #endif // wxUSE_CONTROLS
404 wxWindow
*item
= current
->GetData();
405 if ( item
->GetHWND() == hWnd
)
409 if ( item
->ContainsHWND(hWnd
) )
414 current
= current
->GetNext();
419 // Default command handler
420 bool wxWindowMSW
::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
425 // ----------------------------------------------------------------------------
426 // constructors and such
427 // ----------------------------------------------------------------------------
429 void wxWindowMSW
::Init()
432 m_isBeingDeleted
= false;
434 m_mouseInWindow
= false;
435 m_lastKeydownProcessed
= false;
437 m_childrenDisabled
= NULL
;
446 #if wxUSE_MOUSEEVENT_HACK
449 m_lastMouseEvent
= -1;
450 #endif // wxUSE_MOUSEEVENT_HACK
454 wxWindowMSW
::~wxWindowMSW()
456 m_isBeingDeleted
= true;
458 #ifndef __WXUNIVERSAL__
459 // VS: make sure there's no wxFrame with last focus set to us:
460 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
462 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
465 if ( frame
->GetLastFocus() == this )
467 frame
->SetLastFocus(NULL
);
472 #endif // __WXUNIVERSAL__
474 // VS: destroy children first and _then_ detach *this from its parent.
475 // If we'd do it the other way around, children wouldn't be able
476 // find their parent frame (see above).
481 // VZ: test temp removed to understand what really happens here
482 //if (::IsWindow(GetHwnd()))
484 if ( !::DestroyWindow(GetHwnd()) )
485 wxLogLastError(wxT("DestroyWindow"));
488 // remove hWnd <-> wxWindow association
489 wxRemoveHandleAssociation(this);
492 delete m_childrenDisabled
;
495 // real construction (Init() must have been called before!)
496 bool wxWindowMSW
::Create(wxWindow
*parent
,
501 const wxString
& name
)
503 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
505 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
508 parent
->AddChild(this);
511 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
513 #ifdef __WXUNIVERSAL__
514 // no borders, we draw them ourselves
515 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
519 msflags
&= ~WS_BORDER
;
520 #endif // wxUniversal
524 msflags
|= WS_VISIBLE
;
527 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
535 // ---------------------------------------------------------------------------
537 // ---------------------------------------------------------------------------
539 void wxWindowMSW
::SetFocus()
541 HWND hWnd
= GetHwnd();
542 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
544 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
548 if ( !::SetFocus(hWnd
) )
550 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
551 // was there really an error?
552 DWORD dwRes
= ::GetLastError();
555 HWND hwndFocus
= ::GetFocus();
556 if ( hwndFocus
!= hWnd
)
558 wxLogApiError(_T("SetFocus"), dwRes
);
565 void wxWindowMSW
::SetFocusFromKbd()
567 // when the focus is given to the control with DLGC_HASSETSEL style from
568 // keyboard its contents should be entirely selected: this is what
569 // ::IsDialogMessage() does and so we should do it as well to provide the
570 // same LNF as the native programs
571 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
573 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
576 // do this after (maybe) setting the selection as like this when
577 // wxEVT_SET_FOCUS handler is called, the selection would have been already
578 // set correctly -- this may be important
579 wxWindowBase
::SetFocusFromKbd();
582 // Get the window with the focus
583 wxWindow
*wxWindowBase
::DoFindFocus()
585 HWND hWnd
= ::GetFocus();
588 return wxGetWindowFromHWND((WXHWND
)hWnd
);
594 bool wxWindowMSW
::Enable(bool enable
)
596 if ( !wxWindowBase
::Enable(enable
) )
599 HWND hWnd
= GetHwnd();
601 ::EnableWindow(hWnd
, (BOOL
)enable
);
603 // the logic below doesn't apply to the top level windows -- otherwise
604 // showing a modal dialog would result in total greying out (and ungreying
605 // out later) of everything which would be really ugly
609 // when the parent is disabled, all of its children should be disabled as
610 // well but when it is enabled back, only those of the children which
611 // hadn't been already disabled in the beginning should be enabled again,
612 // so we have to keep the list of those children
613 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
615 node
= node
->GetNext() )
617 wxWindow
*child
= node
->GetData();
618 if ( child
->IsTopLevel() )
620 // the logic below doesn't apply to top level children
626 // enable the child back unless it had been disabled before us
627 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
630 else // we're being disabled
632 if ( child
->IsEnabled() )
634 // disable it as children shouldn't stay enabled while the
638 else // child already disabled, remember it
640 // have we created the list of disabled children already?
641 if ( !m_childrenDisabled
)
642 m_childrenDisabled
= new wxWindowList
;
644 m_childrenDisabled
->Append(child
);
649 if ( enable
&& m_childrenDisabled
)
651 // we don't need this list any more, don't keep unused memory
652 delete m_childrenDisabled
;
653 m_childrenDisabled
= NULL
;
659 bool wxWindowMSW
::Show(bool show
)
661 if ( !wxWindowBase
::Show(show
) )
664 HWND hWnd
= GetHwnd();
665 int cshow
= show ? SW_SHOW
: SW_HIDE
;
666 ::ShowWindow(hWnd
, cshow
);
668 if ( show
&& IsTopLevel() )
670 wxBringWindowToTop(hWnd
);
676 // Raise the window to the top of the Z order
677 void wxWindowMSW
::Raise()
679 wxBringWindowToTop(GetHwnd());
682 // Lower the window to the bottom of the Z order
683 void wxWindowMSW
::Lower()
685 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
686 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
689 void wxWindowMSW
::SetTitle( const wxString
& title
)
691 SetWindowText(GetHwnd(), title
.c_str());
694 wxString wxWindowMSW
::GetTitle() const
696 return wxGetWindowText(GetHWND());
699 void wxWindowMSW
::DoCaptureMouse()
701 HWND hWnd
= GetHwnd();
708 void wxWindowMSW
::DoReleaseMouse()
710 if ( !::ReleaseCapture() )
712 wxLogLastError(_T("ReleaseCapture"));
716 /* static */ wxWindow
*wxWindowBase
::GetCapture()
718 HWND hwnd
= ::GetCapture();
719 return hwnd ?
wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
722 bool wxWindowMSW
::SetFont(const wxFont
& font
)
724 if ( !wxWindowBase
::SetFont(font
) )
730 HWND hWnd
= GetHwnd();
733 WXHANDLE hFont
= m_font
.GetResourceHandle();
735 wxASSERT_MSG( hFont
, wxT("should have valid font") );
737 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
742 bool wxWindowMSW
::SetCursor(const wxCursor
& cursor
)
744 if ( !wxWindowBase
::SetCursor(cursor
) )
752 HWND hWnd
= GetHwnd();
754 // Change the cursor NOW if we're within the correct window
756 ::GetCursorPos(&point
);
758 RECT rect
= wxGetWindowRect(hWnd
);
760 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
761 ::SetCursor(GetHcursorOf(m_cursor
));
767 void wxWindowMSW
::WarpPointer (int x
, int y
)
769 ClientToScreen(&x
, &y
);
771 if ( !::SetCursorPos(x
, y
) )
773 wxLogLastError(_T("SetCursorPos"));
777 // ---------------------------------------------------------------------------
779 // ---------------------------------------------------------------------------
781 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
782 static inline int wxDirToWinStyle(int orient
)
784 return orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
;
787 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
789 #ifdef __WXMICROWIN__
790 return ::GetScrollPosWX(hWnd
, wOrient
);
792 WinStruct
<SCROLLINFO
> scrollInfo
;
793 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
794 scrollInfo
.fMask
= SIF_POS
;
795 if ( !::GetScrollInfo(hWnd
,
799 // Not neccessarily an error, if there are no scrollbars yet.
800 // wxLogLastError(_T("GetScrollInfo"));
802 return scrollInfo
.nPos
;
803 // return ::GetScrollPos(hWnd, wOrient);
807 int wxWindowMSW
::GetScrollPos(int orient
) const
809 HWND hWnd
= GetHwnd();
810 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
812 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
);
815 // This now returns the whole range, not just the number
816 // of positions that we can scroll.
817 int wxWindowMSW
::GetScrollRange(int orient
) const
820 HWND hWnd
= GetHwnd();
824 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
827 WinStruct
<SCROLLINFO
> scrollInfo
;
828 scrollInfo
.fMask
= SIF_RANGE
;
829 if ( !::GetScrollInfo(hWnd
,
830 orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
833 // Most of the time this is not really an error, since the return
834 // value can also be zero when there is no scrollbar yet.
835 // wxLogLastError(_T("GetScrollInfo"));
837 maxPos
= scrollInfo
.nMax
;
839 // undo "range - 1" done in SetScrollbar()
843 int wxWindowMSW
::GetScrollThumb(int orient
) const
845 return orient
== wxHORIZONTAL ? m_xThumbSize
: m_yThumbSize
;
848 void wxWindowMSW
::SetScrollPos(int orient
, int pos
, bool refresh
)
850 HWND hWnd
= GetHwnd();
851 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
853 WinStruct
<SCROLLINFO
> info
;
857 info
.fMask
= SIF_POS
;
858 if ( HasFlag(wxALWAYS_SHOW_SB
) )
860 // disable scrollbar instead of removing it then
861 info
.fMask
|= SIF_DISABLENOSCROLL
;
864 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
868 // New function that will replace some of the above.
869 void wxWindowMSW
::SetScrollbar(int orient
,
875 WinStruct
<SCROLLINFO
> info
;
876 info
.nPage
= pageSize
;
877 info
.nMin
= 0; // range is nMax - nMin + 1
878 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
880 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
881 if ( HasFlag(wxALWAYS_SHOW_SB
) )
883 // disable scrollbar instead of removing it then
884 info
.fMask
|= SIF_DISABLENOSCROLL
;
887 HWND hWnd
= GetHwnd();
890 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
894 *(orient
== wxHORIZONTAL ?
&m_xThumbSize
: &m_yThumbSize
) = pageSize
;
897 void wxWindowMSW
::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
903 rect
.left
= prect
->x
;
905 rect
.right
= prect
->x
+ prect
->width
;
906 rect
.bottom
= prect
->y
+ prect
->height
;
916 // FIXME: is this the exact equivalent of the line below?
917 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
919 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
923 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
925 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
928 for ( int n
= 0; n
< count
; n
++ )
930 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
932 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
935 // don't bother to continue, we're already at top/bottom
942 return pos
!= posStart
;
945 bool wxWindowMSW
::ScrollLines(int lines
)
947 bool down
= lines
> 0;
949 return ScrollVertically(GetHwnd(),
950 down ? SB_LINEDOWN
: SB_LINEUP
,
951 down ? lines
: -lines
);
954 bool wxWindowMSW
::ScrollPages(int pages
)
956 bool down
= pages
> 0;
958 return ScrollVertically(GetHwnd(),
959 down ? SB_PAGEDOWN
: SB_PAGEUP
,
960 down ? pages
: -pages
);
963 // ---------------------------------------------------------------------------
965 // ---------------------------------------------------------------------------
967 void wxWindowMSW
::SubclassWin(WXHWND hWnd
)
969 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
971 HWND hwnd
= (HWND
)hWnd
;
972 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
974 wxAssociateWinWithHandle(hwnd
, this);
976 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
978 // we don't need to subclass the window of our own class (in the Windows
979 // sense of the word)
980 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
982 wxSetWindowProc(hwnd
, wxWndProc
);
986 // don't bother restoring it neither: this also makes it easy to
987 // implement IsOfStandardClass() method which returns true for the
988 // standard controls and false for the wxWidgets own windows as it can
989 // simply check m_oldWndProc
994 void wxWindowMSW
::UnsubclassWin()
996 wxRemoveHandleAssociation(this);
998 // Restore old Window proc
999 HWND hwnd
= GetHwnd();
1004 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1008 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1010 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1013 m_oldWndProc
= NULL
;
1018 void wxWindowMSW
::AssociateHandle(WXWidget handle
)
1022 if ( !::DestroyWindow(GetHwnd()) )
1023 wxLogLastError(wxT("DestroyWindow"));
1026 WXHWND wxhwnd
= (WXHWND
)handle
;
1029 SubclassWin(wxhwnd
);
1032 void wxWindowMSW
::DissociateHandle()
1034 // this also calls SetHWND(0) for us
1039 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1041 // Unicows note: the code below works, but only because WNDCLASS contains
1042 // original window handler rather that the unicows fake one. This may not
1043 // be on purpose, though; if it stops working with future versions of
1044 // unicows.dll, we can override unicows hooks by setting
1045 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1046 // versions that keep track of fake<->real wnd proc mapping.
1048 // On WinCE (at least), the wndproc comparison doesn't work,
1049 // so have to use something like this.
1051 extern wxChar
*wxCanvasClassName
;
1052 extern wxChar
*wxCanvasClassNameNR
;
1053 extern const wxChar
*wxMDIFrameClassName
;
1054 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1055 extern const wxChar
*wxMDIChildFrameClassName
;
1056 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1057 wxString
str(wxGetWindowClass(hWnd
));
1058 if (str
== wxCanvasClassName
||
1059 str
== wxCanvasClassNameNR
||
1060 str
== wxMDIFrameClassName
||
1061 str
== wxMDIFrameClassNameNoRedraw
||
1062 str
== wxMDIChildFrameClassName
||
1063 str
== wxMDIChildFrameClassNameNoRedraw
||
1064 str
== _T("wxTLWHiddenParent"))
1065 return true; // Effectively means don't subclass
1070 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1072 wxLogLastError(_T("GetClassInfo"));
1077 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1081 // ----------------------------------------------------------------------------
1083 // ----------------------------------------------------------------------------
1085 void wxWindowMSW
::SetWindowStyleFlag(long flags
)
1087 long flagsOld
= GetWindowStyleFlag();
1088 if ( flags
== flagsOld
)
1091 // update the internal variable
1092 wxWindowBase
::SetWindowStyleFlag(flags
);
1094 // now update the Windows style as well if needed - and if the window had
1095 // been already created
1099 WXDWORD exstyle
, exstyleOld
;
1100 long style
= MSWGetStyle(flags
, &exstyle
),
1101 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1103 if ( style
!= styleOld
)
1105 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1106 // this function so instead of simply setting the style to the new
1107 // value we clear the bits which were set in styleOld but are set in
1108 // the new one and set the ones which were not set before
1109 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1110 styleReal
&= ~styleOld
;
1113 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1116 // and the extended style
1117 if ( exstyle
!= exstyleOld
)
1119 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1120 exstyleReal
&= ~exstyleOld
;
1121 exstyleReal
|= exstyle
;
1123 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1125 // we must call SetWindowPos() to flash the cached extended style and
1126 // also to make the change to wxSTAY_ON_TOP style take effect: just
1127 // setting the style simply doesn't work
1128 if ( !::SetWindowPos(GetHwnd(),
1129 exstyleReal
& WS_EX_TOPMOST ? HWND_TOPMOST
1132 SWP_NOMOVE
| SWP_NOSIZE
) )
1134 wxLogLastError(_T("SetWindowPos"));
1139 WXDWORD wxWindowMSW
::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1141 // translate common wxWidgets styles to Windows ones
1143 // most of windows are child ones, those which are not (such as
1144 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1145 WXDWORD style
= WS_CHILD
;
1147 // using this flag results in very significant reduction in flicker,
1148 // especially with controls inside the static boxes (as the interior of the
1149 // box is not redrawn twice).
1150 // wxCLIP_CHILDREN support is for compatibility with old applications only.
1151 if ((!wxSystemOptions
::GetOptionInt(wxT("msw.window.no-clip-children")) == 1) || (flags
& wxCLIP_CHILDREN
))
1152 style
|= WS_CLIPCHILDREN
;
1154 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1155 // don't support overlapping windows and it only makes sense for them and,
1156 // presumably, gives the system some extra work (to manage more clipping
1157 // regions), so avoid it alltogether
1160 if ( flags
& wxVSCROLL
)
1161 style
|= WS_VSCROLL
;
1163 if ( flags
& wxHSCROLL
)
1164 style
|= WS_HSCROLL
;
1166 const wxBorder border
= GetBorder(flags
);
1168 // WS_BORDER is only required for wxBORDER_SIMPLE
1169 if ( border
== wxBORDER_SIMPLE
)
1172 // now deal with ext style if the caller wants it
1178 if ( flags
& wxTRANSPARENT_WINDOW
)
1179 *exstyle
|= WS_EX_TRANSPARENT
;
1185 case wxBORDER_DEFAULT
:
1186 wxFAIL_MSG( _T("unknown border style") );
1190 case wxBORDER_SIMPLE
:
1193 case wxBORDER_STATIC
:
1194 *exstyle
|= WS_EX_STATICEDGE
;
1197 case wxBORDER_RAISED
:
1198 *exstyle
|= WS_EX_DLGMODALFRAME
;
1201 case wxBORDER_SUNKEN
:
1202 *exstyle
|= WS_EX_CLIENTEDGE
;
1203 style
&= ~WS_BORDER
;
1206 case wxBORDER_DOUBLE
:
1207 *exstyle
|= WS_EX_DLGMODALFRAME
;
1211 // wxUniv doesn't use Windows dialog navigation functions at all
1212 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1213 // to make the dialog navigation work with the nested panels we must
1214 // use this style (top level windows such as dialogs don't need it)
1215 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1217 *exstyle
|= WS_EX_CONTROLPARENT
;
1219 #endif // __WXUNIVERSAL__
1225 // Setup background and foreground colours correctly
1226 void wxWindowMSW
::SetupColours()
1229 SetBackgroundColour(GetParent()->GetBackgroundColour());
1232 bool wxWindowMSW
::IsMouseInWindow() const
1234 // get the mouse position
1236 ::GetCursorPos(&pt
);
1238 // find the window which currently has the cursor and go up the window
1239 // chain until we find this window - or exhaust it
1240 HWND hwnd
= ::WindowFromPoint(pt
);
1241 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1242 hwnd
= ::GetParent(hwnd
);
1244 return hwnd
!= NULL
;
1247 void wxWindowMSW
::OnInternalIdle()
1250 // Check if we need to send a LEAVE event
1251 if ( m_mouseInWindow
)
1253 // note that we should generate the leave event whether the window has
1254 // or doesn't have mouse capture
1255 if ( !IsMouseInWindow() )
1257 GenerateMouseLeave();
1260 #endif // !__WXWINCE__
1262 if (wxUpdateUIEvent
::CanUpdate(this))
1263 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1266 // Set this window to be the child of 'parent'.
1267 bool wxWindowMSW
::Reparent(wxWindowBase
*parent
)
1269 if ( !wxWindowBase
::Reparent(parent
) )
1272 HWND hWndChild
= GetHwnd();
1273 HWND hWndParent
= GetParent() ?
GetWinHwnd(GetParent()) : (HWND
)0;
1275 ::SetParent(hWndChild
, hWndParent
);
1278 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1280 EnsureParentHasControlParentStyle(GetParent());
1282 #endif // !__WXWINCE__
1287 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1289 #ifndef __WXMICROWIN__
1290 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1294 void wxWindowMSW
::Freeze()
1296 if ( !m_frozenness
++ )
1298 SendSetRedraw(GetHwnd(), false);
1302 void wxWindowMSW
::Thaw()
1304 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1306 if ( !--m_frozenness
)
1308 SendSetRedraw(GetHwnd(), true);
1310 // we need to refresh everything or otherwise he invalidated area is not
1316 void wxWindowMSW
::Refresh(bool eraseBack
, const wxRect
*rect
)
1318 HWND hWnd
= GetHwnd();
1324 mswRect
.left
= rect
->x
;
1325 mswRect
.top
= rect
->y
;
1326 mswRect
.right
= rect
->x
+ rect
->width
;
1327 mswRect
.bottom
= rect
->y
+ rect
->height
;
1329 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1332 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1336 void wxWindowMSW
::Update()
1338 if ( !::UpdateWindow(GetHwnd()) )
1340 wxLogLastError(_T("UpdateWindow"));
1343 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1344 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1345 // handler needs to be really drawn right now
1350 // ---------------------------------------------------------------------------
1352 // ---------------------------------------------------------------------------
1355 #if wxUSE_DRAG_AND_DROP
1356 void wxWindowMSW
::SetDropTarget(wxDropTarget
*pDropTarget
)
1358 if ( m_dropTarget
!= 0 ) {
1359 m_dropTarget
->Revoke(m_hWnd
);
1360 delete m_dropTarget
;
1363 m_dropTarget
= pDropTarget
;
1364 if ( m_dropTarget
!= 0 )
1365 m_dropTarget
->Register(m_hWnd
);
1367 #endif // wxUSE_DRAG_AND_DROP
1369 // old style file-manager drag&drop support: we retain the old-style
1370 // DragAcceptFiles in parallel with SetDropTarget.
1371 void wxWindowMSW
::DragAcceptFiles(bool accept
)
1373 #if !defined(__WXWINCE__)
1374 HWND hWnd
= GetHwnd();
1376 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1378 wxUnusedVar(accept
);
1382 // ----------------------------------------------------------------------------
1384 // ----------------------------------------------------------------------------
1388 void wxWindowMSW
::DoSetToolTip(wxToolTip
*tooltip
)
1390 wxWindowBase
::DoSetToolTip(tooltip
);
1393 m_tooltip
->SetWindow((wxWindow
*)this);
1396 #endif // wxUSE_TOOLTIPS
1398 // ---------------------------------------------------------------------------
1399 // moving and resizing
1400 // ---------------------------------------------------------------------------
1403 void wxWindowMSW
::DoGetSize(int *x
, int *y
) const
1405 RECT rect
= wxGetWindowRect(GetHwnd());
1408 *x
= rect
.right
- rect
.left
;
1410 *y
= rect
.bottom
- rect
.top
;
1413 // Get size *available for subwindows* i.e. excluding menu bar etc.
1414 void wxWindowMSW
::DoGetClientSize(int *x
, int *y
) const
1416 RECT rect
= wxGetClientRect(GetHwnd());
1424 void wxWindowMSW
::DoGetPosition(int *x
, int *y
) const
1426 RECT rect
= wxGetWindowRect(GetHwnd());
1429 point
.x
= rect
.left
;
1432 // we do the adjustments with respect to the parent only for the "real"
1433 // children, not for the dialogs/frames
1434 if ( !IsTopLevel() )
1436 HWND hParentWnd
= 0;
1437 wxWindow
*parent
= GetParent();
1439 hParentWnd
= GetWinHwnd(parent
);
1441 // Since we now have the absolute screen coords, if there's a parent we
1442 // must subtract its top left corner
1445 ::ScreenToClient(hParentWnd
, &point
);
1450 // We may be faking the client origin. So a window that's really at (0,
1451 // 30) may appear (to wxWin apps) to be at (0, 0).
1452 wxPoint
pt(parent
->GetClientAreaOrigin());
1464 void wxWindowMSW
::DoScreenToClient(int *x
, int *y
) const
1472 ::ScreenToClient(GetHwnd(), &pt
);
1480 void wxWindowMSW
::DoClientToScreen(int *x
, int *y
) const
1488 ::ClientToScreen(GetHwnd(), &pt
);
1496 void wxWindowMSW
::DoMoveWindow(int x
, int y
, int width
, int height
)
1498 // TODO: is this consistent with other platforms?
1499 // Still, negative width or height shouldn't be allowed
1505 // if our parent had prepared a defer window handle for us, use it (unless
1506 // we are a top level window)
1507 wxWindowMSW
*parent
= GetParent();
1508 HDWP hdwp
= (parent
&& !IsTopLevel()) ?
(HDWP
)parent
->m_hDWP
: NULL
;
1511 hdwp
= ::DeferWindowPos(hdwp
, GetHwnd(), NULL
,
1512 x
, y
, width
, height
,
1516 wxLogLastError(_T("DeferWindowPos"));
1519 // hdwp must be updated as it may have been changed
1520 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1523 // otherwise (or if deferring failed) move the window in place immediately
1526 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1528 wxLogLastError(wxT("MoveWindow"));
1533 // set the size of the window: if the dimensions are positive, just use them,
1534 // but if any of them is equal to -1, it means that we must find the value for
1535 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1536 // which case -1 is a valid value for x and y)
1538 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1539 // the width/height to best suit our contents, otherwise we reuse the current
1541 void wxWindowMSW
::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1543 // get the current size and position...
1544 int currentX
, currentY
;
1545 GetPosition(¤tX
, ¤tY
);
1546 int currentW
,currentH
;
1547 GetSize(¤tW
, ¤tH
);
1549 // ... and don't do anything (avoiding flicker) if it's already ok
1550 if ( x
== currentX
&& y
== currentY
&&
1551 width
== currentW
&& height
== currentH
)
1556 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1558 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1561 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1563 wxSize size
= wxDefaultSize
;
1564 if ( width
== wxDefaultCoord
)
1566 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1568 size
= DoGetBestSize();
1573 // just take the current one
1578 if ( height
== wxDefaultCoord
)
1580 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1582 if ( size
.x
== wxDefaultCoord
)
1584 size
= DoGetBestSize();
1586 //else: already called DoGetBestSize() above
1592 // just take the current one
1597 DoMoveWindow(x
, y
, width
, height
);
1600 void wxWindowMSW
::DoSetClientSize(int width
, int height
)
1602 // setting the client size is less obvious than it it could have been
1603 // because in the result of changing the total size the window scrollbar
1604 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1605 // will not be correct as the difference between the total and client size
1606 // changes - so we keep changing it until we get it right
1608 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1609 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1610 // may become 3 if the window had 0 size originally and so we didn't
1611 // calculate the scrollbar correction correctly during the first iteration)
1612 // but just to be on the safe side we check for it instead of making it an
1613 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1614 for ( int i
= 0; i
< 4; i
++ )
1617 ::GetClientRect(GetHwnd(), &rectClient
);
1619 // if the size is already ok, stop here (rectClient.left = top = 0)
1620 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1621 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1626 int widthClient
= width
,
1627 heightClient
= height
;
1629 // Find the difference between the entire window (title bar and all)
1630 // and the client area; add this to the new client size to move the
1633 ::GetWindowRect(GetHwnd(), &rectWin
);
1635 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1636 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1639 point
.x
= rectWin
.left
;
1640 point
.y
= rectWin
.top
;
1642 // MoveWindow positions the child windows relative to the parent, so
1643 // adjust if necessary
1644 if ( !IsTopLevel() )
1646 wxWindow
*parent
= GetParent();
1649 ::ScreenToClient(GetHwndOf(parent
), &point
);
1653 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1657 // ---------------------------------------------------------------------------
1659 // ---------------------------------------------------------------------------
1661 int wxWindowMSW
::GetCharHeight() const
1663 return wxGetTextMetrics(this).tmHeight
;
1666 int wxWindowMSW
::GetCharWidth() const
1668 // +1 is needed because Windows apparently adds it when calculating the
1669 // dialog units size in pixels
1670 #if wxDIALOG_UNIT_COMPATIBILITY
1671 return wxGetTextMetrics(this).tmAveCharWidth
;
1673 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1677 void wxWindowMSW
::GetTextExtent(const wxString
& string
,
1679 int *descent
, int *externalLeading
,
1680 const wxFont
*theFont
) const
1682 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1683 _T("invalid font in GetTextExtent()") );
1687 fontToUse
= *theFont
;
1689 fontToUse
= GetFont();
1691 WindowHDC
hdc(GetHwnd());
1692 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1696 GetTextExtentPoint(hdc
, string
, string
.length(), &sizeRect
);
1697 GetTextMetrics(hdc
, &tm
);
1704 *descent
= tm
.tmDescent
;
1705 if ( externalLeading
)
1706 *externalLeading
= tm
.tmExternalLeading
;
1709 // ---------------------------------------------------------------------------
1711 // ---------------------------------------------------------------------------
1713 #if wxUSE_MENUS_NATIVE
1715 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1716 // immediately, without waiting for the next event loop iteration
1718 // NB: this function should probably be made public later as it can almost
1719 // surely replace wxYield() elsewhere as well
1720 static void wxYieldForCommandsOnly()
1722 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1723 // want to process it here)
1725 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1727 if ( msg
.message
== WM_QUIT
)
1729 // if we retrieved a WM_QUIT, insert back into the message queue.
1730 ::PostQuitMessage(0);
1734 // luckily (as we don't have access to wxEventLoopImpl method from here
1735 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1737 ::TranslateMessage(&msg
);
1738 ::DispatchMessage(&msg
);
1742 bool wxWindowMSW
::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1744 menu
->SetInvokingWindow(this);
1747 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1749 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1750 x
= mouse
.x
; y
= mouse
.y
;
1753 HWND hWnd
= GetHwnd();
1754 HMENU hMenu
= GetHmenuOf(menu
);
1758 ::ClientToScreen(hWnd
, &point
);
1759 wxCurrentPopupMenu
= menu
;
1760 #if defined(__WXWINCE__)
1763 UINT flags
= TPM_RIGHTBUTTON
;
1765 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1767 // we need to do it righ now as otherwise the events are never going to be
1768 // sent to wxCurrentPopupMenu from HandleCommand()
1770 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1771 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1772 // destroyed as soon as we return (it can be a local variable in the caller
1773 // for example) and so we do need to process the event immediately
1774 wxYieldForCommandsOnly();
1776 wxCurrentPopupMenu
= NULL
;
1778 menu
->SetInvokingWindow(NULL
);
1783 #endif // wxUSE_MENUS_NATIVE
1785 // ===========================================================================
1786 // pre/post message processing
1787 // ===========================================================================
1789 WXLRESULT wxWindowMSW
::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1792 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1794 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1797 bool wxWindowMSW
::MSWProcessMessage(WXMSG
* pMsg
)
1799 // wxUniversal implements tab traversal itself
1800 #ifndef __WXUNIVERSAL__
1801 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1803 // intercept dialog navigation keys
1804 MSG
*msg
= (MSG
*)pMsg
;
1806 // here we try to do all the job which ::IsDialogMessage() usually does
1808 if ( msg
->message
== WM_KEYDOWN
)
1810 bool bCtrlDown
= wxIsCtrlDown();
1811 bool bShiftDown
= wxIsShiftDown();
1813 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1814 // don't process it if it's the case (except for Ctrl-Tab/Enter
1815 // combinations which are always processed)
1819 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1821 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1822 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1823 // it, of course, implies them
1824 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1826 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1830 bool bForward
= true,
1831 bWindowChange
= false;
1833 // should we process this message specially?
1834 bool bProcess
= true;
1835 switch ( msg
->wParam
)
1838 if ( lDlgCode
& DLGC_WANTTAB
) {
1842 // Ctrl-Tab cycles thru notebook pages
1843 bWindowChange
= bCtrlDown
;
1844 bForward
= !bShiftDown
;
1850 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1858 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1865 wxButton
*btn
= wxDynamicCast(FindWindow(wxID_CANCEL
),wxButton
);
1867 // our own wxLogDialog should react to Esc
1868 // without Cancel button but this is a private class
1869 // so let's try recognize it by content
1870 #if wxUSE_LOG_DIALOG
1872 wxDynamicCast(this,wxDialog
) &&
1873 FindWindow(wxID_MORE
) &&
1874 FindWindow(wxID_OK
) &&
1875 !FindWindow(wxID_CANCEL
) &&
1876 GetTitle().MakeLower().StartsWith(wxTheApp
->GetAppName().c_str())
1878 btn
= wxDynamicCast(FindWindow(wxID_OK
),wxButton
);
1879 #endif // wxUSE_LOG_DIALOG
1880 if ( btn
&& btn
->IsEnabled() )
1882 // if we do have a cancel button, do press it
1883 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1885 // we consumed the message
1888 #endif // wxUSE_BUTTON
1896 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1898 // control wants to process Enter itself, don't
1899 // call IsDialogMessage() which would interpret
1903 else if ( lDlgCode
& DLGC_BUTTON
)
1905 // let IsDialogMessage() handle this for all
1906 // buttons except the owner-drawn ones which it
1907 // just seems to ignore
1908 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1909 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1911 // emulate the button click
1912 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1914 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1919 // FIXME: this should be handled by
1920 // wxNavigationKeyEvent handler and not here!
1924 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1926 if ( btn
&& btn
->IsEnabled() )
1928 // if we do have a default button, do press it
1929 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1933 else // no default button
1934 #endif // wxUSE_BUTTON
1936 // this is a quick and dirty test for a text
1938 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1940 // don't process Enter, the control might
1941 // need it for itself and don't let
1942 // ::IsDialogMessage() have it as it can
1943 // eat the Enter events sometimes
1946 else if (!IsTopLevel())
1948 // if not a top level window, let parent
1952 //else: treat Enter as TAB: pass to the next
1953 // control as this is the best thing to do
1954 // if the text doesn't handle Enter itself
1966 wxNavigationKeyEvent event
;
1967 event
.SetDirection(bForward
);
1968 event
.SetWindowChange(bWindowChange
);
1969 event
.SetEventObject(this);
1971 if ( GetEventHandler()->ProcessEvent(event
) )
1978 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
1979 // message even when there is no cancel button and when the message is
1980 // needed by the control itself: in particular, it prevents the tree in
1981 // place edit control from being closed with Escape in a dialog
1982 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
1984 // ::IsDialogMessage() is broken and may sometimes hang the
1985 // application by going into an infinite loop, so we try to detect
1986 // [some of] the situatations when this may happen and not call it
1989 // assume we can call it by default
1990 bool canSafelyCallIsDlgMsg
= true;
1992 HWND hwndFocus
= ::GetFocus();
1994 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
1995 // an infinite loop, because it will recursively check the child
1996 // windows but not the window itself and so if none of the children
1997 // accepts focus it loops forever (as it only stops when it gets
1998 // back to the window it started from)
2000 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2001 // style has the focus, it can happen. One such possibility is if
2002 // all windows are either toplevel, wxDialog, wxPanel or static
2003 // controls and no window can actually accept keyboard input.
2004 #if !defined(__WXWINCE__)
2005 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2007 // passimistic by default
2008 canSafelyCallIsDlgMsg
= false;
2009 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
2011 node
= node
->GetNext() )
2013 wxWindow
* const win
= node
->GetData();
2014 if ( win
->AcceptsFocus() &&
2015 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2016 WS_EX_CONTROLPARENT
) )
2018 // it shouldn't hang...
2019 canSafelyCallIsDlgMsg
= true;
2025 #endif // !__WXWINCE__
2027 if ( canSafelyCallIsDlgMsg
)
2029 // ::IsDialogMessage() can enter in an infinite loop when the
2030 // currently focused window is disabled or hidden and its
2031 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2035 if ( !::IsWindowEnabled(hwndFocus
) ||
2036 !::IsWindowVisible(hwndFocus
) )
2038 // it would enter an infinite loop if we do this!
2039 canSafelyCallIsDlgMsg
= false;
2044 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2046 // it's a top level window, don't go further -- e.g. even
2047 // if the parent of a dialog is disabled, this doesn't
2048 // break navigation inside the dialog
2052 hwndFocus
= ::GetParent(hwndFocus
);
2056 // let IsDialogMessage() have the message if it's safe to call it
2057 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2059 // IsDialogMessage() did something...
2064 #endif // __WXUNIVERSAL__
2069 // relay mouse move events to the tooltip control
2070 MSG
*msg
= (MSG
*)pMsg
;
2071 if ( msg
->message
== WM_MOUSEMOVE
)
2072 m_tooltip
->RelayEvent(pMsg
);
2074 #endif // wxUSE_TOOLTIPS
2079 bool wxWindowMSW
::MSWTranslateMessage(WXMSG
* pMsg
)
2081 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2082 return m_acceleratorTable
.Translate(this, pMsg
);
2086 #endif // wxUSE_ACCEL
2089 bool wxWindowMSW
::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2091 // preprocess all messages by default
2095 // ---------------------------------------------------------------------------
2096 // message params unpackers
2097 // ---------------------------------------------------------------------------
2099 void wxWindowMSW
::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2100 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2102 *id
= LOWORD(wParam
);
2103 *hwnd
= (WXHWND
)lParam
;
2104 *cmd
= HIWORD(wParam
);
2107 void wxWindowMSW
::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2108 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2110 *state
= LOWORD(wParam
);
2111 *minimized
= HIWORD(wParam
);
2112 *hwnd
= (WXHWND
)lParam
;
2115 void wxWindowMSW
::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2116 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2118 *code
= LOWORD(wParam
);
2119 *pos
= HIWORD(wParam
);
2120 *hwnd
= (WXHWND
)lParam
;
2123 void wxWindowMSW
::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2124 WXHDC
*hdc
, WXHWND
*hwnd
)
2126 *hwnd
= (WXHWND
)lParam
;
2127 *hdc
= (WXHDC
)wParam
;
2130 void wxWindowMSW
::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2131 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2133 *item
= (WXWORD
)wParam
;
2134 *flags
= HIWORD(wParam
);
2135 *hmenu
= (WXHMENU
)lParam
;
2138 // ---------------------------------------------------------------------------
2139 // Main wxWidgets window proc and the window proc for wxWindow
2140 // ---------------------------------------------------------------------------
2142 // Hook for new window just as it's being created, when the window isn't yet
2143 // associated with the handle
2144 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2146 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2147 // window being created and insures that it's always unset back later
2148 wxWindowCreationHook
::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2150 gs_winBeingCreated
= winBeingCreated
;
2153 wxWindowCreationHook
::~wxWindowCreationHook()
2155 gs_winBeingCreated
= NULL
;
2159 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2161 // trace all messages - useful for the debugging
2163 wxLogTrace(wxTraceMessages
,
2164 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2165 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2166 #endif // __WXDEBUG__
2168 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2170 // when we get the first message for the HWND we just created, we associate
2171 // it with wxWindow stored in gs_winBeingCreated
2172 if ( !wnd
&& gs_winBeingCreated
)
2174 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2175 wnd
= gs_winBeingCreated
;
2176 gs_winBeingCreated
= NULL
;
2177 wnd
->SetHWND((WXHWND
)hWnd
);
2183 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2185 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2190 WXLRESULT wxWindowMSW
::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2192 // did we process the message?
2193 bool processed
= false;
2204 // for most messages we should return 0 when we do process the message
2212 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2215 // return 0 to allow window creation
2216 rc
.result
= mayCreate ?
0 : -1;
2222 // never set processed to true and *always* pass WM_DESTROY to
2223 // DefWindowProc() as Windows may do some internal cleanup when
2224 // processing it and failing to pass the message along may cause
2225 // memory and resource leaks!
2226 (void)HandleDestroy();
2230 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2234 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2237 #if !defined(__WXWINCE__)
2240 LPRECT pRect
= (LPRECT
)lParam
;
2242 rc
.SetLeft(pRect
->left
);
2243 rc
.SetTop(pRect
->top
);
2244 rc
.SetRight(pRect
->right
);
2245 rc
.SetBottom(pRect
->bottom
);
2246 processed
= HandleMoving(rc
);
2248 pRect
->left
= rc
.GetLeft();
2249 pRect
->top
= rc
.GetTop();
2250 pRect
->right
= rc
.GetRight();
2251 pRect
->bottom
= rc
.GetBottom();
2258 LPRECT pRect
= (LPRECT
)lParam
;
2260 rc
.SetLeft(pRect
->left
);
2261 rc
.SetTop(pRect
->top
);
2262 rc
.SetRight(pRect
->right
);
2263 rc
.SetBottom(pRect
->bottom
);
2264 processed
= HandleSizing(rc
);
2266 pRect
->left
= rc
.GetLeft();
2267 pRect
->top
= rc
.GetTop();
2268 pRect
->right
= rc
.GetRight();
2269 pRect
->bottom
= rc
.GetBottom();
2273 #endif // !__WXWINCE__
2275 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2276 case WM_ACTIVATEAPP
:
2277 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2283 WXWORD state
, minimized
;
2285 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2287 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2292 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2296 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2303 // cast to wxWindow is needed for wxUniv
2304 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2305 processed
= HandlePaint();
2309 processed
= HandlePaint();
2317 if ( lParam
& PRF_ERASEBKGND
)
2318 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2320 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2321 processed
= HandlePaint();
2327 #ifdef __WXUNIVERSAL__
2328 // Universal uses its own wxFrame/wxDialog, so we don't receive
2329 // close events unless we have this.
2334 // don't let the DefWindowProc() destroy our window - we'll do it
2335 // ourselves in ~wxWindow
2342 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2346 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2347 GET_Y_LPARAM(lParam
),
2351 #ifdef WM_MOUSELEAVE
2354 // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
2355 if ( m_mouseInWindow
)
2357 GenerateMouseLeave();
2360 // always pass processed back as false, this allows the window
2361 // manager to process the message too. This is needed to
2362 // ensure windows XP themes work properly as the mouse moves
2363 // over widgets like buttons.
2367 #endif // WM_MOUSELEAVE
2369 #if wxUSE_MOUSEWHEEL
2371 processed
= HandleMouseWheel(wParam
, lParam
);
2375 case WM_LBUTTONDOWN
:
2377 case WM_LBUTTONDBLCLK
:
2378 case WM_RBUTTONDOWN
:
2380 case WM_RBUTTONDBLCLK
:
2381 case WM_MBUTTONDOWN
:
2383 case WM_MBUTTONDBLCLK
:
2385 #ifdef __WXMICROWIN__
2386 // MicroWindows seems to ignore the fact that a window is
2387 // disabled. So catch mouse events and throw them away if
2389 wxWindowMSW
* win
= this;
2392 if (!win
->IsEnabled())
2398 win
= win
->GetParent();
2399 if ( !win
|| win
->IsTopLevel() )
2406 #endif // __WXMICROWIN__
2407 int x
= GET_X_LPARAM(lParam
),
2408 y
= GET_Y_LPARAM(lParam
);
2410 // redirect the event to a static control if necessary by
2411 // finding one under mouse
2413 if ( GetCapture() == this )
2415 // but don't do it if the mouse is captured by this window
2416 // because then it should really get this event itself
2421 win
= FindWindowForMouseEvent(this, &x
, &y
);
2423 // this should never happen
2424 wxCHECK_MSG( win
, 0,
2425 _T("FindWindowForMouseEvent() returned NULL") );
2428 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2430 // if the app didn't eat the event, handle it in the default
2431 // way, that is by giving this window the focus
2434 // for the standard classes their WndProc sets the focus to
2435 // them anyhow and doing it from here results in some weird
2436 // problems, so don't do it for them (unnecessary anyhow)
2437 if ( !win
->IsOfStandardClass() )
2439 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2451 case MM_JOY1BUTTONDOWN
:
2452 case MM_JOY2BUTTONDOWN
:
2453 case MM_JOY1BUTTONUP
:
2454 case MM_JOY2BUTTONUP
:
2455 processed
= HandleJoystickEvent(message
,
2456 GET_X_LPARAM(lParam
),
2457 GET_Y_LPARAM(lParam
),
2460 #endif // __WXMICROWIN__
2466 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2468 processed
= HandleCommand(id
, cmd
, hwnd
);
2473 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2476 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2477 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2478 // apparently doesn't always behave properly and needs some help
2479 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2480 case WM_NOTIFYFORMAT
:
2481 if ( lParam
== NF_QUERY
)
2484 rc
.result
= NFR_UNICODE
;
2487 #endif // wxUSE_UNICODE_MSLU
2489 // for these messages we must return true if process the message
2492 case WM_MEASUREITEM
:
2494 int idCtrl
= (UINT
)wParam
;
2495 if ( message
== WM_DRAWITEM
)
2497 processed
= MSWOnDrawItem(idCtrl
,
2498 (WXDRAWITEMSTRUCT
*)lParam
);
2502 processed
= MSWOnMeasureItem(idCtrl
,
2503 (WXMEASUREITEMSTRUCT
*)lParam
);
2510 #endif // defined(WM_DRAWITEM)
2513 if ( !IsOfStandardClass() )
2515 // we always want to get the char events
2516 rc
.result
= DLGC_WANTCHARS
;
2518 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2520 // in fact, we want everything
2521 rc
.result
|= DLGC_WANTARROWS
|
2528 //else: get the dlg code from the DefWindowProc()
2533 // If this has been processed by an event handler, return 0 now
2534 // (we've handled it).
2535 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2536 if ( m_lastKeydownProcessed
)
2545 // we consider these message "not interesting" to OnChar, so
2546 // just don't do anything more with them
2556 // avoid duplicate messages to OnChar for these ASCII keys:
2557 // they will be translated by TranslateMessage() and received
2579 // but set processed to false, not true to still pass them
2580 // to the control's default window proc - otherwise
2581 // built-in keyboard handling won't work
2586 // special case of VK_APPS: treat it the same as right mouse
2587 // click because both usually pop up a context menu
2589 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2594 // do generate a CHAR event
2595 processed
= HandleChar((WORD
)wParam
, lParam
);
2598 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2605 // special case of VK_APPS: treat it the same as right mouse button
2606 if ( wParam
== VK_APPS
)
2608 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2613 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2618 case WM_CHAR
: // Always an ASCII character
2619 if ( m_lastKeydownProcessed
)
2621 // The key was handled in the EVT_KEY_DOWN and handling
2622 // a key in an EVT_KEY_DOWN handler is meant, by
2623 // design, to prevent EVT_CHARs from happening
2624 m_lastKeydownProcessed
= false;
2629 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2635 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2637 #endif // wxUSE_HOTKEY
2644 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2646 processed
= MSWOnScroll(message
== WM_HSCROLL ? wxHORIZONTAL
2652 // CTLCOLOR messages are sent by children to query the parent for their
2654 #ifndef __WXMICROWIN__
2655 case WM_CTLCOLORMSGBOX
:
2656 case WM_CTLCOLOREDIT
:
2657 case WM_CTLCOLORLISTBOX
:
2658 case WM_CTLCOLORBTN
:
2659 case WM_CTLCOLORDLG
:
2660 case WM_CTLCOLORSCROLLBAR
:
2661 case WM_CTLCOLORSTATIC
:
2665 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2667 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2670 #endif // !__WXMICROWIN__
2672 case WM_SYSCOLORCHANGE
:
2673 // the return value for this message is ignored
2674 processed
= HandleSysColorChange();
2677 #if !defined(__WXWINCE__)
2678 case WM_DISPLAYCHANGE
:
2679 processed
= HandleDisplayChange();
2683 case WM_PALETTECHANGED
:
2684 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2687 case WM_CAPTURECHANGED
:
2688 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2691 case WM_QUERYNEWPALETTE
:
2692 processed
= HandleQueryNewPalette();
2696 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2699 // we processed the message, i.e. erased the background
2704 #if !defined(__WXWINCE__)
2706 processed
= HandleDropFiles(wParam
);
2711 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2715 // we never set focus from here
2720 #if !defined(__WXWINCE__)
2721 case WM_QUERYENDSESSION
:
2722 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2726 processed
= HandleEndSession(wParam
!= 0, lParam
);
2729 case WM_GETMINMAXINFO
:
2730 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2735 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2736 LOWORD(lParam
), // hit test
2737 HIWORD(lParam
)); // mouse msg
2741 // returning TRUE stops the DefWindowProc() from further
2742 // processing this message - exactly what we need because we've
2743 // just set the cursor.
2748 #if wxUSE_ACCESSIBILITY
2751 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2752 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2754 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2756 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2762 #if defined(WM_HELP)
2765 // HELPINFO doesn't seem to be supported on WinCE.
2767 HELPINFO
* info
= (HELPINFO
*) lParam
;
2768 // Don't yet process menu help events, just windows
2769 if (info
->iContextType
== HELPINFO_WINDOW
)
2772 wxWindowMSW
* subjectOfHelp
= this;
2773 bool eventProcessed
= false;
2774 while (subjectOfHelp
&& !eventProcessed
)
2776 wxHelpEvent
helpEvent(wxEVT_HELP
,
2777 subjectOfHelp
->GetId(),
2781 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2785 helpEvent
.SetEventObject(this);
2787 GetEventHandler()->ProcessEvent(helpEvent
);
2789 // Go up the window hierarchy until the event is
2791 subjectOfHelp
= subjectOfHelp
->GetParent();
2794 processed
= eventProcessed
;
2797 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2799 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2800 helpEvent
.SetEventObject(this);
2801 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2804 //else: processed is already false
2810 #if !defined(__WXWINCE__)
2811 case WM_CONTEXTMENU
:
2813 // we don't convert from screen to client coordinates as
2814 // the event may be handled by a parent window
2815 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2817 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2819 // we could have got an event from our child, reflect it back
2820 // to it if this is the case
2821 wxWindowMSW
*win
= NULL
;
2822 if ( (WXHWND
)wParam
!= m_hWnd
)
2824 win
= FindItemByHWND((WXHWND
)wParam
);
2830 evtCtx
.SetEventObject(win
);
2831 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
2837 // we're only interested in our own menus, not MF_SYSMENU
2838 if ( HIWORD(wParam
) == MF_POPUP
)
2840 // handle menu chars for ownerdrawn menu items
2841 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2842 if ( i
!= wxNOT_FOUND
)
2844 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2854 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2855 wxGetMessageName(message
));
2856 #endif // __WXDEBUG__
2857 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2863 // ----------------------------------------------------------------------------
2864 // wxWindow <-> HWND map
2865 // ----------------------------------------------------------------------------
2867 wxWinHashTable
*wxWinHandleHash
= NULL
;
2869 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2871 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
2874 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2876 // adding NULL hWnd is (first) surely a result of an error and
2877 // (secondly) breaks menu command processing
2878 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2879 wxT("attempt to add a NULL hWnd to window list ignored") );
2881 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2883 if ( oldWin
&& (oldWin
!= win
) )
2885 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2886 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2889 #endif // __WXDEBUG__
2892 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2896 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2898 wxWinHandleHash
->Delete((long)win
->GetHWND());
2901 // ----------------------------------------------------------------------------
2902 // various MSW speciic class dependent functions
2903 // ----------------------------------------------------------------------------
2905 // Default destroyer - override if you destroy it in some other way
2906 // (e.g. with MDI child windows)
2907 void wxWindowMSW
::MSWDestroyWindow()
2911 bool wxWindowMSW
::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2914 int& w
, int& h
) const
2916 // yes, those are just some arbitrary hardcoded numbers
2917 static const int DEFAULT_Y
= 200;
2919 bool nonDefault
= false;
2921 if ( pos
.x
== wxDefaultCoord
)
2923 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
2924 // can just as well set it to CW_USEDEFAULT as well
2930 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2931 // neither because it is not handled as a special value by Windows then
2932 // and so we have to choose some default value for it
2934 y
= pos
.y
== wxDefaultCoord ? DEFAULT_Y
: pos
.y
;
2940 NB: there used to be some code here which set the initial size of the
2941 window to the client size of the parent if no explicit size was
2942 specified. This was wrong because wxWidgets programs often assume
2943 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2944 it. To see why, you should understand that Windows sends WM_SIZE from
2945 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2946 from some base class ctor and so this WM_SIZE is not processed in the
2947 real class' OnSize() (because it's not fully constructed yet and the
2948 event goes to some base class OnSize() instead). So the WM_SIZE we
2949 rely on is the one sent when the parent frame resizes its children
2950 but here is the problem: if the child already has just the right
2951 size, nothing will happen as both wxWidgets and Windows check for
2952 this and ignore any attempts to change the window size to the size it
2953 already has - so no WM_SIZE would be sent.
2957 // we don't use CW_USEDEFAULT here for several reasons:
2959 // 1. it results in huge frames on modern screens (1000*800 is not
2960 // uncommon on my 1280*1024 screen) which is way too big for a half
2961 // empty frame of most of wxWidgets samples for example)
2963 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
2964 // the default is for whatever reason 8*8 which breaks client <->
2965 // window size calculations (it would be nice if it didn't, but it
2966 // does and the simplest way to fix it seemed to change the broken
2967 // default size anyhow)
2969 // 3. there is just no advantage in doing it: with x and y it is
2970 // possible that [future versions of] Windows position the new top
2971 // level window in some smart way which we can't do, but we can
2972 // guess a reasonably good size for a new window just as well
2975 // However, on PocketPC devices, we must use the default
2976 // size if possible.
2978 if (size
.x
== wxDefaultCoord
)
2982 if (size
.y
== wxDefaultCoord
)
2987 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
2991 w
= WidthDefault(size
.x
);
2992 h
= HeightDefault(size
.y
);
2995 AdjustForParentClientOrigin(x
, y
);
3000 WXHWND wxWindowMSW
::MSWGetParent() const
3002 return m_parent ? m_parent
->GetHWND() : WXHWND(NULL
);
3005 bool wxWindowMSW
::MSWCreate(const wxChar
*wclass
,
3006 const wxChar
*title
,
3010 WXDWORD extendedStyle
)
3012 // choose the position/size for the new window
3014 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3016 // controlId is menu handle for the top level windows, so set it to 0
3017 // unless we're creating a child window
3018 int controlId
= style
& WS_CHILD ?
GetId() : 0;
3020 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3021 // which is the same but without CS_[HV]REDRAW class styles so using it
3022 // ensures that the window is not fully repainted on each resize
3023 wxString
className(wclass
);
3024 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3026 className
+= wxT("NR");
3029 // do create the window
3030 wxWindowCreationHook
hook(this);
3032 m_hWnd
= (WXHWND
)::CreateWindowEx
3036 title ? title
: m_windowName
.c_str(),
3039 (HWND
)MSWGetParent(),
3042 NULL
// no extra data
3047 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3052 SubclassWin(m_hWnd
);
3057 // ===========================================================================
3058 // MSW message handlers
3059 // ===========================================================================
3061 // ---------------------------------------------------------------------------
3063 // ---------------------------------------------------------------------------
3067 bool wxWindowMSW
::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3069 #ifndef __WXMICROWIN__
3070 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3071 HWND hWnd
= hdr
->hwndFrom
;
3072 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3074 // if the control is one of our windows, let it handle the message itself
3077 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3080 // VZ: why did we do it? normally this is unnecessary and, besides, it
3081 // breaks the message processing for the toolbars because the tooltip
3082 // notifications were being forwarded to the toolbar child controls
3083 // (if it had any) before being passed to the toolbar itself, so in my
3084 // example the tooltip for the combobox was always shown instead of the
3085 // correct button tooltips
3087 // try all our children
3088 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3091 wxWindow
*child
= node
->GetData();
3092 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3097 node
= node
->GetNext();
3101 // by default, handle it ourselves
3102 return MSWOnNotify(idCtrl
, lParam
, result
);
3103 #else // __WXMICROWIN__
3110 bool wxWindowMSW
::HandleTooltipNotify(WXUINT code
,
3112 const wxString
& ttip
)
3114 // I don't know why it happens, but the versions of comctl32.dll starting
3115 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3116 // this message is supposed to be sent to Unicode programs only) -- hence
3117 // we need to handle it as well, otherwise no tooltips will be shown in
3120 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3123 // not a tooltip message or no tooltip to show anyhow
3128 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3130 // We don't want to use the szText buffer because it has a limit of 80
3131 // bytes and this is not enough, especially for Unicode build where it
3132 // limits the tooltip string length to only 40 characters
3134 // The best would be, of course, to not impose any length limitations at
3135 // all but then the buffer would have to be dynamic and someone would have
3136 // to free it and we don't have the tooltip owner object here any more, so
3137 // for now use our own static buffer with a higher fixed max length.
3139 // Note that using a static buffer should not be a problem as only a single
3140 // tooltip can be shown at the same time anyhow.
3142 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3144 // We need to convert tooltip from multi byte to Unicode on the fly.
3145 static wchar_t buf
[513];
3147 // Truncate tooltip length if needed as otherwise we might not have
3148 // enough space for it in the buffer and MultiByteToWideChar() would
3150 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3152 // Convert to WideChar without adding the NULL character. The NULL
3153 // character is added afterwards (this is more efficient).
3154 int len
= ::MultiByteToWideChar
3166 wxLogLastError(_T("MultiByteToWideChar()"));
3170 ttText
->lpszText
= (LPSTR
) buf
;
3172 else // TTN_NEEDTEXTA
3173 #endif // !wxUSE_UNICODE
3175 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3176 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3177 // to copy the string we have into the buffer
3178 static wxChar buf
[513];
3179 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3180 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3181 ttText
->lpszText
= buf
;
3187 #endif // wxUSE_TOOLTIPS
3189 bool wxWindowMSW
::MSWOnNotify(int WXUNUSED(idCtrl
),
3191 WXLPARAM
* WXUNUSED(result
))
3196 NMHDR
* hdr
= (NMHDR
*)lParam
;
3197 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3204 wxUnusedVar(lParam
);
3205 #endif // wxUSE_TOOLTIPS
3212 // ---------------------------------------------------------------------------
3213 // end session messages
3214 // ---------------------------------------------------------------------------
3216 bool wxWindowMSW
::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3219 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3220 event
.SetEventObject(wxTheApp
);
3221 event
.SetCanVeto(true);
3222 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3224 bool rc
= wxTheApp
->ProcessEvent(event
);
3228 // we may end only if the app didn't veto session closing (double
3230 *mayEnd
= !event
.GetVeto();
3239 bool wxWindowMSW
::HandleEndSession(bool endSession
, long logOff
)
3242 // do nothing if the session isn't ending
3247 if ( (this != wxTheApp
->GetTopWindow()) )
3250 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3251 event
.SetEventObject(wxTheApp
);
3252 event
.SetCanVeto(false);
3253 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3255 return wxTheApp
->ProcessEvent(event
);
3261 // ---------------------------------------------------------------------------
3262 // window creation/destruction
3263 // ---------------------------------------------------------------------------
3265 bool wxWindowMSW
::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3267 // VZ: why is this commented out for WinCE? If it doesn't support
3268 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3269 // not with multiple #ifdef's!
3271 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3272 EnsureParentHasControlParentStyle(GetParent());
3275 #endif // !__WXWINCE__
3277 // TODO: should generate this event from WM_NCCREATE
3278 wxWindowCreateEvent
event((wxWindow
*)this);
3279 (void)GetEventHandler()->ProcessEvent(event
);
3286 bool wxWindowMSW
::HandleDestroy()
3290 // delete our drop target if we've got one
3291 #if wxUSE_DRAG_AND_DROP
3292 if ( m_dropTarget
!= NULL
)
3294 m_dropTarget
->Revoke(m_hWnd
);
3296 delete m_dropTarget
;
3297 m_dropTarget
= NULL
;
3299 #endif // wxUSE_DRAG_AND_DROP
3301 // WM_DESTROY handled
3305 // ---------------------------------------------------------------------------
3307 // ---------------------------------------------------------------------------
3309 bool wxWindowMSW
::HandleActivate(int state
,
3310 bool WXUNUSED(minimized
),
3311 WXHWND
WXUNUSED(activate
))
3313 wxActivateEvent
event(wxEVT_ACTIVATE
,
3314 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3316 event
.SetEventObject(this);
3318 return GetEventHandler()->ProcessEvent(event
);
3321 bool wxWindowMSW
::HandleSetFocus(WXHWND hwnd
)
3323 // Strangly enough, some controls get set focus events when they are being
3324 // deleted, even if they already had focus before.
3325 if ( m_isBeingDeleted
)
3330 // notify the parent keeping track of focus for the kbd navigation
3331 // purposes that we got it
3332 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3333 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3339 m_caret
->OnSetFocus();
3341 #endif // wxUSE_CARET
3344 // If it's a wxTextCtrl don't send the event as it will be done
3345 // after the control gets to process it from EN_FOCUS handler
3346 if ( wxDynamicCastThis(wxTextCtrl
) )
3350 #endif // wxUSE_TEXTCTRL
3352 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3353 event
.SetEventObject(this);
3355 // wxFindWinFromHandle() may return NULL, it is ok
3356 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3358 return GetEventHandler()->ProcessEvent(event
);
3361 bool wxWindowMSW
::HandleKillFocus(WXHWND hwnd
)
3367 m_caret
->OnKillFocus();
3369 #endif // wxUSE_CARET
3372 // If it's a wxTextCtrl don't send the event as it will be done
3373 // after the control gets to process it.
3374 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3381 // Don't send the event when in the process of being deleted. This can
3382 // only cause problems if the event handler tries to access the object.
3383 if ( m_isBeingDeleted
)
3388 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3389 event
.SetEventObject(this);
3391 // wxFindWinFromHandle() may return NULL, it is ok
3392 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3394 return GetEventHandler()->ProcessEvent(event
);
3397 // ---------------------------------------------------------------------------
3399 // ---------------------------------------------------------------------------
3401 bool wxWindowMSW
::HandleShow(bool show
, int WXUNUSED(status
))
3403 wxShowEvent
event(GetId(), show
);
3404 event
.SetEventObject(this);
3406 return GetEventHandler()->ProcessEvent(event
);
3409 bool wxWindowMSW
::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3411 wxInitDialogEvent
event(GetId());
3412 event
.SetEventObject(this);
3414 return GetEventHandler()->ProcessEvent(event
);
3417 bool wxWindowMSW
::HandleDropFiles(WXWPARAM wParam
)
3419 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3420 wxUnusedVar(wParam
);
3422 #else // __WXMICROWIN__
3423 HDROP hFilesInfo
= (HDROP
) wParam
;
3425 // Get the total number of files dropped
3426 UINT gwFilesDropped
= ::DragQueryFile
3434 wxString
*files
= new wxString
[gwFilesDropped
];
3435 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3437 // first get the needed buffer length (+1 for terminating NUL)
3438 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3440 // and now get the file name
3441 ::DragQueryFile(hFilesInfo
, wIndex
,
3442 wxStringBuffer(files
[wIndex
], len
), len
);
3444 DragFinish (hFilesInfo
);
3446 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3447 event
.SetEventObject(this);
3450 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3451 event
.m_pos
.x
= dropPoint
.x
;
3452 event
.m_pos
.y
= dropPoint
.y
;
3454 return GetEventHandler()->ProcessEvent(event
);
3459 bool wxWindowMSW
::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3461 int WXUNUSED(mouseMsg
))
3463 #ifndef __WXMICROWIN__
3464 // the logic is as follows:
3465 // -1. don't set cursor for non client area, including but not limited to
3466 // the title bar, scrollbars, &c
3467 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3468 // 1. if we have the cursor set it unless wxIsBusy()
3469 // 2. if we're a top level window, set some cursor anyhow
3470 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3472 if ( nHitTest
!= HTCLIENT
)
3477 HCURSOR hcursor
= 0;
3479 // first ask the user code - it may wish to set the cursor in some very
3480 // specific way (for example, depending on the current position)
3482 if ( !::GetCursorPos(&pt
) )
3484 wxLogLastError(wxT("GetCursorPos"));
3489 ScreenToClient(&x
, &y
);
3490 wxSetCursorEvent
event(x
, y
);
3492 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3493 if ( processedEvtSetCursor
&& event
.HasCursor() )
3495 hcursor
= GetHcursorOf(event
.GetCursor());
3500 bool isBusy
= wxIsBusy();
3502 // the test for processedEvtSetCursor is here to prevent using m_cursor
3503 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3504 // it - this is a way to say that our cursor shouldn't be used for this
3506 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3508 hcursor
= GetHcursorOf(m_cursor
);
3515 hcursor
= wxGetCurrentBusyCursor();
3517 else if ( !hcursor
)
3519 const wxCursor
*cursor
= wxGetGlobalCursor();
3520 if ( cursor
&& cursor
->Ok() )
3522 hcursor
= GetHcursorOf(*cursor
);
3530 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3532 ::SetCursor(hcursor
);
3534 // cursor set, stop here
3537 #endif // __WXMICROWIN__
3539 // pass up the window chain
3543 // ---------------------------------------------------------------------------
3544 // owner drawn stuff
3545 // ---------------------------------------------------------------------------
3547 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3548 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3549 #define WXUNUSED_UNLESS_ODRAWN(param) param
3551 #define WXUNUSED_UNLESS_ODRAWN(param)
3555 wxWindowMSW
::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3556 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3558 #if wxUSE_OWNER_DRAWN
3560 #if wxUSE_MENUS_NATIVE
3561 // is it a menu item?
3562 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3563 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3565 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3567 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3568 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3570 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3571 // the DC from being released
3572 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3573 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3574 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3575 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3577 return pMenuItem
->OnDrawItem
3581 (wxOwnerDrawn
::wxODAction
)pDrawStruct
->itemAction
,
3582 (wxOwnerDrawn
::wxODStatus
)pDrawStruct
->itemState
3585 #endif // wxUSE_MENUS_NATIVE
3587 #endif // USE_OWNER_DRAWN
3589 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3591 #if wxUSE_OWNER_DRAWN
3592 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3593 #else // !wxUSE_OWNER_DRAWN
3594 // we may still have owner-drawn buttons internally because we have to make
3595 // them owner-drawn to support colour change
3598 wxDynamicCast(FindItem(id
), wxButton
)
3603 #endif // USE_OWNER_DRAWN
3607 return item
->MSWOnDraw(itemStruct
);
3610 #endif // wxUSE_CONTROLS
3616 wxWindowMSW
::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3618 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3619 // is it a menu item?
3620 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3621 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3623 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3625 wxCHECK_MSG( pMenuItem
&& pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)),
3626 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3629 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3631 pMeasureStruct
->itemWidth
= w
;
3632 pMeasureStruct
->itemHeight
= h
;
3637 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3640 return item
->MSWOnMeasure(itemStruct
);
3644 wxUnusedVar(itemStruct
);
3645 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3650 // ---------------------------------------------------------------------------
3651 // colours and palettes
3652 // ---------------------------------------------------------------------------
3654 bool wxWindowMSW
::HandleSysColorChange()
3656 wxSysColourChangedEvent event
;
3657 event
.SetEventObject(this);
3659 (void)GetEventHandler()->ProcessEvent(event
);
3661 // always let the system carry on the default processing to allow the
3662 // native controls to react to the colours update
3666 bool wxWindowMSW
::HandleDisplayChange()
3668 wxDisplayChangedEvent event
;
3669 event
.SetEventObject(this);
3671 return GetEventHandler()->ProcessEvent(event
);
3674 #ifndef __WXMICROWIN__
3676 bool wxWindowMSW
::HandleCtlColor(WXHBRUSH
*brush
, WXHDC pDC
, WXHWND pWnd
)
3679 wxWindow
*item
= FindItemByHWND(pWnd
, true);
3681 *brush
= item
->MSWControlColor(pDC
);
3683 #endif // wxUSE_CONTROLS
3686 return *brush
!= NULL
;
3689 #endif // __WXMICROWIN__
3691 WXHBRUSH wxWindowMSW
::MSWControlColor(WXHDC
WXUNUSED(hDC
))
3696 bool wxWindowMSW
::HandlePaletteChanged(WXHWND hWndPalChange
)
3699 // same as below except we don't respond to our own messages
3700 if ( hWndPalChange
!= GetHWND() )
3702 // check to see if we our our parents have a custom palette
3703 wxWindowMSW
*win
= this;
3704 while ( win
&& !win
->HasCustomPalette() )
3706 win
= win
->GetParent();
3709 if ( win
&& win
->HasCustomPalette() )
3711 // realize the palette to see whether redrawing is needed
3712 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3713 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3714 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3716 int result
= ::RealizePalette(hdc
);
3718 // restore the palette (before releasing the DC)
3719 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3720 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3721 ::RealizePalette(hdc
);
3722 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3724 // now check for the need to redraw
3726 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3730 #endif // wxUSE_PALETTE
3732 wxPaletteChangedEvent
event(GetId());
3733 event
.SetEventObject(this);
3734 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3736 return GetEventHandler()->ProcessEvent(event
);
3739 bool wxWindowMSW
::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3741 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3742 event
.SetEventObject(this);
3744 return GetEventHandler()->ProcessEvent(event
);
3747 bool wxWindowMSW
::HandleQueryNewPalette()
3751 // check to see if we our our parents have a custom palette
3752 wxWindowMSW
*win
= this;
3753 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3754 if (win
->HasCustomPalette()) {
3755 /* realize the palette to see whether redrawing is needed */
3756 HDC hdc
= ::GetDC((HWND
) GetHWND());
3757 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3758 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3760 int result
= ::RealizePalette(hdc
);
3761 /* restore the palette (before releasing the DC) */
3762 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3763 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3764 ::RealizePalette(hdc
);
3765 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3766 /* now check for the need to redraw */
3768 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3770 #endif // wxUSE_PALETTE
3772 wxQueryNewPaletteEvent
event(GetId());
3773 event
.SetEventObject(this);
3775 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3778 // Responds to colour changes: passes event on to children.
3779 void wxWindowMSW
::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3781 // the top level window also reset the standard colour map as it might have
3782 // changed (there is no need to do it for the non top level windows as we
3783 // only have to do it once)
3787 gs_hasStdCmap
= false;
3789 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3792 // Only propagate to non-top-level windows because Windows already
3793 // sends this event to all top-level ones
3794 wxWindow
*win
= node
->GetData();
3795 if ( !win
->IsTopLevel() )
3797 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3798 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3799 // the standard controls
3800 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3803 node
= node
->GetNext();
3807 extern wxCOLORMAP
*wxGetStdColourMap()
3809 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3810 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3812 if ( !gs_hasStdCmap
)
3814 static bool s_coloursInit
= false;
3816 if ( !s_coloursInit
)
3818 // When a bitmap is loaded, the RGB values can change (apparently
3819 // because Windows adjusts them to care for the old programs always
3820 // using 0xc0c0c0 while the transparent colour for the new Windows
3821 // versions is different). But we do this adjustment ourselves so
3822 // we want to avoid Windows' "help" and for this we need to have a
3823 // reference bitmap which can tell us what the RGB values change
3825 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3826 if ( stdColourBitmap
.Ok() )
3828 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3829 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3830 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3833 memDC
.SelectObject(stdColourBitmap
);
3836 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3838 memDC
.GetPixel(i
, 0, &colour
);
3839 s_stdColours
[i
] = wxColourToRGB(colour
);
3842 else // wxBITMAP_STD_COLOURS couldn't be loaded
3844 s_stdColours
[0] = RGB(000,000,000); // black
3845 s_stdColours
[1] = RGB(128,128,128); // dark grey
3846 s_stdColours
[2] = RGB(192,192,192); // light grey
3847 s_stdColours
[3] = RGB(255,255,255); // white
3848 //s_stdColours[4] = RGB(000,000,255); // blue
3849 //s_stdColours[5] = RGB(255,000,255); // magenta
3852 s_coloursInit
= true;
3855 gs_hasStdCmap
= true;
3857 // create the colour map
3858 #define INIT_CMAP_ENTRY(col) \
3859 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3860 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3862 INIT_CMAP_ENTRY(BTNTEXT
);
3863 INIT_CMAP_ENTRY(BTNSHADOW
);
3864 INIT_CMAP_ENTRY(BTNFACE
);
3865 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3867 #undef INIT_CMAP_ENTRY
3873 // ---------------------------------------------------------------------------
3875 // ---------------------------------------------------------------------------
3877 bool wxWindowMSW
::HandlePaint()
3879 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3881 wxLogLastError(wxT("CreateRectRgn"));
3882 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3883 wxLogLastError(wxT("GetUpdateRgn"));
3885 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3887 wxPaintEvent
event(m_windowId
);
3888 event
.SetEventObject(this);
3890 bool processed
= GetEventHandler()->ProcessEvent(event
);
3892 // note that we must generate NC event after the normal one as otherwise
3893 // BeginPaint() will happily overwrite our decorations with the background
3895 wxNcPaintEvent
eventNc(m_windowId
);
3896 eventNc
.SetEventObject(this);
3897 GetEventHandler()->ProcessEvent(eventNc
);
3902 // Can be called from an application's OnPaint handler
3903 void wxWindowMSW
::OnPaint(wxPaintEvent
& event
)
3905 #ifdef __WXUNIVERSAL__
3908 HDC hDC
= (HDC
) wxPaintDC
::FindDCInCache((wxWindow
*) event
.GetEventObject());
3911 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3916 bool wxWindowMSW
::HandleEraseBkgnd(WXHDC hdc
)
3921 dc
.SetWindow((wxWindow
*)this);
3924 wxEraseEvent
event(m_windowId
, &dc
);
3925 event
.SetEventObject(this);
3926 bool rc
= GetEventHandler()->ProcessEvent(event
);
3930 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3931 dc
.SelectOldObjects(hdc
);
3936 void wxWindowMSW
::OnEraseBackground(wxEraseEvent
& event
)
3938 // standard non top level controls (i.e. except the dialogs) always erase
3939 // their background themselves in HandleCtlColor() or have some control-
3940 // specific ways to set the colours (common controls)
3941 if ( IsOfStandardClass() && !IsTopLevel() )
3947 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
3949 // don't skip the event here, custom background means that the app
3950 // is drawing it itself in its OnPaint(), so don't draw it at all
3951 // now to avoid flicker
3956 // do default background painting
3957 if ( !DoEraseBackground(*event
.GetDC()) )
3959 // let the system paint the background
3964 bool wxWindowMSW
::DoEraseBackground(wxDC
& dc
)
3966 HBRUSH hBrush
= (HBRUSH
)MSWGetBgBrush(dc
.GetHDC());
3971 ::GetClientRect(GetHwnd(), &rc
);
3972 ::FillRect(GetHdcOf(dc
), &rc
, hBrush
);
3977 WXHBRUSH wxWindowMSW
::MSWGetSolidBgBrushForChild(wxWindow
*child
)
3979 wxColour col
= MSWGetBgColourForChild(child
);
3982 // draw children with the same colour as the parent
3983 wxBrush
*brush
= wxTheBrushList
->FindOrCreateBrush(col
, wxSOLID
);
3985 return (WXHBRUSH
)brush
->GetResourceHandle();
3991 wxColour wxWindowMSW
::MSWGetBgColourForChild(wxWindow
*child
)
3995 // our background colour applies to:
3996 // 1. this window itself, always
3997 // 2. all children unless the colour is "not inheritable"
3998 // 3. immediate transparent children which should show the same
3999 // background as we do, but not for transparent grandchildren
4000 // which use the background of their immediate parent instead
4001 if ( m_inheritBgCol
||
4003 (child
->HasTransparentBackground() &&
4004 child
->GetParent() == this) )
4006 return GetBackgroundColour();
4010 return wxNullColour
;
4013 WXHBRUSH wxWindowMSW
::MSWGetBgBrushForSelf(wxWindow
*parent
, WXHDC hDC
)
4015 return parent
->MSWGetBgBrushForChild(hDC
, (wxWindow
*)this);
4018 WXHBRUSH wxWindowMSW
::MSWGetBgBrush(WXHDC hDC
)
4020 for ( wxWindow
*win
= (wxWindow
*)this; win
; win
= win
->GetParent() )
4022 WXHBRUSH hBrush
= MSWGetBgBrushForSelf(win
, hDC
);
4026 // background is not inherited beyond the windows which have their own
4027 // fixed background such as top level windows and notebooks and for
4028 // windows for which a custom colour had been explicitly set with
4029 // SetOwnBackgroundColour() and so shouldn't affect its children
4030 if ( win
->ProvidesBackground() ||
4031 (win
->m_hasBgCol
&& !win
->m_inheritBgCol
) )
4038 // ---------------------------------------------------------------------------
4039 // moving and resizing
4040 // ---------------------------------------------------------------------------
4042 bool wxWindowMSW
::HandleMinimize()
4044 wxIconizeEvent
event(m_windowId
);
4045 event
.SetEventObject(this);
4047 return GetEventHandler()->ProcessEvent(event
);
4050 bool wxWindowMSW
::HandleMaximize()
4052 wxMaximizeEvent
event(m_windowId
);
4053 event
.SetEventObject(this);
4055 return GetEventHandler()->ProcessEvent(event
);
4058 bool wxWindowMSW
::HandleMove(int x
, int y
)
4061 wxMoveEvent
event(point
, m_windowId
);
4062 event
.SetEventObject(this);
4064 return GetEventHandler()->ProcessEvent(event
);
4067 bool wxWindowMSW
::HandleMoving(wxRect
& rect
)
4069 wxMoveEvent
event(rect
, m_windowId
);
4070 event
.SetEventObject(this);
4072 bool rc
= GetEventHandler()->ProcessEvent(event
);
4074 rect
= event
.GetRect();
4078 bool wxWindowMSW
::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4080 // when we resize this window, its children are probably going to be
4081 // repositioned as well, prepare to use DeferWindowPos() for them
4082 const int numChildren
= GetChildren().GetCount();
4083 if ( numChildren
> 1 )
4085 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4088 wxLogLastError(_T("BeginDeferWindowPos"));
4092 // update this window size
4093 bool processed
= false;
4097 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4098 // fall through nevertheless
4102 // we're not interested in these messages at all
4105 case SIZE_MINIMIZED
:
4106 processed
= HandleMinimize();
4109 case SIZE_MAXIMIZED
:
4110 /* processed = */ HandleMaximize();
4111 // fall through to send a normal size event as well
4114 // don't use w and h parameters as they specify the client size
4115 // while according to the docs EVT_SIZE handler is supposed to
4116 // receive the total size
4117 wxSizeEvent
event(GetSize(), m_windowId
);
4118 event
.SetEventObject(this);
4120 processed
= GetEventHandler()->ProcessEvent(event
);
4123 // and finally change the positions of all child windows at once
4126 // reset m_hDWP to NULL so that child windows don't try to use our
4127 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4128 // happen anyhow normally but who knows what weird flow of control we
4129 // may have depending on what the users EVT_SIZE handler does...)
4130 HDWP hDWP
= (HDWP
)m_hDWP
;
4133 // do put all child controls in place at once
4134 if ( !::EndDeferWindowPos(hDWP
) )
4136 wxLogLastError(_T("EndDeferWindowPos"));
4143 bool wxWindowMSW
::HandleSizing(wxRect
& rect
)
4145 wxSizeEvent
event(rect
, m_windowId
);
4146 event
.SetEventObject(this);
4148 bool rc
= GetEventHandler()->ProcessEvent(event
);
4150 rect
= event
.GetRect();
4154 bool wxWindowMSW
::HandleGetMinMaxInfo(void *mmInfo
)
4157 wxUnusedVar(mmInfo
);
4160 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4164 int minWidth
= GetMinWidth(),
4165 minHeight
= GetMinHeight(),
4166 maxWidth
= GetMaxWidth(),
4167 maxHeight
= GetMaxHeight();
4169 if ( minWidth
!= wxDefaultCoord
)
4171 info
->ptMinTrackSize
.x
= minWidth
;
4175 if ( minHeight
!= wxDefaultCoord
)
4177 info
->ptMinTrackSize
.y
= minHeight
;
4181 if ( maxWidth
!= wxDefaultCoord
)
4183 info
->ptMaxTrackSize
.x
= maxWidth
;
4187 if ( maxHeight
!= wxDefaultCoord
)
4189 info
->ptMaxTrackSize
.y
= maxHeight
;
4197 // ---------------------------------------------------------------------------
4199 // ---------------------------------------------------------------------------
4201 bool wxWindowMSW
::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4203 #if wxUSE_MENUS_NATIVE
4204 if ( !cmd
&& wxCurrentPopupMenu
)
4206 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4207 wxCurrentPopupMenu
= NULL
;
4209 return popupMenu
->MSWCommand(cmd
, id
);
4211 #endif // wxUSE_MENUS_NATIVE
4213 wxWindow
*win
= NULL
;
4215 // first try to find it from HWND - this works even with the broken
4216 // programs using the same ids for different controls
4219 win
= wxFindWinFromHandle(control
);
4225 // must cast to a signed type before comparing with other ids!
4226 win
= FindItem((signed short)id
);
4231 return win
->MSWCommand(cmd
, id
);
4234 // the messages sent from the in-place edit control used by the treectrl
4235 // for label editing have id == 0, but they should _not_ be treated as menu
4236 // messages (they are EN_XXX ones, in fact) so don't translate anything
4237 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4240 // If no child window, it may be an accelerator, e.g. for a popup menu
4243 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4244 event
.SetEventObject(this);
4248 return GetEventHandler()->ProcessEvent(event
);
4250 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4253 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4254 // notifications to its parent which we want to reflect back to
4256 wxSpinCtrl
*spin
= wxSpinCtrl
::GetSpinForTextCtrl(control
);
4257 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4260 #endif // wxUSE_SPINCTRL
4265 // ---------------------------------------------------------------------------
4267 // ---------------------------------------------------------------------------
4269 void wxWindowMSW
::InitMouseEvent(wxMouseEvent
& event
,
4273 // our client coords are not quite the same as Windows ones
4274 wxPoint pt
= GetClientAreaOrigin();
4275 event
.m_x
= x
- pt
.x
;
4276 event
.m_y
= y
- pt
.y
;
4278 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4279 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4280 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4281 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4282 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4283 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4286 event
.SetTimestamp(::GetMessageTime());
4289 event
.SetEventObject(this);
4290 event
.SetId(GetId());
4292 #if wxUSE_MOUSEEVENT_HACK
4295 m_lastMouseEvent
= event
.GetEventType();
4296 #endif // wxUSE_MOUSEEVENT_HACK
4299 // Windows doesn't send the mouse events to the static controls (which are
4300 // transparent in the sense that their WM_NCHITTEST handler returns
4301 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4302 // and so we manually check if we don't have a child window under mouse and if
4303 // we do, send the event to it instead of the window Windows had sent WM_XXX
4306 // Notice that this is not done for the mouse move events because this could
4307 // (would?) be too slow, but only for clicks which means that the static texts
4308 // still don't get move, enter nor leave events.
4309 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4311 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4313 // first try to find a non transparent child: this allows us to send events
4314 // to a static text which is inside a static box, for example
4315 POINT pt
= { *x
, *y
};
4316 HWND hwnd
= GetHwndOf(win
),
4320 hwndUnderMouse
= ::ChildWindowFromPoint
4326 hwndUnderMouse
= ::ChildWindowFromPointEx
4336 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4338 // now try any child window at all
4339 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4342 // check that we have a child window which is susceptible to receive mouse
4343 // events: for this it must be shown and enabled
4344 if ( hwndUnderMouse
&&
4345 hwndUnderMouse
!= hwnd
&&
4346 ::IsWindowVisible(hwndUnderMouse
) &&
4347 ::IsWindowEnabled(hwndUnderMouse
) )
4349 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4350 if ( winUnderMouse
)
4352 // translate the mouse coords to the other window coords
4353 win
->ClientToScreen(x
, y
);
4354 winUnderMouse
->ScreenToClient(x
, y
);
4356 win
= winUnderMouse
;
4363 bool wxWindowMSW
::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4365 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4366 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4367 // from the message id and take the value in the table to get wxWin event
4369 static const wxEventType eventsMouse
[] =
4383 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4384 InitMouseEvent(event
, x
, y
, flags
);
4386 return GetEventHandler()->ProcessEvent(event
);
4389 bool wxWindowMSW
::HandleMouseMove(int x
, int y
, WXUINT flags
)
4391 if ( !m_mouseInWindow
)
4393 // it would be wrong to assume that just because we get a mouse move
4394 // event that the mouse is inside the window: although this is usually
4395 // true, it is not if we had captured the mouse, so we need to check
4396 // the mouse coordinates here
4397 if ( !HasCapture() || IsMouseInWindow() )
4399 // Generate an ENTER event
4400 m_mouseInWindow
= true;
4402 TRACKMOUSEEVENT trackinfo
;
4404 trackinfo
.cbSize
= sizeof(trackinfo
);
4405 trackinfo
.dwFlags
= TME_LEAVE
;
4406 trackinfo
.hwndTrack
= GetHwnd();
4407 //Use the commctrl.h _TrackMouseEvent, which will call the
4408 // appropriate TrackMouseEvent or emulate it ( win95 )
4409 // else we need _WIN32_WINNT >= 0x0400
4410 _TrackMouseEvent(&trackinfo
);
4411 #endif // __WXWINCE__
4412 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4413 InitMouseEvent(event
, x
, y
, flags
);
4415 (void)GetEventHandler()->ProcessEvent(event
);
4419 #if wxUSE_MOUSEEVENT_HACK
4420 // Window gets a click down message followed by a mouse move message even
4421 // if position isn't changed! We want to discard the trailing move event
4422 // if x and y are the same.
4423 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4424 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4425 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4426 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4428 m_lastMouseEvent
= wxEVT_MOTION
;
4432 #endif // wxUSE_MOUSEEVENT_HACK
4434 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4438 bool wxWindowMSW
::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4440 #if wxUSE_MOUSEWHEEL
4441 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4442 InitMouseEvent(event
,
4443 GET_X_LPARAM(lParam
),
4444 GET_Y_LPARAM(lParam
),
4446 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4447 event
.m_wheelDelta
= WHEEL_DELTA
;
4449 static int s_linesPerRotation
= -1;
4450 if ( s_linesPerRotation
== -1 )
4452 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4453 &s_linesPerRotation
, 0))
4455 // this is not supposed to happen
4456 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4458 // the default is 3, so use it if SystemParametersInfo() failed
4459 s_linesPerRotation
= 3;
4463 event
.m_linesPerAction
= s_linesPerRotation
;
4464 return GetEventHandler()->ProcessEvent(event
);
4466 #else // !wxUSE_MOUSEWHEEL
4467 wxUnusedVar(wParam
);
4468 wxUnusedVar(lParam
);
4471 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
4474 void wxWindowMSW
::GenerateMouseLeave()
4476 m_mouseInWindow
= false;
4479 if ( wxIsShiftDown() )
4481 if ( wxIsCtrlDown() )
4482 state
|= MK_CONTROL
;
4484 // Only the high-order bit should be tested
4485 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
4486 state
|= MK_LBUTTON
;
4487 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
4488 state
|= MK_MBUTTON
;
4489 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
4490 state
|= MK_RBUTTON
;
4493 if ( !::GetCursorPos(&pt
) )
4495 wxLogLastError(_T("GetCursorPos"));
4498 // we need to have client coordinates here for symmetry with
4499 // wxEVT_ENTER_WINDOW
4500 RECT rect
= wxGetWindowRect(GetHwnd());
4504 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
4505 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
4507 (void)GetEventHandler()->ProcessEvent(event
);
4510 // ---------------------------------------------------------------------------
4511 // keyboard handling
4512 // ---------------------------------------------------------------------------
4514 // create the key event of the given type for the given key - used by
4515 // HandleChar and HandleKeyDown/Up
4516 wxKeyEvent wxWindowMSW
::CreateKeyEvent(wxEventType evType
,
4519 WXWPARAM wParam
) const
4521 wxKeyEvent
event(evType
);
4522 event
.SetId(GetId());
4523 event
.m_shiftDown
= wxIsShiftDown();
4524 event
.m_controlDown
= wxIsCtrlDown();
4525 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4527 event
.SetEventObject((wxWindow
*)this); // const_cast
4528 event
.m_keyCode
= id
;
4530 event
.m_uniChar
= (wxChar
) wParam
;
4532 event
.m_rawCode
= (wxUint32
) wParam
;
4533 event
.m_rawFlags
= (wxUint32
) lParam
;
4535 event
.SetTimestamp(::GetMessageTime());
4538 // translate the position to client coords
4542 GetWindowRect(GetHwnd(),&rect
);
4552 // isASCII is true only when we're called from WM_CHAR handler and not from
4554 bool wxWindowMSW
::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4559 // If 1 -> 26, translate to either special keycode or just set
4560 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4561 // ControlDown() == true.
4563 if ( (id
> 0) && (id
< 27) )
4585 else // we're called from WM_KEYDOWN
4587 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4590 // it's ASCII and will be processed here only when called from
4591 // WM_CHAR (i.e. when isASCII = true), don't process it now
4596 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4598 // the alphanumeric keys produced by pressing AltGr+something on European
4599 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4600 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4601 // alphanumeric, so pretend that there are no modifiers at all (the
4602 // KEY_DOWN event would still have the correct modifiers if they're really
4604 if ( event
.m_controlDown
&& event
.m_altDown
&&
4605 (id
>= 32 && id
< 256) )
4607 event
.m_controlDown
=
4608 event
.m_altDown
= false;
4611 return GetEventHandler()->ProcessEvent(event
);
4614 bool wxWindowMSW
::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4616 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4620 // normal ASCII char
4624 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4626 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4627 if ( GetEventHandler()->ProcessEvent(event
) )
4636 bool wxWindowMSW
::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4638 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4642 // normal ASCII char
4646 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4648 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4649 if ( GetEventHandler()->ProcessEvent(event
) )
4656 int wxWindowMSW
::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4658 // FIXME: implement GetMenuItemCount for WinCE, possibly
4659 // in terms of GetMenuItemInfo
4661 const HMENU hmenu
= (HMENU
)lParam
;
4665 mii
.cbSize
= sizeof(MENUITEMINFO
);
4666 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4668 // find if we have this letter in any owner drawn item
4669 const int count
= ::GetMenuItemCount(hmenu
);
4670 for ( int i
= 0; i
< count
; i
++ )
4672 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4674 if ( mii
.fType
== MFT_OWNERDRAW
)
4676 // dwItemData member of the MENUITEMINFO is a
4677 // pointer to the associated wxMenuItem -- see the
4678 // menu creation code
4679 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4681 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4684 if ( *p
== _T('&') )
4686 // this is not the accel char, find the real one
4687 p
= wxStrchr(p
+ 1, _T('&'));
4689 else // got the accel char
4691 // FIXME-UNICODE: this comparison doesn't risk to work
4692 // for non ASCII accelerator characters I'm afraid, but
4694 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
4700 // this one doesn't match
4707 else // failed to get the menu text?
4709 // it's not fatal, so don't show error, but still log
4711 wxLogLastError(_T("GetMenuItemInfo"));
4715 wxUnusedVar(chAccel
);
4716 wxUnusedVar(lParam
);
4721 // ---------------------------------------------------------------------------
4723 // ---------------------------------------------------------------------------
4725 bool wxWindowMSW
::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4729 if ( flags
& JOY_BUTTON1CHG
)
4730 change
= wxJOY_BUTTON1
;
4731 if ( flags
& JOY_BUTTON2CHG
)
4732 change
= wxJOY_BUTTON2
;
4733 if ( flags
& JOY_BUTTON3CHG
)
4734 change
= wxJOY_BUTTON3
;
4735 if ( flags
& JOY_BUTTON4CHG
)
4736 change
= wxJOY_BUTTON4
;
4739 if ( flags
& JOY_BUTTON1
)
4740 buttons
|= wxJOY_BUTTON1
;
4741 if ( flags
& JOY_BUTTON2
)
4742 buttons
|= wxJOY_BUTTON2
;
4743 if ( flags
& JOY_BUTTON3
)
4744 buttons
|= wxJOY_BUTTON3
;
4745 if ( flags
& JOY_BUTTON4
)
4746 buttons
|= wxJOY_BUTTON4
;
4748 // the event ids aren't consecutive so we can't use table based lookup
4750 wxEventType eventType
;
4755 eventType
= wxEVT_JOY_MOVE
;
4760 eventType
= wxEVT_JOY_MOVE
;
4765 eventType
= wxEVT_JOY_ZMOVE
;
4770 eventType
= wxEVT_JOY_ZMOVE
;
4773 case MM_JOY1BUTTONDOWN
:
4775 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4778 case MM_JOY2BUTTONDOWN
:
4780 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4783 case MM_JOY1BUTTONUP
:
4785 eventType
= wxEVT_JOY_BUTTON_UP
;
4788 case MM_JOY2BUTTONUP
:
4790 eventType
= wxEVT_JOY_BUTTON_UP
;
4794 wxFAIL_MSG(wxT("no such joystick event"));
4799 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4800 event
.SetPosition(wxPoint(x
, y
));
4801 event
.SetEventObject(this);
4803 return GetEventHandler()->ProcessEvent(event
);
4813 // ---------------------------------------------------------------------------
4815 // ---------------------------------------------------------------------------
4817 bool wxWindowMSW
::MSWOnScroll(int orientation
, WXWORD wParam
,
4818 WXWORD pos
, WXHWND control
)
4820 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
4822 wxWindow
*child
= wxFindWinFromHandle(control
);
4824 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4827 wxScrollWinEvent event
;
4828 event
.SetPosition(pos
);
4829 event
.SetOrientation(orientation
);
4830 event
.SetEventObject(this);
4835 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
4839 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
4843 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
4847 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
4851 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
4855 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
4858 case SB_THUMBPOSITION
:
4860 // under Win32, the scrollbar range and position are 32 bit integers,
4861 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4862 // explicitly query the scrollbar for the correct position (this must
4863 // be done only for these two SB_ events as they are the only one
4864 // carrying the scrollbar position)
4866 WinStruct
<SCROLLINFO
> scrollInfo
;
4867 scrollInfo
.fMask
= SIF_TRACKPOS
;
4869 if ( !::GetScrollInfo(GetHwnd(),
4870 orientation
== wxHORIZONTAL ? SB_HORZ
4874 // Not neccessarily an error, if there are no scrollbars yet.
4875 // wxLogLastError(_T("GetScrollInfo"));
4878 event
.SetPosition(scrollInfo
.nTrackPos
);
4881 event
.SetEventType( wParam
== SB_THUMBPOSITION
4882 ? wxEVT_SCROLLWIN_THUMBRELEASE
4883 : wxEVT_SCROLLWIN_THUMBTRACK
);
4890 return GetEventHandler()->ProcessEvent(event
);
4893 // ===========================================================================
4895 // ===========================================================================
4897 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
4900 HDC dc
= ::GetDC((HWND
) wnd
);
4903 // the_font.UseResource();
4904 // the_font.RealizeResource();
4905 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
4907 was
= (HFONT
) SelectObject(dc
,fnt
);
4909 GetTextMetrics(dc
, &tm
);
4912 SelectObject(dc
,was
);
4914 ReleaseDC((HWND
)wnd
, dc
);
4917 *x
= tm
.tmAveCharWidth
;
4919 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4921 // the_font.ReleaseResource();
4924 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4925 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4926 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
4931 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4932 case VK_BACK
: id
= WXK_BACK
; break;
4933 case VK_TAB
: id
= WXK_TAB
; break;
4934 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4935 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4936 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4937 case VK_MENU
: id
= WXK_ALT
; break;
4938 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4939 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4940 case VK_SPACE
: id
= WXK_SPACE
; break;
4941 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4942 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4943 case VK_NEXT
: id
= WXK_NEXT
; break;
4944 case VK_END
: id
= WXK_END
; break;
4945 case VK_HOME
: id
= WXK_HOME
; break;
4946 case VK_LEFT
: id
= WXK_LEFT
; break;
4947 case VK_UP
: id
= WXK_UP
; break;
4948 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4949 case VK_DOWN
: id
= WXK_DOWN
; break;
4950 case VK_SELECT
: id
= WXK_SELECT
; break;
4951 case VK_PRINT
: id
= WXK_PRINT
; break;
4952 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4953 case VK_INSERT
: id
= WXK_INSERT
; break;
4954 case VK_DELETE
: id
= WXK_DELETE
; break;
4955 case VK_HELP
: id
= WXK_HELP
; break;
4956 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4957 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4958 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4959 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4960 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4961 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4962 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4963 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4964 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4965 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4966 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4967 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4968 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4969 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4970 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4971 case VK_F1
: id
= WXK_F1
; break;
4972 case VK_F2
: id
= WXK_F2
; break;
4973 case VK_F3
: id
= WXK_F3
; break;
4974 case VK_F4
: id
= WXK_F4
; break;
4975 case VK_F5
: id
= WXK_F5
; break;
4976 case VK_F6
: id
= WXK_F6
; break;
4977 case VK_F7
: id
= WXK_F7
; break;
4978 case VK_F8
: id
= WXK_F8
; break;
4979 case VK_F9
: id
= WXK_F9
; break;
4980 case VK_F10
: id
= WXK_F10
; break;
4981 case VK_F11
: id
= WXK_F11
; break;
4982 case VK_F12
: id
= WXK_F12
; break;
4983 case VK_F13
: id
= WXK_F13
; break;
4984 case VK_F14
: id
= WXK_F14
; break;
4985 case VK_F15
: id
= WXK_F15
; break;
4986 case VK_F16
: id
= WXK_F16
; break;
4987 case VK_F17
: id
= WXK_F17
; break;
4988 case VK_F18
: id
= WXK_F18
; break;
4989 case VK_F19
: id
= WXK_F19
; break;
4990 case VK_F20
: id
= WXK_F20
; break;
4991 case VK_F21
: id
= WXK_F21
; break;
4992 case VK_F22
: id
= WXK_F22
; break;
4993 case VK_F23
: id
= WXK_F23
; break;
4994 case VK_F24
: id
= WXK_F24
; break;
4995 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4996 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4998 // the mapping for these keys may be incorrect on non-US keyboards so
4999 // maybe we shouldn't map them to ASCII values at all
5000 case VK_OEM_1
: id
= ';'; break;
5001 case VK_OEM_PLUS
: id
= '+'; break;
5002 case VK_OEM_COMMA
: id
= ','; break;
5003 case VK_OEM_MINUS
: id
= '-'; break;
5004 case VK_OEM_PERIOD
: id
= '.'; break;
5005 case VK_OEM_2
: id
= '/'; break;
5006 case VK_OEM_3
: id
= '~'; break;
5007 case VK_OEM_4
: id
= '['; break;
5008 case VK_OEM_5
: id
= '\\'; break;
5009 case VK_OEM_6
: id
= ']'; break;
5010 case VK_OEM_7
: id
= '\''; break;
5013 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
5014 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
5015 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
5016 #endif // VK_APPS defined
5019 // the same key is sent for both the "return" key on the main
5020 // keyboard and the numeric keypad but we want to distinguish
5021 // between them: we do this using the "extended" bit (24) of lParam
5022 id
= lParam
& (1 << 24) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5032 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5038 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5039 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5040 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5041 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5042 case WXK_ALT
: keySym
= VK_MENU
; break;
5043 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5044 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5045 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5046 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5047 case WXK_END
: keySym
= VK_END
; break;
5048 case WXK_HOME
: keySym
= VK_HOME
; break;
5049 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5050 case WXK_UP
: keySym
= VK_UP
; break;
5051 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5052 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5053 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5054 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5055 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5056 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5057 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5058 case WXK_HELP
: keySym
= VK_HELP
; break;
5059 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5060 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5061 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5062 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5063 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5064 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5065 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5066 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5067 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5068 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5069 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5070 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5071 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5072 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5073 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5074 case WXK_F1
: keySym
= VK_F1
; break;
5075 case WXK_F2
: keySym
= VK_F2
; break;
5076 case WXK_F3
: keySym
= VK_F3
; break;
5077 case WXK_F4
: keySym
= VK_F4
; break;
5078 case WXK_F5
: keySym
= VK_F5
; break;
5079 case WXK_F6
: keySym
= VK_F6
; break;
5080 case WXK_F7
: keySym
= VK_F7
; break;
5081 case WXK_F8
: keySym
= VK_F8
; break;
5082 case WXK_F9
: keySym
= VK_F9
; break;
5083 case WXK_F10
: keySym
= VK_F10
; break;
5084 case WXK_F11
: keySym
= VK_F11
; break;
5085 case WXK_F12
: keySym
= VK_F12
; break;
5086 case WXK_F13
: keySym
= VK_F13
; break;
5087 case WXK_F14
: keySym
= VK_F14
; break;
5088 case WXK_F15
: keySym
= VK_F15
; break;
5089 case WXK_F16
: keySym
= VK_F16
; break;
5090 case WXK_F17
: keySym
= VK_F17
; break;
5091 case WXK_F18
: keySym
= VK_F18
; break;
5092 case WXK_F19
: keySym
= VK_F19
; break;
5093 case WXK_F20
: keySym
= VK_F20
; break;
5094 case WXK_F21
: keySym
= VK_F21
; break;
5095 case WXK_F22
: keySym
= VK_F22
; break;
5096 case WXK_F23
: keySym
= VK_F23
; break;
5097 case WXK_F24
: keySym
= VK_F24
; break;
5098 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5099 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5110 bool wxGetKeyState(wxKeyCode key
)
5114 //High order with GetAsyncKeyState only available on WIN32
5116 //If the requested key is a LED key, return
5117 //true if the led is pressed
5118 if (key
== WXK_NUMLOCK
||
5119 key
== WXK_CAPITAL
||
5123 //low order bit means LED is highlighted,
5124 //high order means key is down
5125 //Here, for compat with other ports we want both
5126 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5133 //low order bit means key pressed since last call
5134 //high order means key is down
5135 //We want only the high order bit - the key may not be down if only low order
5136 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5141 wxWindow
*wxGetActiveWindow()
5143 HWND hWnd
= GetActiveWindow();
5146 return wxFindWinFromHandle((WXHWND
) hWnd
);
5151 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5153 HWND hwnd
= (HWND
)hWnd
;
5155 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5156 // by code in msw/radiobox.cpp), for all the others we just search up the
5158 wxWindow
*win
= (wxWindow
*)NULL
;
5161 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5165 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5166 // wxWindow class which overrides WM_GETDLGCODE processing to
5167 // do it as well, win would be already non NULL
5168 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5170 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5172 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5173 #endif // wxUSE_RADIOBOX
5175 // spin control text buddy window should be mapped to spin ctrl
5176 // itself so try it too
5177 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5180 win
= wxSpinCtrl
::GetSpinForTextCtrl((WXHWND
)hwnd
);
5182 #endif // wxUSE_SPINCTRL
5186 while ( hwnd
&& !win
)
5188 // this is a really ugly hack needed to avoid mistakenly returning the
5189 // parent frame wxWindow for the find/replace modeless dialog HWND -
5190 // this, in turn, is needed to call IsDialogMessage() from
5191 // wxApp::ProcessMessage() as for this we must return NULL from here
5193 // FIXME: this is clearly not the best way to do it but I think we'll
5194 // need to change HWND <-> wxWindow code more heavily than I can
5195 // do it now to fix it
5196 #ifndef __WXMICROWIN__
5197 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5199 // it's a dialog box, don't go upwards
5204 hwnd
= ::GetParent(hwnd
);
5205 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5211 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5213 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5214 // in active frames and dialogs, regardless of where the focus is.
5215 static HHOOK wxTheKeyboardHook
= 0;
5216 static FARPROC wxTheKeyboardHookProc
= 0;
5217 int APIENTRY _EXPORT
5218 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5220 void wxSetKeyboardHook(bool doIt
)
5224 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5225 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5227 GetCurrentThreadId()
5228 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5233 UnhookWindowsHookEx(wxTheKeyboardHook
);
5237 int APIENTRY _EXPORT
5238 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5240 DWORD hiWord
= HIWORD(lParam
);
5241 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5243 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5246 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5247 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5248 event
.m_altDown
= true;
5250 event
.SetEventObject(NULL
);
5251 event
.m_keyCode
= id
;
5252 event
.m_shiftDown
= wxIsShiftDown();
5253 event
.m_controlDown
= wxIsCtrlDown();
5255 event
.SetTimestamp(::GetMessageTime());
5257 wxWindow
*win
= wxGetActiveWindow();
5258 wxEvtHandler
*handler
;
5261 handler
= win
->GetEventHandler();
5262 event
.SetId(win
->GetId());
5267 event
.SetId(wxID_ANY
);
5270 if ( handler
&& handler
->ProcessEvent(event
) )
5278 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5281 #endif // !__WXMICROWIN__
5284 const char *wxGetMessageName(int message
)
5288 case 0x0000: return "WM_NULL";
5289 case 0x0001: return "WM_CREATE";
5290 case 0x0002: return "WM_DESTROY";
5291 case 0x0003: return "WM_MOVE";
5292 case 0x0005: return "WM_SIZE";
5293 case 0x0006: return "WM_ACTIVATE";
5294 case 0x0007: return "WM_SETFOCUS";
5295 case 0x0008: return "WM_KILLFOCUS";
5296 case 0x000A: return "WM_ENABLE";
5297 case 0x000B: return "WM_SETREDRAW";
5298 case 0x000C: return "WM_SETTEXT";
5299 case 0x000D: return "WM_GETTEXT";
5300 case 0x000E: return "WM_GETTEXTLENGTH";
5301 case 0x000F: return "WM_PAINT";
5302 case 0x0010: return "WM_CLOSE";
5303 case 0x0011: return "WM_QUERYENDSESSION";
5304 case 0x0012: return "WM_QUIT";
5305 case 0x0013: return "WM_QUERYOPEN";
5306 case 0x0014: return "WM_ERASEBKGND";
5307 case 0x0015: return "WM_SYSCOLORCHANGE";
5308 case 0x0016: return "WM_ENDSESSION";
5309 case 0x0017: return "WM_SYSTEMERROR";
5310 case 0x0018: return "WM_SHOWWINDOW";
5311 case 0x0019: return "WM_CTLCOLOR";
5312 case 0x001A: return "WM_WININICHANGE";
5313 case 0x001B: return "WM_DEVMODECHANGE";
5314 case 0x001C: return "WM_ACTIVATEAPP";
5315 case 0x001D: return "WM_FONTCHANGE";
5316 case 0x001E: return "WM_TIMECHANGE";
5317 case 0x001F: return "WM_CANCELMODE";
5318 case 0x0020: return "WM_SETCURSOR";
5319 case 0x0021: return "WM_MOUSEACTIVATE";
5320 case 0x0022: return "WM_CHILDACTIVATE";
5321 case 0x0023: return "WM_QUEUESYNC";
5322 case 0x0024: return "WM_GETMINMAXINFO";
5323 case 0x0026: return "WM_PAINTICON";
5324 case 0x0027: return "WM_ICONERASEBKGND";
5325 case 0x0028: return "WM_NEXTDLGCTL";
5326 case 0x002A: return "WM_SPOOLERSTATUS";
5327 case 0x002B: return "WM_DRAWITEM";
5328 case 0x002C: return "WM_MEASUREITEM";
5329 case 0x002D: return "WM_DELETEITEM";
5330 case 0x002E: return "WM_VKEYTOITEM";
5331 case 0x002F: return "WM_CHARTOITEM";
5332 case 0x0030: return "WM_SETFONT";
5333 case 0x0031: return "WM_GETFONT";
5334 case 0x0037: return "WM_QUERYDRAGICON";
5335 case 0x0039: return "WM_COMPAREITEM";
5336 case 0x0041: return "WM_COMPACTING";
5337 case 0x0044: return "WM_COMMNOTIFY";
5338 case 0x0046: return "WM_WINDOWPOSCHANGING";
5339 case 0x0047: return "WM_WINDOWPOSCHANGED";
5340 case 0x0048: return "WM_POWER";
5342 case 0x004A: return "WM_COPYDATA";
5343 case 0x004B: return "WM_CANCELJOURNAL";
5344 case 0x004E: return "WM_NOTIFY";
5345 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5346 case 0x0051: return "WM_INPUTLANGCHANGE";
5347 case 0x0052: return "WM_TCARD";
5348 case 0x0053: return "WM_HELP";
5349 case 0x0054: return "WM_USERCHANGED";
5350 case 0x0055: return "WM_NOTIFYFORMAT";
5351 case 0x007B: return "WM_CONTEXTMENU";
5352 case 0x007C: return "WM_STYLECHANGING";
5353 case 0x007D: return "WM_STYLECHANGED";
5354 case 0x007E: return "WM_DISPLAYCHANGE";
5355 case 0x007F: return "WM_GETICON";
5356 case 0x0080: return "WM_SETICON";
5358 case 0x0081: return "WM_NCCREATE";
5359 case 0x0082: return "WM_NCDESTROY";
5360 case 0x0083: return "WM_NCCALCSIZE";
5361 case 0x0084: return "WM_NCHITTEST";
5362 case 0x0085: return "WM_NCPAINT";
5363 case 0x0086: return "WM_NCACTIVATE";
5364 case 0x0087: return "WM_GETDLGCODE";
5365 case 0x00A0: return "WM_NCMOUSEMOVE";
5366 case 0x00A1: return "WM_NCLBUTTONDOWN";
5367 case 0x00A2: return "WM_NCLBUTTONUP";
5368 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5369 case 0x00A4: return "WM_NCRBUTTONDOWN";
5370 case 0x00A5: return "WM_NCRBUTTONUP";
5371 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5372 case 0x00A7: return "WM_NCMBUTTONDOWN";
5373 case 0x00A8: return "WM_NCMBUTTONUP";
5374 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5375 case 0x0100: return "WM_KEYDOWN";
5376 case 0x0101: return "WM_KEYUP";
5377 case 0x0102: return "WM_CHAR";
5378 case 0x0103: return "WM_DEADCHAR";
5379 case 0x0104: return "WM_SYSKEYDOWN";
5380 case 0x0105: return "WM_SYSKEYUP";
5381 case 0x0106: return "WM_SYSCHAR";
5382 case 0x0107: return "WM_SYSDEADCHAR";
5383 case 0x0108: return "WM_KEYLAST";
5385 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5386 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5387 case 0x010F: return "WM_IME_COMPOSITION";
5389 case 0x0110: return "WM_INITDIALOG";
5390 case 0x0111: return "WM_COMMAND";
5391 case 0x0112: return "WM_SYSCOMMAND";
5392 case 0x0113: return "WM_TIMER";
5393 case 0x0114: return "WM_HSCROLL";
5394 case 0x0115: return "WM_VSCROLL";
5395 case 0x0116: return "WM_INITMENU";
5396 case 0x0117: return "WM_INITMENUPOPUP";
5397 case 0x011F: return "WM_MENUSELECT";
5398 case 0x0120: return "WM_MENUCHAR";
5399 case 0x0121: return "WM_ENTERIDLE";
5400 case 0x0200: return "WM_MOUSEMOVE";
5401 case 0x0201: return "WM_LBUTTONDOWN";
5402 case 0x0202: return "WM_LBUTTONUP";
5403 case 0x0203: return "WM_LBUTTONDBLCLK";
5404 case 0x0204: return "WM_RBUTTONDOWN";
5405 case 0x0205: return "WM_RBUTTONUP";
5406 case 0x0206: return "WM_RBUTTONDBLCLK";
5407 case 0x0207: return "WM_MBUTTONDOWN";
5408 case 0x0208: return "WM_MBUTTONUP";
5409 case 0x0209: return "WM_MBUTTONDBLCLK";
5410 case 0x020A: return "WM_MOUSEWHEEL";
5411 case 0x0210: return "WM_PARENTNOTIFY";
5412 case 0x0211: return "WM_ENTERMENULOOP";
5413 case 0x0212: return "WM_EXITMENULOOP";
5415 case 0x0213: return "WM_NEXTMENU";
5416 case 0x0214: return "WM_SIZING";
5417 case 0x0215: return "WM_CAPTURECHANGED";
5418 case 0x0216: return "WM_MOVING";
5419 case 0x0218: return "WM_POWERBROADCAST";
5420 case 0x0219: return "WM_DEVICECHANGE";
5422 case 0x0220: return "WM_MDICREATE";
5423 case 0x0221: return "WM_MDIDESTROY";
5424 case 0x0222: return "WM_MDIACTIVATE";
5425 case 0x0223: return "WM_MDIRESTORE";
5426 case 0x0224: return "WM_MDINEXT";
5427 case 0x0225: return "WM_MDIMAXIMIZE";
5428 case 0x0226: return "WM_MDITILE";
5429 case 0x0227: return "WM_MDICASCADE";
5430 case 0x0228: return "WM_MDIICONARRANGE";
5431 case 0x0229: return "WM_MDIGETACTIVE";
5432 case 0x0230: return "WM_MDISETMENU";
5433 case 0x0233: return "WM_DROPFILES";
5435 case 0x0281: return "WM_IME_SETCONTEXT";
5436 case 0x0282: return "WM_IME_NOTIFY";
5437 case 0x0283: return "WM_IME_CONTROL";
5438 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5439 case 0x0285: return "WM_IME_SELECT";
5440 case 0x0286: return "WM_IME_CHAR";
5441 case 0x0290: return "WM_IME_KEYDOWN";
5442 case 0x0291: return "WM_IME_KEYUP";
5444 case 0x0300: return "WM_CUT";
5445 case 0x0301: return "WM_COPY";
5446 case 0x0302: return "WM_PASTE";
5447 case 0x0303: return "WM_CLEAR";
5448 case 0x0304: return "WM_UNDO";
5449 case 0x0305: return "WM_RENDERFORMAT";
5450 case 0x0306: return "WM_RENDERALLFORMATS";
5451 case 0x0307: return "WM_DESTROYCLIPBOARD";
5452 case 0x0308: return "WM_DRAWCLIPBOARD";
5453 case 0x0309: return "WM_PAINTCLIPBOARD";
5454 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5455 case 0x030B: return "WM_SIZECLIPBOARD";
5456 case 0x030C: return "WM_ASKCBFORMATNAME";
5457 case 0x030D: return "WM_CHANGECBCHAIN";
5458 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5459 case 0x030F: return "WM_QUERYNEWPALETTE";
5460 case 0x0310: return "WM_PALETTEISCHANGING";
5461 case 0x0311: return "WM_PALETTECHANGED";
5463 case 0x0312: return "WM_HOTKEY";
5466 // common controls messages - although they're not strictly speaking
5467 // standard, it's nice to decode them nevertheless
5470 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5471 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5472 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5473 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5474 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5475 case 0x1000 + 5: return "LVM_GETITEMA";
5476 case 0x1000 + 75: return "LVM_GETITEMW";
5477 case 0x1000 + 6: return "LVM_SETITEMA";
5478 case 0x1000 + 76: return "LVM_SETITEMW";
5479 case 0x1000 + 7: return "LVM_INSERTITEMA";
5480 case 0x1000 + 77: return "LVM_INSERTITEMW";
5481 case 0x1000 + 8: return "LVM_DELETEITEM";
5482 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5483 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5484 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5485 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5486 case 0x1000 + 13: return "LVM_FINDITEMA";
5487 case 0x1000 + 83: return "LVM_FINDITEMW";
5488 case 0x1000 + 14: return "LVM_GETITEMRECT";
5489 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5490 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5491 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5492 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5493 case 0x1000 + 18: return "LVM_HITTEST";
5494 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5495 case 0x1000 + 20: return "LVM_SCROLL";
5496 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5497 case 0x1000 + 22: return "LVM_ARRANGE";
5498 case 0x1000 + 23: return "LVM_EDITLABELA";
5499 case 0x1000 + 118: return "LVM_EDITLABELW";
5500 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5501 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5502 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5503 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5504 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5505 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5506 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5507 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5508 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5509 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5510 case 0x1000 + 31: return "LVM_GETHEADER";
5511 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5512 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5513 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5514 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5515 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5516 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5517 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5518 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5519 case 0x1000 + 41: return "LVM_GETORIGIN";
5520 case 0x1000 + 42: return "LVM_UPDATE";
5521 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5522 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5523 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5524 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5525 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5526 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5527 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5528 case 0x1000 + 48: return "LVM_SORTITEMS";
5529 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5530 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5531 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5532 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5533 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5534 case 0x1000 + 53: return "LVM_SETICONSPACING";
5535 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5536 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5537 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5538 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5539 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5540 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5541 case 0x1000 + 60: return "LVM_SETHOTITEM";
5542 case 0x1000 + 61: return "LVM_GETHOTITEM";
5543 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5544 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5545 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5546 case 0x1000 + 65: return "LVM_SETWORKAREA";
5549 case 0x1100 + 0: return "TVM_INSERTITEMA";
5550 case 0x1100 + 50: return "TVM_INSERTITEMW";
5551 case 0x1100 + 1: return "TVM_DELETEITEM";
5552 case 0x1100 + 2: return "TVM_EXPAND";
5553 case 0x1100 + 4: return "TVM_GETITEMRECT";
5554 case 0x1100 + 5: return "TVM_GETCOUNT";
5555 case 0x1100 + 6: return "TVM_GETINDENT";
5556 case 0x1100 + 7: return "TVM_SETINDENT";
5557 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5558 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5559 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5560 case 0x1100 + 11: return "TVM_SELECTITEM";
5561 case 0x1100 + 12: return "TVM_GETITEMA";
5562 case 0x1100 + 62: return "TVM_GETITEMW";
5563 case 0x1100 + 13: return "TVM_SETITEMA";
5564 case 0x1100 + 63: return "TVM_SETITEMW";
5565 case 0x1100 + 14: return "TVM_EDITLABELA";
5566 case 0x1100 + 65: return "TVM_EDITLABELW";
5567 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5568 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5569 case 0x1100 + 17: return "TVM_HITTEST";
5570 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5571 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5572 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5573 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5574 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5575 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5576 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5577 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5578 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5581 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5582 case 0x1200 + 1: return "HDM_INSERTITEMA";
5583 case 0x1200 + 10: return "HDM_INSERTITEMW";
5584 case 0x1200 + 2: return "HDM_DELETEITEM";
5585 case 0x1200 + 3: return "HDM_GETITEMA";
5586 case 0x1200 + 11: return "HDM_GETITEMW";
5587 case 0x1200 + 4: return "HDM_SETITEMA";
5588 case 0x1200 + 12: return "HDM_SETITEMW";
5589 case 0x1200 + 5: return "HDM_LAYOUT";
5590 case 0x1200 + 6: return "HDM_HITTEST";
5591 case 0x1200 + 7: return "HDM_GETITEMRECT";
5592 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5593 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5594 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5595 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5596 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5597 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5598 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5601 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5602 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5603 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5604 case 0x1300 + 5: return "TCM_GETITEMA";
5605 case 0x1300 + 60: return "TCM_GETITEMW";
5606 case 0x1300 + 6: return "TCM_SETITEMA";
5607 case 0x1300 + 61: return "TCM_SETITEMW";
5608 case 0x1300 + 7: return "TCM_INSERTITEMA";
5609 case 0x1300 + 62: return "TCM_INSERTITEMW";
5610 case 0x1300 + 8: return "TCM_DELETEITEM";
5611 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5612 case 0x1300 + 10: return "TCM_GETITEMRECT";
5613 case 0x1300 + 11: return "TCM_GETCURSEL";
5614 case 0x1300 + 12: return "TCM_SETCURSEL";
5615 case 0x1300 + 13: return "TCM_HITTEST";
5616 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5617 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5618 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5619 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5620 case 0x1300 + 43: return "TCM_SETPADDING";
5621 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5622 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5623 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5624 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5625 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5626 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5627 case 0x1300 + 50: return "TCM_DESELECTALL";
5630 case WM_USER
+1: return "TB_ENABLEBUTTON";
5631 case WM_USER
+2: return "TB_CHECKBUTTON";
5632 case WM_USER
+3: return "TB_PRESSBUTTON";
5633 case WM_USER
+4: return "TB_HIDEBUTTON";
5634 case WM_USER
+5: return "TB_INDETERMINATE";
5635 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5636 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5637 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5638 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5639 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5640 case WM_USER
+17: return "TB_SETSTATE";
5641 case WM_USER
+18: return "TB_GETSTATE";
5642 case WM_USER
+19: return "TB_ADDBITMAP";
5643 case WM_USER
+20: return "TB_ADDBUTTONS";
5644 case WM_USER
+21: return "TB_INSERTBUTTON";
5645 case WM_USER
+22: return "TB_DELETEBUTTON";
5646 case WM_USER
+23: return "TB_GETBUTTON";
5647 case WM_USER
+24: return "TB_BUTTONCOUNT";
5648 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5649 case WM_USER
+26: return "TB_SAVERESTOREA";
5650 case WM_USER
+76: return "TB_SAVERESTOREW";
5651 case WM_USER
+27: return "TB_CUSTOMIZE";
5652 case WM_USER
+28: return "TB_ADDSTRINGA";
5653 case WM_USER
+77: return "TB_ADDSTRINGW";
5654 case WM_USER
+29: return "TB_GETITEMRECT";
5655 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5656 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5657 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5658 case WM_USER
+33: return "TB_AUTOSIZE";
5659 case WM_USER
+35: return "TB_GETTOOLTIPS";
5660 case WM_USER
+36: return "TB_SETTOOLTIPS";
5661 case WM_USER
+37: return "TB_SETPARENT";
5662 case WM_USER
+39: return "TB_SETROWS";
5663 case WM_USER
+40: return "TB_GETROWS";
5664 case WM_USER
+42: return "TB_SETCMDID";
5665 case WM_USER
+43: return "TB_CHANGEBITMAP";
5666 case WM_USER
+44: return "TB_GETBITMAP";
5667 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5668 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5669 case WM_USER
+46: return "TB_REPLACEBITMAP";
5670 case WM_USER
+47: return "TB_SETINDENT";
5671 case WM_USER
+48: return "TB_SETIMAGELIST";
5672 case WM_USER
+49: return "TB_GETIMAGELIST";
5673 case WM_USER
+50: return "TB_LOADIMAGES";
5674 case WM_USER
+51: return "TB_GETRECT";
5675 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5676 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5677 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5678 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5679 case WM_USER
+56: return "TB_SETSTYLE";
5680 case WM_USER
+57: return "TB_GETSTYLE";
5681 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5682 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5683 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5684 case WM_USER
+61: return "TB_GETTEXTROWS";
5685 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5688 static char s_szBuf
[128];
5689 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5693 #endif //__WXDEBUG__
5695 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5699 HWND hwnd
= GetHwndOf(win
);
5700 HDC hdc
= ::GetDC(hwnd
);
5702 #if !wxDIALOG_UNIT_COMPATIBILITY
5703 // and select the current font into it
5704 HFONT hfont
= GetHfontOf(win
->GetFont());
5707 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5711 // finally retrieve the text metrics from it
5712 GetTextMetrics(hdc
, &tm
);
5714 #if !wxDIALOG_UNIT_COMPATIBILITY
5718 (void)::SelectObject(hdc
, hfont
);
5722 ::ReleaseDC(hwnd
, hdc
);
5727 // Find the wxWindow at the current mouse position, returning the mouse
5729 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5731 pt
= wxGetMousePosition();
5732 return wxFindWindowAtPoint(pt
);
5735 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5740 HWND hWndHit
= ::WindowFromPoint(pt2
);
5742 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5743 HWND hWnd
= hWndHit
;
5745 // Try to find a window with a wxWindow associated with it
5746 while (!win
&& (hWnd
!= 0))
5748 hWnd
= ::GetParent(hWnd
);
5749 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5754 // Get the current mouse position.
5755 wxPoint
wxGetMousePosition()
5758 GetCursorPos( & pt
);
5760 return wxPoint(pt
.x
, pt
.y
);
5765 bool wxWindowMSW
::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5767 UINT win_modifiers
=0;
5768 if ( modifiers
& wxMOD_ALT
)
5769 win_modifiers
|= MOD_ALT
;
5770 if ( modifiers
& wxMOD_SHIFT
)
5771 win_modifiers
|= MOD_SHIFT
;
5772 if ( modifiers
& wxMOD_CONTROL
)
5773 win_modifiers
|= MOD_CONTROL
;
5774 if ( modifiers
& wxMOD_WIN
)
5775 win_modifiers
|= MOD_WIN
;
5777 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5779 wxLogLastError(_T("RegisterHotKey"));
5787 bool wxWindowMSW
::UnregisterHotKey(int hotkeyId
)
5789 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5791 wxLogLastError(_T("UnregisterHotKey"));
5801 bool wxWindowMSW
::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5803 int hotkeyId
= wParam
;
5804 int virtualKey
= HIWORD(lParam
);
5805 int win_modifiers
= LOWORD(lParam
);
5807 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5808 event
.SetId(hotkeyId
);
5809 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5810 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5811 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5812 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5814 return GetEventHandler()->ProcessEvent(event
);
5817 #endif // wxUSE_ACCEL
5819 #endif // wxUSE_HOTKEY
5821 // Not tested under WinCE
5824 // this class installs a message hook which really wakes up our idle processing
5825 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
5826 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
5827 // being dragged or even inside ::MessageBox()) and so don't control message
5828 // dispatching otherwise
5829 class wxIdleWakeUpModule
: public wxModule
5832 virtual bool OnInit()
5834 ms_hMsgHookProc
= ::SetWindowsHookEx
5837 &wxIdleWakeUpModule
::MsgHookProc
,
5839 GetCurrentThreadId()
5842 if ( !ms_hMsgHookProc
)
5844 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
5852 virtual void OnExit()
5854 ::UnhookWindowsHookEx(wxIdleWakeUpModule
::ms_hMsgHookProc
);
5857 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
5859 MSG
*msg
= (MSG
*)lParam
;
5861 // only process the message if it is actually going to be removed from
5862 // the message queue, this prevents that the same event from being
5863 // processed multiple times if now someone just called PeekMessage()
5864 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
5866 wxTheApp
->ProcessPendingEvents();
5869 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
5873 static HHOOK ms_hMsgHookProc
;
5875 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
5878 HHOOK wxIdleWakeUpModule
::ms_hMsgHookProc
= 0;
5880 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
5882 #endif // __WXWINCE__
5887 static void wxAdjustZOrder(wxWindow
* parent
)
5889 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
5891 // Set the z-order correctly
5892 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
5895 wxWindowList
::compatibility_iterator current
= parent
->GetChildren().GetFirst();
5898 wxWindow
*childWin
= current
->GetData();
5899 wxAdjustZOrder(childWin
);
5900 current
= current
->GetNext();
5905 // We need to adjust the z-order of static boxes in WinCE, to
5906 // make 'contained' controls visible
5907 void wxWindowMSW
::OnInitDialog( wxInitDialogEvent
& event
)
5910 wxAdjustZOrder(this);