1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ===========================================================================
14 // ===========================================================================
16 // ---------------------------------------------------------------------------
18 // ---------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "window.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
38 #include "wx/dcclient.h"
39 #include "wx/dcmemory.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
47 #include "wx/msgdlg.h"
48 #include "wx/settings.h"
49 #include "wx/statbox.h"
52 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
53 #include "wx/ownerdrw.h"
56 #include "wx/module.h"
58 #if wxUSE_DRAG_AND_DROP
62 #if wxUSE_ACCESSIBILITY
63 #include "wx/access.h"
67 #define WM_GETOBJECT 0x003D
70 #define OBJID_CLIENT 0xFFFFFFFC
74 #include "wx/menuitem.h"
77 #include "wx/msw/private.h"
80 #include "wx/tooltip.h"
88 #include "wx/spinctrl.h"
89 #endif // wxUSE_SPINCTRL
94 #include "wx/textctrl.h"
95 #include "wx/notebook.h"
96 #include "wx/listctrl.h"
100 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
101 #include <shellapi.h>
102 #include <mmsystem.h>
106 #include <windowsx.h>
109 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
111 #include <commctrl.h>
113 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
114 #include "wx/msw/gnuwin32/extra.h"
117 #include "wx/msw/missing.h"
119 #if defined(__WXWINCE__)
120 #include "wx/msw/wince/missing.h"
123 // ---------------------------------------------------------------------------
125 // ---------------------------------------------------------------------------
127 #if wxUSE_MENUS_NATIVE
128 wxMenu
*wxCurrentPopupMenu
= NULL
;
129 #endif // wxUSE_MENUS_NATIVE
131 extern const wxChar
*wxCanvasClassName
;
133 // true if we had already created the std colour map, used by
134 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
135 static bool gs_hasStdCmap
= FALSE
;
137 // ---------------------------------------------------------------------------
139 // ---------------------------------------------------------------------------
141 // the window proc for all our windows
142 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
143 WPARAM wParam
, LPARAM lParam
);
147 const char *wxGetMessageName(int message
);
150 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
151 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
152 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
154 // this magical function is used to translate VK_APPS key presses to right
156 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
157 int *x
, int *y
, WPARAM
*flags
);
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"));
183 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
184 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
187 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
188 parent as well as otherwise several Win32 functions using
189 GetNextDlgTabItem() to iterate over all controls such as
190 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
191 all of them iterate over all the controls starting from the currently
192 focused one and stop iterating when they get back to the focus but
193 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
194 get back to the initial (focused) window: as we do have this style,
195 GetNextDlgTabItem() will leave this window and continue in its parent,
196 but if the parent doesn't have it, it wouldn't recurse inside it later
197 on and so wouldn't have a chance of getting back to this window neither.
200 while ( parent
&& !parent
->IsTopLevel() )
202 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
203 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
205 // force the parent to have this style
206 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
207 exStyle
| WS_EX_CONTROLPARENT
);
210 parent
= parent
->GetParent();
212 #endif // !__WXWINCE__
215 // ---------------------------------------------------------------------------
217 // ---------------------------------------------------------------------------
219 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
221 #ifdef __WXUNIVERSAL__
222 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
224 #if wxUSE_EXTENDED_RTTI
226 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
227 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
228 // windows with negative ids never can be recreated anyway
230 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
232 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
233 if ( win
&& win
->GetId() < 0 )
238 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
240 // make wxWindowList known before the property is used
242 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
244 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
246 wxListCollectionToVariantArray
<wxWindowList::compatibility_iterator
>( theList
, value
) ;
249 WX_DEFINE_FLAGS( wxWindowStyle
)
251 wxBEGIN_FLAGS( wxWindowStyle
)
252 // new style border flags, we put them first to
253 // use them for streaming out
255 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
256 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
257 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
258 wxFLAGS_MEMBER(wxBORDER_RAISED
)
259 wxFLAGS_MEMBER(wxBORDER_STATIC
)
260 wxFLAGS_MEMBER(wxBORDER_NONE
)
262 // old style border flags
263 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
264 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
265 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
266 wxFLAGS_MEMBER(wxRAISED_BORDER
)
267 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
268 wxFLAGS_MEMBER(wxBORDER
)
270 // standard window styles
271 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
272 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
273 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
274 wxFLAGS_MEMBER(wxWANTS_CHARS
)
275 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
276 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
277 wxFLAGS_MEMBER(wxVSCROLL
)
278 wxFLAGS_MEMBER(wxHSCROLL
)
280 wxEND_FLAGS( wxWindowStyle
)
282 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
283 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
284 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
285 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
286 // Always constructor Properties first
288 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
289 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
290 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxPoint(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
291 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxSize(-1,-1) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
292 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
294 // Then all relations of the object graph
296 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
298 // and finally all other properties
300 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
301 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
302 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
303 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
304 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
306 // possible property candidates (not in xrc) or not valid in all subclasses
307 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxT("") )
308 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
309 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxT("") )
310 // MaxHeight, Width , MinHeight , Width
311 // TODO switch label to control and title to toplevels
313 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
314 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
315 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
316 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
321 wxEND_PROPERTIES_TABLE()
323 wxBEGIN_HANDLERS_TABLE(wxWindow
)
324 wxEND_HANDLERS_TABLE()
326 wxCONSTRUCTOR_DUMMY(wxWindow
)
329 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
331 #endif // __WXUNIVERSAL__/__WXMSW__
333 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
334 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground
)
335 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged
)
336 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog
)
339 // ===========================================================================
341 // ===========================================================================
343 // ---------------------------------------------------------------------------
344 // wxWindow utility functions
345 // ---------------------------------------------------------------------------
347 // Find an item given the MS Windows id
348 wxWindow
*wxWindowMSW::FindItem(long id
) const
351 wxControl
*item
= wxDynamicCastThis(wxControl
);
354 // is it we or one of our "internal" children?
355 if ( item
->GetId() == id
356 #ifndef __WXUNIVERSAL__
357 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
358 #endif // __WXUNIVERSAL__
364 #endif // wxUSE_CONTROLS
366 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
369 wxWindow
*childWin
= current
->GetData();
371 wxWindow
*wnd
= childWin
->FindItem(id
);
375 current
= current
->GetNext();
381 // Find an item given the MS Windows handle
382 wxWindow
*wxWindowMSW::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
384 wxWindowList::compatibility_iterator current
= GetChildren().GetFirst();
387 wxWindow
*parent
= current
->GetData();
389 // Do a recursive search.
390 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
396 || parent
->IsKindOf(CLASSINFO(wxControl
))
397 #endif // wxUSE_CONTROLS
400 wxWindow
*item
= current
->GetData();
401 if ( item
->GetHWND() == hWnd
)
405 if ( item
->ContainsHWND(hWnd
) )
410 current
= current
->GetNext();
415 // Default command handler
416 bool wxWindowMSW::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
421 // ----------------------------------------------------------------------------
422 // constructors and such
423 // ----------------------------------------------------------------------------
425 void wxWindowMSW::Init()
428 m_isBeingDeleted
= FALSE
;
430 m_mouseInWindow
= FALSE
;
431 m_lastKeydownProcessed
= FALSE
;
433 m_childrenDisabled
= NULL
;
443 // as all windows are created with WS_VISIBLE style...
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
522 // all windows are created visible by default except popup ones (which are
523 // like the wxTopLevelWindows in this aspect)
524 if ( style
& wxPOPUP_WINDOW
)
526 msflags
&= ~WS_VISIBLE
;
531 msflags
|= WS_VISIBLE
;
534 return MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
);
537 // ---------------------------------------------------------------------------
539 // ---------------------------------------------------------------------------
541 void wxWindowMSW::SetFocus()
543 HWND hWnd
= GetHwnd();
544 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
546 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
550 if ( !::SetFocus(hWnd
) )
552 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
553 // was there really an error?
554 DWORD dwRes
= ::GetLastError();
557 HWND hwndFocus
= ::GetFocus();
558 if ( hwndFocus
!= hWnd
)
560 wxLogApiError(_T("SetFocus"), dwRes
);
567 void wxWindowMSW::SetFocusFromKbd()
569 // when the focus is given to the control with DLGC_HASSETSEL style from
570 // keyboard its contents should be entirely selected: this is what
571 // ::IsDialogMessage() does and so we should do it as well to provide the
572 // same LNF as the native programs
573 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
575 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
578 // do this after (maybe) setting the selection as like this when
579 // wxEVT_SET_FOCUS handler is called, the selection would have been already
580 // set correctly -- this may be important
581 wxWindowBase::SetFocusFromKbd();
584 // Get the window with the focus
585 wxWindow
*wxWindowBase::FindFocus()
587 HWND hWnd
= ::GetFocus();
590 return wxGetWindowFromHWND((WXHWND
)hWnd
);
596 bool wxWindowMSW::Enable(bool enable
)
598 if ( !wxWindowBase::Enable(enable
) )
601 HWND hWnd
= GetHwnd();
603 ::EnableWindow(hWnd
, (BOOL
)enable
);
605 // the logic below doesn't apply to the top level windows -- otherwise
606 // showing a modal dialog would result in total greying out (and ungreying
607 // out later) of everything which would be really ugly
611 // when the parent is disabled, all of its children should be disabled as
612 // well but when it is enabled back, only those of the children which
613 // hadn't been already disabled in the beginning should be enabled again,
614 // so we have to keep the list of those children
615 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
617 node
= node
->GetNext() )
619 wxWindow
*child
= node
->GetData();
620 if ( child
->IsTopLevel() )
622 // the logic below doesn't apply to top level children
628 // enable the child back unless it had been disabled before us
629 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
632 else // we're being disabled
634 if ( child
->IsEnabled() )
636 // disable it as children shouldn't stay enabled while the
640 else // child already disabled, remember it
642 // have we created the list of disabled children already?
643 if ( !m_childrenDisabled
)
644 m_childrenDisabled
= new wxWindowList
;
646 m_childrenDisabled
->Append(child
);
651 if ( enable
&& m_childrenDisabled
)
653 // we don't need this list any more, don't keep unused memory
654 delete m_childrenDisabled
;
655 m_childrenDisabled
= NULL
;
661 bool wxWindowMSW::Show(bool show
)
663 if ( !wxWindowBase::Show(show
) )
666 HWND hWnd
= GetHwnd();
667 int cshow
= show
? SW_SHOW
: SW_HIDE
;
668 ::ShowWindow(hWnd
, cshow
);
670 if ( show
&& IsTopLevel() )
672 wxBringWindowToTop(hWnd
);
678 // Raise the window to the top of the Z order
679 void wxWindowMSW::Raise()
681 wxBringWindowToTop(GetHwnd());
684 // Lower the window to the bottom of the Z order
685 void wxWindowMSW::Lower()
687 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
688 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
691 void wxWindowMSW::SetTitle( const wxString
& title
)
693 SetWindowText(GetHwnd(), title
.c_str());
696 wxString
wxWindowMSW::GetTitle() const
698 return wxGetWindowText(GetHWND());
701 void wxWindowMSW::DoCaptureMouse()
703 HWND hWnd
= GetHwnd();
710 void wxWindowMSW::DoReleaseMouse()
712 if ( !::ReleaseCapture() )
714 wxLogLastError(_T("ReleaseCapture"));
718 /* static */ wxWindow
*wxWindowBase::GetCapture()
720 HWND hwnd
= ::GetCapture();
721 return hwnd
? wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
724 bool wxWindowMSW::SetFont(const wxFont
& font
)
726 if ( !wxWindowBase::SetFont(font
) )
732 HWND hWnd
= GetHwnd();
735 WXHANDLE hFont
= m_font
.GetResourceHandle();
737 wxASSERT_MSG( hFont
, wxT("should have valid font") );
739 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
744 bool wxWindowMSW::SetCursor(const wxCursor
& cursor
)
746 if ( !wxWindowBase::SetCursor(cursor
) )
754 HWND hWnd
= GetHwnd();
756 // Change the cursor NOW if we're within the correct window
758 ::GetCursorPos(&point
);
760 RECT rect
= wxGetWindowRect(hWnd
);
762 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
763 ::SetCursor(GetHcursorOf(m_cursor
));
769 void wxWindowMSW::WarpPointer (int x
, int y
)
771 ClientToScreen(&x
, &y
);
773 if ( !::SetCursorPos(x
, y
) )
775 wxLogLastError(_T("SetCursorPos"));
779 // ---------------------------------------------------------------------------
781 // ---------------------------------------------------------------------------
783 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
784 static inline int wxDirToWinStyle(int orient
)
786 return orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
;
789 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
791 #ifdef __WXMICROWIN__
792 return ::GetScrollPosWX(hWnd
, wOrient
);
794 WinStruct
<SCROLLINFO
> scrollInfo
;
795 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
796 scrollInfo
.fMask
= SIF_POS
;
797 if ( !::GetScrollInfo(hWnd
,
801 // Not neccessarily an error, if there are no scrollbars yet.
802 // wxLogLastError(_T("GetScrollInfo"));
804 return scrollInfo
.nPos
;
805 // return ::GetScrollPos(hWnd, wOrient);
809 int wxWindowMSW::GetScrollPos(int orient
) const
811 HWND hWnd
= GetHwnd();
812 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
814 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
);
817 // This now returns the whole range, not just the number
818 // of positions that we can scroll.
819 int wxWindowMSW::GetScrollRange(int orient
) const
822 HWND hWnd
= GetHwnd();
826 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
829 WinStruct
<SCROLLINFO
> scrollInfo
;
830 scrollInfo
.fMask
= SIF_RANGE
;
831 if ( !::GetScrollInfo(hWnd
,
832 orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
835 // Most of the time this is not really an error, since the return
836 // value can also be zero when there is no scrollbar yet.
837 // wxLogLastError(_T("GetScrollInfo"));
839 maxPos
= scrollInfo
.nMax
;
841 // undo "range - 1" done in SetScrollbar()
845 int wxWindowMSW::GetScrollThumb(int orient
) const
847 return orient
== wxHORIZONTAL
? m_xThumbSize
: m_yThumbSize
;
850 void wxWindowMSW::SetScrollPos(int orient
, int pos
, bool refresh
)
852 HWND hWnd
= GetHwnd();
853 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
855 WinStruct
<SCROLLINFO
> info
;
859 info
.fMask
= SIF_POS
;
860 if ( HasFlag(wxALWAYS_SHOW_SB
) )
862 // disable scrollbar instead of removing it then
863 info
.fMask
|= SIF_DISABLENOSCROLL
;
866 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
870 // New function that will replace some of the above.
871 void wxWindowMSW::SetScrollbar(int orient
,
877 WinStruct
<SCROLLINFO
> info
;
878 info
.nPage
= pageSize
;
879 info
.nMin
= 0; // range is nMax - nMin + 1
880 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
882 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
883 if ( HasFlag(wxALWAYS_SHOW_SB
) )
885 // disable scrollbar instead of removing it then
886 info
.fMask
|= SIF_DISABLENOSCROLL
;
889 HWND hWnd
= GetHwnd();
892 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL
? SB_HORZ
: SB_VERT
,
896 *(orient
== wxHORIZONTAL
? &m_xThumbSize
: &m_yThumbSize
) = pageSize
;
899 void wxWindowMSW::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
905 rect
.left
= prect
->x
;
907 rect
.right
= prect
->x
+ prect
->width
;
908 rect
.bottom
= prect
->y
+ prect
->height
;
917 // FIXME: is this the exact equivalent of the line below?
918 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_ERASE
|SW_INVALIDATE
);
920 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
924 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
926 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
929 for ( int n
= 0; n
< count
; n
++ )
931 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
933 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
936 // don't bother to continue, we're already at top/bottom
943 return pos
!= posStart
;
946 bool wxWindowMSW::ScrollLines(int lines
)
948 bool down
= lines
> 0;
950 return ScrollVertically(GetHwnd(),
951 down
? SB_LINEDOWN
: SB_LINEUP
,
952 down
? lines
: -lines
);
955 bool wxWindowMSW::ScrollPages(int pages
)
957 bool down
= pages
> 0;
959 return ScrollVertically(GetHwnd(),
960 down
? SB_PAGEDOWN
: SB_PAGEUP
,
961 down
? pages
: -pages
);
964 // ---------------------------------------------------------------------------
966 // ---------------------------------------------------------------------------
968 void wxWindowMSW::SubclassWin(WXHWND hWnd
)
970 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
972 HWND hwnd
= (HWND
)hWnd
;
973 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
975 wxAssociateWinWithHandle(hwnd
, this);
977 m_oldWndProc
= (WXFARPROC
)::GetWindowLong((HWND
)hWnd
, GWL_WNDPROC
);
979 // we don't need to subclass the window of our own class (in the Windows
980 // sense of the word)
981 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
983 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) wxWndProc
);
987 // don't bother restoring it neither: this also makes it easy to
988 // implement IsOfStandardClass() method which returns TRUE for the
989 // standard controls and FALSE for the wxWindows own windows as it can
990 // simply check m_oldWndProc
995 void wxWindowMSW::UnsubclassWin()
997 wxRemoveHandleAssociation(this);
999 // Restore old Window proc
1000 HWND hwnd
= GetHwnd();
1005 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1009 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1011 ::SetWindowLong(hwnd
, GWL_WNDPROC
, (LONG
) m_oldWndProc
);
1014 m_oldWndProc
= NULL
;
1019 bool wxCheckWindowWndProc(WXHWND hWnd
, WXFARPROC wndProc
)
1021 // Unicows note: the code below works, but only because WNDCLASS contains
1022 // original window handler rather that the unicows fake one. This may not
1023 // be on purpose, though; if it stops working with future versions of
1024 // unicows.dll, we can override unicows hooks by setting
1025 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1026 // versions that keep track of fake<->real wnd proc mapping.
1028 // On WinCE (at least), the wndproc comparison doesn't work,
1029 // so have to use something like this.
1031 extern const wxChar
*wxCanvasClassName
;
1032 extern const wxChar
*wxCanvasClassNameNR
;
1033 extern const wxChar
*wxMDIFrameClassName
;
1034 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1035 extern const wxChar
*wxMDIChildFrameClassName
;
1036 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1037 wxString
str(wxGetWindowClass(hWnd
));
1038 if (str
== wxCanvasClassName
||
1039 str
== wxCanvasClassNameNR
||
1040 str
== wxMDIFrameClassName
||
1041 str
== wxMDIFrameClassNameNoRedraw
||
1042 str
== wxMDIChildFrameClassName
||
1043 str
== wxMDIChildFrameClassNameNoRedraw
||
1044 str
== _T("wxTLWHiddenParent"))
1045 return TRUE
; // Effectively means don't subclass
1050 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1052 wxLogLastError(_T("GetClassInfo"));
1057 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1061 // ----------------------------------------------------------------------------
1063 // ----------------------------------------------------------------------------
1065 void wxWindowMSW::SetWindowStyleFlag(long flags
)
1067 long flagsOld
= GetWindowStyleFlag();
1068 if ( flags
== flagsOld
)
1071 // update the internal variable
1072 wxWindowBase::SetWindowStyleFlag(flags
);
1074 // now update the Windows style as well if needed - and if the window had
1075 // been already created
1079 WXDWORD exstyle
, exstyleOld
;
1080 long style
= MSWGetStyle(flags
, &exstyle
),
1081 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1083 if ( style
!= styleOld
)
1085 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1086 // this function so instead of simply setting the style to the new
1087 // value we clear the bits which were set in styleOld but are set in
1088 // the new one and set the ones which were not set before
1089 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1090 styleReal
&= ~styleOld
;
1093 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1096 // and the extended style
1097 if ( exstyle
!= exstyleOld
)
1099 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1100 exstyleReal
&= ~exstyleOld
;
1101 exstyleReal
|= exstyle
;
1103 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1105 // we must call SetWindowPos() to flash the cached extended style and
1106 // also to make the change to wxSTAY_ON_TOP style take effect: just
1107 // setting the style simply doesn't work
1108 if ( !::SetWindowPos(GetHwnd(),
1109 exstyleReal
& WS_EX_TOPMOST
? HWND_TOPMOST
1112 SWP_NOMOVE
| SWP_NOSIZE
) )
1114 wxLogLastError(_T("SetWindowPos"));
1119 WXDWORD
wxWindowMSW::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1121 // translate the style
1122 WXDWORD style
= WS_CHILD
| WS_VISIBLE
;
1124 if ( flags
& wxCLIP_CHILDREN
)
1125 style
|= WS_CLIPCHILDREN
;
1127 if ( flags
& wxCLIP_SIBLINGS
)
1128 style
|= WS_CLIPSIBLINGS
;
1130 if ( flags
& wxVSCROLL
)
1131 style
|= WS_VSCROLL
;
1133 if ( flags
& wxHSCROLL
)
1134 style
|= WS_HSCROLL
;
1136 const wxBorder border
= GetBorder(flags
);
1138 // WS_BORDER is only required for wxBORDER_SIMPLE
1139 if ( border
== wxBORDER_SIMPLE
)
1142 // now deal with ext style if the caller wants it
1148 if ( flags
& wxTRANSPARENT_WINDOW
)
1149 *exstyle
|= WS_EX_TRANSPARENT
;
1155 case wxBORDER_DEFAULT
:
1156 wxFAIL_MSG( _T("unknown border style") );
1160 case wxBORDER_SIMPLE
:
1163 case wxBORDER_STATIC
:
1164 *exstyle
|= WS_EX_STATICEDGE
;
1167 case wxBORDER_RAISED
:
1168 *exstyle
|= WS_EX_DLGMODALFRAME
;
1171 case wxBORDER_SUNKEN
:
1172 *exstyle
|= WS_EX_CLIENTEDGE
;
1173 style
&= ~WS_BORDER
;
1176 case wxBORDER_DOUBLE
:
1177 *exstyle
|= WS_EX_DLGMODALFRAME
;
1181 // wxUniv doesn't use Windows dialog navigation functions at all
1182 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1183 // to make the dialog navigation work with the nested panels we must
1184 // use this style (top level windows such as dialogs don't need it)
1185 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1187 *exstyle
|= WS_EX_CONTROLPARENT
;
1189 #endif // __WXUNIVERSAL__
1195 // Setup background and foreground colours correctly
1196 void wxWindowMSW::SetupColours()
1199 SetBackgroundColour(GetParent()->GetBackgroundColour());
1202 bool wxWindowMSW::IsMouseInWindow() const
1204 // get the mouse position
1206 ::GetCursorPos(&pt
);
1208 // find the window which currently has the cursor and go up the window
1209 // chain until we find this window - or exhaust it
1210 HWND hwnd
= ::WindowFromPoint(pt
);
1211 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1212 hwnd
= ::GetParent(hwnd
);
1214 return hwnd
!= NULL
;
1217 void wxWindowMSW::OnInternalIdle()
1219 // Check if we need to send a LEAVE event
1220 if ( m_mouseInWindow
)
1222 // note that we should generate the leave event whether the window has
1223 // or doesn't have mouse capture
1224 if ( !IsMouseInWindow() )
1226 // Generate a LEAVE event
1227 m_mouseInWindow
= FALSE
;
1229 // Unfortunately the mouse button and keyboard state may have
1230 // changed by the time the OnInternalIdle function is called, so 'state'
1231 // may be meaningless.
1233 if ( wxIsShiftDown() )
1235 if ( wxIsCtrlDown() )
1236 state
|= MK_CONTROL
;
1237 if ( GetKeyState( VK_LBUTTON
) )
1238 state
|= MK_LBUTTON
;
1239 if ( GetKeyState( VK_MBUTTON
) )
1240 state
|= MK_MBUTTON
;
1241 if ( GetKeyState( VK_RBUTTON
) )
1242 state
|= MK_RBUTTON
;
1245 if ( !::GetCursorPos(&pt
) )
1247 wxLogLastError(_T("GetCursorPos"));
1250 // we need to have client coordinates here for symmetry with
1251 // wxEVT_ENTER_WINDOW
1252 RECT rect
= wxGetWindowRect(GetHwnd());
1256 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
1257 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
1259 (void)GetEventHandler()->ProcessEvent(event2
);
1263 if (wxUpdateUIEvent::CanUpdate(this))
1264 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1267 // Set this window to be the child of 'parent'.
1268 bool wxWindowMSW::Reparent(wxWindowBase
*parent
)
1270 if ( !wxWindowBase::Reparent(parent
) )
1273 HWND hWndChild
= GetHwnd();
1274 HWND hWndParent
= GetParent() ? GetWinHwnd(GetParent()) : (HWND
)0;
1276 ::SetParent(hWndChild
, hWndParent
);
1279 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1281 EnsureParentHasControlParentStyle(GetParent());
1283 #endif // !__WXWINCE__
1288 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1290 #ifndef __WXMICROWIN__
1291 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1295 void wxWindowMSW::Freeze()
1297 SendSetRedraw(GetHwnd(), FALSE
);
1300 void wxWindowMSW::Thaw()
1302 SendSetRedraw(GetHwnd(), TRUE
);
1304 // we need to refresh everything or otherwise he invalidated area is not
1309 void wxWindowMSW::Refresh(bool eraseBack
, const wxRect
*rect
)
1311 HWND hWnd
= GetHwnd();
1317 mswRect
.left
= rect
->x
;
1318 mswRect
.top
= rect
->y
;
1319 mswRect
.right
= rect
->x
+ rect
->width
;
1320 mswRect
.bottom
= rect
->y
+ rect
->height
;
1322 ::InvalidateRect(hWnd
, &mswRect
, eraseBack
);
1325 ::InvalidateRect(hWnd
, NULL
, eraseBack
);
1329 void wxWindowMSW::Update()
1331 if ( !::UpdateWindow(GetHwnd()) )
1333 wxLogLastError(_T("UpdateWindow"));
1336 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1337 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1338 // handler needs to be really drawn right now
1343 // ---------------------------------------------------------------------------
1345 // ---------------------------------------------------------------------------
1348 #if wxUSE_DRAG_AND_DROP
1349 void wxWindowMSW::SetDropTarget(wxDropTarget
*pDropTarget
)
1351 if ( m_dropTarget
!= 0 ) {
1352 m_dropTarget
->Revoke(m_hWnd
);
1353 delete m_dropTarget
;
1356 m_dropTarget
= pDropTarget
;
1357 if ( m_dropTarget
!= 0 )
1358 m_dropTarget
->Register(m_hWnd
);
1360 #endif // wxUSE_DRAG_AND_DROP
1362 // old style file-manager drag&drop support: we retain the old-style
1363 // DragAcceptFiles in parallel with SetDropTarget.
1364 void wxWindowMSW::DragAcceptFiles(bool accept
)
1366 #if !defined(__WXWINCE__)
1367 HWND hWnd
= GetHwnd();
1369 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1373 // ----------------------------------------------------------------------------
1375 // ----------------------------------------------------------------------------
1379 void wxWindowMSW::DoSetToolTip(wxToolTip
*tooltip
)
1381 wxWindowBase::DoSetToolTip(tooltip
);
1384 m_tooltip
->SetWindow((wxWindow
*)this);
1387 #endif // wxUSE_TOOLTIPS
1389 // ---------------------------------------------------------------------------
1390 // moving and resizing
1391 // ---------------------------------------------------------------------------
1394 void wxWindowMSW::DoGetSize(int *x
, int *y
) const
1396 RECT rect
= wxGetWindowRect(GetHwnd());
1399 *x
= rect
.right
- rect
.left
;
1401 *y
= rect
.bottom
- rect
.top
;
1404 // Get size *available for subwindows* i.e. excluding menu bar etc.
1405 void wxWindowMSW::DoGetClientSize(int *x
, int *y
) const
1407 RECT rect
= wxGetClientRect(GetHwnd());
1415 void wxWindowMSW::DoGetPosition(int *x
, int *y
) const
1417 RECT rect
= wxGetWindowRect(GetHwnd());
1420 point
.x
= rect
.left
;
1423 // we do the adjustments with respect to the parent only for the "real"
1424 // children, not for the dialogs/frames
1425 if ( !IsTopLevel() )
1427 HWND hParentWnd
= 0;
1428 wxWindow
*parent
= GetParent();
1430 hParentWnd
= GetWinHwnd(parent
);
1432 // Since we now have the absolute screen coords, if there's a parent we
1433 // must subtract its top left corner
1436 ::ScreenToClient(hParentWnd
, &point
);
1441 // We may be faking the client origin. So a window that's really at (0,
1442 // 30) may appear (to wxWin apps) to be at (0, 0).
1443 wxPoint
pt(parent
->GetClientAreaOrigin());
1455 void wxWindowMSW::DoScreenToClient(int *x
, int *y
) const
1463 ::ScreenToClient(GetHwnd(), &pt
);
1471 void wxWindowMSW::DoClientToScreen(int *x
, int *y
) const
1479 ::ClientToScreen(GetHwnd(), &pt
);
1487 void wxWindowMSW::DoMoveWindow(int x
, int y
, int width
, int height
)
1489 // TODO: is this consistent with other platforms?
1490 // Still, negative width or height shouldn't be allowed
1495 if ( !::MoveWindow(GetHwnd(), x
, y
, width
, height
, TRUE
) )
1497 wxLogLastError(wxT("MoveWindow"));
1501 // set the size of the window: if the dimensions are positive, just use them,
1502 // but if any of them is equal to -1, it means that we must find the value for
1503 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1504 // which case -1 is a valid value for x and y)
1506 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1507 // the width/height to best suit our contents, otherwise we reuse the current
1509 void wxWindowMSW::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1511 // get the current size and position...
1512 int currentX
, currentY
;
1513 GetPosition(¤tX
, ¤tY
);
1514 int currentW
,currentH
;
1515 GetSize(¤tW
, ¤tH
);
1517 // ... and don't do anything (avoiding flicker) if it's already ok
1518 if ( x
== currentX
&& y
== currentY
&&
1519 width
== currentW
&& height
== currentH
)
1524 if ( x
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1526 if ( y
== -1 && !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1529 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1531 wxSize
size(-1, -1);
1534 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1536 size
= DoGetBestSize();
1541 // just take the current one
1548 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1552 size
= DoGetBestSize();
1554 //else: already called DoGetBestSize() above
1560 // just take the current one
1565 DoMoveWindow(x
, y
, width
, height
);
1568 void wxWindowMSW::DoSetClientSize(int width
, int height
)
1570 // setting the client size is less obvious than it it could have been
1571 // because in the result of changing the total size the window scrollbar
1572 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1573 // will not be correct as the difference between the total and client size
1574 // changes - so we keep changing it until we get it right
1576 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1577 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1578 // may become 3 if the window had 0 size originally and so we didn't
1579 // calculate the scrollbar correction correctly during the first iteration)
1580 // but just to be on the safe side we check for it instead of making it an
1581 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1582 for ( int i
= 0; i
< 4; i
++ )
1585 ::GetClientRect(GetHwnd(), &rectClient
);
1587 // if the size is already ok, stop here (rectClient.left = top = 0)
1588 if ( (rectClient
.right
== width
|| width
== -1) &&
1589 (rectClient
.bottom
== height
|| height
== -1) )
1594 int widthClient
= width
,
1595 heightClient
= height
;
1597 // Find the difference between the entire window (title bar and all)
1598 // and the client area; add this to the new client size to move the
1601 ::GetWindowRect(GetHwnd(), &rectWin
);
1603 widthClient
+= rectWin
.right
- rectWin
.left
- rectClient
.right
;
1604 heightClient
+= rectWin
.bottom
- rectWin
.top
- rectClient
.bottom
;
1607 point
.x
= rectWin
.left
;
1608 point
.y
= rectWin
.top
;
1610 // MoveWindow positions the child windows relative to the parent, so
1611 // adjust if necessary
1612 if ( !IsTopLevel() )
1614 wxWindow
*parent
= GetParent();
1617 ::ScreenToClient(GetHwndOf(parent
), &point
);
1621 DoMoveWindow(point
.x
, point
.y
, widthClient
, heightClient
);
1625 // For implementation purposes - sometimes decorations make the client area
1627 wxPoint
wxWindowMSW::GetClientAreaOrigin() const
1629 return wxPoint(0, 0);
1632 // ---------------------------------------------------------------------------
1634 // ---------------------------------------------------------------------------
1636 int wxWindowMSW::GetCharHeight() const
1638 return wxGetTextMetrics(this).tmHeight
;
1641 int wxWindowMSW::GetCharWidth() const
1643 // +1 is needed because Windows apparently adds it when calculating the
1644 // dialog units size in pixels
1645 #if wxDIALOG_UNIT_COMPATIBILITY
1646 return wxGetTextMetrics(this).tmAveCharWidth
;
1648 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1652 void wxWindowMSW::GetTextExtent(const wxString
& string
,
1654 int *descent
, int *externalLeading
,
1655 const wxFont
*theFont
) const
1657 const wxFont
*fontToUse
= theFont
;
1659 fontToUse
= &m_font
;
1661 HWND hWnd
= GetHwnd();
1662 HDC dc
= ::GetDC(hWnd
);
1666 if ( fontToUse
&& fontToUse
->Ok() )
1668 fnt
= (HFONT
)((wxFont
*)fontToUse
)->GetResourceHandle(); // const_cast
1670 hfontOld
= (HFONT
)SelectObject(dc
,fnt
);
1675 GetTextExtentPoint(dc
, string
, (int)string
.Length(), &sizeRect
);
1676 GetTextMetrics(dc
, &tm
);
1678 if ( fontToUse
&& fnt
&& hfontOld
)
1679 SelectObject(dc
, hfontOld
);
1681 ReleaseDC(hWnd
, dc
);
1688 *descent
= tm
.tmDescent
;
1689 if ( externalLeading
)
1690 *externalLeading
= tm
.tmExternalLeading
;
1693 // ---------------------------------------------------------------------------
1695 // ---------------------------------------------------------------------------
1697 #if wxUSE_MENUS_NATIVE
1699 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1700 // immediately, without waiting for the next event loop iteration
1702 // NB: this function should probably be made public later as it can almost
1703 // surely replace wxYield() elsewhere as well
1704 static void wxYieldForCommandsOnly()
1706 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1707 // want to process it here)
1709 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1711 if ( msg
.message
== WM_QUIT
)
1713 // if we retrieved a WM_QUIT, insert back into the message queue.
1714 ::PostQuitMessage(0);
1718 // luckily (as we don't have access to wxEventLoopImpl method from here
1719 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1721 ::TranslateMessage(&msg
);
1722 ::DispatchMessage(&msg
);
1726 bool wxWindowMSW::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1728 menu
->SetInvokingWindow(this);
1731 HWND hWnd
= GetHwnd();
1732 HMENU hMenu
= GetHmenuOf(menu
);
1736 ::ClientToScreen(hWnd
, &point
);
1737 wxCurrentPopupMenu
= menu
;
1739 #if !defined(__WXWINCE__)
1740 flags
= TPM_RIGHTBUTTON
;
1742 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1744 // we need to do it righ now as otherwise the events are never going to be
1745 // sent to wxCurrentPopupMenu from HandleCommand()
1747 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1748 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1749 // destroyed as soon as we return (it can be a local variable in the caller
1750 // for example) and so we do need to process the event immediately
1751 wxYieldForCommandsOnly();
1753 wxCurrentPopupMenu
= NULL
;
1755 menu
->SetInvokingWindow(NULL
);
1760 #endif // wxUSE_MENUS_NATIVE
1762 // ===========================================================================
1763 // pre/post message processing
1764 // ===========================================================================
1766 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1769 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1771 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1774 bool wxWindowMSW::MSWProcessMessage(WXMSG
* pMsg
)
1776 // wxUniversal implements tab traversal itself
1777 #ifndef __WXUNIVERSAL__
1778 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1780 // intercept dialog navigation keys
1781 MSG
*msg
= (MSG
*)pMsg
;
1783 // here we try to do all the job which ::IsDialogMessage() usually does
1786 if ( msg
->message
== WM_KEYDOWN
)
1788 bool bCtrlDown
= wxIsCtrlDown();
1789 bool bShiftDown
= wxIsShiftDown();
1791 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1792 // don't process it if it's the case (except for Ctrl-Tab/Enter
1793 // combinations which are always processed)
1797 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1799 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1800 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1801 // it, of course, implies them
1802 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1804 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1808 bool bForward
= TRUE
,
1809 bWindowChange
= FALSE
;
1811 // should we process this message specially?
1812 bool bProcess
= TRUE
;
1813 switch ( msg
->wParam
)
1816 if ( lDlgCode
& DLGC_WANTTAB
) {
1820 // Ctrl-Tab cycles thru notebook pages
1821 bWindowChange
= bCtrlDown
;
1822 bForward
= !bShiftDown
;
1828 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1836 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1842 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1844 // control wants to process Enter itself, don't
1845 // call IsDialogMessage() which would interpret
1849 else if ( lDlgCode
& DLGC_BUTTON
)
1851 // let IsDialogMessage() handle this for all
1852 // buttons except the owner-drawn ones which it
1853 // just seems to ignore
1854 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1855 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1857 // emulate the button click
1858 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1860 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1865 // FIXME: this should be handled by
1866 // wxNavigationKeyEvent handler and not here!!
1870 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1872 if ( btn
&& btn
->IsEnabled() )
1874 // if we do have a default button, do press it
1875 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1879 else // no default button
1881 #endif // wxUSE_BUTTON
1882 // this is a quick and dirty test for a text
1884 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1886 // don't process Enter, the control might
1887 // need it for itself and don't let
1888 // ::IsDialogMessage() have it as it can
1889 // eat the Enter events sometimes
1892 else if (!IsTopLevel())
1894 // if not a top level window, let parent
1898 //else: treat Enter as TAB: pass to the next
1899 // control as this is the best thing to do
1900 // if the text doesn't handle Enter itself
1912 wxNavigationKeyEvent event
;
1913 event
.SetDirection(bForward
);
1914 event
.SetWindowChange(bWindowChange
);
1915 event
.SetEventObject(this);
1917 if ( GetEventHandler()->ProcessEvent(event
) )
1924 // let ::IsDialogMessage() do almost everything and handle just the
1925 // things it doesn't here: Ctrl-TAB for switching notebook pages
1926 if ( msg
->message
== WM_KEYDOWN
)
1928 // don't process system keys here
1929 if ( !(HIWORD(msg
->lParam
) & KF_ALTDOWN
) )
1931 if ( (msg
->wParam
== VK_TAB
) && wxIsCtrlDown() )
1933 // find the first notebook parent and change its page
1934 wxWindow
*win
= this;
1935 wxNotebook
*nbook
= NULL
;
1936 while ( win
&& !nbook
)
1938 nbook
= wxDynamicCast(win
, wxNotebook
);
1939 win
= win
->GetParent();
1944 bool forward
= !wxIsShiftDown();
1946 nbook
->AdvanceSelection(forward
);
1953 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1954 // shouldn't let IsDialogMessage() get it as it _always_ eats the
1955 // message even when there is no cancel button and when the message is
1956 // needed by the control itself: in particular, it prevents the tree in
1957 // place edit control from being closed with Escape in a dialog
1958 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
1960 // ::IsDialogMessage() is broken and may sometimes hang the
1961 // application by going into an infinite loop, so we try to detect
1962 // [some of] the situatations when this may happen and not call it
1965 // assume we can call it by default
1966 bool canSafelyCallIsDlgMsg
= TRUE
;
1968 HWND hwndFocus
= ::GetFocus();
1970 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
1971 // an infinite loop, because it will recursively check the child
1972 // windows but not the window itself and so if none of the children
1973 // accepts focus it loops forever (as it only stops when it gets
1974 // back to the window it started from)
1976 // while it is very unusual that a window with WS_EX_CONTROLPARENT
1977 // style has the focus, it can happen. One such possibility is if
1978 // all windows are either toplevel, wxDialog, wxPanel or static
1979 // controls and no window can actually accept keyboard input.
1980 #if !defined(__WXWINCE__)
1981 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1983 // passimistic by default
1984 canSafelyCallIsDlgMsg
= FALSE
;
1985 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1987 node
= node
->GetNext() )
1989 wxWindow
* const win
= node
->GetData();
1990 if ( win
->AcceptsFocus() &&
1991 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
1992 WS_EX_CONTROLPARENT
) )
1994 // it shouldn't hang...
1995 canSafelyCallIsDlgMsg
= TRUE
;
2001 #endif // !__WXWINCE__
2003 if ( canSafelyCallIsDlgMsg
)
2005 // ::IsDialogMessage() can enter in an infinite loop when the
2006 // currently focused window is disabled or hidden and its
2007 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2011 if ( !::IsWindowEnabled(hwndFocus
) ||
2012 !::IsWindowVisible(hwndFocus
) )
2014 // it would enter an infinite loop if we do this!
2015 canSafelyCallIsDlgMsg
= FALSE
;
2020 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2022 // it's a top level window, don't go further -- e.g. even
2023 // if the parent of a dialog is disabled, this doesn't
2024 // break navigation inside the dialog
2028 hwndFocus
= ::GetParent(hwndFocus
);
2032 // let IsDialogMessage() have the message if it's safe to call it
2033 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2035 // IsDialogMessage() did something...
2040 #endif // __WXUNIVERSAL__
2045 // relay mouse move events to the tooltip control
2046 MSG
*msg
= (MSG
*)pMsg
;
2047 if ( msg
->message
== WM_MOUSEMOVE
)
2048 m_tooltip
->RelayEvent(pMsg
);
2050 #endif // wxUSE_TOOLTIPS
2055 bool wxWindowMSW::MSWTranslateMessage(WXMSG
* pMsg
)
2057 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2058 return m_acceleratorTable
.Translate(this, pMsg
);
2062 #endif // wxUSE_ACCEL
2065 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2067 // preprocess all messages by default
2071 // ---------------------------------------------------------------------------
2072 // message params unpackers
2073 // ---------------------------------------------------------------------------
2075 void wxWindowMSW::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2076 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2078 *id
= LOWORD(wParam
);
2079 *hwnd
= (WXHWND
)lParam
;
2080 *cmd
= HIWORD(wParam
);
2083 void wxWindowMSW::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2084 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2086 *state
= LOWORD(wParam
);
2087 *minimized
= HIWORD(wParam
);
2088 *hwnd
= (WXHWND
)lParam
;
2091 void wxWindowMSW::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2092 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2094 *code
= LOWORD(wParam
);
2095 *pos
= HIWORD(wParam
);
2096 *hwnd
= (WXHWND
)lParam
;
2099 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2100 WXWORD
*nCtlColor
, WXHDC
*hdc
, WXHWND
*hwnd
)
2102 #ifndef __WXMICROWIN__
2103 *nCtlColor
= CTLCOLOR_BTN
;
2104 *hwnd
= (WXHWND
)lParam
;
2105 *hdc
= (WXHDC
)wParam
;
2109 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2110 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2112 *item
= (WXWORD
)wParam
;
2113 *flags
= HIWORD(wParam
);
2114 *hmenu
= (WXHMENU
)lParam
;
2117 // ---------------------------------------------------------------------------
2118 // Main wxWindows window proc and the window proc for wxWindow
2119 // ---------------------------------------------------------------------------
2121 // Hook for new window just as it's being created, when the window isn't yet
2122 // associated with the handle
2123 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2125 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2126 // window being created and insures that it's always unset back later
2127 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2129 gs_winBeingCreated
= winBeingCreated
;
2132 wxWindowCreationHook::~wxWindowCreationHook()
2134 gs_winBeingCreated
= NULL
;
2138 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2140 // trace all messages - useful for the debugging
2142 wxLogTrace(wxTraceMessages
,
2143 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2144 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2145 #endif // __WXDEBUG__
2147 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2149 // when we get the first message for the HWND we just created, we associate
2150 // it with wxWindow stored in gs_winBeingCreated
2151 if ( !wnd
&& gs_winBeingCreated
)
2153 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2154 wnd
= gs_winBeingCreated
;
2155 gs_winBeingCreated
= NULL
;
2156 wnd
->SetHWND((WXHWND
)hWnd
);
2162 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2164 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2169 long wxWindowMSW::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2171 // did we process the message?
2172 bool processed
= FALSE
;
2183 // for most messages we should return 0 when we do process the message
2191 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2194 // return 0 to allow window creation
2195 rc
.result
= mayCreate
? 0 : -1;
2201 // never set processed to TRUE and *always* pass WM_DESTROY to
2202 // DefWindowProc() as Windows may do some internal cleanup when
2203 // processing it and failing to pass the message along may cause
2204 // memory and resource leaks!
2205 (void)HandleDestroy();
2209 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2212 #if !defined(__WXWINCE__)
2215 LPRECT pRect
= (LPRECT
)lParam
;
2217 rc
.SetLeft(pRect
->left
);
2218 rc
.SetTop(pRect
->top
);
2219 rc
.SetRight(pRect
->right
);
2220 rc
.SetBottom(pRect
->bottom
);
2221 processed
= HandleMoving(rc
);
2223 pRect
->left
= rc
.GetLeft();
2224 pRect
->top
= rc
.GetTop();
2225 pRect
->right
= rc
.GetRight();
2226 pRect
->bottom
= rc
.GetBottom();
2237 // we're not interested in these messages at all
2240 case SIZE_MINIMIZED
:
2241 // we shouldn't send sizev events for these messages as the
2242 // client size may be negative which breaks existing code
2244 // OTOH we might send another (wxMinimizedEvent?) one or
2245 // add an additional parameter to wxSizeEvent if this is
2246 // useful to anybody
2250 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2251 // fall through nevertheless
2253 case SIZE_MAXIMIZED
:
2255 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
),
2260 #if !defined(__WXWINCE__)
2263 LPRECT pRect
= (LPRECT
)lParam
;
2265 rc
.SetLeft(pRect
->left
);
2266 rc
.SetTop(pRect
->top
);
2267 rc
.SetRight(pRect
->right
);
2268 rc
.SetBottom(pRect
->bottom
);
2269 processed
= HandleSizing(rc
);
2271 pRect
->left
= rc
.GetLeft();
2272 pRect
->top
= rc
.GetTop();
2273 pRect
->right
= rc
.GetRight();
2274 pRect
->bottom
= rc
.GetBottom();
2280 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2281 case WM_ACTIVATEAPP
:
2282 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2288 WXWORD state
, minimized
;
2290 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2292 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2297 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2301 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2308 // cast to wxWindow is needed for wxUniv
2309 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2310 processed
= HandlePaint();
2314 processed
= HandlePaint();
2322 // Don't call the wx handlers in this case
2323 if ( wxIsKindOf(this, wxListCtrl
) )
2326 if ( lParam
& PRF_ERASEBKGND
)
2327 HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2329 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2330 processed
= HandlePaint();
2336 #ifdef __WXUNIVERSAL__
2337 // Universal uses its own wxFrame/wxDialog, so we don't receive
2338 // close events unless we have this.
2343 // don't let the DefWindowProc() destroy our window - we'll do it
2344 // ourselves in ~wxWindow
2351 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2355 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2356 GET_Y_LPARAM(lParam
),
2360 // Seems to be broken currently
2361 #if 0 // ndef __WXWINCE__
2364 wxASSERT_MSG( !m_mouseInWindow
, wxT("the mouse should be in a window to generate this event!") );
2366 // only process this message if the mouse is not in the window,
2367 // This can also check for children in composite windows.
2368 // however, this may mean the the wxEVT_LEAVE_WINDOW is never sent
2369 // if the mouse does not enter the window from it's child before
2370 // leaving the scope of the window. ( perhaps this can be picked
2371 // up in the OnIdle code as before, for this special case )
2372 if ( /*IsComposite() && */ !IsMouseInWindow() )
2374 m_mouseInWindow
= FALSE
;
2376 // Unfortunately no mouse state is passed with a WM_MOUSE_LEAVE
2378 if ( wxIsShiftDown() )
2380 if ( wxIsCtrlDown() )
2381 state
|= MK_CONTROL
;
2382 if ( GetKeyState( VK_LBUTTON
) )
2383 state
|= MK_LBUTTON
;
2384 if ( GetKeyState( VK_MBUTTON
) )
2385 state
|= MK_MBUTTON
;
2386 if ( GetKeyState( VK_RBUTTON
) )
2387 state
|= MK_RBUTTON
;
2390 if ( !::GetCursorPos(&pt
) )
2392 wxLogLastError(_T("GetCursorPos"));
2395 // we need to have client coordinates here for symmetry with
2396 // wxEVT_ENTER_WINDOW
2397 RECT rect
= wxGetWindowRect(GetHwnd());
2401 wxMouseEvent
event2(wxEVT_LEAVE_WINDOW
);
2402 InitMouseEvent(event2
, pt
.x
, pt
.y
, state
);
2404 (void)GetEventHandler()->ProcessEvent(event2
);
2406 // always pass processed back as false, this allows the window
2407 // manager to process the message too. This is needed to ensure
2408 // windows XP themes work properly as the mouse moves over widgets
2416 #if wxUSE_MOUSEWHEEL
2418 processed
= HandleMouseWheel(wParam
, lParam
);
2422 case WM_LBUTTONDOWN
:
2424 case WM_LBUTTONDBLCLK
:
2425 case WM_RBUTTONDOWN
:
2427 case WM_RBUTTONDBLCLK
:
2428 case WM_MBUTTONDOWN
:
2430 case WM_MBUTTONDBLCLK
:
2432 #ifdef __WXMICROWIN__
2433 // MicroWindows seems to ignore the fact that a window is
2434 // disabled. So catch mouse events and throw them away if
2436 wxWindowMSW
* win
= this;
2439 if (!win
->IsEnabled())
2445 win
= win
->GetParent();
2446 if ( !win
|| win
->IsTopLevel() )
2453 #endif // __WXMICROWIN__
2454 int x
= GET_X_LPARAM(lParam
),
2455 y
= GET_Y_LPARAM(lParam
);
2457 // redirect the event to a static control if necessary by
2458 // finding one under mouse
2460 if ( GetCapture() == this )
2462 // but don't do it if the mouse is captured by this window
2463 // because then it should really get this event itself
2468 win
= FindWindowForMouseEvent(this, &x
, &y
);
2470 // this should never happen
2471 wxCHECK_MSG( win
, 0,
2472 _T("FindWindowForMouseEvent() returned NULL") );
2474 // for the standard classes their WndProc sets the focus to
2475 // them anyhow and doing it from here results in some weird
2476 // problems, but for our windows we want them to acquire
2477 // focus when clicked
2478 if ( !win
->IsOfStandardClass() )
2480 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2485 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2494 case MM_JOY1BUTTONDOWN
:
2495 case MM_JOY2BUTTONDOWN
:
2496 case MM_JOY1BUTTONUP
:
2497 case MM_JOY2BUTTONUP
:
2498 processed
= HandleJoystickEvent(message
,
2499 GET_X_LPARAM(lParam
),
2500 GET_Y_LPARAM(lParam
),
2503 #endif // __WXMICROWIN__
2506 processed
= HandleSysCommand(wParam
, lParam
);
2513 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2515 processed
= HandleCommand(id
, cmd
, hwnd
);
2520 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2523 // for these messages we must return TRUE if process the message
2526 case WM_MEASUREITEM
:
2528 int idCtrl
= (UINT
)wParam
;
2529 if ( message
== WM_DRAWITEM
)
2531 processed
= MSWOnDrawItem(idCtrl
,
2532 (WXDRAWITEMSTRUCT
*)lParam
);
2536 processed
= MSWOnMeasureItem(idCtrl
,
2537 (WXMEASUREITEMSTRUCT
*)lParam
);
2544 #endif // defined(WM_DRAWITEM)
2547 if ( !IsOfStandardClass() )
2549 // we always want to get the char events
2550 rc
.result
= DLGC_WANTCHARS
;
2552 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2554 // in fact, we want everything
2555 rc
.result
|= DLGC_WANTARROWS
|
2562 //else: get the dlg code from the DefWindowProc()
2567 // If this has been processed by an event handler, return 0 now
2568 // (we've handled it).
2569 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2570 if ( m_lastKeydownProcessed
)
2579 // we consider these message "not interesting" to OnChar, so
2580 // just don't do anything more with them
2590 // avoid duplicate messages to OnChar for these ASCII keys:
2591 // they will be translated by TranslateMessage() and received
2613 // but set processed to FALSE, not TRUE to still pass them
2614 // to the control's default window proc - otherwise
2615 // built-in keyboard handling won't work
2620 // special case of VK_APPS: treat it the same as right mouse
2621 // click because both usually pop up a context menu
2627 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2628 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, x
, y
, flags
);
2634 // do generate a CHAR event
2635 processed
= HandleChar((WORD
)wParam
, lParam
);
2638 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2645 // special case of VK_APPS: treat it the same as right mouse button
2646 if ( wParam
== VK_APPS
)
2651 TranslateKbdEventToMouse(this, &x
, &y
, &flags
);
2652 processed
= HandleMouseEvent(WM_RBUTTONUP
, x
, y
, flags
);
2657 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2662 case WM_CHAR
: // Always an ASCII character
2663 if ( m_lastKeydownProcessed
)
2665 // The key was handled in the EVT_KEY_DOWN and handling
2666 // a key in an EVT_KEY_DOWN handler is meant, by
2667 // design, to prevent EVT_CHARs from happening
2668 m_lastKeydownProcessed
= FALSE
;
2673 processed
= HandleChar((WORD
)wParam
, lParam
, TRUE
);
2679 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2681 #endif // wxUSE_HOTKEY
2688 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2690 processed
= MSWOnScroll(message
== WM_HSCROLL
? wxHORIZONTAL
2696 // CTLCOLOR messages are sent by children to query the parent for their
2697 // colors#ifndef __WXMICROWIN__
2698 #ifndef __WXMICROWIN__
2699 case WM_CTLCOLORMSGBOX
:
2700 case WM_CTLCOLOREDIT
:
2701 case WM_CTLCOLORLISTBOX
:
2702 case WM_CTLCOLORBTN
:
2703 case WM_CTLCOLORDLG
:
2704 case WM_CTLCOLORSCROLLBAR
:
2705 case WM_CTLCOLORSTATIC
:
2710 UnpackCtlColor(wParam
, lParam
, &nCtlColor
, &hdc
, &hwnd
);
2712 processed
= HandleCtlColor(&rc
.hBrush
,
2721 #endif // !__WXMICROWIN__
2723 case WM_SYSCOLORCHANGE
:
2724 // the return value for this message is ignored
2725 processed
= HandleSysColorChange();
2728 #if !defined(__WXWINCE__)
2729 case WM_DISPLAYCHANGE
:
2730 processed
= HandleDisplayChange();
2734 case WM_PALETTECHANGED
:
2735 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2738 case WM_CAPTURECHANGED
:
2739 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2742 case WM_QUERYNEWPALETTE
:
2743 processed
= HandleQueryNewPalette();
2747 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2750 // we processed the message, i.e. erased the background
2755 #if !defined(__WXWINCE__)
2757 processed
= HandleDropFiles(wParam
);
2762 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2766 // we never set focus from here
2771 #if !defined(__WXWINCE__)
2772 case WM_QUERYENDSESSION
:
2773 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2777 processed
= HandleEndSession(wParam
!= 0, lParam
);
2780 case WM_GETMINMAXINFO
:
2781 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2786 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2787 LOWORD(lParam
), // hit test
2788 HIWORD(lParam
)); // mouse msg
2792 // returning TRUE stops the DefWindowProc() from further
2793 // processing this message - exactly what we need because we've
2794 // just set the cursor.
2799 #if wxUSE_ACCESSIBILITY
2802 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2803 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2805 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2807 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2813 #if defined(WM_HELP)
2816 // HELPINFO doesn't seem to be supported on WinCE.
2818 HELPINFO
* info
= (HELPINFO
*) lParam
;
2819 // Don't yet process menu help events, just windows
2820 if (info
->iContextType
== HELPINFO_WINDOW
)
2823 wxWindowMSW
* subjectOfHelp
= this;
2824 bool eventProcessed
= FALSE
;
2825 while (subjectOfHelp
&& !eventProcessed
)
2827 wxHelpEvent
helpEvent(wxEVT_HELP
,
2828 subjectOfHelp
->GetId(),
2832 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2836 helpEvent
.SetEventObject(this);
2838 GetEventHandler()->ProcessEvent(helpEvent
);
2840 // Go up the window hierarchy until the event is
2842 subjectOfHelp
= subjectOfHelp
->GetParent();
2845 processed
= eventProcessed
;
2848 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2850 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2851 helpEvent
.SetEventObject(this);
2852 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2855 //else: processed is already FALSE
2861 #if !defined(__WXWINCE__)
2862 case WM_CONTEXTMENU
:
2864 // we don't convert from screen to client coordinates as
2865 // the event may be handled by a parent window
2866 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2868 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2869 evtCtx
.SetEventObject(this);
2870 processed
= GetEventHandler()->ProcessEvent(evtCtx
);
2876 // we're only interested in our own menus, not MF_SYSMENU
2877 if ( HIWORD(wParam
) == MF_POPUP
)
2879 // handle menu chars for ownerdrawn menu items
2880 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2881 if ( i
!= wxNOT_FOUND
)
2883 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2893 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2894 wxGetMessageName(message
));
2895 #endif // __WXDEBUG__
2896 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2902 // ----------------------------------------------------------------------------
2903 // wxWindow <-> HWND map
2904 // ----------------------------------------------------------------------------
2906 wxWinHashTable
*wxWinHandleHash
= NULL
;
2908 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2910 return wxWinHandleHash
->Get((long)hWnd
);
2913 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2915 // adding NULL hWnd is (first) surely a result of an error and
2916 // (secondly) breaks menu command processing
2917 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2918 wxT("attempt to add a NULL hWnd to window list ignored") );
2920 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2922 if ( oldWin
&& (oldWin
!= win
) )
2924 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2925 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2928 #endif // __WXDEBUG__
2931 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2935 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2937 wxWinHandleHash
->Delete((long)win
->GetHWND());
2940 // ----------------------------------------------------------------------------
2941 // various MSW speciic class dependent functions
2942 // ----------------------------------------------------------------------------
2944 // Default destroyer - override if you destroy it in some other way
2945 // (e.g. with MDI child windows)
2946 void wxWindowMSW::MSWDestroyWindow()
2950 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2953 int& w
, int& h
) const
2955 // yes, those are just some arbitrary hardcoded numbers
2956 static const int DEFAULT_Y
= 200;
2957 static const int DEFAULT_W
= 400;
2958 static const int DEFAULT_H
= 250;
2960 bool nonDefault
= FALSE
;
2964 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
2965 // can just as well set it to CW_USEDEFAULT as well
2971 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2972 // neither because it is not handled as a special value by Windows then
2973 // and so we have to choose some default value for it
2975 y
= pos
.y
== -1 ? DEFAULT_Y
: pos
.y
;
2981 NB: there used to be some code here which set the initial size of the
2982 window to the client size of the parent if no explicit size was
2983 specified. This was wrong because wxWindows programs often assume
2984 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2985 it. To see why, you should understand that Windows sends WM_SIZE from
2986 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2987 from some base class ctor and so this WM_SIZE is not processed in the
2988 real class' OnSize() (because it's not fully constructed yet and the
2989 event goes to some base class OnSize() instead). So the WM_SIZE we
2990 rely on is the one sent when the parent frame resizes its children
2991 but here is the problem: if the child already has just the right
2992 size, nothing will happen as both wxWindows and Windows check for
2993 this and ignore any attempts to change the window size to the size it
2994 already has - so no WM_SIZE would be sent.
2998 // we don't use CW_USEDEFAULT here for several reasons:
3000 // 1. it results in huge frames on modern screens (1000*800 is not
3001 // uncommon on my 1280*1024 screen) which is way too big for a half
3002 // empty frame of most of wxWindows samples for example)
3004 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3005 // the default is for whatever reason 8*8 which breaks client <->
3006 // window size calculations (it would be nice if it didn't, but it
3007 // does and the simplest way to fix it seemed to change the broken
3008 // default size anyhow)
3010 // 3. there is just no advantage in doing it: with x and y it is
3011 // possible that [future versions of] Windows position the new top
3012 // level window in some smart way which we can't do, but we can
3013 // guess a reasonably good size for a new window just as well
3020 // and, again as above, we can't set the height to CW_USEDEFAULT here
3022 h
= size
.y
== -1 ? DEFAULT_H
: size
.y
;
3027 AdjustForParentClientOrigin(x
, y
);
3032 WXHWND
wxWindowMSW::MSWGetParent() const
3034 return m_parent
? m_parent
->GetHWND() : WXHWND(NULL
);
3037 bool wxWindowMSW::MSWCreate(const wxChar
*wclass
,
3038 const wxChar
*title
,
3042 WXDWORD extendedStyle
)
3044 // choose the position/size for the new window
3046 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3048 // controlId is menu handle for the top level windows, so set it to 0
3049 // unless we're creating a child window
3050 int controlId
= style
& WS_CHILD
? GetId() : 0;
3052 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3053 // which is the same but without CS_[HV]REDRAW class styles so using it
3054 // ensures that the window is not fully repainted on each resize
3055 wxString
className(wclass
);
3056 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3058 className
+= wxT("NR");
3061 // do create the window
3062 wxWindowCreationHook
hook(this);
3065 if (extendedStyle
== 0)
3067 m_hWnd
= (WXHWND
)::CreateWindow
3070 title
? title
: wxEmptyString
,
3073 (HWND
)MSWGetParent(),
3076 NULL
// no extra data
3082 m_hWnd
= (WXHWND
)::CreateWindowEx
3086 title
? title
: wxEmptyString
,
3089 (HWND
)MSWGetParent(),
3092 NULL
// no extra data
3098 wxLogSysError(_("Can't create window of class %s"), wclass
);
3103 SubclassWin(m_hWnd
);
3105 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
3110 // ===========================================================================
3111 // MSW message handlers
3112 // ===========================================================================
3114 // ---------------------------------------------------------------------------
3116 // ---------------------------------------------------------------------------
3120 bool wxWindowMSW::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3122 #ifndef __WXMICROWIN__
3123 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3124 HWND hWnd
= hdr
->hwndFrom
;
3125 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3127 // if the control is one of our windows, let it handle the message itself
3130 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3133 // VZ: why did we do it? normally this is unnecessary and, besides, it
3134 // breaks the message processing for the toolbars because the tooltip
3135 // notifications were being forwarded to the toolbar child controls
3136 // (if it had any) before being passed to the toolbar itself, so in my
3137 // example the tooltip for the combobox was always shown instead of the
3138 // correct button tooltips
3140 // try all our children
3141 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3144 wxWindow
*child
= node
->GetData();
3145 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3150 node
= node
->GetNext();
3154 // by default, handle it ourselves
3155 return MSWOnNotify(idCtrl
, lParam
, result
);
3156 #else // __WXMICROWIN__
3163 bool wxWindowMSW::HandleTooltipNotify(WXUINT code
,
3165 const wxString
& ttip
)
3167 // I don't know why it happens, but the versions of comctl32.dll starting
3168 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3169 // this message is supposed to be sent to Unicode programs only) -- hence
3170 // we need to handle it as well, otherwise no tooltips will be shown in
3173 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
) || ttip
.empty() )
3175 // not a tooltip message or no tooltip to show anyhow
3180 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3183 if ( code
== (WXUINT
) TTN_NEEDTEXTA
)
3185 // we pass just the pointer as we store the string internally anyhow
3186 ttText
->lpszText
= (char *)ttip
.c_str();
3188 else // TTN_NEEDTEXTW
3192 // in Unicode mode this is just what we need
3193 ttText
->lpszText
= (wxChar
*)ttip
.c_str();
3196 MultiByteToWideChar(CP_ACP, 0, ttip, ttip.length()+1,
3197 (wchar_t *)ttText->szText,
3198 sizeof(ttText->szText) / sizeof(wchar_t));
3200 // Fix by dimitrishortcut: see patch 771772
3202 // FIXME: szText has a max of 80 bytes, so limit the tooltip string
3203 // length accordingly. Ideally lpszText should be used, but who
3204 // would be responsible for freeing the buffer?
3206 // Maximum length of a tip is 39 characters. 39 is 80/2 minus 1 byte
3207 // needed for NULL character.
3208 size_t tipLength
= wxMin(ttip
.Len(), 39);
3210 // Convert to WideChar without adding the NULL character. The NULL
3211 // character is added afterwards (Could have used ttip.Left(tipLength)
3212 // and a cchMultiByte parameter of tipLength+1, but this is more
3214 ::MultiByteToWideChar(CP_ACP
, 0, ttip
, tipLength
,
3215 (wchar_t *)ttText
->szText
,
3216 sizeof(ttText
->szText
) / sizeof(wchar_t));
3218 // Add the NULL character.
3219 ttText
->szText
[tipLength
*2+0] = '\0';
3220 ttText
->szText
[tipLength
*2+1] = '\0';
3222 #endif // Unicode/!Unicode
3228 #endif // wxUSE_TOOLTIPS
3230 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl
),
3232 WXLPARAM
* WXUNUSED(result
))
3237 NMHDR
* hdr
= (NMHDR
*)lParam
;
3238 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3244 #endif // wxUSE_TOOLTIPS
3251 // ---------------------------------------------------------------------------
3252 // end session messages
3253 // ---------------------------------------------------------------------------
3255 bool wxWindowMSW::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3258 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, -1);
3259 event
.SetEventObject(wxTheApp
);
3260 event
.SetCanVeto(TRUE
);
3261 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3263 bool rc
= wxTheApp
->ProcessEvent(event
);
3267 // we may end only if the app didn't veto session closing (double
3269 *mayEnd
= !event
.GetVeto();
3278 bool wxWindowMSW::HandleEndSession(bool endSession
, long logOff
)
3281 // do nothing if the session isn't ending
3286 if ( (this != wxTheApp
->GetTopWindow()) )
3289 wxCloseEvent
event(wxEVT_END_SESSION
, -1);
3290 event
.SetEventObject(wxTheApp
);
3291 event
.SetCanVeto(FALSE
);
3292 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3294 return wxTheApp
->ProcessEvent(event
);
3300 // ---------------------------------------------------------------------------
3301 // window creation/destruction
3302 // ---------------------------------------------------------------------------
3304 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs
, bool *mayCreate
)
3306 // VZ: why is this commented out for WinCE? If it doesn't support
3307 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3308 // not with multiple #ifdef's!
3310 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3311 EnsureParentHasControlParentStyle(GetParent());
3312 #endif // !__WXWINCE__
3314 // TODO: should generate this event from WM_NCCREATE
3315 wxWindowCreateEvent
event((wxWindow
*)this);
3316 (void)GetEventHandler()->ProcessEvent(event
);
3323 bool wxWindowMSW::HandleDestroy()
3327 // delete our drop target if we've got one
3328 #if wxUSE_DRAG_AND_DROP
3329 if ( m_dropTarget
!= NULL
)
3331 m_dropTarget
->Revoke(m_hWnd
);
3333 delete m_dropTarget
;
3334 m_dropTarget
= NULL
;
3336 #endif // wxUSE_DRAG_AND_DROP
3338 // WM_DESTROY handled
3342 // ---------------------------------------------------------------------------
3344 // ---------------------------------------------------------------------------
3346 bool wxWindowMSW::HandleActivate(int state
,
3347 bool WXUNUSED(minimized
),
3348 WXHWND
WXUNUSED(activate
))
3350 wxActivateEvent
event(wxEVT_ACTIVATE
,
3351 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3353 event
.SetEventObject(this);
3355 return GetEventHandler()->ProcessEvent(event
);
3358 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd
)
3360 // notify the parent keeping track of focus for the kbd navigation
3361 // purposes that we got it
3362 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3363 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3369 m_caret
->OnSetFocus();
3371 #endif // wxUSE_CARET
3374 // If it's a wxTextCtrl don't send the event as it will be done
3375 // after the control gets to process it from EN_FOCUS handler
3376 if ( wxDynamicCastThis(wxTextCtrl
) )
3380 #endif // wxUSE_TEXTCTRL
3382 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3383 event
.SetEventObject(this);
3385 // wxFindWinFromHandle() may return NULL, it is ok
3386 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3388 return GetEventHandler()->ProcessEvent(event
);
3391 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd
)
3397 m_caret
->OnKillFocus();
3399 #endif // wxUSE_CARET
3402 // If it's a wxTextCtrl don't send the event as it will be done
3403 // after the control gets to process it.
3404 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3411 // Don't send the event when in the process of being deleted. This can
3412 // only cause problems if the event handler tries to access the object.
3413 if ( m_isBeingDeleted
)
3418 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3419 event
.SetEventObject(this);
3421 // wxFindWinFromHandle() may return NULL, it is ok
3422 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3424 return GetEventHandler()->ProcessEvent(event
);
3427 // ---------------------------------------------------------------------------
3429 // ---------------------------------------------------------------------------
3431 bool wxWindowMSW::HandleShow(bool show
, int WXUNUSED(status
))
3433 wxShowEvent
event(GetId(), show
);
3434 event
.m_eventObject
= this;
3436 return GetEventHandler()->ProcessEvent(event
);
3439 bool wxWindowMSW::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3441 wxInitDialogEvent
event(GetId());
3442 event
.m_eventObject
= this;
3444 return GetEventHandler()->ProcessEvent(event
);
3447 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam
)
3449 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3451 #else // __WXMICROWIN__
3452 HDROP hFilesInfo
= (HDROP
) wParam
;
3454 // Get the total number of files dropped
3455 UINT gwFilesDropped
= ::DragQueryFile
3463 wxString
*files
= new wxString
[gwFilesDropped
];
3464 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3466 // first get the needed buffer length (+1 for terminating NUL)
3467 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3469 // and now get the file name
3470 ::DragQueryFile(hFilesInfo
, wIndex
,
3471 wxStringBuffer(files
[wIndex
], len
), len
);
3473 DragFinish (hFilesInfo
);
3475 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3476 event
.m_eventObject
= this;
3479 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3480 event
.m_pos
.x
= dropPoint
.x
;
3481 event
.m_pos
.y
= dropPoint
.y
;
3483 return GetEventHandler()->ProcessEvent(event
);
3488 bool wxWindowMSW::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3490 int WXUNUSED(mouseMsg
))
3492 #ifndef __WXMICROWIN__
3493 // the logic is as follows:
3494 // -1. don't set cursor for non client area, including but not limited to
3495 // the title bar, scrollbars, &c
3496 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3497 // 1. if we have the cursor set it unless wxIsBusy()
3498 // 2. if we're a top level window, set some cursor anyhow
3499 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3501 if ( nHitTest
!= HTCLIENT
)
3506 HCURSOR hcursor
= 0;
3508 // first ask the user code - it may wish to set the cursor in some very
3509 // specific way (for example, depending on the current position)
3511 if ( !::GetCursorPos(&pt
) )
3513 wxLogLastError(wxT("GetCursorPos"));
3518 ScreenToClient(&x
, &y
);
3519 wxSetCursorEvent
event(x
, y
);
3521 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3522 if ( processedEvtSetCursor
&& event
.HasCursor() )
3524 hcursor
= GetHcursorOf(event
.GetCursor());
3529 bool isBusy
= wxIsBusy();
3531 // the test for processedEvtSetCursor is here to prevent using m_cursor
3532 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3533 // it - this is a way to say that our cursor shouldn't be used for this
3535 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3537 hcursor
= GetHcursorOf(m_cursor
);
3544 hcursor
= wxGetCurrentBusyCursor();
3546 else if ( !hcursor
)
3548 const wxCursor
*cursor
= wxGetGlobalCursor();
3549 if ( cursor
&& cursor
->Ok() )
3551 hcursor
= GetHcursorOf(*cursor
);
3559 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3561 ::SetCursor(hcursor
);
3563 // cursor set, stop here
3566 #endif // __WXMICROWIN__
3568 // pass up the window chain
3572 // ---------------------------------------------------------------------------
3573 // owner drawn stuff
3574 // ---------------------------------------------------------------------------
3576 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3577 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3578 #define WXUNUSED_UNLESS_ODRAWN(param) param
3580 #define WXUNUSED_UNLESS_ODRAWN(param)
3584 wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3585 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3587 #if wxUSE_OWNER_DRAWN
3589 #if wxUSE_MENUS_NATIVE
3590 // is it a menu item?
3591 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3592 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3594 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3596 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3598 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3599 // the DC from being released
3600 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3601 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3602 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3603 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3605 return pMenuItem
->OnDrawItem
3609 (wxOwnerDrawn::wxODAction
)pDrawStruct
->itemAction
,
3610 (wxOwnerDrawn::wxODStatus
)pDrawStruct
->itemState
3613 #endif // wxUSE_MENUS_NATIVE
3615 #endif // USE_OWNER_DRAWN
3617 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3619 #if wxUSE_OWNER_DRAWN
3620 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3621 #else // !wxUSE_OWNER_DRAWN
3622 // we may still have owner-drawn buttons internally because we have to make
3623 // them owner-drawn to support colour change
3624 wxControl
*item
= wxDynamicCast(FindItem(id
), wxButton
);
3625 #endif // USE_OWNER_DRAWN
3629 return item
->MSWOnDraw(itemStruct
);
3632 #endif // wxUSE_CONTROLS
3638 wxWindowMSW::MSWOnMeasureItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3639 WXMEASUREITEMSTRUCT
*
3640 WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3642 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3643 // is it a menu item?
3644 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3645 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3647 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3649 wxCHECK( pMenuItem
->IsKindOf(CLASSINFO(wxMenuItem
)), FALSE
);
3651 return pMenuItem
->OnMeasureItem(&pMeasureStruct
->itemWidth
,
3652 &pMeasureStruct
->itemHeight
);
3655 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3658 return item
->MSWOnMeasure(itemStruct
);
3660 #endif // wxUSE_OWNER_DRAWN
3665 // ---------------------------------------------------------------------------
3666 // colours and palettes
3667 // ---------------------------------------------------------------------------
3669 bool wxWindowMSW::HandleSysColorChange()
3671 wxSysColourChangedEvent event
;
3672 event
.SetEventObject(this);
3674 (void)GetEventHandler()->ProcessEvent(event
);
3676 // always let the system carry on the default processing to allow the
3677 // native controls to react to the colours update
3681 bool wxWindowMSW::HandleDisplayChange()
3683 wxDisplayChangedEvent event
;
3684 event
.SetEventObject(this);
3686 return GetEventHandler()->ProcessEvent(event
);
3689 bool wxWindowMSW::HandleCtlColor(WXHBRUSH
*brush
,
3697 #ifndef __WXMICROWIN__
3698 WXHBRUSH hBrush
= 0;
3703 if ( nCtlColor
== CTLCOLOR_DLG
)
3706 hBrush
= OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3711 wxControl
*item
= (wxControl
*)FindItemByHWND(pWnd
, TRUE
);
3713 hBrush
= item
->OnCtlColor(pDC
, pWnd
, nCtlColor
, message
, wParam
, lParam
);
3715 #endif // wxUSE_CONTROLS
3721 #else // __WXMICROWIN__
3726 // Define for each class of dialog and control
3727 WXHBRUSH
wxWindowMSW::OnCtlColor(WXHDC
WXUNUSED(hDC
),
3728 WXHWND
WXUNUSED(hWnd
),
3729 WXUINT
WXUNUSED(nCtlColor
),
3730 WXUINT
WXUNUSED(message
),
3731 WXWPARAM
WXUNUSED(wParam
),
3732 WXLPARAM
WXUNUSED(lParam
))
3737 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange
)
3740 // same as below except we don't respond to our own messages
3741 if ( hWndPalChange
!= GetHWND() )
3743 // check to see if we our our parents have a custom palette
3744 wxWindowMSW
*win
= this;
3745 while ( win
&& !win
->HasCustomPalette() )
3747 win
= win
->GetParent();
3750 if ( win
&& win
->HasCustomPalette() )
3752 // realize the palette to see whether redrawing is needed
3753 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3754 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3755 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3757 int result
= ::RealizePalette(hdc
);
3759 // restore the palette (before releasing the DC)
3760 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3761 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3762 ::RealizePalette(hdc
);
3763 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3765 // now check for the need to redraw
3767 InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3771 #endif // wxUSE_PALETTE
3773 wxPaletteChangedEvent
event(GetId());
3774 event
.SetEventObject(this);
3775 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3777 return GetEventHandler()->ProcessEvent(event
);
3780 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3782 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3783 event
.SetEventObject(this);
3785 return GetEventHandler()->ProcessEvent(event
);
3788 bool wxWindowMSW::HandleQueryNewPalette()
3792 // check to see if we our our parents have a custom palette
3793 wxWindowMSW
*win
= this;
3794 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3795 if (win
->HasCustomPalette()) {
3796 /* realize the palette to see whether redrawing is needed */
3797 HDC hdc
= GetDC((HWND
) GetHWND());
3798 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3799 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3801 int result
= ::RealizePalette(hdc
);
3802 /* restore the palette (before releasing the DC) */
3803 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3804 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3805 ::RealizePalette(hdc
);
3806 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3807 /* now check for the need to redraw */
3809 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3811 #endif // wxUSE_PALETTE
3813 wxQueryNewPaletteEvent
event(GetId());
3814 event
.SetEventObject(this);
3816 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3819 // Responds to colour changes: passes event on to children.
3820 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3822 // the top level window also reset the standard colour map as it might have
3823 // changed (there is no need to do it for the non top level windows as we
3824 // only have to do it once)
3828 gs_hasStdCmap
= FALSE
;
3830 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
3833 // Only propagate to non-top-level windows because Windows already
3834 // sends this event to all top-level ones
3835 wxWindow
*win
= node
->GetData();
3836 if ( !win
->IsTopLevel() )
3838 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3839 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3840 // the standard controls
3841 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3844 node
= node
->GetNext();
3847 // update the colours we use if they were not set explicitly by the user:
3848 // this must be done or OnCtlColor() would continue to use the old colours
3851 m_foregroundColour
= wxSystemSettings::
3852 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT
);
3857 m_backgroundColour
= wxSystemSettings::
3858 GetSystemColour(wxSYS_COLOUR_BTNFACE
);
3862 extern wxCOLORMAP
*wxGetStdColourMap()
3864 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3865 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3867 if ( !gs_hasStdCmap
)
3869 static bool s_coloursInit
= FALSE
;
3871 if ( !s_coloursInit
)
3873 // When a bitmap is loaded, the RGB values can change (apparently
3874 // because Windows adjusts them to care for the old programs always
3875 // using 0xc0c0c0 while the transparent colour for the new Windows
3876 // versions is different). But we do this adjustment ourselves so
3877 // we want to avoid Windows' "help" and for this we need to have a
3878 // reference bitmap which can tell us what the RGB values change
3880 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3881 if ( stdColourBitmap
.Ok() )
3883 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3884 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3885 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3888 memDC
.SelectObject(stdColourBitmap
);
3891 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3893 memDC
.GetPixel(i
, 0, &colour
);
3894 s_stdColours
[i
] = wxColourToRGB(colour
);
3897 else // wxBITMAP_STD_COLOURS couldn't be loaded
3899 s_stdColours
[0] = RGB(000,000,000); // black
3900 s_stdColours
[1] = RGB(128,128,128); // dark grey
3901 s_stdColours
[2] = RGB(192,192,192); // light grey
3902 s_stdColours
[3] = RGB(255,255,255); // white
3903 //s_stdColours[4] = RGB(000,000,255); // blue
3904 //s_stdColours[5] = RGB(255,000,255); // magenta
3907 s_coloursInit
= TRUE
;
3910 gs_hasStdCmap
= TRUE
;
3912 // create the colour map
3913 #define INIT_CMAP_ENTRY(col) \
3914 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3915 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3917 INIT_CMAP_ENTRY(BTNTEXT
);
3918 INIT_CMAP_ENTRY(BTNSHADOW
);
3919 INIT_CMAP_ENTRY(BTNFACE
);
3920 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3922 #undef INIT_CMAP_ENTRY
3928 // ---------------------------------------------------------------------------
3930 // ---------------------------------------------------------------------------
3932 bool wxWindowMSW::HandlePaint()
3934 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3937 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3939 wxLogLastError(wxT("CreateRectRgn"));
3940 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3941 wxLogLastError(wxT("GetUpdateRgn"));
3943 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3945 wxPaintEvent
event(m_windowId
);
3946 event
.SetEventObject(this);
3948 bool processed
= GetEventHandler()->ProcessEvent(event
);
3950 // note that we must generate NC event after the normal one as otherwise
3951 // BeginPaint() will happily overwrite our decorations with the background
3953 wxNcPaintEvent
eventNc(m_windowId
);
3954 eventNc
.SetEventObject(this);
3955 GetEventHandler()->ProcessEvent(eventNc
);
3960 // Can be called from an application's OnPaint handler
3961 void wxWindowMSW::OnPaint(wxPaintEvent
& event
)
3963 #ifdef __WXUNIVERSAL__
3966 HDC hDC
= (HDC
) wxPaintDC::FindDCInCache((wxWindow
*) event
.GetEventObject());
3969 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3974 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc
)
3976 // Prevents flicker when dragging
3977 if ( ::IsIconic(GetHwnd()) )
3981 if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3986 if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND
)
3988 if (wxUxThemeEngine::Get())
3990 WXHTHEME hTheme
= wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L
"TAB");
3994 ::GetClientRect((HWND
) GetHWND(), (RECT
*) & rect
);
3995 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme
, hdc
, 10 /* TABP_BODY */, 0, &rect
, &rect
);
3996 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme
);
4006 dc
.SetWindow((wxWindow
*)this);
4009 wxEraseEvent
event(m_windowId
, &dc
);
4010 event
.SetEventObject(this);
4011 bool rc
= GetEventHandler()->ProcessEvent(event
);
4015 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4016 dc
.SelectOldObjects(hdc
);
4021 void wxWindowMSW::OnEraseBackground(wxEraseEvent
& event
)
4024 ::GetClientRect(GetHwnd(), &rect
);
4026 COLORREF ref
= PALETTERGB(m_backgroundColour
.Red(),
4027 m_backgroundColour
.Green(),
4028 m_backgroundColour
.Blue());
4029 HBRUSH hBrush
= ::CreateSolidBrush(ref
);
4031 wxLogLastError(wxT("CreateSolidBrush"));
4033 HDC hdc
= (HDC
)event
.GetDC()->GetHDC();
4036 int mode
= ::SetMapMode(hdc
, MM_TEXT
);
4039 ::FillRect(hdc
, &rect
, hBrush
);
4040 ::DeleteObject(hBrush
);
4043 ::SetMapMode(hdc
, mode
);
4047 // ---------------------------------------------------------------------------
4048 // moving and resizing
4049 // ---------------------------------------------------------------------------
4051 bool wxWindowMSW::HandleMinimize()
4053 wxIconizeEvent
event(m_windowId
);
4054 event
.SetEventObject(this);
4056 return GetEventHandler()->ProcessEvent(event
);
4059 bool wxWindowMSW::HandleMaximize()
4061 wxMaximizeEvent
event(m_windowId
);
4062 event
.SetEventObject(this);
4064 return GetEventHandler()->ProcessEvent(event
);
4067 bool wxWindowMSW::HandleMove(int x
, int y
)
4069 wxMoveEvent
event(wxPoint(x
, y
), m_windowId
);
4070 event
.SetEventObject(this);
4072 return GetEventHandler()->ProcessEvent(event
);
4075 bool wxWindowMSW::HandleMoving(wxRect
& rect
)
4077 wxMoveEvent
event(rect
, m_windowId
);
4078 event
.SetEventObject(this);
4080 bool rc
= GetEventHandler()->ProcessEvent(event
);
4082 rect
= event
.GetRect();
4086 bool wxWindowMSW::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
),
4087 WXUINT
WXUNUSED(flag
))
4089 // don't use w and h parameters as they specify the client size while
4090 // according to the docs EVT_SIZE handler is supposed to receive the total
4092 wxSizeEvent
event(GetSize(), m_windowId
);
4093 event
.SetEventObject(this);
4095 return GetEventHandler()->ProcessEvent(event
);
4098 bool wxWindowMSW::HandleSizing(wxRect
& rect
)
4100 wxSizeEvent
event(rect
, m_windowId
);
4101 event
.SetEventObject(this);
4103 bool rc
= GetEventHandler()->ProcessEvent(event
);
4105 rect
= event
.GetRect();
4109 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo
)
4114 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4118 int minWidth
= GetMinWidth(),
4119 minHeight
= GetMinHeight(),
4120 maxWidth
= GetMaxWidth(),
4121 maxHeight
= GetMaxHeight();
4123 if ( minWidth
!= -1 )
4125 info
->ptMinTrackSize
.x
= minWidth
;
4129 if ( minHeight
!= -1 )
4131 info
->ptMinTrackSize
.y
= minHeight
;
4135 if ( maxWidth
!= -1 )
4137 info
->ptMaxTrackSize
.x
= maxWidth
;
4141 if ( maxHeight
!= -1 )
4143 info
->ptMaxTrackSize
.y
= maxHeight
;
4151 // ---------------------------------------------------------------------------
4153 // ---------------------------------------------------------------------------
4155 bool wxWindowMSW::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4157 #if wxUSE_MENUS_NATIVE
4158 if ( !cmd
&& wxCurrentPopupMenu
)
4160 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4161 wxCurrentPopupMenu
= NULL
;
4163 return popupMenu
->MSWCommand(cmd
, id
);
4165 #endif // wxUSE_MENUS_NATIVE
4167 wxWindow
*win
= NULL
;
4169 // first try to find it from HWND - this works even with the broken
4170 // programs using the same ids for different controls
4173 win
= wxFindWinFromHandle(control
);
4179 // must cast to a signed type before comparing with other ids!
4180 win
= FindItem((signed short)id
);
4185 return win
->MSWCommand(cmd
, id
);
4188 // the messages sent from the in-place edit control used by the treectrl
4189 // for label editing have id == 0, but they should _not_ be treated as menu
4190 // messages (they are EN_XXX ones, in fact) so don't translate anything
4191 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4194 // If no child window, it may be an accelerator, e.g. for a popup menu
4197 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4198 event
.SetEventObject(this);
4202 return GetEventHandler()->ProcessEvent(event
);
4204 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4207 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4208 // notifications to its parent which we want to reflect back to
4210 wxSpinCtrl
*spin
= wxSpinCtrl::GetSpinForTextCtrl(control
);
4211 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4214 #endif // wxUSE_SPINCTRL
4219 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam
, WXLPARAM
WXUNUSED(lParam
))
4222 // 4 bits are reserved
4223 switch ( wParam
& 0xFFFFFFF0 )
4226 return HandleMaximize();
4229 return HandleMinimize();
4236 // ---------------------------------------------------------------------------
4238 // ---------------------------------------------------------------------------
4240 void wxWindowMSW::InitMouseEvent(wxMouseEvent
& event
,
4244 // our client coords are not quite the same as Windows ones
4245 wxPoint pt
= GetClientAreaOrigin();
4246 event
.m_x
= x
- pt
.x
;
4247 event
.m_y
= y
- pt
.y
;
4249 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4250 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4251 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4252 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4253 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4254 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4255 // Returns different negative values on WinME and WinNT,
4256 // so simply test for negative value.
4257 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4260 event
.SetTimestamp(::GetMessageTime());
4263 event
.m_eventObject
= this;
4264 event
.SetId(GetId());
4266 #if wxUSE_MOUSEEVENT_HACK
4269 m_lastMouseEvent
= event
.GetEventType();
4270 #endif // wxUSE_MOUSEEVENT_HACK
4273 // Windows doesn't send the mouse events to the static controls (which are
4274 // transparent in the sense that their WM_NCHITTEST handler returns
4275 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4276 // and so we manually check if we don't have a child window under mouse and if
4277 // we do, send the event to it instead of the window Windows had sent WM_XXX
4280 // Notice that this is not done for the mouse move events because this could
4281 // (would?) be too slow, but only for clicks which means that the static texts
4282 // still don't get move, enter nor leave events.
4283 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4285 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4287 // first try to find a non transparent child: this allows us to send events
4288 // to a static text which is inside a static box, for example
4289 POINT pt
= { *x
, *y
};
4290 HWND hwnd
= GetHwndOf(win
),
4294 hwndUnderMouse
= ::ChildWindowFromPoint
4300 hwndUnderMouse
= ::ChildWindowFromPointEx
4310 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4312 // now try any child window at all
4313 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4316 // check that we have a child window which is susceptible to receive mouse
4317 // events: for this it must be shown and enabled
4318 if ( hwndUnderMouse
&&
4319 hwndUnderMouse
!= hwnd
&&
4320 ::IsWindowVisible(hwndUnderMouse
) &&
4321 ::IsWindowEnabled(hwndUnderMouse
) )
4323 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4324 if ( winUnderMouse
)
4326 // translate the mouse coords to the other window coords
4327 win
->ClientToScreen(x
, y
);
4328 winUnderMouse
->ScreenToClient(x
, y
);
4330 win
= winUnderMouse
;
4337 bool wxWindowMSW::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4339 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4340 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4341 // from the message id and take the value in the table to get wxWin event
4343 static const wxEventType eventsMouse
[] =
4357 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4358 InitMouseEvent(event
, x
, y
, flags
);
4360 return GetEventHandler()->ProcessEvent(event
);
4363 bool wxWindowMSW::HandleMouseMove(int x
, int y
, WXUINT flags
)
4365 if ( !m_mouseInWindow
)
4367 // it would be wrong to assume that just because we get a mouse move
4368 // event that the mouse is inside the window: although this is usually
4369 // true, it is not if we had captured the mouse, so we need to check
4370 // the mouse coordinates here
4371 if ( !HasCapture() || IsMouseInWindow() )
4373 // Generate an ENTER event
4374 m_mouseInWindow
= TRUE
;
4375 #if _WIN32_WINNT >= 0x0400
4377 TRACKMOUSEEVENT trackinfo
;
4379 trackinfo
.cbSize
= sizeof(trackinfo
);
4380 trackinfo
.dwFlags
= TME_LEAVE
;
4381 trackinfo
.hwndTrack
= GetHwnd();
4382 //Use the commctrl.h _TrackMouseEvent, which will call the
4383 // appropriate TrackMouseEvent or emulate it ( win95 )
4384 // else we need _WIN32_WINNT >= 0x0400
4385 _TrackMouseEvent(&trackinfo
);
4388 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4389 InitMouseEvent(event
, x
, y
, flags
);
4391 (void)GetEventHandler()->ProcessEvent(event
);
4395 #if wxUSE_MOUSEEVENT_HACK
4396 // Window gets a click down message followed by a mouse move message even
4397 // if position isn't changed! We want to discard the trailing move event
4398 // if x and y are the same.
4399 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4400 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4401 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4402 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4404 m_lastMouseEvent
= wxEVT_MOTION
;
4408 #endif // wxUSE_MOUSEEVENT_HACK
4410 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4414 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4416 #if wxUSE_MOUSEWHEEL
4417 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4418 InitMouseEvent(event
,
4419 GET_X_LPARAM(lParam
),
4420 GET_Y_LPARAM(lParam
),
4422 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4423 event
.m_wheelDelta
= WHEEL_DELTA
;
4425 static int s_linesPerRotation
= -1;
4426 if ( s_linesPerRotation
== -1 )
4428 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4429 &s_linesPerRotation
, 0))
4431 // this is not supposed to happen
4432 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4434 // the default is 3, so use it if SystemParametersInfo() failed
4435 s_linesPerRotation
= 3;
4439 event
.m_linesPerAction
= s_linesPerRotation
;
4440 return GetEventHandler()->ProcessEvent(event
);
4451 // ---------------------------------------------------------------------------
4452 // keyboard handling
4453 // ---------------------------------------------------------------------------
4455 // create the key event of the given type for the given key - used by
4456 // HandleChar and HandleKeyDown/Up
4457 wxKeyEvent
wxWindowMSW::CreateKeyEvent(wxEventType evType
,
4460 WXWPARAM wParam
) const
4462 wxKeyEvent
event(evType
);
4463 event
.SetId(GetId());
4464 event
.m_shiftDown
= wxIsShiftDown();
4465 event
.m_controlDown
= wxIsCtrlDown();
4466 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4468 event
.m_eventObject
= (wxWindow
*)this; // const_cast
4469 event
.m_keyCode
= id
;
4470 event
.m_rawCode
= (wxUint32
) wParam
;
4471 event
.m_rawFlags
= (wxUint32
) lParam
;
4473 event
.SetTimestamp(::GetMessageTime());
4476 // translate the position to client coords
4480 GetWindowRect(GetHwnd(),&rect
);
4490 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4492 bool wxWindowMSW::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4497 // If 1 -> 26, translate to either special keycode or just set
4498 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4499 // ControlDown() == TRUE.
4501 if ( (id
> 0) && (id
< 27) )
4523 else // we're called from WM_KEYDOWN
4525 id
= wxCharCodeMSWToWX(wParam
);
4528 // it's ASCII and will be processed here only when called from
4529 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4534 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4536 // the alphanumeric keys produced by pressing AltGr+something on European
4537 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4538 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4539 // alphanumeric, so pretend that there are no modifiers at all (the
4540 // KEY_DOWN event would still have the correct modifiers if they're really
4542 if ( event
.m_controlDown
&& event
.m_altDown
&&
4543 (id
>= 32 && id
< 256) )
4545 event
.m_controlDown
=
4546 event
.m_altDown
= FALSE
;
4549 return GetEventHandler()->ProcessEvent(event
);
4552 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4554 int id
= wxCharCodeMSWToWX(wParam
);
4558 // normal ASCII char
4562 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4564 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4565 if ( GetEventHandler()->ProcessEvent(event
) )
4574 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4576 int id
= wxCharCodeMSWToWX(wParam
);
4580 // normal ASCII char
4584 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4586 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4587 if ( GetEventHandler()->ProcessEvent(event
) )
4594 int wxWindowMSW::HandleMenuChar(int chAccel
, WXLPARAM lParam
)
4596 // FIXME: implement GetMenuItemCount for WinCE, possibly
4597 // in terms of GetMenuItemInfo
4599 const HMENU hmenu
= (HMENU
)lParam
;
4603 mii
.cbSize
= sizeof(MENUITEMINFO
);
4604 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4606 // find if we have this letter in any owner drawn item
4607 const int count
= ::GetMenuItemCount(hmenu
);
4608 for ( int i
= 0; i
< count
; i
++ )
4610 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4612 if ( mii
.fType
== MFT_OWNERDRAW
)
4614 // dwItemData member of the MENUITEMINFO is a
4615 // pointer to the associated wxMenuItem -- see the
4616 // menu creation code
4617 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4619 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4622 if ( *p
== _T('&') )
4624 // this is not the accel char, find the real one
4625 p
= wxStrchr(p
+ 1, _T('&'));
4627 else // got the accel char
4629 // FIXME-UNICODE: this comparison doesn't risk to work
4630 // for non ASCII accelerator characters I'm afraid, but
4632 if ( wxToupper(*p
) == chAccel
)
4638 // this one doesn't match
4645 else // failed to get the menu text?
4647 // it's not fatal, so don't show error, but still log
4649 wxLogLastError(_T("GetMenuItemInfo"));
4656 // ---------------------------------------------------------------------------
4658 // ---------------------------------------------------------------------------
4660 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4664 if ( flags
& JOY_BUTTON1CHG
)
4665 change
= wxJOY_BUTTON1
;
4666 if ( flags
& JOY_BUTTON2CHG
)
4667 change
= wxJOY_BUTTON2
;
4668 if ( flags
& JOY_BUTTON3CHG
)
4669 change
= wxJOY_BUTTON3
;
4670 if ( flags
& JOY_BUTTON4CHG
)
4671 change
= wxJOY_BUTTON4
;
4674 if ( flags
& JOY_BUTTON1
)
4675 buttons
|= wxJOY_BUTTON1
;
4676 if ( flags
& JOY_BUTTON2
)
4677 buttons
|= wxJOY_BUTTON2
;
4678 if ( flags
& JOY_BUTTON3
)
4679 buttons
|= wxJOY_BUTTON3
;
4680 if ( flags
& JOY_BUTTON4
)
4681 buttons
|= wxJOY_BUTTON4
;
4683 // the event ids aren't consecutive so we can't use table based lookup
4685 wxEventType eventType
;
4690 eventType
= wxEVT_JOY_MOVE
;
4695 eventType
= wxEVT_JOY_MOVE
;
4700 eventType
= wxEVT_JOY_ZMOVE
;
4705 eventType
= wxEVT_JOY_ZMOVE
;
4708 case MM_JOY1BUTTONDOWN
:
4710 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4713 case MM_JOY2BUTTONDOWN
:
4715 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4718 case MM_JOY1BUTTONUP
:
4720 eventType
= wxEVT_JOY_BUTTON_UP
;
4723 case MM_JOY2BUTTONUP
:
4725 eventType
= wxEVT_JOY_BUTTON_UP
;
4729 wxFAIL_MSG(wxT("no such joystick event"));
4734 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4735 event
.SetPosition(wxPoint(x
, y
));
4736 event
.SetEventObject(this);
4738 return GetEventHandler()->ProcessEvent(event
);
4744 // ---------------------------------------------------------------------------
4746 // ---------------------------------------------------------------------------
4748 bool wxWindowMSW::MSWOnScroll(int orientation
, WXWORD wParam
,
4749 WXWORD pos
, WXHWND control
)
4753 wxWindow
*child
= wxFindWinFromHandle(control
);
4755 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4758 wxScrollWinEvent event
;
4759 event
.SetPosition(pos
);
4760 event
.SetOrientation(orientation
);
4761 event
.m_eventObject
= this;
4766 event
.m_eventType
= wxEVT_SCROLLWIN_TOP
;
4770 event
.m_eventType
= wxEVT_SCROLLWIN_BOTTOM
;
4774 event
.m_eventType
= wxEVT_SCROLLWIN_LINEUP
;
4778 event
.m_eventType
= wxEVT_SCROLLWIN_LINEDOWN
;
4782 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEUP
;
4786 event
.m_eventType
= wxEVT_SCROLLWIN_PAGEDOWN
;
4789 case SB_THUMBPOSITION
:
4791 // under Win32, the scrollbar range and position are 32 bit integers,
4792 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4793 // explicitly query the scrollbar for the correct position (this must
4794 // be done only for these two SB_ events as they are the only one
4795 // carrying the scrollbar position)
4797 WinStruct
<SCROLLINFO
> scrollInfo
;
4798 scrollInfo
.fMask
= SIF_TRACKPOS
;
4800 if ( !::GetScrollInfo(GetHwnd(),
4801 orientation
== wxHORIZONTAL
? SB_HORZ
4805 // Not neccessarily an error, if there are no scrollbars yet.
4806 // wxLogLastError(_T("GetScrollInfo"));
4809 event
.SetPosition(scrollInfo
.nTrackPos
);
4812 event
.m_eventType
= wParam
== SB_THUMBPOSITION
4813 ? wxEVT_SCROLLWIN_THUMBRELEASE
4814 : wxEVT_SCROLLWIN_THUMBTRACK
;
4821 return GetEventHandler()->ProcessEvent(event
);
4824 // ===========================================================================
4826 // ===========================================================================
4828 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
*the_font
)
4831 HDC dc
= ::GetDC((HWND
) wnd
);
4836 // the_font->UseResource();
4837 // the_font->RealizeResource();
4838 fnt
= (HFONT
)((wxFont
*)the_font
)->GetResourceHandle(); // const_cast
4840 was
= (HFONT
) SelectObject(dc
,fnt
);
4842 GetTextMetrics(dc
, &tm
);
4843 if ( the_font
&& fnt
&& was
)
4845 SelectObject(dc
,was
);
4847 ReleaseDC((HWND
)wnd
, dc
);
4850 *x
= tm
.tmAveCharWidth
;
4852 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
4855 // the_font->ReleaseResource();
4858 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4859 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4860 int wxCharCodeMSWToWX(int keySym
)
4865 case VK_CANCEL
: id
= WXK_CANCEL
; break;
4866 case VK_BACK
: id
= WXK_BACK
; break;
4867 case VK_TAB
: id
= WXK_TAB
; break;
4868 case VK_CLEAR
: id
= WXK_CLEAR
; break;
4869 case VK_RETURN
: id
= WXK_RETURN
; break;
4870 case VK_SHIFT
: id
= WXK_SHIFT
; break;
4871 case VK_CONTROL
: id
= WXK_CONTROL
; break;
4872 case VK_MENU
: id
= WXK_MENU
; break;
4873 case VK_PAUSE
: id
= WXK_PAUSE
; break;
4874 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
4875 case VK_SPACE
: id
= WXK_SPACE
; break;
4876 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
4877 case VK_PRIOR
: id
= WXK_PRIOR
; break;
4878 case VK_NEXT
: id
= WXK_NEXT
; break;
4879 case VK_END
: id
= WXK_END
; break;
4880 case VK_HOME
: id
= WXK_HOME
; break;
4881 case VK_LEFT
: id
= WXK_LEFT
; break;
4882 case VK_UP
: id
= WXK_UP
; break;
4883 case VK_RIGHT
: id
= WXK_RIGHT
; break;
4884 case VK_DOWN
: id
= WXK_DOWN
; break;
4885 case VK_SELECT
: id
= WXK_SELECT
; break;
4886 case VK_PRINT
: id
= WXK_PRINT
; break;
4887 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
4888 case VK_INSERT
: id
= WXK_INSERT
; break;
4889 case VK_DELETE
: id
= WXK_DELETE
; break;
4890 case VK_HELP
: id
= WXK_HELP
; break;
4891 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
4892 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
4893 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
4894 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
4895 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
4896 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
4897 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
4898 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
4899 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
4900 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
4901 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
4902 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
4903 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
4904 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
4905 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
4906 case VK_F1
: id
= WXK_F1
; break;
4907 case VK_F2
: id
= WXK_F2
; break;
4908 case VK_F3
: id
= WXK_F3
; break;
4909 case VK_F4
: id
= WXK_F4
; break;
4910 case VK_F5
: id
= WXK_F5
; break;
4911 case VK_F6
: id
= WXK_F6
; break;
4912 case VK_F7
: id
= WXK_F7
; break;
4913 case VK_F8
: id
= WXK_F8
; break;
4914 case VK_F9
: id
= WXK_F9
; break;
4915 case VK_F10
: id
= WXK_F10
; break;
4916 case VK_F11
: id
= WXK_F11
; break;
4917 case VK_F12
: id
= WXK_F12
; break;
4918 case VK_F13
: id
= WXK_F13
; break;
4919 case VK_F14
: id
= WXK_F14
; break;
4920 case VK_F15
: id
= WXK_F15
; break;
4921 case VK_F16
: id
= WXK_F16
; break;
4922 case VK_F17
: id
= WXK_F17
; break;
4923 case VK_F18
: id
= WXK_F18
; break;
4924 case VK_F19
: id
= WXK_F19
; break;
4925 case VK_F20
: id
= WXK_F20
; break;
4926 case VK_F21
: id
= WXK_F21
; break;
4927 case VK_F22
: id
= WXK_F22
; break;
4928 case VK_F23
: id
= WXK_F23
; break;
4929 case VK_F24
: id
= WXK_F24
; break;
4930 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
4931 case VK_SCROLL
: id
= WXK_SCROLL
; break;
4933 case VK_OEM_1
: id
= ';'; break;
4934 case VK_OEM_PLUS
: id
= '+'; break;
4935 case VK_OEM_COMMA
: id
= ','; break;
4936 case VK_OEM_MINUS
: id
= '-'; break;
4937 case VK_OEM_PERIOD
: id
= '.'; break;
4938 case VK_OEM_2
: id
= '/'; break;
4939 case VK_OEM_3
: id
= '~'; break;
4940 case VK_OEM_4
: id
= '['; break;
4941 case VK_OEM_5
: id
= '\\'; break;
4942 case VK_OEM_6
: id
= ']'; break;
4943 case VK_OEM_7
: id
= '\''; break;
4946 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
4947 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
4948 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
4949 #endif // VK_APPS defined
4958 int wxCharCodeWXToMSW(int id
, bool *isVirtual
)
4964 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
4965 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
4966 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
4967 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
4968 case WXK_MENU
: keySym
= VK_MENU
; break;
4969 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
4970 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
4971 case WXK_NEXT
: keySym
= VK_NEXT
; break;
4972 case WXK_END
: keySym
= VK_END
; break;
4973 case WXK_HOME
: keySym
= VK_HOME
; break;
4974 case WXK_LEFT
: keySym
= VK_LEFT
; break;
4975 case WXK_UP
: keySym
= VK_UP
; break;
4976 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
4977 case WXK_DOWN
: keySym
= VK_DOWN
; break;
4978 case WXK_SELECT
: keySym
= VK_SELECT
; break;
4979 case WXK_PRINT
: keySym
= VK_PRINT
; break;
4980 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
4981 case WXK_INSERT
: keySym
= VK_INSERT
; break;
4982 case WXK_DELETE
: keySym
= VK_DELETE
; break;
4983 case WXK_HELP
: keySym
= VK_HELP
; break;
4984 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
4985 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
4986 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
4987 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
4988 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
4989 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
4990 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
4991 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
4992 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
4993 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
4994 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
4995 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
4996 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
4997 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
4998 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
4999 case WXK_F1
: keySym
= VK_F1
; break;
5000 case WXK_F2
: keySym
= VK_F2
; break;
5001 case WXK_F3
: keySym
= VK_F3
; break;
5002 case WXK_F4
: keySym
= VK_F4
; break;
5003 case WXK_F5
: keySym
= VK_F5
; break;
5004 case WXK_F6
: keySym
= VK_F6
; break;
5005 case WXK_F7
: keySym
= VK_F7
; break;
5006 case WXK_F8
: keySym
= VK_F8
; break;
5007 case WXK_F9
: keySym
= VK_F9
; break;
5008 case WXK_F10
: keySym
= VK_F10
; break;
5009 case WXK_F11
: keySym
= VK_F11
; break;
5010 case WXK_F12
: keySym
= VK_F12
; break;
5011 case WXK_F13
: keySym
= VK_F13
; break;
5012 case WXK_F14
: keySym
= VK_F14
; break;
5013 case WXK_F15
: keySym
= VK_F15
; break;
5014 case WXK_F16
: keySym
= VK_F16
; break;
5015 case WXK_F17
: keySym
= VK_F17
; break;
5016 case WXK_F18
: keySym
= VK_F18
; break;
5017 case WXK_F19
: keySym
= VK_F19
; break;
5018 case WXK_F20
: keySym
= VK_F20
; break;
5019 case WXK_F21
: keySym
= VK_F21
; break;
5020 case WXK_F22
: keySym
= VK_F22
; break;
5021 case WXK_F23
: keySym
= VK_F23
; break;
5022 case WXK_F24
: keySym
= VK_F24
; break;
5023 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5024 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5035 bool wxGetKeyState(wxKeyCode key
)
5038 int vkey
= wxCharCodeWXToMSW(key
, &bVirtual
);
5040 //there aren't WXK_ macros for non-virtual key codes
5041 if (bVirtual
== false)
5044 return GetKeyState(vkey
) < 0;
5047 wxWindow
*wxGetActiveWindow()
5049 HWND hWnd
= GetActiveWindow();
5052 return wxFindWinFromHandle((WXHWND
) hWnd
);
5057 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5059 HWND hwnd
= (HWND
)hWnd
;
5061 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5062 // by code in msw/radiobox.cpp), for all the others we just search up the
5064 wxWindow
*win
= (wxWindow
*)NULL
;
5067 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5071 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5072 // wxWindow class which overrides WM_GETDLGCODE processing to
5073 // do it as well, win would be already non NULL
5074 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5076 win
= (wxWindow
*)::GetWindowLong(hwnd
, GWL_USERDATA
);
5078 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5079 #endif // wxUSE_RADIOBOX
5081 // spin control text buddy window should be mapped to spin ctrl
5082 // itself so try it too
5083 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5086 win
= wxSpinCtrl::GetSpinForTextCtrl((WXHWND
)hwnd
);
5088 #endif // wxUSE_SPINCTRL
5092 while ( hwnd
&& !win
)
5094 // this is a really ugly hack needed to avoid mistakenly returning the
5095 // parent frame wxWindow for the find/replace modeless dialog HWND -
5096 // this, in turn, is needed to call IsDialogMessage() from
5097 // wxApp::ProcessMessage() as for this we must return NULL from here
5099 // FIXME: this is clearly not the best way to do it but I think we'll
5100 // need to change HWND <-> wxWindow code more heavily than I can
5101 // do it now to fix it
5102 #ifndef __WXMICROWIN__
5103 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5105 // it's a dialog box, don't go upwards
5110 hwnd
= ::GetParent(hwnd
);
5111 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5117 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5119 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5120 // in active frames and dialogs, regardless of where the focus is.
5121 static HHOOK wxTheKeyboardHook
= 0;
5122 static FARPROC wxTheKeyboardHookProc
= 0;
5123 int APIENTRY _EXPORT
5124 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5126 void wxSetKeyboardHook(bool doIt
)
5130 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5131 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5133 GetCurrentThreadId()
5134 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5139 UnhookWindowsHookEx(wxTheKeyboardHook
);
5143 int APIENTRY _EXPORT
5144 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5146 DWORD hiWord
= HIWORD(lParam
);
5147 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5149 int id
= wxCharCodeMSWToWX(wParam
);
5152 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5153 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5154 event
.m_altDown
= TRUE
;
5156 event
.m_eventObject
= NULL
;
5157 event
.m_keyCode
= id
;
5158 event
.m_shiftDown
= wxIsShiftDown();
5159 event
.m_controlDown
= wxIsCtrlDown();
5161 event
.SetTimestamp(::GetMessageTime());
5163 wxWindow
*win
= wxGetActiveWindow();
5164 wxEvtHandler
*handler
;
5167 handler
= win
->GetEventHandler();
5168 event
.SetId(win
->GetId());
5176 if ( handler
&& handler
->ProcessEvent(event
) )
5184 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5187 #endif // !__WXMICROWIN__
5190 const char *wxGetMessageName(int message
)
5194 case 0x0000: return "WM_NULL";
5195 case 0x0001: return "WM_CREATE";
5196 case 0x0002: return "WM_DESTROY";
5197 case 0x0003: return "WM_MOVE";
5198 case 0x0005: return "WM_SIZE";
5199 case 0x0006: return "WM_ACTIVATE";
5200 case 0x0007: return "WM_SETFOCUS";
5201 case 0x0008: return "WM_KILLFOCUS";
5202 case 0x000A: return "WM_ENABLE";
5203 case 0x000B: return "WM_SETREDRAW";
5204 case 0x000C: return "WM_SETTEXT";
5205 case 0x000D: return "WM_GETTEXT";
5206 case 0x000E: return "WM_GETTEXTLENGTH";
5207 case 0x000F: return "WM_PAINT";
5208 case 0x0010: return "WM_CLOSE";
5209 case 0x0011: return "WM_QUERYENDSESSION";
5210 case 0x0012: return "WM_QUIT";
5211 case 0x0013: return "WM_QUERYOPEN";
5212 case 0x0014: return "WM_ERASEBKGND";
5213 case 0x0015: return "WM_SYSCOLORCHANGE";
5214 case 0x0016: return "WM_ENDSESSION";
5215 case 0x0017: return "WM_SYSTEMERROR";
5216 case 0x0018: return "WM_SHOWWINDOW";
5217 case 0x0019: return "WM_CTLCOLOR";
5218 case 0x001A: return "WM_WININICHANGE";
5219 case 0x001B: return "WM_DEVMODECHANGE";
5220 case 0x001C: return "WM_ACTIVATEAPP";
5221 case 0x001D: return "WM_FONTCHANGE";
5222 case 0x001E: return "WM_TIMECHANGE";
5223 case 0x001F: return "WM_CANCELMODE";
5224 case 0x0020: return "WM_SETCURSOR";
5225 case 0x0021: return "WM_MOUSEACTIVATE";
5226 case 0x0022: return "WM_CHILDACTIVATE";
5227 case 0x0023: return "WM_QUEUESYNC";
5228 case 0x0024: return "WM_GETMINMAXINFO";
5229 case 0x0026: return "WM_PAINTICON";
5230 case 0x0027: return "WM_ICONERASEBKGND";
5231 case 0x0028: return "WM_NEXTDLGCTL";
5232 case 0x002A: return "WM_SPOOLERSTATUS";
5233 case 0x002B: return "WM_DRAWITEM";
5234 case 0x002C: return "WM_MEASUREITEM";
5235 case 0x002D: return "WM_DELETEITEM";
5236 case 0x002E: return "WM_VKEYTOITEM";
5237 case 0x002F: return "WM_CHARTOITEM";
5238 case 0x0030: return "WM_SETFONT";
5239 case 0x0031: return "WM_GETFONT";
5240 case 0x0037: return "WM_QUERYDRAGICON";
5241 case 0x0039: return "WM_COMPAREITEM";
5242 case 0x0041: return "WM_COMPACTING";
5243 case 0x0044: return "WM_COMMNOTIFY";
5244 case 0x0046: return "WM_WINDOWPOSCHANGING";
5245 case 0x0047: return "WM_WINDOWPOSCHANGED";
5246 case 0x0048: return "WM_POWER";
5248 case 0x004A: return "WM_COPYDATA";
5249 case 0x004B: return "WM_CANCELJOURNAL";
5250 case 0x004E: return "WM_NOTIFY";
5251 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5252 case 0x0051: return "WM_INPUTLANGCHANGE";
5253 case 0x0052: return "WM_TCARD";
5254 case 0x0053: return "WM_HELP";
5255 case 0x0054: return "WM_USERCHANGED";
5256 case 0x0055: return "WM_NOTIFYFORMAT";
5257 case 0x007B: return "WM_CONTEXTMENU";
5258 case 0x007C: return "WM_STYLECHANGING";
5259 case 0x007D: return "WM_STYLECHANGED";
5260 case 0x007E: return "WM_DISPLAYCHANGE";
5261 case 0x007F: return "WM_GETICON";
5262 case 0x0080: return "WM_SETICON";
5264 case 0x0081: return "WM_NCCREATE";
5265 case 0x0082: return "WM_NCDESTROY";
5266 case 0x0083: return "WM_NCCALCSIZE";
5267 case 0x0084: return "WM_NCHITTEST";
5268 case 0x0085: return "WM_NCPAINT";
5269 case 0x0086: return "WM_NCACTIVATE";
5270 case 0x0087: return "WM_GETDLGCODE";
5271 case 0x00A0: return "WM_NCMOUSEMOVE";
5272 case 0x00A1: return "WM_NCLBUTTONDOWN";
5273 case 0x00A2: return "WM_NCLBUTTONUP";
5274 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5275 case 0x00A4: return "WM_NCRBUTTONDOWN";
5276 case 0x00A5: return "WM_NCRBUTTONUP";
5277 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5278 case 0x00A7: return "WM_NCMBUTTONDOWN";
5279 case 0x00A8: return "WM_NCMBUTTONUP";
5280 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5281 case 0x0100: return "WM_KEYDOWN";
5282 case 0x0101: return "WM_KEYUP";
5283 case 0x0102: return "WM_CHAR";
5284 case 0x0103: return "WM_DEADCHAR";
5285 case 0x0104: return "WM_SYSKEYDOWN";
5286 case 0x0105: return "WM_SYSKEYUP";
5287 case 0x0106: return "WM_SYSCHAR";
5288 case 0x0107: return "WM_SYSDEADCHAR";
5289 case 0x0108: return "WM_KEYLAST";
5291 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5292 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5293 case 0x010F: return "WM_IME_COMPOSITION";
5295 case 0x0110: return "WM_INITDIALOG";
5296 case 0x0111: return "WM_COMMAND";
5297 case 0x0112: return "WM_SYSCOMMAND";
5298 case 0x0113: return "WM_TIMER";
5299 case 0x0114: return "WM_HSCROLL";
5300 case 0x0115: return "WM_VSCROLL";
5301 case 0x0116: return "WM_INITMENU";
5302 case 0x0117: return "WM_INITMENUPOPUP";
5303 case 0x011F: return "WM_MENUSELECT";
5304 case 0x0120: return "WM_MENUCHAR";
5305 case 0x0121: return "WM_ENTERIDLE";
5306 case 0x0200: return "WM_MOUSEMOVE";
5307 case 0x0201: return "WM_LBUTTONDOWN";
5308 case 0x0202: return "WM_LBUTTONUP";
5309 case 0x0203: return "WM_LBUTTONDBLCLK";
5310 case 0x0204: return "WM_RBUTTONDOWN";
5311 case 0x0205: return "WM_RBUTTONUP";
5312 case 0x0206: return "WM_RBUTTONDBLCLK";
5313 case 0x0207: return "WM_MBUTTONDOWN";
5314 case 0x0208: return "WM_MBUTTONUP";
5315 case 0x0209: return "WM_MBUTTONDBLCLK";
5316 case 0x020A: return "WM_MOUSEWHEEL";
5317 case 0x0210: return "WM_PARENTNOTIFY";
5318 case 0x0211: return "WM_ENTERMENULOOP";
5319 case 0x0212: return "WM_EXITMENULOOP";
5321 case 0x0213: return "WM_NEXTMENU";
5322 case 0x0214: return "WM_SIZING";
5323 case 0x0215: return "WM_CAPTURECHANGED";
5324 case 0x0216: return "WM_MOVING";
5325 case 0x0218: return "WM_POWERBROADCAST";
5326 case 0x0219: return "WM_DEVICECHANGE";
5328 case 0x0220: return "WM_MDICREATE";
5329 case 0x0221: return "WM_MDIDESTROY";
5330 case 0x0222: return "WM_MDIACTIVATE";
5331 case 0x0223: return "WM_MDIRESTORE";
5332 case 0x0224: return "WM_MDINEXT";
5333 case 0x0225: return "WM_MDIMAXIMIZE";
5334 case 0x0226: return "WM_MDITILE";
5335 case 0x0227: return "WM_MDICASCADE";
5336 case 0x0228: return "WM_MDIICONARRANGE";
5337 case 0x0229: return "WM_MDIGETACTIVE";
5338 case 0x0230: return "WM_MDISETMENU";
5339 case 0x0233: return "WM_DROPFILES";
5341 case 0x0281: return "WM_IME_SETCONTEXT";
5342 case 0x0282: return "WM_IME_NOTIFY";
5343 case 0x0283: return "WM_IME_CONTROL";
5344 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5345 case 0x0285: return "WM_IME_SELECT";
5346 case 0x0286: return "WM_IME_CHAR";
5347 case 0x0290: return "WM_IME_KEYDOWN";
5348 case 0x0291: return "WM_IME_KEYUP";
5350 case 0x0300: return "WM_CUT";
5351 case 0x0301: return "WM_COPY";
5352 case 0x0302: return "WM_PASTE";
5353 case 0x0303: return "WM_CLEAR";
5354 case 0x0304: return "WM_UNDO";
5355 case 0x0305: return "WM_RENDERFORMAT";
5356 case 0x0306: return "WM_RENDERALLFORMATS";
5357 case 0x0307: return "WM_DESTROYCLIPBOARD";
5358 case 0x0308: return "WM_DRAWCLIPBOARD";
5359 case 0x0309: return "WM_PAINTCLIPBOARD";
5360 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5361 case 0x030B: return "WM_SIZECLIPBOARD";
5362 case 0x030C: return "WM_ASKCBFORMATNAME";
5363 case 0x030D: return "WM_CHANGECBCHAIN";
5364 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5365 case 0x030F: return "WM_QUERYNEWPALETTE";
5366 case 0x0310: return "WM_PALETTEISCHANGING";
5367 case 0x0311: return "WM_PALETTECHANGED";
5369 case 0x0312: return "WM_HOTKEY";
5372 // common controls messages - although they're not strictly speaking
5373 // standard, it's nice to decode them nevertheless
5376 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5377 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5378 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5379 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5380 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5381 case 0x1000 + 5: return "LVM_GETITEMA";
5382 case 0x1000 + 75: return "LVM_GETITEMW";
5383 case 0x1000 + 6: return "LVM_SETITEMA";
5384 case 0x1000 + 76: return "LVM_SETITEMW";
5385 case 0x1000 + 7: return "LVM_INSERTITEMA";
5386 case 0x1000 + 77: return "LVM_INSERTITEMW";
5387 case 0x1000 + 8: return "LVM_DELETEITEM";
5388 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5389 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5390 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5391 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5392 case 0x1000 + 13: return "LVM_FINDITEMA";
5393 case 0x1000 + 83: return "LVM_FINDITEMW";
5394 case 0x1000 + 14: return "LVM_GETITEMRECT";
5395 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5396 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5397 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5398 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5399 case 0x1000 + 18: return "LVM_HITTEST";
5400 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5401 case 0x1000 + 20: return "LVM_SCROLL";
5402 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5403 case 0x1000 + 22: return "LVM_ARRANGE";
5404 case 0x1000 + 23: return "LVM_EDITLABELA";
5405 case 0x1000 + 118: return "LVM_EDITLABELW";
5406 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5407 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5408 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5409 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5410 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5411 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5412 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5413 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5414 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5415 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5416 case 0x1000 + 31: return "LVM_GETHEADER";
5417 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5418 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5419 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5420 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5421 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5422 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5423 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5424 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5425 case 0x1000 + 41: return "LVM_GETORIGIN";
5426 case 0x1000 + 42: return "LVM_UPDATE";
5427 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5428 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5429 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5430 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5431 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5432 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5433 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5434 case 0x1000 + 48: return "LVM_SORTITEMS";
5435 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5436 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5437 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5438 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5439 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5440 case 0x1000 + 53: return "LVM_SETICONSPACING";
5441 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5442 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5443 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5444 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5445 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5446 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5447 case 0x1000 + 60: return "LVM_SETHOTITEM";
5448 case 0x1000 + 61: return "LVM_GETHOTITEM";
5449 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5450 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5451 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5452 case 0x1000 + 65: return "LVM_SETWORKAREA";
5455 case 0x1100 + 0: return "TVM_INSERTITEMA";
5456 case 0x1100 + 50: return "TVM_INSERTITEMW";
5457 case 0x1100 + 1: return "TVM_DELETEITEM";
5458 case 0x1100 + 2: return "TVM_EXPAND";
5459 case 0x1100 + 4: return "TVM_GETITEMRECT";
5460 case 0x1100 + 5: return "TVM_GETCOUNT";
5461 case 0x1100 + 6: return "TVM_GETINDENT";
5462 case 0x1100 + 7: return "TVM_SETINDENT";
5463 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5464 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5465 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5466 case 0x1100 + 11: return "TVM_SELECTITEM";
5467 case 0x1100 + 12: return "TVM_GETITEMA";
5468 case 0x1100 + 62: return "TVM_GETITEMW";
5469 case 0x1100 + 13: return "TVM_SETITEMA";
5470 case 0x1100 + 63: return "TVM_SETITEMW";
5471 case 0x1100 + 14: return "TVM_EDITLABELA";
5472 case 0x1100 + 65: return "TVM_EDITLABELW";
5473 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5474 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5475 case 0x1100 + 17: return "TVM_HITTEST";
5476 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5477 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5478 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5479 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5480 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5481 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5482 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5483 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5484 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5487 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5488 case 0x1200 + 1: return "HDM_INSERTITEMA";
5489 case 0x1200 + 10: return "HDM_INSERTITEMW";
5490 case 0x1200 + 2: return "HDM_DELETEITEM";
5491 case 0x1200 + 3: return "HDM_GETITEMA";
5492 case 0x1200 + 11: return "HDM_GETITEMW";
5493 case 0x1200 + 4: return "HDM_SETITEMA";
5494 case 0x1200 + 12: return "HDM_SETITEMW";
5495 case 0x1200 + 5: return "HDM_LAYOUT";
5496 case 0x1200 + 6: return "HDM_HITTEST";
5497 case 0x1200 + 7: return "HDM_GETITEMRECT";
5498 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5499 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5500 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5501 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5502 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5503 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5504 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5507 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5508 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5509 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5510 case 0x1300 + 5: return "TCM_GETITEMA";
5511 case 0x1300 + 60: return "TCM_GETITEMW";
5512 case 0x1300 + 6: return "TCM_SETITEMA";
5513 case 0x1300 + 61: return "TCM_SETITEMW";
5514 case 0x1300 + 7: return "TCM_INSERTITEMA";
5515 case 0x1300 + 62: return "TCM_INSERTITEMW";
5516 case 0x1300 + 8: return "TCM_DELETEITEM";
5517 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5518 case 0x1300 + 10: return "TCM_GETITEMRECT";
5519 case 0x1300 + 11: return "TCM_GETCURSEL";
5520 case 0x1300 + 12: return "TCM_SETCURSEL";
5521 case 0x1300 + 13: return "TCM_HITTEST";
5522 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5523 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5524 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5525 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5526 case 0x1300 + 43: return "TCM_SETPADDING";
5527 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5528 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5529 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5530 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5531 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5532 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5533 case 0x1300 + 50: return "TCM_DESELECTALL";
5536 case WM_USER
+1: return "TB_ENABLEBUTTON";
5537 case WM_USER
+2: return "TB_CHECKBUTTON";
5538 case WM_USER
+3: return "TB_PRESSBUTTON";
5539 case WM_USER
+4: return "TB_HIDEBUTTON";
5540 case WM_USER
+5: return "TB_INDETERMINATE";
5541 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5542 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5543 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5544 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5545 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5546 case WM_USER
+17: return "TB_SETSTATE";
5547 case WM_USER
+18: return "TB_GETSTATE";
5548 case WM_USER
+19: return "TB_ADDBITMAP";
5549 case WM_USER
+20: return "TB_ADDBUTTONS";
5550 case WM_USER
+21: return "TB_INSERTBUTTON";
5551 case WM_USER
+22: return "TB_DELETEBUTTON";
5552 case WM_USER
+23: return "TB_GETBUTTON";
5553 case WM_USER
+24: return "TB_BUTTONCOUNT";
5554 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5555 case WM_USER
+26: return "TB_SAVERESTOREA";
5556 case WM_USER
+76: return "TB_SAVERESTOREW";
5557 case WM_USER
+27: return "TB_CUSTOMIZE";
5558 case WM_USER
+28: return "TB_ADDSTRINGA";
5559 case WM_USER
+77: return "TB_ADDSTRINGW";
5560 case WM_USER
+29: return "TB_GETITEMRECT";
5561 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5562 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5563 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5564 case WM_USER
+33: return "TB_AUTOSIZE";
5565 case WM_USER
+35: return "TB_GETTOOLTIPS";
5566 case WM_USER
+36: return "TB_SETTOOLTIPS";
5567 case WM_USER
+37: return "TB_SETPARENT";
5568 case WM_USER
+39: return "TB_SETROWS";
5569 case WM_USER
+40: return "TB_GETROWS";
5570 case WM_USER
+42: return "TB_SETCMDID";
5571 case WM_USER
+43: return "TB_CHANGEBITMAP";
5572 case WM_USER
+44: return "TB_GETBITMAP";
5573 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5574 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5575 case WM_USER
+46: return "TB_REPLACEBITMAP";
5576 case WM_USER
+47: return "TB_SETINDENT";
5577 case WM_USER
+48: return "TB_SETIMAGELIST";
5578 case WM_USER
+49: return "TB_GETIMAGELIST";
5579 case WM_USER
+50: return "TB_LOADIMAGES";
5580 case WM_USER
+51: return "TB_GETRECT";
5581 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5582 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5583 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5584 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5585 case WM_USER
+56: return "TB_SETSTYLE";
5586 case WM_USER
+57: return "TB_GETSTYLE";
5587 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5588 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5589 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5590 case WM_USER
+61: return "TB_GETTEXTROWS";
5591 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5594 static char s_szBuf
[128];
5595 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5599 #endif //__WXDEBUG__
5601 static void TranslateKbdEventToMouse(wxWindowMSW
*win
,
5602 int *x
, int *y
, WPARAM
*flags
)
5604 // construct the key mask
5605 WPARAM
& fwKeys
= *flags
;
5607 fwKeys
= MK_RBUTTON
;
5608 if ( wxIsCtrlDown() )
5609 fwKeys
|= MK_CONTROL
;
5610 if ( wxIsShiftDown() )
5613 // simulate right mouse button click
5614 DWORD dwPos
= ::GetMessagePos();
5615 *x
= GET_X_LPARAM(dwPos
);
5616 *y
= GET_Y_LPARAM(dwPos
);
5618 win
->ScreenToClient(x
, y
);
5621 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5625 HWND hwnd
= GetHwndOf(win
);
5626 HDC hdc
= ::GetDC(hwnd
);
5628 #if !wxDIALOG_UNIT_COMPATIBILITY
5629 // and select the current font into it
5630 HFONT hfont
= GetHfontOf(win
->GetFont());
5633 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5637 // finally retrieve the text metrics from it
5638 GetTextMetrics(hdc
, &tm
);
5640 #if !wxDIALOG_UNIT_COMPATIBILITY
5644 (void)::SelectObject(hdc
, hfont
);
5648 ::ReleaseDC(hwnd
, hdc
);
5653 // Find the wxWindow at the current mouse position, returning the mouse
5655 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5657 pt
= wxGetMousePosition();
5658 return wxFindWindowAtPoint(pt
);
5661 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5666 HWND hWndHit
= ::WindowFromPoint(pt2
);
5668 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5669 HWND hWnd
= hWndHit
;
5671 // Try to find a window with a wxWindow associated with it
5672 while (!win
&& (hWnd
!= 0))
5674 hWnd
= ::GetParent(hWnd
);
5675 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5680 // Get the current mouse position.
5681 wxPoint
wxGetMousePosition()
5684 GetCursorPos( & pt
);
5686 return wxPoint(pt
.x
, pt
.y
);
5691 bool wxWindowMSW::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5693 UINT win_modifiers
=0;
5694 if ( modifiers
& wxMOD_ALT
)
5695 win_modifiers
|= MOD_ALT
;
5696 if ( modifiers
& wxMOD_SHIFT
)
5697 win_modifiers
|= MOD_SHIFT
;
5698 if ( modifiers
& wxMOD_CONTROL
)
5699 win_modifiers
|= MOD_CONTROL
;
5700 if ( modifiers
& wxMOD_WIN
)
5701 win_modifiers
|= MOD_WIN
;
5703 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5705 wxLogLastError(_T("RegisterHotKey"));
5713 bool wxWindowMSW::UnregisterHotKey(int hotkeyId
)
5715 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5717 wxLogLastError(_T("UnregisterHotKey"));
5725 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5727 int hotkeyId
= wParam
;
5728 int virtualKey
= HIWORD(lParam
);
5729 int win_modifiers
= LOWORD(lParam
);
5731 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5732 event
.SetId(hotkeyId
);
5733 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5734 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5735 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5736 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5738 return GetEventHandler()->ProcessEvent(event
);
5741 #endif // wxUSE_HOTKEY
5743 // Not verified for WinCE
5746 * wxEventFixModule (needs a better name) allows message handling to continute while a menu
5747 * is being shown - ie, to continue processing messages from a worker thread.
5749 * Code originally by Jason W. from wx-dev, reworked into a wxModule by Chris Mellon
5752 class wxEventFixModule
: public wxModule
{
5754 //base class virtuals
5755 virtual bool OnInit() {
5756 wxEventFixModule::s_hMsgHookProc
= SetWindowsHookEx(
5758 &wxEventFixModule::MsgHookProc
,
5760 GetCurrentThreadId());
5761 wxLogDebug(_T("Loaded event fix module"));
5764 virtual void OnExit() {
5765 UnhookWindowsHookEx(wxEventFixModule::s_hMsgHookProc
);
5768 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
) {
5769 MSG
*msg
= (MSG
*)lParam
;
5770 switch (msg
->message
)
5773 static bool bInHookProc
= false;
5777 wxTheApp
->ProcessPendingEvents();
5778 bInHookProc
= false;
5782 return CallNextHookEx(wxEventFixModule::s_hMsgHookProc
, nCode
, wParam
, lParam
);
5785 static HHOOK s_hMsgHookProc
;
5786 DECLARE_DYNAMIC_CLASS(wxEventFixModule
)
5788 HHOOK
wxEventFixModule::s_hMsgHookProc
= 0;
5790 IMPLEMENT_DYNAMIC_CLASS(wxEventFixModule
, wxModule
)