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"
53 #if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
54 #include "wx/ownerdrw.h"
57 #include "wx/module.h"
58 #include "wx/sysopt.h"
60 #if wxUSE_DRAG_AND_DROP
64 #if wxUSE_ACCESSIBILITY
65 #include "wx/access.h"
69 #define WM_GETOBJECT 0x003D
72 #define OBJID_CLIENT 0xFFFFFFFC
76 #include "wx/menuitem.h"
79 #include "wx/msw/private.h"
82 #include "wx/tooltip.h"
90 #include "wx/spinctrl.h"
91 #endif // wxUSE_SPINCTRL
96 #include "wx/textctrl.h"
97 #include "wx/notebook.h"
98 #include "wx/listctrl.h"
102 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
103 #include <shellapi.h>
104 #include <mmsystem.h>
108 #include <windowsx.h>
111 #include <commctrl.h>
113 #include "wx/msw/missing.h"
115 #if defined(__WXWINCE__)
116 #include "wx/msw/wince/missing.h"
119 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE)
120 #define HAVE_TRACKMOUSEEVENT
121 #endif // everything needed for TrackMouseEvent()
123 #define USE_DEFERRED_SIZING 1
124 #define USE_DEFER_BUG_WORKAROUND 1
126 // ---------------------------------------------------------------------------
128 // ---------------------------------------------------------------------------
130 #if wxUSE_MENUS_NATIVE
131 wxMenu
*wxCurrentPopupMenu
= NULL
;
132 #endif // wxUSE_MENUS_NATIVE
135 extern wxChar
*wxCanvasClassName
;
137 extern const wxChar
*wxCanvasClassName
;
140 // true if we had already created the std colour map, used by
141 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
142 static bool gs_hasStdCmap
= false;
144 // ---------------------------------------------------------------------------
146 // ---------------------------------------------------------------------------
148 // the window proc for all our windows
149 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
150 WPARAM wParam
, LPARAM lParam
);
154 const char *wxGetMessageName(int message
);
157 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
158 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
159 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
161 // get the text metrics for the current font
162 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
164 // find the window for the mouse event at the specified position
165 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
167 // wrapper around BringWindowToTop() API
168 static inline void wxBringWindowToTop(HWND hwnd
)
170 #ifdef __WXMICROWIN__
171 // It seems that MicroWindows brings the _parent_ of the window to the top,
172 // which can be the wrong one.
174 // activate (set focus to) specified window
178 // raise top level parent to top of z order
179 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
181 wxLogLastError(_T("SetWindowPos"));
187 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
188 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
191 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
192 parent as well as otherwise several Win32 functions using
193 GetNextDlgTabItem() to iterate over all controls such as
194 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
195 all of them iterate over all the controls starting from the currently
196 focused one and stop iterating when they get back to the focus but
197 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
198 get back to the initial (focused) window: as we do have this style,
199 GetNextDlgTabItem() will leave this window and continue in its parent,
200 but if the parent doesn't have it, it wouldn't recurse inside it later
201 on and so wouldn't have a chance of getting back to this window neither.
203 while ( parent
&& !parent
->IsTopLevel() )
205 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
206 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
208 // force the parent to have this style
209 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
210 exStyle
| WS_EX_CONTROLPARENT
);
213 parent
= parent
->GetParent();
217 #endif // !__WXWINCE__
220 // On Windows CE, GetCursorPos can return an error, so use this function
222 bool GetCursorPosWinCE(POINT
* pt
)
224 if (!GetCursorPos(pt
))
226 DWORD pos
= GetMessagePos();
234 // ---------------------------------------------------------------------------
236 // ---------------------------------------------------------------------------
238 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
240 #ifdef __WXUNIVERSAL__
241 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
243 #if wxUSE_EXTENDED_RTTI
245 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
246 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
247 // windows with negative ids never can be recreated anyway
249 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
251 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
252 if ( win
&& win
->GetId() < 0 )
257 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
259 // make wxWindowList known before the property is used
261 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
263 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
265 wxListCollectionToVariantArray
<wxWindowList
::compatibility_iterator
>( theList
, value
) ;
268 WX_DEFINE_FLAGS( wxWindowStyle
)
270 wxBEGIN_FLAGS( wxWindowStyle
)
271 // new style border flags, we put them first to
272 // use them for streaming out
274 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
275 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
276 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
277 wxFLAGS_MEMBER(wxBORDER_RAISED
)
278 wxFLAGS_MEMBER(wxBORDER_STATIC
)
279 wxFLAGS_MEMBER(wxBORDER_NONE
)
281 // old style border flags
282 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
283 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
284 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
285 wxFLAGS_MEMBER(wxRAISED_BORDER
)
286 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
287 wxFLAGS_MEMBER(wxBORDER
)
289 // standard window styles
290 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
291 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
292 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
293 wxFLAGS_MEMBER(wxWANTS_CHARS
)
294 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
295 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
296 wxFLAGS_MEMBER(wxVSCROLL
)
297 wxFLAGS_MEMBER(wxHSCROLL
)
299 wxEND_FLAGS( wxWindowStyle
)
301 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
302 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
303 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
304 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
305 // Always constructor Properties first
307 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
308 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
309 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
310 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
311 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
313 // Then all relations of the object graph
315 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
317 // and finally all other properties
319 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
320 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
321 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
322 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
323 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
325 // possible property candidates (not in xrc) or not valid in all subclasses
326 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
327 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
328 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
329 // MaxHeight, Width , MinHeight , Width
330 // TODO switch label to control and title to toplevels
332 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
333 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
334 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
335 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
340 wxEND_PROPERTIES_TABLE()
342 wxBEGIN_HANDLERS_TABLE(wxWindow
)
343 wxEND_HANDLERS_TABLE()
345 wxCONSTRUCTOR_DUMMY(wxWindow
)
348 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
350 #endif // __WXUNIVERSAL__/__WXMSW__
352 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
353 EVT_SYS_COLOUR_CHANGED(wxWindowMSW
::OnSysColourChanged
)
354 EVT_ERASE_BACKGROUND(wxWindowMSW
::OnEraseBackground
)
356 EVT_INIT_DIALOG(wxWindowMSW
::OnInitDialog
)
360 // ===========================================================================
362 // ===========================================================================
364 // ---------------------------------------------------------------------------
365 // wxWindow utility functions
366 // ---------------------------------------------------------------------------
368 // Find an item given the MS Windows id
369 wxWindow
*wxWindowMSW
::FindItem(long id
) const
372 wxControl
*item
= wxDynamicCastThis(wxControl
);
375 // is it we or one of our "internal" children?
376 if ( item
->GetId() == id
377 #ifndef __WXUNIVERSAL__
378 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
379 #endif // __WXUNIVERSAL__
385 #endif // wxUSE_CONTROLS
387 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
390 wxWindow
*childWin
= current
->GetData();
392 wxWindow
*wnd
= childWin
->FindItem(id
);
396 current
= current
->GetNext();
402 // Find an item given the MS Windows handle
403 wxWindow
*wxWindowMSW
::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
405 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
408 wxWindow
*parent
= current
->GetData();
410 // Do a recursive search.
411 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
417 || parent
->IsKindOf(CLASSINFO(wxControl
))
418 #endif // wxUSE_CONTROLS
421 wxWindow
*item
= current
->GetData();
422 if ( item
->GetHWND() == hWnd
)
426 if ( item
->ContainsHWND(hWnd
) )
431 current
= current
->GetNext();
436 // Default command handler
437 bool wxWindowMSW
::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
442 // ----------------------------------------------------------------------------
443 // constructors and such
444 // ----------------------------------------------------------------------------
446 void wxWindowMSW
::Init()
449 m_isBeingDeleted
= false;
451 m_mouseInWindow
= false;
452 m_lastKeydownProcessed
= false;
454 m_childrenDisabled
= NULL
;
463 #if wxUSE_MOUSEEVENT_HACK
466 m_lastMouseEvent
= -1;
467 #endif // wxUSE_MOUSEEVENT_HACK
469 m_pendingPosition
= wxDefaultPosition
;
470 m_pendingSize
= wxDefaultSize
;
474 wxWindowMSW
::~wxWindowMSW()
476 m_isBeingDeleted
= true;
478 #ifndef __WXUNIVERSAL__
479 // VS: make sure there's no wxFrame with last focus set to us:
480 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
482 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
485 if ( frame
->GetLastFocus() == this )
487 frame
->SetLastFocus(NULL
);
490 // apparently sometimes we can end up with our grand parent
491 // pointing to us as well: this is surely a bug in focus handling
492 // code but it's not clear where it happens so for now just try to
493 // fix it here by not breaking out of the loop
497 #endif // __WXUNIVERSAL__
499 // VS: destroy children first and _then_ detach *this from its parent.
500 // If we'd do it the other way around, children wouldn't be able
501 // find their parent frame (see above).
506 // VZ: test temp removed to understand what really happens here
507 //if (::IsWindow(GetHwnd()))
509 if ( !::DestroyWindow(GetHwnd()) )
510 wxLogLastError(wxT("DestroyWindow"));
513 // remove hWnd <-> wxWindow association
514 wxRemoveHandleAssociation(this);
517 delete m_childrenDisabled
;
521 // real construction (Init() must have been called before!)
522 bool wxWindowMSW
::Create(wxWindow
*parent
,
527 const wxString
& name
)
529 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
531 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
534 parent
->AddChild(this);
537 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
539 #ifdef __WXUNIVERSAL__
540 // no borders, we draw them ourselves
541 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
545 msflags
&= ~WS_BORDER
;
546 #endif // wxUniversal
550 msflags
|= WS_VISIBLE
;
553 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
561 // ---------------------------------------------------------------------------
563 // ---------------------------------------------------------------------------
565 void wxWindowMSW
::SetFocus()
567 HWND hWnd
= GetHwnd();
568 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
570 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
574 if ( !::SetFocus(hWnd
) )
576 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
577 // was there really an error?
578 DWORD dwRes
= ::GetLastError();
581 HWND hwndFocus
= ::GetFocus();
582 if ( hwndFocus
!= hWnd
)
584 wxLogApiError(_T("SetFocus"), dwRes
);
591 void wxWindowMSW
::SetFocusFromKbd()
593 // when the focus is given to the control with DLGC_HASSETSEL style from
594 // keyboard its contents should be entirely selected: this is what
595 // ::IsDialogMessage() does and so we should do it as well to provide the
596 // same LNF as the native programs
597 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
599 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
602 // do this after (maybe) setting the selection as like this when
603 // wxEVT_SET_FOCUS handler is called, the selection would have been already
604 // set correctly -- this may be important
605 wxWindowBase
::SetFocusFromKbd();
608 // Get the window with the focus
609 wxWindow
*wxWindowBase
::DoFindFocus()
611 HWND hWnd
= ::GetFocus();
614 return wxGetWindowFromHWND((WXHWND
)hWnd
);
620 bool wxWindowMSW
::Enable(bool enable
)
622 if ( !wxWindowBase
::Enable(enable
) )
625 HWND hWnd
= GetHwnd();
627 ::EnableWindow(hWnd
, (BOOL
)enable
);
629 // the logic below doesn't apply to the top level windows -- otherwise
630 // showing a modal dialog would result in total greying out (and ungreying
631 // out later) of everything which would be really ugly
635 // when the parent is disabled, all of its children should be disabled as
636 // well but when it is enabled back, only those of the children which
637 // hadn't been already disabled in the beginning should be enabled again,
638 // so we have to keep the list of those children
639 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
641 node
= node
->GetNext() )
643 wxWindow
*child
= node
->GetData();
644 if ( child
->IsTopLevel() )
646 // the logic below doesn't apply to top level children
652 // enable the child back unless it had been disabled before us
653 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
656 else // we're being disabled
658 if ( child
->IsEnabled() )
660 // disable it as children shouldn't stay enabled while the
664 else // child already disabled, remember it
666 // have we created the list of disabled children already?
667 if ( !m_childrenDisabled
)
668 m_childrenDisabled
= new wxWindowList
;
670 m_childrenDisabled
->Append(child
);
675 if ( enable
&& m_childrenDisabled
)
677 // we don't need this list any more, don't keep unused memory
678 delete m_childrenDisabled
;
679 m_childrenDisabled
= NULL
;
685 bool wxWindowMSW
::Show(bool show
)
687 if ( !wxWindowBase
::Show(show
) )
690 HWND hWnd
= GetHwnd();
691 int cshow
= show ? SW_SHOW
: SW_HIDE
;
692 ::ShowWindow(hWnd
, cshow
);
694 if ( show
&& IsTopLevel() )
696 wxBringWindowToTop(hWnd
);
702 // Raise the window to the top of the Z order
703 void wxWindowMSW
::Raise()
705 wxBringWindowToTop(GetHwnd());
708 // Lower the window to the bottom of the Z order
709 void wxWindowMSW
::Lower()
711 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
712 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
715 void wxWindowMSW
::SetTitle( const wxString
& title
)
717 SetWindowText(GetHwnd(), title
.c_str());
720 wxString wxWindowMSW
::GetTitle() const
722 return wxGetWindowText(GetHWND());
725 void wxWindowMSW
::DoCaptureMouse()
727 HWND hWnd
= GetHwnd();
734 void wxWindowMSW
::DoReleaseMouse()
736 if ( !::ReleaseCapture() )
738 wxLogLastError(_T("ReleaseCapture"));
742 /* static */ wxWindow
*wxWindowBase
::GetCapture()
744 HWND hwnd
= ::GetCapture();
745 return hwnd ?
wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
748 bool wxWindowMSW
::SetFont(const wxFont
& font
)
750 if ( !wxWindowBase
::SetFont(font
) )
756 HWND hWnd
= GetHwnd();
759 WXHANDLE hFont
= m_font
.GetResourceHandle();
761 wxASSERT_MSG( hFont
, wxT("should have valid font") );
763 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
768 bool wxWindowMSW
::SetCursor(const wxCursor
& cursor
)
770 if ( !wxWindowBase
::SetCursor(cursor
) )
778 HWND hWnd
= GetHwnd();
780 // Change the cursor NOW if we're within the correct window
783 ::GetCursorPosWinCE(&point
);
785 ::GetCursorPos(&point
);
788 RECT rect
= wxGetWindowRect(hWnd
);
790 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
791 ::SetCursor(GetHcursorOf(m_cursor
));
797 void wxWindowMSW
::WarpPointer (int x
, int y
)
799 ClientToScreen(&x
, &y
);
801 if ( !::SetCursorPos(x
, y
) )
803 wxLogLastError(_T("SetCursorPos"));
807 // ---------------------------------------------------------------------------
809 // ---------------------------------------------------------------------------
811 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
813 #ifdef __WXMICROWIN__
814 return ::GetScrollPosWX(hWnd
, wOrient
);
816 WinStruct
<SCROLLINFO
> scrollInfo
;
817 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
818 scrollInfo
.fMask
= SIF_POS
;
819 if ( !::GetScrollInfo(hWnd
,
823 // Not necessarily an error, if there are no scrollbars yet.
824 // wxLogLastError(_T("GetScrollInfo"));
826 return scrollInfo
.nPos
;
827 // return ::GetScrollPos(hWnd, wOrient);
831 int wxWindowMSW
::GetScrollPos(int orient
) const
833 HWND hWnd
= GetHwnd();
834 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
836 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
);
839 // This now returns the whole range, not just the number
840 // of positions that we can scroll.
841 int wxWindowMSW
::GetScrollRange(int orient
) const
844 HWND hWnd
= GetHwnd();
848 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
851 WinStruct
<SCROLLINFO
> scrollInfo
;
852 scrollInfo
.fMask
= SIF_RANGE
;
853 if ( !::GetScrollInfo(hWnd
,
854 orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
857 // Most of the time this is not really an error, since the return
858 // value can also be zero when there is no scrollbar yet.
859 // wxLogLastError(_T("GetScrollInfo"));
861 maxPos
= scrollInfo
.nMax
;
863 // undo "range - 1" done in SetScrollbar()
867 int wxWindowMSW
::GetScrollThumb(int orient
) const
869 return orient
== wxHORIZONTAL ? m_xThumbSize
: m_yThumbSize
;
872 void wxWindowMSW
::SetScrollPos(int orient
, int pos
, bool refresh
)
874 HWND hWnd
= GetHwnd();
875 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
877 WinStruct
<SCROLLINFO
> info
;
881 info
.fMask
= SIF_POS
;
882 if ( HasFlag(wxALWAYS_SHOW_SB
) )
884 // disable scrollbar instead of removing it then
885 info
.fMask
|= SIF_DISABLENOSCROLL
;
888 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
892 // New function that will replace some of the above.
893 void wxWindowMSW
::SetScrollbar(int orient
,
899 WinStruct
<SCROLLINFO
> info
;
900 info
.nPage
= pageSize
;
901 info
.nMin
= 0; // range is nMax - nMin + 1
902 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
904 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
905 if ( HasFlag(wxALWAYS_SHOW_SB
) )
907 // disable scrollbar instead of removing it then
908 info
.fMask
|= SIF_DISABLENOSCROLL
;
911 HWND hWnd
= GetHwnd();
914 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
918 *(orient
== wxHORIZONTAL ?
&m_xThumbSize
: &m_yThumbSize
) = pageSize
;
921 void wxWindowMSW
::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
927 rect
.left
= prect
->x
;
929 rect
.right
= prect
->x
+ prect
->width
;
930 rect
.bottom
= prect
->y
+ prect
->height
;
940 // FIXME: is this the exact equivalent of the line below?
941 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
943 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
947 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
949 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
952 for ( int n
= 0; n
< count
; n
++ )
954 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
956 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
959 // don't bother to continue, we're already at top/bottom
966 return pos
!= posStart
;
969 bool wxWindowMSW
::ScrollLines(int lines
)
971 bool down
= lines
> 0;
973 return ScrollVertically(GetHwnd(),
974 down ? SB_LINEDOWN
: SB_LINEUP
,
975 down ? lines
: -lines
);
978 bool wxWindowMSW
::ScrollPages(int pages
)
980 bool down
= pages
> 0;
982 return ScrollVertically(GetHwnd(),
983 down ? SB_PAGEDOWN
: SB_PAGEUP
,
984 down ? pages
: -pages
);
987 // ---------------------------------------------------------------------------
989 // ---------------------------------------------------------------------------
991 void wxWindowMSW
::SubclassWin(WXHWND hWnd
)
993 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
995 HWND hwnd
= (HWND
)hWnd
;
996 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
998 wxAssociateWinWithHandle(hwnd
, this);
1000 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1002 // we don't need to subclass the window of our own class (in the Windows
1003 // sense of the word)
1004 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1006 wxSetWindowProc(hwnd
, wxWndProc
);
1010 // don't bother restoring it neither: this also makes it easy to
1011 // implement IsOfStandardClass() method which returns true for the
1012 // standard controls and false for the wxWidgets own windows as it can
1013 // simply check m_oldWndProc
1014 m_oldWndProc
= NULL
;
1018 void wxWindowMSW
::UnsubclassWin()
1020 wxRemoveHandleAssociation(this);
1022 // Restore old Window proc
1023 HWND hwnd
= GetHwnd();
1028 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1032 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1034 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1037 m_oldWndProc
= NULL
;
1042 void wxWindowMSW
::AssociateHandle(WXWidget handle
)
1046 if ( !::DestroyWindow(GetHwnd()) )
1047 wxLogLastError(wxT("DestroyWindow"));
1050 WXHWND wxhwnd
= (WXHWND
)handle
;
1053 SubclassWin(wxhwnd
);
1056 void wxWindowMSW
::DissociateHandle()
1058 // this also calls SetHWND(0) for us
1063 bool wxCheckWindowWndProc(WXHWND hWnd
,
1064 WXFARPROC
WXUNUSED_IN_WINCE(wndProc
))
1066 // Unicows note: the code below works, but only because WNDCLASS contains
1067 // original window handler rather that the unicows fake one. This may not
1068 // be on purpose, though; if it stops working with future versions of
1069 // unicows.dll, we can override unicows hooks by setting
1070 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1071 // versions that keep track of fake<->real wnd proc mapping.
1073 // On WinCE (at least), the wndproc comparison doesn't work,
1074 // so have to use something like this.
1076 extern wxChar
*wxCanvasClassName
;
1077 extern wxChar
*wxCanvasClassNameNR
;
1078 extern const wxChar
*wxMDIFrameClassName
;
1079 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1080 extern const wxChar
*wxMDIChildFrameClassName
;
1081 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1082 wxString
str(wxGetWindowClass(hWnd
));
1083 if (str
== wxCanvasClassName
||
1084 str
== wxCanvasClassNameNR
||
1085 str
== wxMDIFrameClassName
||
1086 str
== wxMDIFrameClassNameNoRedraw
||
1087 str
== wxMDIChildFrameClassName
||
1088 str
== wxMDIChildFrameClassNameNoRedraw
||
1089 str
== _T("wxTLWHiddenParent"))
1090 return true; // Effectively means don't subclass
1095 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1097 wxLogLastError(_T("GetClassInfo"));
1102 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1106 // ----------------------------------------------------------------------------
1108 // ----------------------------------------------------------------------------
1110 void wxWindowMSW
::SetWindowStyleFlag(long flags
)
1112 long flagsOld
= GetWindowStyleFlag();
1113 if ( flags
== flagsOld
)
1116 // update the internal variable
1117 wxWindowBase
::SetWindowStyleFlag(flags
);
1119 // now update the Windows style as well if needed - and if the window had
1120 // been already created
1124 WXDWORD exstyle
, exstyleOld
;
1125 long style
= MSWGetStyle(flags
, &exstyle
),
1126 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1128 if ( style
!= styleOld
)
1130 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1131 // this function so instead of simply setting the style to the new
1132 // value we clear the bits which were set in styleOld but are set in
1133 // the new one and set the ones which were not set before
1134 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1135 styleReal
&= ~styleOld
;
1138 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1141 // and the extended style
1142 if ( exstyle
!= exstyleOld
)
1144 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1145 exstyleReal
&= ~exstyleOld
;
1146 exstyleReal
|= exstyle
;
1148 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1150 // we must call SetWindowPos() to flush the cached extended style and
1151 // also to make the change to wxSTAY_ON_TOP style take effect: just
1152 // setting the style simply doesn't work
1153 if ( !::SetWindowPos(GetHwnd(),
1154 exstyleReal
& WS_EX_TOPMOST ? HWND_TOPMOST
1157 SWP_NOMOVE
| SWP_NOSIZE
) )
1159 wxLogLastError(_T("SetWindowPos"));
1164 WXDWORD wxWindowMSW
::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1166 // translate common wxWidgets styles to Windows ones
1168 // most of windows are child ones, those which are not (such as
1169 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1170 WXDWORD style
= WS_CHILD
;
1172 // using this flag results in very significant reduction in flicker,
1173 // especially with controls inside the static boxes (as the interior of the
1174 // box is not redrawn twice).but sometimes results in redraw problems, so
1175 // optionally allow the old code to continue to use it provided a special
1176 // system option is turned on
1177 if ( !wxSystemOptions
::GetOptionInt(wxT("msw.window.no-clip-children"))
1178 || (flags
& wxCLIP_CHILDREN
) )
1179 style
|= WS_CLIPCHILDREN
;
1181 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1182 // don't support overlapping windows and it only makes sense for them and,
1183 // presumably, gives the system some extra work (to manage more clipping
1184 // regions), so avoid it alltogether
1187 if ( flags
& wxVSCROLL
)
1188 style
|= WS_VSCROLL
;
1190 if ( flags
& wxHSCROLL
)
1191 style
|= WS_HSCROLL
;
1193 const wxBorder border
= GetBorder(flags
);
1195 // WS_BORDER is only required for wxBORDER_SIMPLE
1196 if ( border
== wxBORDER_SIMPLE
)
1199 // now deal with ext style if the caller wants it
1205 if ( flags
& wxTRANSPARENT_WINDOW
)
1206 *exstyle
|= WS_EX_TRANSPARENT
;
1212 case wxBORDER_DEFAULT
:
1213 wxFAIL_MSG( _T("unknown border style") );
1217 case wxBORDER_SIMPLE
:
1220 case wxBORDER_STATIC
:
1221 *exstyle
|= WS_EX_STATICEDGE
;
1224 case wxBORDER_RAISED
:
1225 *exstyle
|= WS_EX_DLGMODALFRAME
;
1228 case wxBORDER_SUNKEN
:
1229 *exstyle
|= WS_EX_CLIENTEDGE
;
1230 style
&= ~WS_BORDER
;
1233 case wxBORDER_DOUBLE
:
1234 *exstyle
|= WS_EX_DLGMODALFRAME
;
1238 // wxUniv doesn't use Windows dialog navigation functions at all
1239 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1240 // to make the dialog navigation work with the nested panels we must
1241 // use this style (top level windows such as dialogs don't need it)
1242 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1244 *exstyle
|= WS_EX_CONTROLPARENT
;
1246 #endif // __WXUNIVERSAL__
1252 // Setup background and foreground colours correctly
1253 void wxWindowMSW
::SetupColours()
1256 SetBackgroundColour(GetParent()->GetBackgroundColour());
1259 bool wxWindowMSW
::IsMouseInWindow() const
1261 // get the mouse position
1264 ::GetCursorPosWinCE(&pt
);
1266 ::GetCursorPos(&pt
);
1269 // find the window which currently has the cursor and go up the window
1270 // chain until we find this window - or exhaust it
1271 HWND hwnd
= ::WindowFromPoint(pt
);
1272 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1273 hwnd
= ::GetParent(hwnd
);
1275 return hwnd
!= NULL
;
1278 void wxWindowMSW
::OnInternalIdle()
1280 #ifndef HAVE_TRACKMOUSEEVENT
1281 // Check if we need to send a LEAVE event
1282 if ( m_mouseInWindow
)
1284 // note that we should generate the leave event whether the window has
1285 // or doesn't have mouse capture
1286 if ( !IsMouseInWindow() )
1288 GenerateMouseLeave();
1291 #endif // !HAVE_TRACKMOUSEEVENT
1293 if (wxUpdateUIEvent
::CanUpdate(this))
1294 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1297 // Set this window to be the child of 'parent'.
1298 bool wxWindowMSW
::Reparent(wxWindowBase
*parent
)
1300 if ( !wxWindowBase
::Reparent(parent
) )
1303 HWND hWndChild
= GetHwnd();
1304 HWND hWndParent
= GetParent() ?
GetWinHwnd(GetParent()) : (HWND
)0;
1306 ::SetParent(hWndChild
, hWndParent
);
1309 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1311 EnsureParentHasControlParentStyle(GetParent());
1313 #endif // !__WXWINCE__
1318 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1320 #ifndef __WXMICROWIN__
1321 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1325 void wxWindowMSW
::Freeze()
1327 if ( !m_frozenness
++ )
1330 SendSetRedraw(GetHwnd(), false);
1334 void wxWindowMSW
::Thaw()
1336 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1338 if ( !--m_frozenness
)
1342 SendSetRedraw(GetHwnd(), true);
1344 // we need to refresh everything or otherwise the invalidated area
1345 // is not going to be repainted
1351 void wxWindowMSW
::Refresh(bool eraseBack
, const wxRect
*rect
)
1353 HWND hWnd
= GetHwnd();
1360 mswRect
.left
= rect
->x
;
1361 mswRect
.top
= rect
->y
;
1362 mswRect
.right
= rect
->x
+ rect
->width
;
1363 mswRect
.bottom
= rect
->y
+ rect
->height
;
1372 // RedrawWindow not available on SmartPhone or eVC++ 3
1373 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1374 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1378 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1380 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1385 void wxWindowMSW
::Update()
1387 if ( !::UpdateWindow(GetHwnd()) )
1389 wxLogLastError(_T("UpdateWindow"));
1392 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1393 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1394 // handler needs to be really drawn right now
1399 // ---------------------------------------------------------------------------
1401 // ---------------------------------------------------------------------------
1404 #if wxUSE_DRAG_AND_DROP
1405 void wxWindowMSW
::SetDropTarget(wxDropTarget
*pDropTarget
)
1407 if ( m_dropTarget
!= 0 ) {
1408 m_dropTarget
->Revoke(m_hWnd
);
1409 delete m_dropTarget
;
1412 m_dropTarget
= pDropTarget
;
1413 if ( m_dropTarget
!= 0 )
1414 m_dropTarget
->Register(m_hWnd
);
1416 #endif // wxUSE_DRAG_AND_DROP
1418 // old style file-manager drag&drop support: we retain the old-style
1419 // DragAcceptFiles in parallel with SetDropTarget.
1420 void wxWindowMSW
::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1423 HWND hWnd
= GetHwnd();
1425 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1429 // ----------------------------------------------------------------------------
1431 // ----------------------------------------------------------------------------
1435 void wxWindowMSW
::DoSetToolTip(wxToolTip
*tooltip
)
1437 wxWindowBase
::DoSetToolTip(tooltip
);
1440 m_tooltip
->SetWindow((wxWindow
*)this);
1443 #endif // wxUSE_TOOLTIPS
1445 // ---------------------------------------------------------------------------
1446 // moving and resizing
1447 // ---------------------------------------------------------------------------
1450 void wxWindowMSW
::DoGetSize(int *x
, int *y
) const
1452 RECT rect
= wxGetWindowRect(GetHwnd());
1455 *x
= rect
.right
- rect
.left
;
1457 *y
= rect
.bottom
- rect
.top
;
1460 // Get size *available for subwindows* i.e. excluding menu bar etc.
1461 void wxWindowMSW
::DoGetClientSize(int *x
, int *y
) const
1463 RECT rect
= wxGetClientRect(GetHwnd());
1471 void wxWindowMSW
::DoGetPosition(int *x
, int *y
) const
1473 RECT rect
= wxGetWindowRect(GetHwnd());
1476 point
.x
= rect
.left
;
1479 // we do the adjustments with respect to the parent only for the "real"
1480 // children, not for the dialogs/frames
1481 if ( !IsTopLevel() )
1483 HWND hParentWnd
= 0;
1484 wxWindow
*parent
= GetParent();
1486 hParentWnd
= GetWinHwnd(parent
);
1488 // Since we now have the absolute screen coords, if there's a parent we
1489 // must subtract its top left corner
1492 ::ScreenToClient(hParentWnd
, &point
);
1497 // We may be faking the client origin. So a window that's really at (0,
1498 // 30) may appear (to wxWin apps) to be at (0, 0).
1499 wxPoint
pt(parent
->GetClientAreaOrigin());
1511 void wxWindowMSW
::DoScreenToClient(int *x
, int *y
) const
1519 ::ScreenToClient(GetHwnd(), &pt
);
1527 void wxWindowMSW
::DoClientToScreen(int *x
, int *y
) const
1535 ::ClientToScreen(GetHwnd(), &pt
);
1543 void wxWindowMSW
::DoMoveWindow(int x
, int y
, int width
, int height
)
1545 // TODO: is this consistent with other platforms?
1546 // Still, negative width or height shouldn't be allowed
1552 // if our parent had prepared a defer window handle for us, use it (unless
1553 // we are a top level window)
1554 wxWindowMSW
*parent
= GetParent();
1556 #if USE_DEFERRED_SIZING
1557 HDWP hdwp
= parent
&& !IsTopLevel() ?
(HDWP
)parent
->m_hDWP
: NULL
;
1562 wxMoveWindowDeferred(hdwp
, this, GetHwnd(), x
, y
, width
, height
);
1564 #if USE_DEFERRED_SIZING
1566 // hdwp must be updated as it may have been changed
1567 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1571 // set the size of the window: if the dimensions are positive, just use them,
1572 // but if any of them is equal to -1, it means that we must find the value for
1573 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1574 // which case -1 is a valid value for x and y)
1576 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1577 // the width/height to best suit our contents, otherwise we reuse the current
1579 void wxWindowMSW
::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1581 // get the current size and position...
1582 int currentX
, currentY
;
1583 int currentW
, currentH
;
1585 #if USE_DEFER_BUG_WORKAROUND
1586 currentX
= m_pendingPosition
.x
;
1587 if (currentX
== wxDefaultCoord
)
1588 GetPosition(¤tX
, NULL
);
1590 currentY
= m_pendingPosition
.y
;
1591 if (currentY
== wxDefaultCoord
)
1592 GetPosition(NULL
, ¤tY
);
1594 currentW
= m_pendingSize
.x
;
1595 if (currentW
== wxDefaultCoord
)
1596 GetSize(¤tW
, NULL
);
1598 currentH
= m_pendingSize
.y
;
1599 if (currentH
== wxDefaultCoord
)
1600 GetSize(NULL
, ¤tH
);
1602 GetPosition(¤tX
, ¤tY
);
1603 GetSize(¤tW
, ¤tH
);
1606 // ... and don't do anything (avoiding flicker) if it's already ok
1607 if ( x
== currentX
&& y
== currentY
&&
1608 width
== currentW
&& height
== currentH
)
1613 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1615 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1618 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1620 wxSize size
= wxDefaultSize
;
1621 if ( width
== wxDefaultCoord
)
1623 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1625 size
= DoGetBestSize();
1630 // just take the current one
1635 if ( height
== wxDefaultCoord
)
1637 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1639 if ( size
.x
== wxDefaultCoord
)
1641 size
= DoGetBestSize();
1643 //else: already called DoGetBestSize() above
1649 // just take the current one
1654 #if USE_DEFER_BUG_WORKAROUND
1655 // We don't actually use the hdwp here, but we need to know whether to
1656 // save the pending dimensions or not. This isn't done in DoMoveWindow
1657 // (where the hdwp is used) because some controls have thier own
1658 // DoMoveWindow so it is easier to catch it here.
1659 wxWindowMSW
*parent
= GetParent();
1660 HDWP hdwp
= parent
&& !IsTopLevel() ?
(HDWP
)parent
->m_hDWP
: NULL
;
1663 m_pendingPosition
= wxPoint(x
, y
);
1664 m_pendingSize
= wxSize(width
, height
);
1668 m_pendingPosition
= wxDefaultPosition
;
1669 m_pendingSize
= wxDefaultSize
;
1673 DoMoveWindow(x
, y
, width
, height
);
1676 void wxWindowMSW
::DoSetClientSize(int width
, int height
)
1678 // setting the client size is less obvious than it it could have been
1679 // because in the result of changing the total size the window scrollbar
1680 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1681 // will not be correct as the difference between the total and client size
1682 // changes - so we keep changing it until we get it right
1684 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1685 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1686 // may become 3 if the window had 0 size originally and so we didn't
1687 // calculate the scrollbar correction correctly during the first iteration)
1688 // but just to be on the safe side we check for it instead of making it an
1689 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1690 for ( int i
= 0; i
< 4; i
++ )
1693 ::GetClientRect(GetHwnd(), &rectClient
);
1695 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
1696 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1697 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1702 // Find the difference between the entire window (title bar and all)
1703 // and the client area; add this to the new client size to move the
1706 ::GetWindowRect(GetHwnd(), &rectWin
);
1708 const int widthWin
= rectWin
.right
- rectWin
.left
,
1709 heightWin
= rectWin
.bottom
- rectWin
.top
;
1711 // MoveWindow positions the child windows relative to the parent, so
1712 // adjust if necessary
1713 if ( !IsTopLevel() )
1715 wxWindow
*parent
= GetParent();
1718 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
1722 // don't call DoMoveWindow() because we want to move window immediately
1723 // and not defer it here
1724 if ( !::MoveWindow(GetHwnd(),
1727 width
+ widthWin
- rectClient
.right
,
1728 height
+ heightWin
- rectClient
.bottom
,
1731 wxLogLastError(_T("MoveWindow"));
1736 // ---------------------------------------------------------------------------
1738 // ---------------------------------------------------------------------------
1740 int wxWindowMSW
::GetCharHeight() const
1742 return wxGetTextMetrics(this).tmHeight
;
1745 int wxWindowMSW
::GetCharWidth() const
1747 // +1 is needed because Windows apparently adds it when calculating the
1748 // dialog units size in pixels
1749 #if wxDIALOG_UNIT_COMPATIBILITY
1750 return wxGetTextMetrics(this).tmAveCharWidth
;
1752 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1756 void wxWindowMSW
::GetTextExtent(const wxString
& string
,
1758 int *descent
, int *externalLeading
,
1759 const wxFont
*theFont
) const
1761 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1762 _T("invalid font in GetTextExtent()") );
1766 fontToUse
= *theFont
;
1768 fontToUse
= GetFont();
1770 WindowHDC
hdc(GetHwnd());
1771 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1775 ::GetTextExtentPoint32(hdc
, string
, string
.length(), &sizeRect
);
1776 GetTextMetrics(hdc
, &tm
);
1783 *descent
= tm
.tmDescent
;
1784 if ( externalLeading
)
1785 *externalLeading
= tm
.tmExternalLeading
;
1788 // ---------------------------------------------------------------------------
1790 // ---------------------------------------------------------------------------
1792 #if wxUSE_MENUS_NATIVE
1794 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1795 // immediately, without waiting for the next event loop iteration
1797 // NB: this function should probably be made public later as it can almost
1798 // surely replace wxYield() elsewhere as well
1799 static void wxYieldForCommandsOnly()
1801 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1802 // want to process it here)
1804 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1806 if ( msg
.message
== WM_QUIT
)
1808 // if we retrieved a WM_QUIT, insert back into the message queue.
1809 ::PostQuitMessage(0);
1813 // luckily (as we don't have access to wxEventLoopImpl method from here
1814 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1816 ::TranslateMessage(&msg
);
1817 ::DispatchMessage(&msg
);
1821 bool wxWindowMSW
::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1823 menu
->SetInvokingWindow(this);
1826 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1828 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1829 x
= mouse
.x
; y
= mouse
.y
;
1832 HWND hWnd
= GetHwnd();
1833 HMENU hMenu
= GetHmenuOf(menu
);
1837 ::ClientToScreen(hWnd
, &point
);
1838 wxCurrentPopupMenu
= menu
;
1839 #if defined(__WXWINCE__)
1842 UINT flags
= TPM_RIGHTBUTTON
;
1844 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1846 // we need to do it righ now as otherwise the events are never going to be
1847 // sent to wxCurrentPopupMenu from HandleCommand()
1849 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1850 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1851 // destroyed as soon as we return (it can be a local variable in the caller
1852 // for example) and so we do need to process the event immediately
1853 wxYieldForCommandsOnly();
1855 wxCurrentPopupMenu
= NULL
;
1857 menu
->SetInvokingWindow(NULL
);
1862 #endif // wxUSE_MENUS_NATIVE
1864 // ===========================================================================
1865 // pre/post message processing
1866 // ===========================================================================
1868 WXLRESULT wxWindowMSW
::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1871 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1873 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1876 bool wxWindowMSW
::MSWProcessMessage(WXMSG
* pMsg
)
1878 // wxUniversal implements tab traversal itself
1879 #ifndef __WXUNIVERSAL__
1880 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1882 // intercept dialog navigation keys
1883 MSG
*msg
= (MSG
*)pMsg
;
1885 // here we try to do all the job which ::IsDialogMessage() usually does
1887 if ( msg
->message
== WM_KEYDOWN
)
1889 bool bCtrlDown
= wxIsCtrlDown();
1890 bool bShiftDown
= wxIsShiftDown();
1892 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1893 // don't process it if it's the case (except for Ctrl-Tab/Enter
1894 // combinations which are always processed)
1898 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1900 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1901 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1902 // it, of course, implies them
1903 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1905 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1909 bool bForward
= true,
1910 bWindowChange
= false,
1913 // should we process this message specially?
1914 bool bProcess
= true;
1915 switch ( msg
->wParam
)
1918 if ( lDlgCode
& DLGC_WANTTAB
) {
1922 // Ctrl-Tab cycles thru notebook pages
1923 bWindowChange
= bCtrlDown
;
1924 bForward
= !bShiftDown
;
1931 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1939 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1945 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1947 // control wants to process Enter itself, don't
1948 // call IsDialogMessage() which would interpret
1952 else if ( lDlgCode
& DLGC_BUTTON
)
1954 // let IsDialogMessage() handle this for all
1955 // buttons except the owner-drawn ones which it
1956 // just seems to ignore
1957 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1958 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1960 // emulate the button click
1961 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1963 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1968 // FIXME: this should be handled by
1969 // wxNavigationKeyEvent handler and not here!
1973 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1975 if ( btn
&& btn
->IsEnabled() )
1977 // if we do have a default button, do press it
1978 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1982 else // no default button
1983 #endif // wxUSE_BUTTON
1985 // this is a quick and dirty test for a text
1987 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1989 // don't process Enter, the control might
1990 // need it for itself and don't let
1991 // ::IsDialogMessage() have it as it can
1992 // eat the Enter events sometimes
1995 else if (!IsTopLevel())
1997 // if not a top level window, let parent
2001 //else: treat Enter as TAB: pass to the next
2002 // control as this is the best thing to do
2003 // if the text doesn't handle Enter itself
2015 wxNavigationKeyEvent event
;
2016 event
.SetDirection(bForward
);
2017 event
.SetWindowChange(bWindowChange
);
2018 event
.SetFromTab(bFromTab
);
2019 event
.SetEventObject(this);
2021 if ( GetEventHandler()->ProcessEvent(event
) )
2028 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2029 // message even when there is no cancel button and when the message is
2030 // needed by the control itself: in particular, it prevents the tree in
2031 // place edit control from being closed with Escape in a dialog
2032 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2034 // ::IsDialogMessage() is broken and may sometimes hang the
2035 // application by going into an infinite loop, so we try to detect
2036 // [some of] the situatations when this may happen and not call it
2039 // assume we can call it by default
2040 bool canSafelyCallIsDlgMsg
= true;
2042 HWND hwndFocus
= ::GetFocus();
2044 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2045 // an infinite loop, because it will recursively check the child
2046 // windows but not the window itself and so if none of the children
2047 // accepts focus it loops forever (as it only stops when it gets
2048 // back to the window it started from)
2050 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2051 // style has the focus, it can happen. One such possibility is if
2052 // all windows are either toplevel, wxDialog, wxPanel or static
2053 // controls and no window can actually accept keyboard input.
2054 #if !defined(__WXWINCE__)
2055 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2057 // passimistic by default
2058 canSafelyCallIsDlgMsg
= false;
2059 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
2061 node
= node
->GetNext() )
2063 wxWindow
* const win
= node
->GetData();
2064 if ( win
->AcceptsFocus() &&
2065 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2066 WS_EX_CONTROLPARENT
) )
2068 // it shouldn't hang...
2069 canSafelyCallIsDlgMsg
= true;
2075 #endif // !__WXWINCE__
2077 if ( canSafelyCallIsDlgMsg
)
2079 // ::IsDialogMessage() can enter in an infinite loop when the
2080 // currently focused window is disabled or hidden and its
2081 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2085 if ( !::IsWindowEnabled(hwndFocus
) ||
2086 !::IsWindowVisible(hwndFocus
) )
2088 // it would enter an infinite loop if we do this!
2089 canSafelyCallIsDlgMsg
= false;
2094 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2096 // it's a top level window, don't go further -- e.g. even
2097 // if the parent of a dialog is disabled, this doesn't
2098 // break navigation inside the dialog
2102 hwndFocus
= ::GetParent(hwndFocus
);
2106 // let IsDialogMessage() have the message if it's safe to call it
2107 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2109 // IsDialogMessage() did something...
2114 #endif // __WXUNIVERSAL__
2119 // relay mouse move events to the tooltip control
2120 MSG
*msg
= (MSG
*)pMsg
;
2121 if ( msg
->message
== WM_MOUSEMOVE
)
2122 m_tooltip
->RelayEvent(pMsg
);
2124 #endif // wxUSE_TOOLTIPS
2129 bool wxWindowMSW
::MSWTranslateMessage(WXMSG
* pMsg
)
2131 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2132 return m_acceleratorTable
.Translate(this, pMsg
);
2136 #endif // wxUSE_ACCEL
2139 bool wxWindowMSW
::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2141 // preprocess all messages by default
2145 // ---------------------------------------------------------------------------
2146 // message params unpackers
2147 // ---------------------------------------------------------------------------
2149 void wxWindowMSW
::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2150 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2152 *id
= LOWORD(wParam
);
2153 *hwnd
= (WXHWND
)lParam
;
2154 *cmd
= HIWORD(wParam
);
2157 void wxWindowMSW
::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2158 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2160 *state
= LOWORD(wParam
);
2161 *minimized
= HIWORD(wParam
);
2162 *hwnd
= (WXHWND
)lParam
;
2165 void wxWindowMSW
::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2166 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2168 *code
= LOWORD(wParam
);
2169 *pos
= HIWORD(wParam
);
2170 *hwnd
= (WXHWND
)lParam
;
2173 void wxWindowMSW
::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2174 WXHDC
*hdc
, WXHWND
*hwnd
)
2176 *hwnd
= (WXHWND
)lParam
;
2177 *hdc
= (WXHDC
)wParam
;
2180 void wxWindowMSW
::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2181 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2183 *item
= (WXWORD
)wParam
;
2184 *flags
= HIWORD(wParam
);
2185 *hmenu
= (WXHMENU
)lParam
;
2188 // ---------------------------------------------------------------------------
2189 // Main wxWidgets window proc and the window proc for wxWindow
2190 // ---------------------------------------------------------------------------
2192 // Hook for new window just as it's being created, when the window isn't yet
2193 // associated with the handle
2194 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2196 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2197 // window being created and insures that it's always unset back later
2198 wxWindowCreationHook
::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2200 gs_winBeingCreated
= winBeingCreated
;
2203 wxWindowCreationHook
::~wxWindowCreationHook()
2205 gs_winBeingCreated
= NULL
;
2209 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2211 // trace all messages - useful for the debugging
2213 wxLogTrace(wxTraceMessages
,
2214 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2215 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2216 #endif // __WXDEBUG__
2218 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2220 // when we get the first message for the HWND we just created, we associate
2221 // it with wxWindow stored in gs_winBeingCreated
2222 if ( !wnd
&& gs_winBeingCreated
)
2224 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2225 wnd
= gs_winBeingCreated
;
2226 gs_winBeingCreated
= NULL
;
2227 wnd
->SetHWND((WXHWND
)hWnd
);
2233 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2235 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2240 WXLRESULT wxWindowMSW
::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2242 // did we process the message?
2243 bool processed
= false;
2253 // for most messages we should return 0 when we do process the message
2261 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2264 // return 0 to allow window creation
2265 rc
.result
= mayCreate ?
0 : -1;
2271 // never set processed to true and *always* pass WM_DESTROY to
2272 // DefWindowProc() as Windows may do some internal cleanup when
2273 // processing it and failing to pass the message along may cause
2274 // memory and resource leaks!
2275 (void)HandleDestroy();
2279 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2283 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2286 #if !defined(__WXWINCE__)
2289 LPRECT pRect
= (LPRECT
)lParam
;
2291 rc
.SetLeft(pRect
->left
);
2292 rc
.SetTop(pRect
->top
);
2293 rc
.SetRight(pRect
->right
);
2294 rc
.SetBottom(pRect
->bottom
);
2295 processed
= HandleMoving(rc
);
2297 pRect
->left
= rc
.GetLeft();
2298 pRect
->top
= rc
.GetTop();
2299 pRect
->right
= rc
.GetRight();
2300 pRect
->bottom
= rc
.GetBottom();
2307 LPRECT pRect
= (LPRECT
)lParam
;
2309 rc
.SetLeft(pRect
->left
);
2310 rc
.SetTop(pRect
->top
);
2311 rc
.SetRight(pRect
->right
);
2312 rc
.SetBottom(pRect
->bottom
);
2313 processed
= HandleSizing(rc
);
2315 pRect
->left
= rc
.GetLeft();
2316 pRect
->top
= rc
.GetTop();
2317 pRect
->right
= rc
.GetRight();
2318 pRect
->bottom
= rc
.GetBottom();
2322 #endif // !__WXWINCE__
2324 #if !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
2325 case WM_WINDOWPOSCHANGED
:
2327 WINDOWPOS
*lpPos
= (WINDOWPOS
*)lParam
;
2329 if ( !(lpPos
->flags
& SWP_NOSIZE
) )
2332 ::GetClientRect(GetHwnd(), &rc
);
2334 AutoHRGN
hrgnClient(::CreateRectRgnIndirect(&rc
));
2335 AutoHRGN
hrgnNew(::CreateRectRgn(lpPos
->x
, lpPos
->y
,
2336 lpPos
->cx
, lpPos
->cy
));
2338 // we need to invalidate any new exposed areas here
2339 // to force them to repaint
2340 if ( ::CombineRgn(hrgnNew
, hrgnNew
, hrgnClient
, RGN_DIFF
) != NULLREGION
)
2341 ::InvalidateRgn(GetHwnd(), hrgnNew
, TRUE
);
2346 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2347 case WM_ACTIVATEAPP
:
2348 // This implicitly sends a wxEVT_ACTIVATE_APP event
2349 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2355 WXWORD state
, minimized
;
2357 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2359 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2364 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2368 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2371 case WM_PRINTCLIENT
:
2372 processed
= HandlePrintClient((WXHDC
)wParam
);
2378 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2380 processed
= HandlePaint();
2384 processed
= HandlePaint();
2389 #ifdef __WXUNIVERSAL__
2390 // Universal uses its own wxFrame/wxDialog, so we don't receive
2391 // close events unless we have this.
2393 #endif // __WXUNIVERSAL__
2395 // don't let the DefWindowProc() destroy our window - we'll do it
2396 // ourselves in ~wxWindow
2402 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2406 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2407 GET_Y_LPARAM(lParam
),
2411 #ifdef HAVE_TRACKMOUSEEVENT
2413 // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
2414 if ( m_mouseInWindow
)
2416 GenerateMouseLeave();
2419 // always pass processed back as false, this allows the window
2420 // manager to process the message too. This is needed to
2421 // ensure windows XP themes work properly as the mouse moves
2422 // over widgets like buttons. So don't set processed to true here.
2424 #endif // HAVE_TRACKMOUSEEVENT
2426 #if wxUSE_MOUSEWHEEL
2428 processed
= HandleMouseWheel(wParam
, lParam
);
2432 case WM_LBUTTONDOWN
:
2434 case WM_LBUTTONDBLCLK
:
2435 case WM_RBUTTONDOWN
:
2437 case WM_RBUTTONDBLCLK
:
2438 case WM_MBUTTONDOWN
:
2440 case WM_MBUTTONDBLCLK
:
2442 #ifdef __WXMICROWIN__
2443 // MicroWindows seems to ignore the fact that a window is
2444 // disabled. So catch mouse events and throw them away if
2446 wxWindowMSW
* win
= this;
2449 if (!win
->IsEnabled())
2455 win
= win
->GetParent();
2456 if ( !win
|| win
->IsTopLevel() )
2463 #endif // __WXMICROWIN__
2464 int x
= GET_X_LPARAM(lParam
),
2465 y
= GET_Y_LPARAM(lParam
);
2467 // redirect the event to a static control if necessary by
2468 // finding one under mouse
2470 if ( GetCapture() == this )
2472 // but don't do it if the mouse is captured by this window
2473 // because then it should really get this event itself
2478 win
= FindWindowForMouseEvent(this, &x
, &y
);
2480 // this should never happen
2481 wxCHECK_MSG( win
, 0,
2482 _T("FindWindowForMouseEvent() returned NULL") );
2485 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2487 // if the app didn't eat the event, handle it in the default
2488 // way, that is by giving this window the focus
2491 // for the standard classes their WndProc sets the focus to
2492 // them anyhow and doing it from here results in some weird
2493 // problems, so don't do it for them (unnecessary anyhow)
2494 if ( !win
->IsOfStandardClass() )
2496 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2508 case MM_JOY1BUTTONDOWN
:
2509 case MM_JOY2BUTTONDOWN
:
2510 case MM_JOY1BUTTONUP
:
2511 case MM_JOY2BUTTONUP
:
2512 processed
= HandleJoystickEvent(message
,
2513 GET_X_LPARAM(lParam
),
2514 GET_Y_LPARAM(lParam
),
2517 #endif // __WXMICROWIN__
2523 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2525 processed
= HandleCommand(id
, cmd
, hwnd
);
2530 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2533 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2534 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2535 // apparently doesn't always behave properly and needs some help
2536 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2537 case WM_NOTIFYFORMAT
:
2538 if ( lParam
== NF_QUERY
)
2541 rc
.result
= NFR_UNICODE
;
2544 #endif // wxUSE_UNICODE_MSLU
2546 // for these messages we must return true if process the message
2549 case WM_MEASUREITEM
:
2551 int idCtrl
= (UINT
)wParam
;
2552 if ( message
== WM_DRAWITEM
)
2554 processed
= MSWOnDrawItem(idCtrl
,
2555 (WXDRAWITEMSTRUCT
*)lParam
);
2559 processed
= MSWOnMeasureItem(idCtrl
,
2560 (WXMEASUREITEMSTRUCT
*)lParam
);
2567 #endif // defined(WM_DRAWITEM)
2570 if ( !IsOfStandardClass() )
2572 // we always want to get the char events
2573 rc
.result
= DLGC_WANTCHARS
;
2575 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2577 // in fact, we want everything
2578 rc
.result
|= DLGC_WANTARROWS
|
2585 //else: get the dlg code from the DefWindowProc()
2590 // If this has been processed by an event handler, return 0 now
2591 // (we've handled it).
2592 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2593 if ( m_lastKeydownProcessed
)
2602 // we consider these message "not interesting" to OnChar, so
2603 // just don't do anything more with them
2613 // avoid duplicate messages to OnChar for these ASCII keys:
2614 // they will be translated by TranslateMessage() and received
2636 // but set processed to false, not true to still pass them
2637 // to the control's default window proc - otherwise
2638 // built-in keyboard handling won't work
2643 // special case of VK_APPS: treat it the same as right mouse
2644 // click because both usually pop up a context menu
2646 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2651 // do generate a CHAR event
2652 processed
= HandleChar((WORD
)wParam
, lParam
);
2655 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2662 // special case of VK_APPS: treat it the same as right mouse button
2663 if ( wParam
== VK_APPS
)
2665 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2670 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2675 case WM_CHAR
: // Always an ASCII character
2676 if ( m_lastKeydownProcessed
)
2678 // The key was handled in the EVT_KEY_DOWN and handling
2679 // a key in an EVT_KEY_DOWN handler is meant, by
2680 // design, to prevent EVT_CHARs from happening
2681 m_lastKeydownProcessed
= false;
2686 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2692 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2694 #endif // wxUSE_HOTKEY
2701 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2703 processed
= MSWOnScroll(message
== WM_HSCROLL ? wxHORIZONTAL
2709 // CTLCOLOR messages are sent by children to query the parent for their
2711 #ifndef __WXMICROWIN__
2712 case WM_CTLCOLORMSGBOX
:
2713 case WM_CTLCOLOREDIT
:
2714 case WM_CTLCOLORLISTBOX
:
2715 case WM_CTLCOLORBTN
:
2716 case WM_CTLCOLORDLG
:
2717 case WM_CTLCOLORSCROLLBAR
:
2718 case WM_CTLCOLORSTATIC
:
2722 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2724 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2727 #endif // !__WXMICROWIN__
2729 case WM_SYSCOLORCHANGE
:
2730 // the return value for this message is ignored
2731 processed
= HandleSysColorChange();
2734 #if !defined(__WXWINCE__)
2735 case WM_DISPLAYCHANGE
:
2736 processed
= HandleDisplayChange();
2740 case WM_PALETTECHANGED
:
2741 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2744 case WM_CAPTURECHANGED
:
2745 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2748 case WM_QUERYNEWPALETTE
:
2749 processed
= HandleQueryNewPalette();
2753 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2756 // we processed the message, i.e. erased the background
2761 #if !defined(__WXWINCE__)
2763 processed
= HandleDropFiles(wParam
);
2768 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2772 // we never set focus from here
2777 #if !defined(__WXWINCE__)
2778 case WM_QUERYENDSESSION
:
2779 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2783 processed
= HandleEndSession(wParam
!= 0, lParam
);
2786 case WM_GETMINMAXINFO
:
2787 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2792 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2793 LOWORD(lParam
), // hit test
2794 HIWORD(lParam
)); // mouse msg
2798 // returning TRUE stops the DefWindowProc() from further
2799 // processing this message - exactly what we need because we've
2800 // just set the cursor.
2805 #if wxUSE_ACCESSIBILITY
2808 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2809 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2811 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2813 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2819 #if defined(WM_HELP)
2822 // HELPINFO doesn't seem to be supported on WinCE.
2824 HELPINFO
* info
= (HELPINFO
*) lParam
;
2825 // Don't yet process menu help events, just windows
2826 if (info
->iContextType
== HELPINFO_WINDOW
)
2829 wxWindowMSW
* subjectOfHelp
= this;
2830 bool eventProcessed
= false;
2831 while (subjectOfHelp
&& !eventProcessed
)
2833 wxHelpEvent
helpEvent(wxEVT_HELP
,
2834 subjectOfHelp
->GetId(),
2838 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2842 helpEvent
.SetEventObject(this);
2844 GetEventHandler()->ProcessEvent(helpEvent
);
2846 // Go up the window hierarchy until the event is
2848 subjectOfHelp
= subjectOfHelp
->GetParent();
2851 processed
= eventProcessed
;
2854 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2856 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2857 helpEvent
.SetEventObject(this);
2858 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2861 //else: processed is already false
2867 #if !defined(__WXWINCE__)
2868 case WM_CONTEXTMENU
:
2870 // we don't convert from screen to client coordinates as
2871 // the event may be handled by a parent window
2872 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2874 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2876 // we could have got an event from our child, reflect it back
2877 // to it if this is the case
2878 wxWindowMSW
*win
= NULL
;
2879 if ( (WXHWND
)wParam
!= m_hWnd
)
2881 win
= FindItemByHWND((WXHWND
)wParam
);
2887 evtCtx
.SetEventObject(win
);
2888 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
2894 // we're only interested in our own menus, not MF_SYSMENU
2895 if ( HIWORD(wParam
) == MF_POPUP
)
2897 // handle menu chars for ownerdrawn menu items
2898 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2899 if ( i
!= wxNOT_FOUND
)
2901 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2911 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2912 wxGetMessageName(message
));
2913 #endif // __WXDEBUG__
2914 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2920 // ----------------------------------------------------------------------------
2921 // wxWindow <-> HWND map
2922 // ----------------------------------------------------------------------------
2924 wxWinHashTable
*wxWinHandleHash
= NULL
;
2926 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2928 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
2931 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2933 // adding NULL hWnd is (first) surely a result of an error and
2934 // (secondly) breaks menu command processing
2935 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2936 wxT("attempt to add a NULL hWnd to window list ignored") );
2938 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2940 if ( oldWin
&& (oldWin
!= win
) )
2942 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2943 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2946 #endif // __WXDEBUG__
2949 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2953 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2955 wxWinHandleHash
->Delete((long)win
->GetHWND());
2958 // ----------------------------------------------------------------------------
2959 // various MSW speciic class dependent functions
2960 // ----------------------------------------------------------------------------
2962 // Default destroyer - override if you destroy it in some other way
2963 // (e.g. with MDI child windows)
2964 void wxWindowMSW
::MSWDestroyWindow()
2968 bool wxWindowMSW
::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2971 int& w
, int& h
) const
2973 // yes, those are just some arbitrary hardcoded numbers
2974 static const int DEFAULT_Y
= 200;
2976 bool nonDefault
= false;
2978 if ( pos
.x
== wxDefaultCoord
)
2980 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
2981 // can just as well set it to CW_USEDEFAULT as well
2987 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2988 // neither because it is not handled as a special value by Windows then
2989 // and so we have to choose some default value for it
2991 y
= pos
.y
== wxDefaultCoord ? DEFAULT_Y
: pos
.y
;
2997 NB: there used to be some code here which set the initial size of the
2998 window to the client size of the parent if no explicit size was
2999 specified. This was wrong because wxWidgets programs often assume
3000 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3001 it. To see why, you should understand that Windows sends WM_SIZE from
3002 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3003 from some base class ctor and so this WM_SIZE is not processed in the
3004 real class' OnSize() (because it's not fully constructed yet and the
3005 event goes to some base class OnSize() instead). So the WM_SIZE we
3006 rely on is the one sent when the parent frame resizes its children
3007 but here is the problem: if the child already has just the right
3008 size, nothing will happen as both wxWidgets and Windows check for
3009 this and ignore any attempts to change the window size to the size it
3010 already has - so no WM_SIZE would be sent.
3014 // we don't use CW_USEDEFAULT here for several reasons:
3016 // 1. it results in huge frames on modern screens (1000*800 is not
3017 // uncommon on my 1280*1024 screen) which is way too big for a half
3018 // empty frame of most of wxWidgets samples for example)
3020 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3021 // the default is for whatever reason 8*8 which breaks client <->
3022 // window size calculations (it would be nice if it didn't, but it
3023 // does and the simplest way to fix it seemed to change the broken
3024 // default size anyhow)
3026 // 3. there is just no advantage in doing it: with x and y it is
3027 // possible that [future versions of] Windows position the new top
3028 // level window in some smart way which we can't do, but we can
3029 // guess a reasonably good size for a new window just as well
3032 // However, on PocketPC devices, we must use the default
3033 // size if possible.
3035 if (size
.x
== wxDefaultCoord
)
3039 if (size
.y
== wxDefaultCoord
)
3044 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3048 w
= WidthDefault(size
.x
);
3049 h
= HeightDefault(size
.y
);
3052 AdjustForParentClientOrigin(x
, y
);
3057 WXHWND wxWindowMSW
::MSWGetParent() const
3059 return m_parent ? m_parent
->GetHWND() : WXHWND(NULL
);
3062 bool wxWindowMSW
::MSWCreate(const wxChar
*wclass
,
3063 const wxChar
*title
,
3067 WXDWORD extendedStyle
)
3069 // choose the position/size for the new window
3071 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3073 // controlId is menu handle for the top level windows, so set it to 0
3074 // unless we're creating a child window
3075 int controlId
= style
& WS_CHILD ?
GetId() : 0;
3077 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3078 // which is the same but without CS_[HV]REDRAW class styles so using it
3079 // ensures that the window is not fully repainted on each resize
3080 wxString
className(wclass
);
3081 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3083 className
+= wxT("NR");
3086 // do create the window
3087 wxWindowCreationHook
hook(this);
3089 m_hWnd
= (WXHWND
)::CreateWindowEx
3093 title ? title
: m_windowName
.c_str(),
3096 (HWND
)MSWGetParent(),
3099 NULL
// no extra data
3104 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3109 SubclassWin(m_hWnd
);
3114 // ===========================================================================
3115 // MSW message handlers
3116 // ===========================================================================
3118 // ---------------------------------------------------------------------------
3120 // ---------------------------------------------------------------------------
3124 bool wxWindowMSW
::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3126 #ifndef __WXMICROWIN__
3127 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3128 HWND hWnd
= hdr
->hwndFrom
;
3129 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3131 // if the control is one of our windows, let it handle the message itself
3134 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3137 // VZ: why did we do it? normally this is unnecessary and, besides, it
3138 // breaks the message processing for the toolbars because the tooltip
3139 // notifications were being forwarded to the toolbar child controls
3140 // (if it had any) before being passed to the toolbar itself, so in my
3141 // example the tooltip for the combobox was always shown instead of the
3142 // correct button tooltips
3144 // try all our children
3145 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3148 wxWindow
*child
= node
->GetData();
3149 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3154 node
= node
->GetNext();
3158 // by default, handle it ourselves
3159 return MSWOnNotify(idCtrl
, lParam
, result
);
3160 #else // __WXMICROWIN__
3167 bool wxWindowMSW
::HandleTooltipNotify(WXUINT code
,
3169 const wxString
& ttip
)
3171 // I don't know why it happens, but the versions of comctl32.dll starting
3172 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3173 // this message is supposed to be sent to Unicode programs only) -- hence
3174 // we need to handle it as well, otherwise no tooltips will be shown in
3177 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3180 // not a tooltip message or no tooltip to show anyhow
3185 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3187 // We don't want to use the szText buffer because it has a limit of 80
3188 // bytes and this is not enough, especially for Unicode build where it
3189 // limits the tooltip string length to only 40 characters
3191 // The best would be, of course, to not impose any length limitations at
3192 // all but then the buffer would have to be dynamic and someone would have
3193 // to free it and we don't have the tooltip owner object here any more, so
3194 // for now use our own static buffer with a higher fixed max length.
3196 // Note that using a static buffer should not be a problem as only a single
3197 // tooltip can be shown at the same time anyhow.
3199 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3201 // We need to convert tooltip from multi byte to Unicode on the fly.
3202 static wchar_t buf
[513];
3204 // Truncate tooltip length if needed as otherwise we might not have
3205 // enough space for it in the buffer and MultiByteToWideChar() would
3207 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3209 // Convert to WideChar without adding the NULL character. The NULL
3210 // character is added afterwards (this is more efficient).
3211 int len
= ::MultiByteToWideChar
3223 wxLogLastError(_T("MultiByteToWideChar()"));
3227 ttText
->lpszText
= (LPSTR
) buf
;
3229 else // TTN_NEEDTEXTA
3230 #endif // !wxUSE_UNICODE
3232 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3233 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3234 // to copy the string we have into the buffer
3235 static wxChar buf
[513];
3236 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3237 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3238 ttText
->lpszText
= buf
;
3244 #endif // wxUSE_TOOLTIPS
3246 bool wxWindowMSW
::MSWOnNotify(int WXUNUSED(idCtrl
),
3248 WXLPARAM
* WXUNUSED(result
))
3253 NMHDR
* hdr
= (NMHDR
*)lParam
;
3254 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3261 wxUnusedVar(lParam
);
3262 #endif // wxUSE_TOOLTIPS
3269 // ---------------------------------------------------------------------------
3270 // end session messages
3271 // ---------------------------------------------------------------------------
3273 bool wxWindowMSW
::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3275 #ifdef ENDSESSION_LOGOFF
3276 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3277 event
.SetEventObject(wxTheApp
);
3278 event
.SetCanVeto(true);
3279 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3281 bool rc
= wxTheApp
->ProcessEvent(event
);
3285 // we may end only if the app didn't veto session closing (double
3287 *mayEnd
= !event
.GetVeto();
3292 wxUnusedVar(logOff
);
3293 wxUnusedVar(mayEnd
);
3298 bool wxWindowMSW
::HandleEndSession(bool endSession
, long logOff
)
3300 #ifdef ENDSESSION_LOGOFF
3301 // do nothing if the session isn't ending
3306 if ( (this != wxTheApp
->GetTopWindow()) )
3309 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3310 event
.SetEventObject(wxTheApp
);
3311 event
.SetCanVeto(false);
3312 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3314 return wxTheApp
->ProcessEvent(event
);
3316 wxUnusedVar(endSession
);
3317 wxUnusedVar(logOff
);
3322 // ---------------------------------------------------------------------------
3323 // window creation/destruction
3324 // ---------------------------------------------------------------------------
3326 bool wxWindowMSW
::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3329 // VZ: why is this commented out for WinCE? If it doesn't support
3330 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3331 // not with multiple #ifdef's!
3333 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3334 EnsureParentHasControlParentStyle(GetParent());
3335 #endif // !__WXWINCE__
3337 // TODO: should generate this event from WM_NCCREATE
3338 wxWindowCreateEvent
event((wxWindow
*)this);
3339 (void)GetEventHandler()->ProcessEvent(event
);
3346 bool wxWindowMSW
::HandleDestroy()
3350 // delete our drop target if we've got one
3351 #if wxUSE_DRAG_AND_DROP
3352 if ( m_dropTarget
!= NULL
)
3354 m_dropTarget
->Revoke(m_hWnd
);
3356 delete m_dropTarget
;
3357 m_dropTarget
= NULL
;
3359 #endif // wxUSE_DRAG_AND_DROP
3361 // WM_DESTROY handled
3365 // ---------------------------------------------------------------------------
3367 // ---------------------------------------------------------------------------
3369 bool wxWindowMSW
::HandleActivate(int state
,
3370 bool WXUNUSED(minimized
),
3371 WXHWND
WXUNUSED(activate
))
3373 wxActivateEvent
event(wxEVT_ACTIVATE
,
3374 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3376 event
.SetEventObject(this);
3378 return GetEventHandler()->ProcessEvent(event
);
3381 bool wxWindowMSW
::HandleSetFocus(WXHWND hwnd
)
3383 // Strangly enough, some controls get set focus events when they are being
3384 // deleted, even if they already had focus before.
3385 if ( m_isBeingDeleted
)
3390 // notify the parent keeping track of focus for the kbd navigation
3391 // purposes that we got it
3392 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3393 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3399 m_caret
->OnSetFocus();
3401 #endif // wxUSE_CARET
3404 // If it's a wxTextCtrl don't send the event as it will be done
3405 // after the control gets to process it from EN_FOCUS handler
3406 if ( wxDynamicCastThis(wxTextCtrl
) )
3410 #endif // wxUSE_TEXTCTRL
3412 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3413 event
.SetEventObject(this);
3415 // wxFindWinFromHandle() may return NULL, it is ok
3416 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3418 return GetEventHandler()->ProcessEvent(event
);
3421 bool wxWindowMSW
::HandleKillFocus(WXHWND hwnd
)
3427 m_caret
->OnKillFocus();
3429 #endif // wxUSE_CARET
3432 // If it's a wxTextCtrl don't send the event as it will be done
3433 // after the control gets to process it.
3434 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3441 // Don't send the event when in the process of being deleted. This can
3442 // only cause problems if the event handler tries to access the object.
3443 if ( m_isBeingDeleted
)
3448 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3449 event
.SetEventObject(this);
3451 // wxFindWinFromHandle() may return NULL, it is ok
3452 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3454 return GetEventHandler()->ProcessEvent(event
);
3457 // ---------------------------------------------------------------------------
3459 // ---------------------------------------------------------------------------
3461 bool wxWindowMSW
::HandleShow(bool show
, int WXUNUSED(status
))
3463 wxShowEvent
event(GetId(), show
);
3464 event
.SetEventObject(this);
3466 return GetEventHandler()->ProcessEvent(event
);
3469 bool wxWindowMSW
::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3471 wxInitDialogEvent
event(GetId());
3472 event
.SetEventObject(this);
3474 return GetEventHandler()->ProcessEvent(event
);
3477 bool wxWindowMSW
::HandleDropFiles(WXWPARAM wParam
)
3479 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3480 wxUnusedVar(wParam
);
3482 #else // __WXMICROWIN__
3483 HDROP hFilesInfo
= (HDROP
) wParam
;
3485 // Get the total number of files dropped
3486 UINT gwFilesDropped
= ::DragQueryFile
3494 wxString
*files
= new wxString
[gwFilesDropped
];
3495 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3497 // first get the needed buffer length (+1 for terminating NUL)
3498 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3500 // and now get the file name
3501 ::DragQueryFile(hFilesInfo
, wIndex
,
3502 wxStringBuffer(files
[wIndex
], len
), len
);
3504 DragFinish (hFilesInfo
);
3506 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3507 event
.SetEventObject(this);
3510 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3511 event
.m_pos
.x
= dropPoint
.x
;
3512 event
.m_pos
.y
= dropPoint
.y
;
3514 return GetEventHandler()->ProcessEvent(event
);
3519 bool wxWindowMSW
::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3521 int WXUNUSED(mouseMsg
))
3523 #ifndef __WXMICROWIN__
3524 // the logic is as follows:
3525 // -1. don't set cursor for non client area, including but not limited to
3526 // the title bar, scrollbars, &c
3527 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3528 // 1. if we have the cursor set it unless wxIsBusy()
3529 // 2. if we're a top level window, set some cursor anyhow
3530 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3532 if ( nHitTest
!= HTCLIENT
)
3537 HCURSOR hcursor
= 0;
3539 // first ask the user code - it may wish to set the cursor in some very
3540 // specific way (for example, depending on the current position)
3543 if ( !::GetCursorPosWinCE(&pt
))
3545 if ( !::GetCursorPos(&pt
) )
3548 wxLogLastError(wxT("GetCursorPos"));
3553 ScreenToClient(&x
, &y
);
3554 wxSetCursorEvent
event(x
, y
);
3556 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3557 if ( processedEvtSetCursor
&& event
.HasCursor() )
3559 hcursor
= GetHcursorOf(event
.GetCursor());
3564 bool isBusy
= wxIsBusy();
3566 // the test for processedEvtSetCursor is here to prevent using m_cursor
3567 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3568 // it - this is a way to say that our cursor shouldn't be used for this
3570 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3572 hcursor
= GetHcursorOf(m_cursor
);
3579 hcursor
= wxGetCurrentBusyCursor();
3581 else if ( !hcursor
)
3583 const wxCursor
*cursor
= wxGetGlobalCursor();
3584 if ( cursor
&& cursor
->Ok() )
3586 hcursor
= GetHcursorOf(*cursor
);
3594 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3596 ::SetCursor(hcursor
);
3598 // cursor set, stop here
3601 #endif // __WXMICROWIN__
3603 // pass up the window chain
3607 // ---------------------------------------------------------------------------
3608 // owner drawn stuff
3609 // ---------------------------------------------------------------------------
3611 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3612 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3613 #define WXUNUSED_UNLESS_ODRAWN(param) param
3615 #define WXUNUSED_UNLESS_ODRAWN(param)
3619 wxWindowMSW
::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3620 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3622 #if wxUSE_OWNER_DRAWN
3624 #if wxUSE_MENUS_NATIVE
3625 // is it a menu item?
3626 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3627 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3629 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3631 // see comment before the same test in MSWOnMeasureItem() below
3635 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3636 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3638 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3639 // the DC from being released
3640 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3641 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3642 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3643 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3645 return pMenuItem
->OnDrawItem
3649 (wxOwnerDrawn
::wxODAction
)pDrawStruct
->itemAction
,
3650 (wxOwnerDrawn
::wxODStatus
)pDrawStruct
->itemState
3653 #endif // wxUSE_MENUS_NATIVE
3655 #endif // USE_OWNER_DRAWN
3657 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3659 #if wxUSE_OWNER_DRAWN
3660 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3661 #else // !wxUSE_OWNER_DRAWN
3662 // we may still have owner-drawn buttons internally because we have to make
3663 // them owner-drawn to support colour change
3666 wxDynamicCast(FindItem(id
), wxButton
)
3671 #endif // USE_OWNER_DRAWN
3675 return item
->MSWOnDraw(itemStruct
);
3678 #endif // wxUSE_CONTROLS
3684 wxWindowMSW
::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3686 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3687 // is it a menu item?
3688 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3689 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3691 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3693 // according to Carsten Fuchs the pointer may be NULL under XP if an
3694 // MDI child frame is initially maximized, see this for more info:
3695 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
3697 // so silently ignore it instead of asserting
3701 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3702 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3705 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3707 pMeasureStruct
->itemWidth
= w
;
3708 pMeasureStruct
->itemHeight
= h
;
3713 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3716 return item
->MSWOnMeasure(itemStruct
);
3720 wxUnusedVar(itemStruct
);
3721 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3726 // ---------------------------------------------------------------------------
3727 // colours and palettes
3728 // ---------------------------------------------------------------------------
3730 bool wxWindowMSW
::HandleSysColorChange()
3732 wxSysColourChangedEvent event
;
3733 event
.SetEventObject(this);
3735 (void)GetEventHandler()->ProcessEvent(event
);
3737 // always let the system carry on the default processing to allow the
3738 // native controls to react to the colours update
3742 bool wxWindowMSW
::HandleDisplayChange()
3744 wxDisplayChangedEvent event
;
3745 event
.SetEventObject(this);
3747 return GetEventHandler()->ProcessEvent(event
);
3750 #ifndef __WXMICROWIN__
3752 bool wxWindowMSW
::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
3754 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
3758 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
3761 *brush
= item
->MSWControlColor(hDC
, hWnd
);
3763 #endif // wxUSE_CONTROLS
3766 return *brush
!= NULL
;
3769 #endif // __WXMICROWIN__
3771 bool wxWindowMSW
::HandlePaletteChanged(WXHWND hWndPalChange
)
3774 // same as below except we don't respond to our own messages
3775 if ( hWndPalChange
!= GetHWND() )
3777 // check to see if we our our parents have a custom palette
3778 wxWindowMSW
*win
= this;
3779 while ( win
&& !win
->HasCustomPalette() )
3781 win
= win
->GetParent();
3784 if ( win
&& win
->HasCustomPalette() )
3786 // realize the palette to see whether redrawing is needed
3787 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3788 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3789 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3791 int result
= ::RealizePalette(hdc
);
3793 // restore the palette (before releasing the DC)
3794 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3795 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3796 ::RealizePalette(hdc
);
3797 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3799 // now check for the need to redraw
3801 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3805 #endif // wxUSE_PALETTE
3807 wxPaletteChangedEvent
event(GetId());
3808 event
.SetEventObject(this);
3809 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3811 return GetEventHandler()->ProcessEvent(event
);
3814 bool wxWindowMSW
::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3816 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3817 event
.SetEventObject(this);
3819 return GetEventHandler()->ProcessEvent(event
);
3822 bool wxWindowMSW
::HandleQueryNewPalette()
3826 // check to see if we our our parents have a custom palette
3827 wxWindowMSW
*win
= this;
3828 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3829 if (win
->HasCustomPalette()) {
3830 /* realize the palette to see whether redrawing is needed */
3831 HDC hdc
= ::GetDC((HWND
) GetHWND());
3832 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3833 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3835 int result
= ::RealizePalette(hdc
);
3836 /* restore the palette (before releasing the DC) */
3837 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3838 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3839 ::RealizePalette(hdc
);
3840 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3841 /* now check for the need to redraw */
3843 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3845 #endif // wxUSE_PALETTE
3847 wxQueryNewPaletteEvent
event(GetId());
3848 event
.SetEventObject(this);
3850 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3853 // Responds to colour changes: passes event on to children.
3854 void wxWindowMSW
::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3856 // the top level window also reset the standard colour map as it might have
3857 // changed (there is no need to do it for the non top level windows as we
3858 // only have to do it once)
3862 gs_hasStdCmap
= false;
3864 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3867 // Only propagate to non-top-level windows because Windows already
3868 // sends this event to all top-level ones
3869 wxWindow
*win
= node
->GetData();
3870 if ( !win
->IsTopLevel() )
3872 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3873 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3874 // the standard controls
3875 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3878 node
= node
->GetNext();
3882 extern wxCOLORMAP
*wxGetStdColourMap()
3884 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3885 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3887 if ( !gs_hasStdCmap
)
3889 static bool s_coloursInit
= false;
3891 if ( !s_coloursInit
)
3893 // When a bitmap is loaded, the RGB values can change (apparently
3894 // because Windows adjusts them to care for the old programs always
3895 // using 0xc0c0c0 while the transparent colour for the new Windows
3896 // versions is different). But we do this adjustment ourselves so
3897 // we want to avoid Windows' "help" and for this we need to have a
3898 // reference bitmap which can tell us what the RGB values change
3900 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
3901 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3902 if ( stdColourBitmap
.Ok() )
3904 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3905 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3906 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3909 memDC
.SelectObject(stdColourBitmap
);
3912 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3914 memDC
.GetPixel(i
, 0, &colour
);
3915 s_stdColours
[i
] = wxColourToRGB(colour
);
3918 else // wxBITMAP_STD_COLOURS couldn't be loaded
3920 s_stdColours
[0] = RGB(000,000,000); // black
3921 s_stdColours
[1] = RGB(128,128,128); // dark grey
3922 s_stdColours
[2] = RGB(192,192,192); // light grey
3923 s_stdColours
[3] = RGB(255,255,255); // white
3924 //s_stdColours[4] = RGB(000,000,255); // blue
3925 //s_stdColours[5] = RGB(255,000,255); // magenta
3928 s_coloursInit
= true;
3931 gs_hasStdCmap
= true;
3933 // create the colour map
3934 #define INIT_CMAP_ENTRY(col) \
3935 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3936 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3938 INIT_CMAP_ENTRY(BTNTEXT
);
3939 INIT_CMAP_ENTRY(BTNSHADOW
);
3940 INIT_CMAP_ENTRY(BTNFACE
);
3941 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3943 #undef INIT_CMAP_ENTRY
3949 // ---------------------------------------------------------------------------
3951 // ---------------------------------------------------------------------------
3953 bool wxWindowMSW
::HandlePaint()
3955 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3957 wxLogLastError(wxT("CreateRectRgn"));
3958 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3959 wxLogLastError(wxT("GetUpdateRgn"));
3961 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3963 wxPaintEvent
event(m_windowId
);
3964 event
.SetEventObject(this);
3966 bool processed
= GetEventHandler()->ProcessEvent(event
);
3968 // note that we must generate NC event after the normal one as otherwise
3969 // BeginPaint() will happily overwrite our decorations with the background
3971 wxNcPaintEvent
eventNc(m_windowId
);
3972 eventNc
.SetEventObject(this);
3973 GetEventHandler()->ProcessEvent(eventNc
);
3978 // Can be called from an application's OnPaint handler
3979 void wxWindowMSW
::OnPaint(wxPaintEvent
& event
)
3981 #ifdef __WXUNIVERSAL__
3984 HDC hDC
= (HDC
) wxPaintDC
::FindDCInCache((wxWindow
*) event
.GetEventObject());
3987 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3992 bool wxWindowMSW
::HandleEraseBkgnd(WXHDC hdc
)
3997 dc
.SetWindow((wxWindow
*)this);
4000 wxEraseEvent
event(m_windowId
, &dc
);
4001 event
.SetEventObject(this);
4002 bool rc
= GetEventHandler()->ProcessEvent(event
);
4006 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
4007 dc
.SelectOldObjects(hdc
);
4012 void wxWindowMSW
::OnEraseBackground(wxEraseEvent
& event
)
4014 // standard non top level controls (i.e. except the dialogs) always erase
4015 // their background themselves in HandleCtlColor() or have some control-
4016 // specific ways to set the colours (common controls)
4017 if ( IsOfStandardClass() && !IsTopLevel() )
4023 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4025 // don't skip the event here, custom background means that the app
4026 // is drawing it itself in its OnPaint(), so don't draw it at all
4027 // now to avoid flicker
4032 // do default background painting
4033 if ( !DoEraseBackground(GetHdcOf(*event
.GetDC())) )
4035 // let the system paint the background
4040 bool wxWindowMSW
::DoEraseBackground(WXHDC hDC
)
4042 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4046 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4052 wxWindowMSW
::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4056 // our background colour applies to:
4057 // 1. this window itself, always
4058 // 2. all children unless the colour is "not inheritable"
4059 // 3. even if it is not inheritable, our immediate transparent
4060 // children should still inherit it -- but not any transparent
4061 // children because it would look wrong if a child of non
4062 // transparent child would show our bg colour when the child itself
4064 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4067 (win
&& win
->HasTransparentBackground() &&
4068 win
->GetParent() == this) )
4070 // draw children with the same colour as the parent
4072 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4074 return (WXHBRUSH
)GetHbrushOf(*brush
);
4081 WXHBRUSH wxWindowMSW
::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4084 hWndToPaint
= GetHWND();
4086 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4088 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4092 // background is not inherited beyond top level windows
4093 if ( win
->IsTopLevel() )
4100 bool wxWindowMSW
::HandlePrintClient(WXHDC hDC
)
4102 // we receive this message when DrawThemeParentBackground() is
4103 // called from def window proc of several controls under XP and we
4104 // must draw properly themed background here
4106 // note that naively I'd expect filling the client rect with the
4107 // brush returned by MSWGetBgBrush() work -- but for some reason it
4108 // doesn't and we have to call parents MSWPrintChild() which is
4109 // supposed to call DrawThemeBackground() with appropriate params
4111 // also note that in this case lParam == PRF_CLIENT but we're
4112 // clearly expected to paint the background and nothing else!
4114 if ( IsTopLevel() || InheritsBackgroundColour() )
4117 // sometimes we don't want the parent to handle it at all, instead
4118 // return whatever value this window wants
4119 if ( !MSWShouldPropagatePrintChild() )
4120 return MSWPrintChild(hDC
, (wxWindow
*)this);
4122 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4124 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4127 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4134 // ---------------------------------------------------------------------------
4135 // moving and resizing
4136 // ---------------------------------------------------------------------------
4138 bool wxWindowMSW
::HandleMinimize()
4140 wxIconizeEvent
event(m_windowId
);
4141 event
.SetEventObject(this);
4143 return GetEventHandler()->ProcessEvent(event
);
4146 bool wxWindowMSW
::HandleMaximize()
4148 wxMaximizeEvent
event(m_windowId
);
4149 event
.SetEventObject(this);
4151 return GetEventHandler()->ProcessEvent(event
);
4154 bool wxWindowMSW
::HandleMove(int x
, int y
)
4157 wxMoveEvent
event(point
, m_windowId
);
4158 event
.SetEventObject(this);
4160 return GetEventHandler()->ProcessEvent(event
);
4163 bool wxWindowMSW
::HandleMoving(wxRect
& rect
)
4165 wxMoveEvent
event(rect
, m_windowId
);
4166 event
.SetEventObject(this);
4168 bool rc
= GetEventHandler()->ProcessEvent(event
);
4170 rect
= event
.GetRect();
4174 bool wxWindowMSW
::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4176 #if USE_DEFERRED_SIZING
4177 // when we resize this window, its children are probably going to be
4178 // repositioned as well, prepare to use DeferWindowPos() for them
4179 int numChildren
= 0;
4180 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4182 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4187 // Protect against valid m_hDWP being overwritten
4188 bool useDefer
= false;
4190 if ( numChildren
> 1 )
4194 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4197 wxLogLastError(_T("BeginDeferWindowPos"));
4205 // update this window size
4206 bool processed
= false;
4210 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4211 // fall through nevertheless
4215 // we're not interested in these messages at all
4218 case SIZE_MINIMIZED
:
4219 processed
= HandleMinimize();
4222 case SIZE_MAXIMIZED
:
4223 /* processed = */ HandleMaximize();
4224 // fall through to send a normal size event as well
4227 // don't use w and h parameters as they specify the client size
4228 // while according to the docs EVT_SIZE handler is supposed to
4229 // receive the total size
4230 wxSizeEvent
event(GetSize(), m_windowId
);
4231 event
.SetEventObject(this);
4233 processed
= GetEventHandler()->ProcessEvent(event
);
4236 #if USE_DEFERRED_SIZING
4237 // and finally change the positions of all child windows at once
4238 if ( useDefer
&& m_hDWP
)
4240 // reset m_hDWP to NULL so that child windows don't try to use our
4241 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4242 // happen anyhow normally but who knows what weird flow of control we
4243 // may have depending on what the users EVT_SIZE handler does...)
4244 HDWP hDWP
= (HDWP
)m_hDWP
;
4247 // do put all child controls in place at once
4248 if ( !::EndDeferWindowPos(hDWP
) )
4250 wxLogLastError(_T("EndDeferWindowPos"));
4253 #if USE_DEFER_BUG_WORKAROUND
4254 // Reset our children's pending pos/size values.
4255 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
4257 node
= node
->GetNext() )
4259 wxWindowMSW
*child
= node
->GetData();
4260 child
->m_pendingPosition
= wxDefaultPosition
;
4261 child
->m_pendingSize
= wxDefaultSize
;
4270 bool wxWindowMSW
::HandleSizing(wxRect
& rect
)
4272 wxSizeEvent
event(rect
, m_windowId
);
4273 event
.SetEventObject(this);
4275 bool rc
= GetEventHandler()->ProcessEvent(event
);
4277 rect
= event
.GetRect();
4281 bool wxWindowMSW
::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4286 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4290 int minWidth
= GetMinWidth(),
4291 minHeight
= GetMinHeight(),
4292 maxWidth
= GetMaxWidth(),
4293 maxHeight
= GetMaxHeight();
4295 if ( minWidth
!= wxDefaultCoord
)
4297 info
->ptMinTrackSize
.x
= minWidth
;
4301 if ( minHeight
!= wxDefaultCoord
)
4303 info
->ptMinTrackSize
.y
= minHeight
;
4307 if ( maxWidth
!= wxDefaultCoord
)
4309 info
->ptMaxTrackSize
.x
= maxWidth
;
4313 if ( maxHeight
!= wxDefaultCoord
)
4315 info
->ptMaxTrackSize
.y
= maxHeight
;
4323 // ---------------------------------------------------------------------------
4325 // ---------------------------------------------------------------------------
4327 bool wxWindowMSW
::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4329 #if wxUSE_MENUS_NATIVE
4330 if ( !cmd
&& wxCurrentPopupMenu
)
4332 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4333 wxCurrentPopupMenu
= NULL
;
4335 return popupMenu
->MSWCommand(cmd
, id
);
4337 #endif // wxUSE_MENUS_NATIVE
4339 wxWindow
*win
= NULL
;
4341 // first try to find it from HWND - this works even with the broken
4342 // programs using the same ids for different controls
4345 win
= wxFindWinFromHandle(control
);
4351 // must cast to a signed type before comparing with other ids!
4352 win
= FindItem((signed short)id
);
4357 return win
->MSWCommand(cmd
, id
);
4360 // the messages sent from the in-place edit control used by the treectrl
4361 // for label editing have id == 0, but they should _not_ be treated as menu
4362 // messages (they are EN_XXX ones, in fact) so don't translate anything
4363 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4366 // If no child window, it may be an accelerator, e.g. for a popup menu
4369 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4370 event
.SetEventObject(this);
4374 return GetEventHandler()->ProcessEvent(event
);
4378 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4379 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4380 // notifications to its parent which we want to reflect back to
4382 wxSpinCtrl
*spin
= wxSpinCtrl
::GetSpinForTextCtrl(control
);
4383 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4385 #endif // wxUSE_SPINCTRL
4387 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
4388 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
4389 // notifications to its parent which we want to reflect back to
4391 wxChoice
*choice
= wxChoice
::GetChoiceForListBox(control
);
4392 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
4400 // ---------------------------------------------------------------------------
4402 // ---------------------------------------------------------------------------
4404 void wxWindowMSW
::InitMouseEvent(wxMouseEvent
& event
,
4408 // our client coords are not quite the same as Windows ones
4409 wxPoint pt
= GetClientAreaOrigin();
4410 event
.m_x
= x
- pt
.x
;
4411 event
.m_y
= y
- pt
.y
;
4413 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4414 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4415 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4416 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4417 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4418 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4421 event
.SetTimestamp(::GetMessageTime());
4424 event
.SetEventObject(this);
4425 event
.SetId(GetId());
4427 #if wxUSE_MOUSEEVENT_HACK
4430 m_lastMouseEvent
= event
.GetEventType();
4431 #endif // wxUSE_MOUSEEVENT_HACK
4434 // Windows doesn't send the mouse events to the static controls (which are
4435 // transparent in the sense that their WM_NCHITTEST handler returns
4436 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4437 // and so we manually check if we don't have a child window under mouse and if
4438 // we do, send the event to it instead of the window Windows had sent WM_XXX
4441 // Notice that this is not done for the mouse move events because this could
4442 // (would?) be too slow, but only for clicks which means that the static texts
4443 // still don't get move, enter nor leave events.
4444 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4446 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4448 // first try to find a non transparent child: this allows us to send events
4449 // to a static text which is inside a static box, for example
4450 POINT pt
= { *x
, *y
};
4451 HWND hwnd
= GetHwndOf(win
),
4455 hwndUnderMouse
= ::ChildWindowFromPoint
4461 hwndUnderMouse
= ::ChildWindowFromPointEx
4471 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4473 // now try any child window at all
4474 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4477 // check that we have a child window which is susceptible to receive mouse
4478 // events: for this it must be shown and enabled
4479 if ( hwndUnderMouse
&&
4480 hwndUnderMouse
!= hwnd
&&
4481 ::IsWindowVisible(hwndUnderMouse
) &&
4482 ::IsWindowEnabled(hwndUnderMouse
) )
4484 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4485 if ( winUnderMouse
)
4487 // translate the mouse coords to the other window coords
4488 win
->ClientToScreen(x
, y
);
4489 winUnderMouse
->ScreenToClient(x
, y
);
4491 win
= winUnderMouse
;
4498 bool wxWindowMSW
::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4500 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4501 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4502 // from the message id and take the value in the table to get wxWin event
4504 static const wxEventType eventsMouse
[] =
4518 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4519 InitMouseEvent(event
, x
, y
, flags
);
4521 return GetEventHandler()->ProcessEvent(event
);
4524 bool wxWindowMSW
::HandleMouseMove(int x
, int y
, WXUINT flags
)
4526 if ( !m_mouseInWindow
)
4528 // it would be wrong to assume that just because we get a mouse move
4529 // event that the mouse is inside the window: although this is usually
4530 // true, it is not if we had captured the mouse, so we need to check
4531 // the mouse coordinates here
4532 if ( !HasCapture() || IsMouseInWindow() )
4534 // Generate an ENTER event
4535 m_mouseInWindow
= true;
4537 #ifdef HAVE_TRACKMOUSEEVENT
4538 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
4540 trackinfo
.dwFlags
= TME_LEAVE
;
4541 trackinfo
.hwndTrack
= GetHwnd();
4543 // Use the commctrl.h _TrackMouseEvent(), which will call the real
4544 // TrackMouseEvent() if available or emulate it
4545 _TrackMouseEvent(&trackinfo
);
4546 #endif // HAVE_TRACKMOUSEEVENT
4548 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4549 InitMouseEvent(event
, x
, y
, flags
);
4551 (void)GetEventHandler()->ProcessEvent(event
);
4555 #if wxUSE_MOUSEEVENT_HACK
4556 // Window gets a click down message followed by a mouse move message even
4557 // if position isn't changed! We want to discard the trailing move event
4558 // if x and y are the same.
4559 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4560 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4561 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4562 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4564 m_lastMouseEvent
= wxEVT_MOTION
;
4568 #endif // wxUSE_MOUSEEVENT_HACK
4570 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4574 bool wxWindowMSW
::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4576 #if wxUSE_MOUSEWHEEL
4577 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4578 InitMouseEvent(event
,
4579 GET_X_LPARAM(lParam
),
4580 GET_Y_LPARAM(lParam
),
4582 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4583 event
.m_wheelDelta
= WHEEL_DELTA
;
4585 static int s_linesPerRotation
= -1;
4586 if ( s_linesPerRotation
== -1 )
4588 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4589 &s_linesPerRotation
, 0))
4591 // this is not supposed to happen
4592 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4594 // the default is 3, so use it if SystemParametersInfo() failed
4595 s_linesPerRotation
= 3;
4599 event
.m_linesPerAction
= s_linesPerRotation
;
4600 return GetEventHandler()->ProcessEvent(event
);
4602 #else // !wxUSE_MOUSEWHEEL
4603 wxUnusedVar(wParam
);
4604 wxUnusedVar(lParam
);
4607 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
4610 void wxWindowMSW
::GenerateMouseLeave()
4612 m_mouseInWindow
= false;
4615 if ( wxIsShiftDown() )
4617 if ( wxIsCtrlDown() )
4618 state
|= MK_CONTROL
;
4620 // Only the high-order bit should be tested
4621 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
4622 state
|= MK_LBUTTON
;
4623 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
4624 state
|= MK_MBUTTON
;
4625 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
4626 state
|= MK_RBUTTON
;
4630 if ( !::GetCursorPosWinCE(&pt
) )
4632 if ( !::GetCursorPos(&pt
) )
4635 wxLogLastError(_T("GetCursorPos"));
4638 // we need to have client coordinates here for symmetry with
4639 // wxEVT_ENTER_WINDOW
4640 RECT rect
= wxGetWindowRect(GetHwnd());
4644 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
4645 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
4647 (void)GetEventHandler()->ProcessEvent(event
);
4650 // ---------------------------------------------------------------------------
4651 // keyboard handling
4652 // ---------------------------------------------------------------------------
4654 // create the key event of the given type for the given key - used by
4655 // HandleChar and HandleKeyDown/Up
4656 wxKeyEvent wxWindowMSW
::CreateKeyEvent(wxEventType evType
,
4659 WXWPARAM wParam
) const
4661 wxKeyEvent
event(evType
);
4662 event
.SetId(GetId());
4663 event
.m_shiftDown
= wxIsShiftDown();
4664 event
.m_controlDown
= wxIsCtrlDown();
4665 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4667 event
.SetEventObject((wxWindow
*)this); // const_cast
4668 event
.m_keyCode
= id
;
4670 event
.m_uniChar
= (wxChar
) wParam
;
4672 event
.m_rawCode
= (wxUint32
) wParam
;
4673 event
.m_rawFlags
= (wxUint32
) lParam
;
4675 event
.SetTimestamp(::GetMessageTime());
4678 // translate the position to client coords
4681 GetCursorPosWinCE(&pt
);
4686 GetWindowRect(GetHwnd(),&rect
);
4696 // isASCII is true only when we're called from WM_CHAR handler and not from
4698 bool wxWindowMSW
::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4703 // If 1 -> 26, translate to either special keycode or just set
4704 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4705 // ControlDown() == true.
4707 if ( (id
> 0) && (id
< 27) )
4729 else // we're called from WM_KEYDOWN
4731 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4734 // it's ASCII and will be processed here only when called from
4735 // WM_CHAR (i.e. when isASCII = true), don't process it now
4740 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4742 // the alphanumeric keys produced by pressing AltGr+something on European
4743 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4744 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4745 // alphanumeric, so pretend that there are no modifiers at all (the
4746 // KEY_DOWN event would still have the correct modifiers if they're really
4748 if ( event
.m_controlDown
&& event
.m_altDown
&&
4749 (id
>= 32 && id
< 256) )
4751 event
.m_controlDown
=
4752 event
.m_altDown
= false;
4755 return GetEventHandler()->ProcessEvent(event
);
4758 bool wxWindowMSW
::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4760 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4764 // normal ASCII char
4768 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4770 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4771 if ( GetEventHandler()->ProcessEvent(event
) )
4780 bool wxWindowMSW
::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4782 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4786 // normal ASCII char
4790 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4792 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4793 if ( GetEventHandler()->ProcessEvent(event
) )
4800 int wxWindowMSW
::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
4801 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
4803 // FIXME: implement GetMenuItemCount for WinCE, possibly
4804 // in terms of GetMenuItemInfo
4806 const HMENU hmenu
= (HMENU
)lParam
;
4810 mii
.cbSize
= sizeof(MENUITEMINFO
);
4811 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4813 // find if we have this letter in any owner drawn item
4814 const int count
= ::GetMenuItemCount(hmenu
);
4815 for ( int i
= 0; i
< count
; i
++ )
4817 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4819 if ( mii
.fType
== MFT_OWNERDRAW
)
4821 // dwItemData member of the MENUITEMINFO is a
4822 // pointer to the associated wxMenuItem -- see the
4823 // menu creation code
4824 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4826 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4829 if ( *p
== _T('&') )
4831 // this is not the accel char, find the real one
4832 p
= wxStrchr(p
+ 1, _T('&'));
4834 else // got the accel char
4836 // FIXME-UNICODE: this comparison doesn't risk to work
4837 // for non ASCII accelerator characters I'm afraid, but
4839 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
4845 // this one doesn't match
4852 else // failed to get the menu text?
4854 // it's not fatal, so don't show error, but still log
4856 wxLogLastError(_T("GetMenuItemInfo"));
4863 // ---------------------------------------------------------------------------
4865 // ---------------------------------------------------------------------------
4867 bool wxWindowMSW
::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4871 if ( flags
& JOY_BUTTON1CHG
)
4872 change
= wxJOY_BUTTON1
;
4873 if ( flags
& JOY_BUTTON2CHG
)
4874 change
= wxJOY_BUTTON2
;
4875 if ( flags
& JOY_BUTTON3CHG
)
4876 change
= wxJOY_BUTTON3
;
4877 if ( flags
& JOY_BUTTON4CHG
)
4878 change
= wxJOY_BUTTON4
;
4881 if ( flags
& JOY_BUTTON1
)
4882 buttons
|= wxJOY_BUTTON1
;
4883 if ( flags
& JOY_BUTTON2
)
4884 buttons
|= wxJOY_BUTTON2
;
4885 if ( flags
& JOY_BUTTON3
)
4886 buttons
|= wxJOY_BUTTON3
;
4887 if ( flags
& JOY_BUTTON4
)
4888 buttons
|= wxJOY_BUTTON4
;
4890 // the event ids aren't consecutive so we can't use table based lookup
4892 wxEventType eventType
;
4897 eventType
= wxEVT_JOY_MOVE
;
4902 eventType
= wxEVT_JOY_MOVE
;
4907 eventType
= wxEVT_JOY_ZMOVE
;
4912 eventType
= wxEVT_JOY_ZMOVE
;
4915 case MM_JOY1BUTTONDOWN
:
4917 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4920 case MM_JOY2BUTTONDOWN
:
4922 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4925 case MM_JOY1BUTTONUP
:
4927 eventType
= wxEVT_JOY_BUTTON_UP
;
4930 case MM_JOY2BUTTONUP
:
4932 eventType
= wxEVT_JOY_BUTTON_UP
;
4936 wxFAIL_MSG(wxT("no such joystick event"));
4941 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4942 event
.SetPosition(wxPoint(x
, y
));
4943 event
.SetEventObject(this);
4945 return GetEventHandler()->ProcessEvent(event
);
4955 // ---------------------------------------------------------------------------
4957 // ---------------------------------------------------------------------------
4959 bool wxWindowMSW
::MSWOnScroll(int orientation
, WXWORD wParam
,
4960 WXWORD pos
, WXHWND control
)
4962 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
4964 wxWindow
*child
= wxFindWinFromHandle(control
);
4966 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4969 wxScrollWinEvent event
;
4970 event
.SetPosition(pos
);
4971 event
.SetOrientation(orientation
);
4972 event
.SetEventObject(this);
4977 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
4981 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
4985 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
4989 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
4993 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
4997 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
5000 case SB_THUMBPOSITION
:
5002 // under Win32, the scrollbar range and position are 32 bit integers,
5003 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
5004 // explicitly query the scrollbar for the correct position (this must
5005 // be done only for these two SB_ events as they are the only one
5006 // carrying the scrollbar position)
5008 WinStruct
<SCROLLINFO
> scrollInfo
;
5009 scrollInfo
.fMask
= SIF_TRACKPOS
;
5011 if ( !::GetScrollInfo(GetHwnd(),
5012 orientation
== wxHORIZONTAL ? SB_HORZ
5016 // Not necessarily an error, if there are no scrollbars yet.
5017 // wxLogLastError(_T("GetScrollInfo"));
5020 event
.SetPosition(scrollInfo
.nTrackPos
);
5023 event
.SetEventType( wParam
== SB_THUMBPOSITION
5024 ? wxEVT_SCROLLWIN_THUMBRELEASE
5025 : wxEVT_SCROLLWIN_THUMBTRACK
);
5032 return GetEventHandler()->ProcessEvent(event
);
5035 // ===========================================================================
5037 // ===========================================================================
5039 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5042 HDC dc
= ::GetDC((HWND
) wnd
);
5045 // the_font.UseResource();
5046 // the_font.RealizeResource();
5047 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5049 was
= (HFONT
) SelectObject(dc
,fnt
);
5051 GetTextMetrics(dc
, &tm
);
5054 SelectObject(dc
,was
);
5056 ReleaseDC((HWND
)wnd
, dc
);
5059 *x
= tm
.tmAveCharWidth
;
5061 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5063 // the_font.ReleaseResource();
5066 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5067 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5068 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
5073 case VK_CANCEL
: id
= WXK_CANCEL
; break;
5074 case VK_BACK
: id
= WXK_BACK
; break;
5075 case VK_TAB
: id
= WXK_TAB
; break;
5076 case VK_CLEAR
: id
= WXK_CLEAR
; break;
5077 case VK_SHIFT
: id
= WXK_SHIFT
; break;
5078 case VK_CONTROL
: id
= WXK_CONTROL
; break;
5079 case VK_MENU
: id
= WXK_ALT
; break;
5080 case VK_PAUSE
: id
= WXK_PAUSE
; break;
5081 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
5082 case VK_SPACE
: id
= WXK_SPACE
; break;
5083 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
5084 case VK_PRIOR
: id
= WXK_PRIOR
; break;
5085 case VK_NEXT
: id
= WXK_NEXT
; break;
5086 case VK_END
: id
= WXK_END
; break;
5087 case VK_HOME
: id
= WXK_HOME
; break;
5088 case VK_LEFT
: id
= WXK_LEFT
; break;
5089 case VK_UP
: id
= WXK_UP
; break;
5090 case VK_RIGHT
: id
= WXK_RIGHT
; break;
5091 case VK_DOWN
: id
= WXK_DOWN
; break;
5092 case VK_SELECT
: id
= WXK_SELECT
; break;
5093 case VK_PRINT
: id
= WXK_PRINT
; break;
5094 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
5095 case VK_INSERT
: id
= WXK_INSERT
; break;
5096 case VK_DELETE
: id
= WXK_DELETE
; break;
5097 case VK_HELP
: id
= WXK_HELP
; break;
5098 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
5099 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
5100 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
5101 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
5102 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
5103 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
5104 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
5105 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
5106 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
5107 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
5108 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
5109 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
5110 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
5111 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
5112 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
5113 case VK_F1
: id
= WXK_F1
; break;
5114 case VK_F2
: id
= WXK_F2
; break;
5115 case VK_F3
: id
= WXK_F3
; break;
5116 case VK_F4
: id
= WXK_F4
; break;
5117 case VK_F5
: id
= WXK_F5
; break;
5118 case VK_F6
: id
= WXK_F6
; break;
5119 case VK_F7
: id
= WXK_F7
; break;
5120 case VK_F8
: id
= WXK_F8
; break;
5121 case VK_F9
: id
= WXK_F9
; break;
5122 case VK_F10
: id
= WXK_F10
; break;
5123 case VK_F11
: id
= WXK_F11
; break;
5124 case VK_F12
: id
= WXK_F12
; break;
5125 case VK_F13
: id
= WXK_F13
; break;
5126 case VK_F14
: id
= WXK_F14
; break;
5127 case VK_F15
: id
= WXK_F15
; break;
5128 case VK_F16
: id
= WXK_F16
; break;
5129 case VK_F17
: id
= WXK_F17
; break;
5130 case VK_F18
: id
= WXK_F18
; break;
5131 case VK_F19
: id
= WXK_F19
; break;
5132 case VK_F20
: id
= WXK_F20
; break;
5133 case VK_F21
: id
= WXK_F21
; break;
5134 case VK_F22
: id
= WXK_F22
; break;
5135 case VK_F23
: id
= WXK_F23
; break;
5136 case VK_F24
: id
= WXK_F24
; break;
5137 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
5138 case VK_SCROLL
: id
= WXK_SCROLL
; break;
5140 // the mapping for these keys may be incorrect on non-US keyboards so
5141 // maybe we shouldn't map them to ASCII values at all
5142 case VK_OEM_1
: id
= ';'; break;
5143 case VK_OEM_PLUS
: id
= '+'; break;
5144 case VK_OEM_COMMA
: id
= ','; break;
5145 case VK_OEM_MINUS
: id
= '-'; break;
5146 case VK_OEM_PERIOD
: id
= '.'; break;
5147 case VK_OEM_2
: id
= '/'; break;
5148 case VK_OEM_3
: id
= '~'; break;
5149 case VK_OEM_4
: id
= '['; break;
5150 case VK_OEM_5
: id
= '\\'; break;
5151 case VK_OEM_6
: id
= ']'; break;
5152 case VK_OEM_7
: id
= '\''; break;
5155 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
5156 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
5157 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
5158 #endif // VK_APPS defined
5161 // the same key is sent for both the "return" key on the main
5162 // keyboard and the numeric keypad but we want to distinguish
5163 // between them: we do this using the "extended" bit (24) of lParam
5164 id
= lParam
& (1 << 24) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5174 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5180 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5181 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5182 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5183 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5184 case WXK_ALT
: keySym
= VK_MENU
; break;
5185 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5186 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5187 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5188 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5189 case WXK_END
: keySym
= VK_END
; break;
5190 case WXK_HOME
: keySym
= VK_HOME
; break;
5191 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5192 case WXK_UP
: keySym
= VK_UP
; break;
5193 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5194 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5195 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5196 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5197 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5198 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5199 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5200 case WXK_HELP
: keySym
= VK_HELP
; break;
5201 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5202 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5203 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5204 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5205 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5206 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5207 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5208 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5209 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5210 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5211 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5212 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5213 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5214 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5215 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5216 case WXK_F1
: keySym
= VK_F1
; break;
5217 case WXK_F2
: keySym
= VK_F2
; break;
5218 case WXK_F3
: keySym
= VK_F3
; break;
5219 case WXK_F4
: keySym
= VK_F4
; break;
5220 case WXK_F5
: keySym
= VK_F5
; break;
5221 case WXK_F6
: keySym
= VK_F6
; break;
5222 case WXK_F7
: keySym
= VK_F7
; break;
5223 case WXK_F8
: keySym
= VK_F8
; break;
5224 case WXK_F9
: keySym
= VK_F9
; break;
5225 case WXK_F10
: keySym
= VK_F10
; break;
5226 case WXK_F11
: keySym
= VK_F11
; break;
5227 case WXK_F12
: keySym
= VK_F12
; break;
5228 case WXK_F13
: keySym
= VK_F13
; break;
5229 case WXK_F14
: keySym
= VK_F14
; break;
5230 case WXK_F15
: keySym
= VK_F15
; break;
5231 case WXK_F16
: keySym
= VK_F16
; break;
5232 case WXK_F17
: keySym
= VK_F17
; break;
5233 case WXK_F18
: keySym
= VK_F18
; break;
5234 case WXK_F19
: keySym
= VK_F19
; break;
5235 case WXK_F20
: keySym
= VK_F20
; break;
5236 case WXK_F21
: keySym
= VK_F21
; break;
5237 case WXK_F22
: keySym
= VK_F22
; break;
5238 case WXK_F23
: keySym
= VK_F23
; break;
5239 case WXK_F24
: keySym
= VK_F24
; break;
5240 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5241 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5252 bool wxGetKeyState(wxKeyCode key
)
5256 wxASSERT_MSG(key
!= WXK_LBUTTON
&& key
!= WXK_RBUTTON
&& key
!=
5257 WXK_MBUTTON
, wxT("can't use wxGetKeyState() for mouse buttons"));
5259 //High order with GetAsyncKeyState only available on WIN32
5261 //If the requested key is a LED key, return
5262 //true if the led is pressed
5263 if (key
== WXK_NUMLOCK
||
5264 key
== WXK_CAPITAL
||
5268 //low order bit means LED is highlighted,
5269 //high order means key is down
5270 //Here, for compat with other ports we want both
5271 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5278 //low order bit means key pressed since last call
5279 //high order means key is down
5280 //We want only the high order bit - the key may not be down if only low order
5281 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5286 wxWindow
*wxGetActiveWindow()
5288 HWND hWnd
= GetActiveWindow();
5291 return wxFindWinFromHandle((WXHWND
) hWnd
);
5296 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5298 HWND hwnd
= (HWND
)hWnd
;
5300 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5301 // by code in msw/radiobox.cpp), for all the others we just search up the
5303 wxWindow
*win
= (wxWindow
*)NULL
;
5306 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5310 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5311 // wxWindow class which overrides WM_GETDLGCODE processing to
5312 // do it as well, win would be already non NULL
5313 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5315 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5317 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5318 #endif // wxUSE_RADIOBOX
5320 // spin control text buddy window should be mapped to spin ctrl
5321 // itself so try it too
5322 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5325 win
= wxSpinCtrl
::GetSpinForTextCtrl((WXHWND
)hwnd
);
5327 #endif // wxUSE_SPINCTRL
5331 while ( hwnd
&& !win
)
5333 // this is a really ugly hack needed to avoid mistakenly returning the
5334 // parent frame wxWindow for the find/replace modeless dialog HWND -
5335 // this, in turn, is needed to call IsDialogMessage() from
5336 // wxApp::ProcessMessage() as for this we must return NULL from here
5338 // FIXME: this is clearly not the best way to do it but I think we'll
5339 // need to change HWND <-> wxWindow code more heavily than I can
5340 // do it now to fix it
5341 #ifndef __WXMICROWIN__
5342 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5344 // it's a dialog box, don't go upwards
5349 hwnd
= ::GetParent(hwnd
);
5350 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5356 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5358 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5359 // in active frames and dialogs, regardless of where the focus is.
5360 static HHOOK wxTheKeyboardHook
= 0;
5361 static FARPROC wxTheKeyboardHookProc
= 0;
5362 int APIENTRY _EXPORT
5363 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5365 void wxSetKeyboardHook(bool doIt
)
5369 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5370 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5372 GetCurrentThreadId()
5373 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5378 UnhookWindowsHookEx(wxTheKeyboardHook
);
5382 int APIENTRY _EXPORT
5383 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5385 DWORD hiWord
= HIWORD(lParam
);
5386 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5388 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5391 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5392 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5393 event
.m_altDown
= true;
5395 event
.SetEventObject(NULL
);
5396 event
.m_keyCode
= id
;
5397 event
.m_shiftDown
= wxIsShiftDown();
5398 event
.m_controlDown
= wxIsCtrlDown();
5400 event
.SetTimestamp(::GetMessageTime());
5402 wxWindow
*win
= wxGetActiveWindow();
5403 wxEvtHandler
*handler
;
5406 handler
= win
->GetEventHandler();
5407 event
.SetId(win
->GetId());
5412 event
.SetId(wxID_ANY
);
5415 if ( handler
&& handler
->ProcessEvent(event
) )
5423 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5426 #endif // !__WXMICROWIN__
5429 const char *wxGetMessageName(int message
)
5433 case 0x0000: return "WM_NULL";
5434 case 0x0001: return "WM_CREATE";
5435 case 0x0002: return "WM_DESTROY";
5436 case 0x0003: return "WM_MOVE";
5437 case 0x0005: return "WM_SIZE";
5438 case 0x0006: return "WM_ACTIVATE";
5439 case 0x0007: return "WM_SETFOCUS";
5440 case 0x0008: return "WM_KILLFOCUS";
5441 case 0x000A: return "WM_ENABLE";
5442 case 0x000B: return "WM_SETREDRAW";
5443 case 0x000C: return "WM_SETTEXT";
5444 case 0x000D: return "WM_GETTEXT";
5445 case 0x000E: return "WM_GETTEXTLENGTH";
5446 case 0x000F: return "WM_PAINT";
5447 case 0x0010: return "WM_CLOSE";
5448 case 0x0011: return "WM_QUERYENDSESSION";
5449 case 0x0012: return "WM_QUIT";
5450 case 0x0013: return "WM_QUERYOPEN";
5451 case 0x0014: return "WM_ERASEBKGND";
5452 case 0x0015: return "WM_SYSCOLORCHANGE";
5453 case 0x0016: return "WM_ENDSESSION";
5454 case 0x0017: return "WM_SYSTEMERROR";
5455 case 0x0018: return "WM_SHOWWINDOW";
5456 case 0x0019: return "WM_CTLCOLOR";
5457 case 0x001A: return "WM_WININICHANGE";
5458 case 0x001B: return "WM_DEVMODECHANGE";
5459 case 0x001C: return "WM_ACTIVATEAPP";
5460 case 0x001D: return "WM_FONTCHANGE";
5461 case 0x001E: return "WM_TIMECHANGE";
5462 case 0x001F: return "WM_CANCELMODE";
5463 case 0x0020: return "WM_SETCURSOR";
5464 case 0x0021: return "WM_MOUSEACTIVATE";
5465 case 0x0022: return "WM_CHILDACTIVATE";
5466 case 0x0023: return "WM_QUEUESYNC";
5467 case 0x0024: return "WM_GETMINMAXINFO";
5468 case 0x0026: return "WM_PAINTICON";
5469 case 0x0027: return "WM_ICONERASEBKGND";
5470 case 0x0028: return "WM_NEXTDLGCTL";
5471 case 0x002A: return "WM_SPOOLERSTATUS";
5472 case 0x002B: return "WM_DRAWITEM";
5473 case 0x002C: return "WM_MEASUREITEM";
5474 case 0x002D: return "WM_DELETEITEM";
5475 case 0x002E: return "WM_VKEYTOITEM";
5476 case 0x002F: return "WM_CHARTOITEM";
5477 case 0x0030: return "WM_SETFONT";
5478 case 0x0031: return "WM_GETFONT";
5479 case 0x0037: return "WM_QUERYDRAGICON";
5480 case 0x0039: return "WM_COMPAREITEM";
5481 case 0x0041: return "WM_COMPACTING";
5482 case 0x0044: return "WM_COMMNOTIFY";
5483 case 0x0046: return "WM_WINDOWPOSCHANGING";
5484 case 0x0047: return "WM_WINDOWPOSCHANGED";
5485 case 0x0048: return "WM_POWER";
5487 case 0x004A: return "WM_COPYDATA";
5488 case 0x004B: return "WM_CANCELJOURNAL";
5489 case 0x004E: return "WM_NOTIFY";
5490 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5491 case 0x0051: return "WM_INPUTLANGCHANGE";
5492 case 0x0052: return "WM_TCARD";
5493 case 0x0053: return "WM_HELP";
5494 case 0x0054: return "WM_USERCHANGED";
5495 case 0x0055: return "WM_NOTIFYFORMAT";
5496 case 0x007B: return "WM_CONTEXTMENU";
5497 case 0x007C: return "WM_STYLECHANGING";
5498 case 0x007D: return "WM_STYLECHANGED";
5499 case 0x007E: return "WM_DISPLAYCHANGE";
5500 case 0x007F: return "WM_GETICON";
5501 case 0x0080: return "WM_SETICON";
5503 case 0x0081: return "WM_NCCREATE";
5504 case 0x0082: return "WM_NCDESTROY";
5505 case 0x0083: return "WM_NCCALCSIZE";
5506 case 0x0084: return "WM_NCHITTEST";
5507 case 0x0085: return "WM_NCPAINT";
5508 case 0x0086: return "WM_NCACTIVATE";
5509 case 0x0087: return "WM_GETDLGCODE";
5510 case 0x00A0: return "WM_NCMOUSEMOVE";
5511 case 0x00A1: return "WM_NCLBUTTONDOWN";
5512 case 0x00A2: return "WM_NCLBUTTONUP";
5513 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5514 case 0x00A4: return "WM_NCRBUTTONDOWN";
5515 case 0x00A5: return "WM_NCRBUTTONUP";
5516 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5517 case 0x00A7: return "WM_NCMBUTTONDOWN";
5518 case 0x00A8: return "WM_NCMBUTTONUP";
5519 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5520 case 0x0100: return "WM_KEYDOWN";
5521 case 0x0101: return "WM_KEYUP";
5522 case 0x0102: return "WM_CHAR";
5523 case 0x0103: return "WM_DEADCHAR";
5524 case 0x0104: return "WM_SYSKEYDOWN";
5525 case 0x0105: return "WM_SYSKEYUP";
5526 case 0x0106: return "WM_SYSCHAR";
5527 case 0x0107: return "WM_SYSDEADCHAR";
5528 case 0x0108: return "WM_KEYLAST";
5530 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5531 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5532 case 0x010F: return "WM_IME_COMPOSITION";
5534 case 0x0110: return "WM_INITDIALOG";
5535 case 0x0111: return "WM_COMMAND";
5536 case 0x0112: return "WM_SYSCOMMAND";
5537 case 0x0113: return "WM_TIMER";
5538 case 0x0114: return "WM_HSCROLL";
5539 case 0x0115: return "WM_VSCROLL";
5540 case 0x0116: return "WM_INITMENU";
5541 case 0x0117: return "WM_INITMENUPOPUP";
5542 case 0x011F: return "WM_MENUSELECT";
5543 case 0x0120: return "WM_MENUCHAR";
5544 case 0x0121: return "WM_ENTERIDLE";
5545 case 0x0200: return "WM_MOUSEMOVE";
5546 case 0x0201: return "WM_LBUTTONDOWN";
5547 case 0x0202: return "WM_LBUTTONUP";
5548 case 0x0203: return "WM_LBUTTONDBLCLK";
5549 case 0x0204: return "WM_RBUTTONDOWN";
5550 case 0x0205: return "WM_RBUTTONUP";
5551 case 0x0206: return "WM_RBUTTONDBLCLK";
5552 case 0x0207: return "WM_MBUTTONDOWN";
5553 case 0x0208: return "WM_MBUTTONUP";
5554 case 0x0209: return "WM_MBUTTONDBLCLK";
5555 case 0x020A: return "WM_MOUSEWHEEL";
5556 case 0x0210: return "WM_PARENTNOTIFY";
5557 case 0x0211: return "WM_ENTERMENULOOP";
5558 case 0x0212: return "WM_EXITMENULOOP";
5560 case 0x0213: return "WM_NEXTMENU";
5561 case 0x0214: return "WM_SIZING";
5562 case 0x0215: return "WM_CAPTURECHANGED";
5563 case 0x0216: return "WM_MOVING";
5564 case 0x0218: return "WM_POWERBROADCAST";
5565 case 0x0219: return "WM_DEVICECHANGE";
5567 case 0x0220: return "WM_MDICREATE";
5568 case 0x0221: return "WM_MDIDESTROY";
5569 case 0x0222: return "WM_MDIACTIVATE";
5570 case 0x0223: return "WM_MDIRESTORE";
5571 case 0x0224: return "WM_MDINEXT";
5572 case 0x0225: return "WM_MDIMAXIMIZE";
5573 case 0x0226: return "WM_MDITILE";
5574 case 0x0227: return "WM_MDICASCADE";
5575 case 0x0228: return "WM_MDIICONARRANGE";
5576 case 0x0229: return "WM_MDIGETACTIVE";
5577 case 0x0230: return "WM_MDISETMENU";
5578 case 0x0233: return "WM_DROPFILES";
5580 case 0x0281: return "WM_IME_SETCONTEXT";
5581 case 0x0282: return "WM_IME_NOTIFY";
5582 case 0x0283: return "WM_IME_CONTROL";
5583 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5584 case 0x0285: return "WM_IME_SELECT";
5585 case 0x0286: return "WM_IME_CHAR";
5586 case 0x0290: return "WM_IME_KEYDOWN";
5587 case 0x0291: return "WM_IME_KEYUP";
5589 case 0x0300: return "WM_CUT";
5590 case 0x0301: return "WM_COPY";
5591 case 0x0302: return "WM_PASTE";
5592 case 0x0303: return "WM_CLEAR";
5593 case 0x0304: return "WM_UNDO";
5594 case 0x0305: return "WM_RENDERFORMAT";
5595 case 0x0306: return "WM_RENDERALLFORMATS";
5596 case 0x0307: return "WM_DESTROYCLIPBOARD";
5597 case 0x0308: return "WM_DRAWCLIPBOARD";
5598 case 0x0309: return "WM_PAINTCLIPBOARD";
5599 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5600 case 0x030B: return "WM_SIZECLIPBOARD";
5601 case 0x030C: return "WM_ASKCBFORMATNAME";
5602 case 0x030D: return "WM_CHANGECBCHAIN";
5603 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5604 case 0x030F: return "WM_QUERYNEWPALETTE";
5605 case 0x0310: return "WM_PALETTEISCHANGING";
5606 case 0x0311: return "WM_PALETTECHANGED";
5608 case 0x0312: return "WM_HOTKEY";
5611 // common controls messages - although they're not strictly speaking
5612 // standard, it's nice to decode them nevertheless
5615 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5616 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5617 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5618 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5619 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5620 case 0x1000 + 5: return "LVM_GETITEMA";
5621 case 0x1000 + 75: return "LVM_GETITEMW";
5622 case 0x1000 + 6: return "LVM_SETITEMA";
5623 case 0x1000 + 76: return "LVM_SETITEMW";
5624 case 0x1000 + 7: return "LVM_INSERTITEMA";
5625 case 0x1000 + 77: return "LVM_INSERTITEMW";
5626 case 0x1000 + 8: return "LVM_DELETEITEM";
5627 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5628 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5629 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5630 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5631 case 0x1000 + 13: return "LVM_FINDITEMA";
5632 case 0x1000 + 83: return "LVM_FINDITEMW";
5633 case 0x1000 + 14: return "LVM_GETITEMRECT";
5634 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5635 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5636 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5637 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5638 case 0x1000 + 18: return "LVM_HITTEST";
5639 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5640 case 0x1000 + 20: return "LVM_SCROLL";
5641 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5642 case 0x1000 + 22: return "LVM_ARRANGE";
5643 case 0x1000 + 23: return "LVM_EDITLABELA";
5644 case 0x1000 + 118: return "LVM_EDITLABELW";
5645 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5646 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5647 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5648 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5649 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5650 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5651 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5652 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5653 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5654 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5655 case 0x1000 + 31: return "LVM_GETHEADER";
5656 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5657 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5658 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5659 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5660 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5661 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5662 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5663 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5664 case 0x1000 + 41: return "LVM_GETORIGIN";
5665 case 0x1000 + 42: return "LVM_UPDATE";
5666 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5667 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5668 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5669 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5670 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5671 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5672 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5673 case 0x1000 + 48: return "LVM_SORTITEMS";
5674 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5675 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5676 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5677 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5678 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5679 case 0x1000 + 53: return "LVM_SETICONSPACING";
5680 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5681 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5682 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5683 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5684 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5685 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5686 case 0x1000 + 60: return "LVM_SETHOTITEM";
5687 case 0x1000 + 61: return "LVM_GETHOTITEM";
5688 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5689 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5690 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5691 case 0x1000 + 65: return "LVM_SETWORKAREA";
5694 case 0x1100 + 0: return "TVM_INSERTITEMA";
5695 case 0x1100 + 50: return "TVM_INSERTITEMW";
5696 case 0x1100 + 1: return "TVM_DELETEITEM";
5697 case 0x1100 + 2: return "TVM_EXPAND";
5698 case 0x1100 + 4: return "TVM_GETITEMRECT";
5699 case 0x1100 + 5: return "TVM_GETCOUNT";
5700 case 0x1100 + 6: return "TVM_GETINDENT";
5701 case 0x1100 + 7: return "TVM_SETINDENT";
5702 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5703 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5704 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5705 case 0x1100 + 11: return "TVM_SELECTITEM";
5706 case 0x1100 + 12: return "TVM_GETITEMA";
5707 case 0x1100 + 62: return "TVM_GETITEMW";
5708 case 0x1100 + 13: return "TVM_SETITEMA";
5709 case 0x1100 + 63: return "TVM_SETITEMW";
5710 case 0x1100 + 14: return "TVM_EDITLABELA";
5711 case 0x1100 + 65: return "TVM_EDITLABELW";
5712 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5713 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5714 case 0x1100 + 17: return "TVM_HITTEST";
5715 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5716 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5717 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5718 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5719 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5720 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5721 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5722 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5723 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5726 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5727 case 0x1200 + 1: return "HDM_INSERTITEMA";
5728 case 0x1200 + 10: return "HDM_INSERTITEMW";
5729 case 0x1200 + 2: return "HDM_DELETEITEM";
5730 case 0x1200 + 3: return "HDM_GETITEMA";
5731 case 0x1200 + 11: return "HDM_GETITEMW";
5732 case 0x1200 + 4: return "HDM_SETITEMA";
5733 case 0x1200 + 12: return "HDM_SETITEMW";
5734 case 0x1200 + 5: return "HDM_LAYOUT";
5735 case 0x1200 + 6: return "HDM_HITTEST";
5736 case 0x1200 + 7: return "HDM_GETITEMRECT";
5737 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5738 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5739 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5740 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5741 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5742 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5743 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5746 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5747 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5748 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5749 case 0x1300 + 5: return "TCM_GETITEMA";
5750 case 0x1300 + 60: return "TCM_GETITEMW";
5751 case 0x1300 + 6: return "TCM_SETITEMA";
5752 case 0x1300 + 61: return "TCM_SETITEMW";
5753 case 0x1300 + 7: return "TCM_INSERTITEMA";
5754 case 0x1300 + 62: return "TCM_INSERTITEMW";
5755 case 0x1300 + 8: return "TCM_DELETEITEM";
5756 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5757 case 0x1300 + 10: return "TCM_GETITEMRECT";
5758 case 0x1300 + 11: return "TCM_GETCURSEL";
5759 case 0x1300 + 12: return "TCM_SETCURSEL";
5760 case 0x1300 + 13: return "TCM_HITTEST";
5761 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5762 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5763 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5764 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5765 case 0x1300 + 43: return "TCM_SETPADDING";
5766 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5767 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5768 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5769 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5770 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5771 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5772 case 0x1300 + 50: return "TCM_DESELECTALL";
5775 case WM_USER
+1: return "TB_ENABLEBUTTON";
5776 case WM_USER
+2: return "TB_CHECKBUTTON";
5777 case WM_USER
+3: return "TB_PRESSBUTTON";
5778 case WM_USER
+4: return "TB_HIDEBUTTON";
5779 case WM_USER
+5: return "TB_INDETERMINATE";
5780 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5781 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5782 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5783 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5784 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5785 case WM_USER
+17: return "TB_SETSTATE";
5786 case WM_USER
+18: return "TB_GETSTATE";
5787 case WM_USER
+19: return "TB_ADDBITMAP";
5788 case WM_USER
+20: return "TB_ADDBUTTONS";
5789 case WM_USER
+21: return "TB_INSERTBUTTON";
5790 case WM_USER
+22: return "TB_DELETEBUTTON";
5791 case WM_USER
+23: return "TB_GETBUTTON";
5792 case WM_USER
+24: return "TB_BUTTONCOUNT";
5793 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5794 case WM_USER
+26: return "TB_SAVERESTOREA";
5795 case WM_USER
+76: return "TB_SAVERESTOREW";
5796 case WM_USER
+27: return "TB_CUSTOMIZE";
5797 case WM_USER
+28: return "TB_ADDSTRINGA";
5798 case WM_USER
+77: return "TB_ADDSTRINGW";
5799 case WM_USER
+29: return "TB_GETITEMRECT";
5800 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5801 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5802 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5803 case WM_USER
+33: return "TB_AUTOSIZE";
5804 case WM_USER
+35: return "TB_GETTOOLTIPS";
5805 case WM_USER
+36: return "TB_SETTOOLTIPS";
5806 case WM_USER
+37: return "TB_SETPARENT";
5807 case WM_USER
+39: return "TB_SETROWS";
5808 case WM_USER
+40: return "TB_GETROWS";
5809 case WM_USER
+42: return "TB_SETCMDID";
5810 case WM_USER
+43: return "TB_CHANGEBITMAP";
5811 case WM_USER
+44: return "TB_GETBITMAP";
5812 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5813 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5814 case WM_USER
+46: return "TB_REPLACEBITMAP";
5815 case WM_USER
+47: return "TB_SETINDENT";
5816 case WM_USER
+48: return "TB_SETIMAGELIST";
5817 case WM_USER
+49: return "TB_GETIMAGELIST";
5818 case WM_USER
+50: return "TB_LOADIMAGES";
5819 case WM_USER
+51: return "TB_GETRECT";
5820 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5821 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5822 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5823 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5824 case WM_USER
+56: return "TB_SETSTYLE";
5825 case WM_USER
+57: return "TB_GETSTYLE";
5826 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5827 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5828 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5829 case WM_USER
+61: return "TB_GETTEXTROWS";
5830 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5833 static char s_szBuf
[128];
5834 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5838 #endif //__WXDEBUG__
5840 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5844 HWND hwnd
= GetHwndOf(win
);
5845 HDC hdc
= ::GetDC(hwnd
);
5847 #if !wxDIALOG_UNIT_COMPATIBILITY
5848 // and select the current font into it
5849 HFONT hfont
= GetHfontOf(win
->GetFont());
5852 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5856 // finally retrieve the text metrics from it
5857 GetTextMetrics(hdc
, &tm
);
5859 #if !wxDIALOG_UNIT_COMPATIBILITY
5863 (void)::SelectObject(hdc
, hfont
);
5867 ::ReleaseDC(hwnd
, hdc
);
5872 // Find the wxWindow at the current mouse position, returning the mouse
5874 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5876 pt
= wxGetMousePosition();
5877 return wxFindWindowAtPoint(pt
);
5880 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5885 HWND hWndHit
= ::WindowFromPoint(pt2
);
5887 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5888 HWND hWnd
= hWndHit
;
5890 // Try to find a window with a wxWindow associated with it
5891 while (!win
&& (hWnd
!= 0))
5893 hWnd
= ::GetParent(hWnd
);
5894 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5899 // Get the current mouse position.
5900 wxPoint
wxGetMousePosition()
5904 GetCursorPosWinCE(&pt
);
5906 GetCursorPos( & pt
);
5909 return wxPoint(pt
.x
, pt
.y
);
5914 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
5915 static void WinCEUnregisterHotKey(int modifiers
, int id
)
5917 // Register hotkeys for the hardware buttons
5919 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
5921 UnregisterFunc1Proc procUnregisterFunc
;
5922 hCoreDll
= LoadLibrary(_T("coredll.dll"));
5925 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
5926 if (procUnregisterFunc
)
5927 procUnregisterFunc(modifiers
, id
);
5928 FreeLibrary(hCoreDll
);
5933 bool wxWindowMSW
::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5935 UINT win_modifiers
=0;
5936 if ( modifiers
& wxMOD_ALT
)
5937 win_modifiers
|= MOD_ALT
;
5938 if ( modifiers
& wxMOD_SHIFT
)
5939 win_modifiers
|= MOD_SHIFT
;
5940 if ( modifiers
& wxMOD_CONTROL
)
5941 win_modifiers
|= MOD_CONTROL
;
5942 if ( modifiers
& wxMOD_WIN
)
5943 win_modifiers
|= MOD_WIN
;
5945 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
5946 // Required for PPC and Smartphone hardware buttons
5947 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
5948 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
5951 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5953 wxLogLastError(_T("RegisterHotKey"));
5961 bool wxWindowMSW
::UnregisterHotKey(int hotkeyId
)
5963 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
5964 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
5967 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5969 wxLogLastError(_T("UnregisterHotKey"));
5979 bool wxWindowMSW
::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5981 int hotkeyId
= wParam
;
5982 int virtualKey
= HIWORD(lParam
);
5983 int win_modifiers
= LOWORD(lParam
);
5985 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5986 event
.SetId(hotkeyId
);
5987 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5988 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5989 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5990 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5992 return GetEventHandler()->ProcessEvent(event
);
5995 #endif // wxUSE_ACCEL
5997 #endif // wxUSE_HOTKEY
5999 // Moves a window by deferred method or normal method
6000 bool wxMoveWindowDeferred(HDWP
& hdwp
, wxWindowBase
* win
, HWND hWnd
, int x
, int y
, int width
, int height
)
6004 hdwp
= ::DeferWindowPos(hdwp
, hWnd
, NULL
,
6005 x
, y
, width
, height
,
6009 wxLogLastError(_T("DeferWindowPos"));
6013 // otherwise (or if deferring failed) move the window in place immediately
6016 if ( !::MoveWindow(hWnd
, x
, y
, width
, height
, win
->IsShown()) )
6018 wxLogLastError(wxT("MoveWindow"));
6021 return hdwp
!= NULL
;
6024 // Not tested under WinCE
6027 // this class installs a message hook which really wakes up our idle processing
6028 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
6029 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
6030 // being dragged or even inside ::MessageBox()) and so don't control message
6031 // dispatching otherwise
6032 class wxIdleWakeUpModule
: public wxModule
6035 virtual bool OnInit()
6037 ms_hMsgHookProc
= ::SetWindowsHookEx
6040 &wxIdleWakeUpModule
::MsgHookProc
,
6042 GetCurrentThreadId()
6045 if ( !ms_hMsgHookProc
)
6047 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6055 virtual void OnExit()
6057 ::UnhookWindowsHookEx(wxIdleWakeUpModule
::ms_hMsgHookProc
);
6060 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6062 MSG
*msg
= (MSG
*)lParam
;
6064 // only process the message if it is actually going to be removed from
6065 // the message queue, this prevents that the same event from being
6066 // processed multiple times if now someone just called PeekMessage()
6067 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
6069 wxTheApp
->ProcessPendingEvents();
6072 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
6076 static HHOOK ms_hMsgHookProc
;
6078 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
6081 HHOOK wxIdleWakeUpModule
::ms_hMsgHookProc
= 0;
6083 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
6085 #endif // __WXWINCE__
6090 static void wxAdjustZOrder(wxWindow
* parent
)
6092 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
6094 // Set the z-order correctly
6095 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
6098 wxWindowList
::compatibility_iterator current
= parent
->GetChildren().GetFirst();
6101 wxWindow
*childWin
= current
->GetData();
6102 wxAdjustZOrder(childWin
);
6103 current
= current
->GetNext();
6108 // We need to adjust the z-order of static boxes in WinCE, to
6109 // make 'contained' controls visible
6110 void wxWindowMSW
::OnInitDialog( wxInitDialogEvent
& event
)
6113 wxAdjustZOrder(this);