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/evtloop.h"
58 #include "wx/module.h"
59 #include "wx/sysopt.h"
61 #if wxUSE_DRAG_AND_DROP
65 #if wxUSE_ACCESSIBILITY
66 #include "wx/access.h"
70 #define WM_GETOBJECT 0x003D
73 #define OBJID_CLIENT 0xFFFFFFFC
77 #include "wx/menuitem.h"
80 #include "wx/msw/private.h"
83 #include "wx/tooltip.h"
91 #include "wx/spinctrl.h"
92 #endif // wxUSE_SPINCTRL
97 #include "wx/textctrl.h"
98 #include "wx/notebook.h"
99 #include "wx/listctrl.h"
103 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
104 #include <shellapi.h>
105 #include <mmsystem.h>
109 #include <windowsx.h>
112 #include <commctrl.h>
114 #include "wx/msw/missing.h"
116 #if defined(__WXWINCE__)
117 #include "wx/msw/wince/missing.h"
120 #if defined(TME_LEAVE) && defined(WM_MOUSELEAVE)
121 #define HAVE_TRACKMOUSEEVENT
122 #endif // everything needed for TrackMouseEvent()
124 // if this is set to 1, we use deferred window sizing to reduce flicker when
125 // resizing complicated window hierarchies, but this can in theory result in
126 // different behaviour than the old code so we keep the possibility to use it
127 // by setting this to 0 (in the future this should be removed completely)
128 #define USE_DEFERRED_SIZING 1
130 // ---------------------------------------------------------------------------
132 // ---------------------------------------------------------------------------
134 #if wxUSE_MENUS_NATIVE
135 wxMenu
*wxCurrentPopupMenu
= NULL
;
136 #endif // wxUSE_MENUS_NATIVE
139 extern wxChar
*wxCanvasClassName
;
141 extern const wxChar
*wxCanvasClassName
;
144 // true if we had already created the std colour map, used by
145 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
146 static bool gs_hasStdCmap
= false;
148 // ---------------------------------------------------------------------------
150 // ---------------------------------------------------------------------------
152 // the window proc for all our windows
153 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
,
154 WPARAM wParam
, LPARAM lParam
);
158 const char *wxGetMessageName(int message
);
161 void wxRemoveHandleAssociation(wxWindowMSW
*win
);
162 extern void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
);
163 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
);
165 // get the text metrics for the current font
166 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
);
168 // find the window for the mouse event at the specified position
169 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
); //TW:REQ:Univ
171 // wrapper around BringWindowToTop() API
172 static inline void wxBringWindowToTop(HWND hwnd
)
174 #ifdef __WXMICROWIN__
175 // It seems that MicroWindows brings the _parent_ of the window to the top,
176 // which can be the wrong one.
178 // activate (set focus to) specified window
182 // raise top level parent to top of z order
183 if (!::SetWindowPos(hwnd
, HWND_TOP
, 0, 0, 0, 0, SWP_NOMOVE
| SWP_NOSIZE
))
185 wxLogLastError(_T("SetWindowPos"));
191 // ensure that all our parent windows have WS_EX_CONTROLPARENT style
192 static void EnsureParentHasControlParentStyle(wxWindow
*parent
)
195 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
196 parent as well as otherwise several Win32 functions using
197 GetNextDlgTabItem() to iterate over all controls such as
198 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
199 all of them iterate over all the controls starting from the currently
200 focused one and stop iterating when they get back to the focus but
201 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
202 get back to the initial (focused) window: as we do have this style,
203 GetNextDlgTabItem() will leave this window and continue in its parent,
204 but if the parent doesn't have it, it wouldn't recurse inside it later
205 on and so wouldn't have a chance of getting back to this window neither.
207 while ( parent
&& !parent
->IsTopLevel() )
209 LONG exStyle
= ::GetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
);
210 if ( !(exStyle
& WS_EX_CONTROLPARENT
) )
212 // force the parent to have this style
213 ::SetWindowLong(GetHwndOf(parent
), GWL_EXSTYLE
,
214 exStyle
| WS_EX_CONTROLPARENT
);
217 parent
= parent
->GetParent();
221 #endif // !__WXWINCE__
224 // On Windows CE, GetCursorPos can return an error, so use this function
226 bool GetCursorPosWinCE(POINT
* pt
)
228 if (!GetCursorPos(pt
))
230 DWORD pos
= GetMessagePos();
238 // ---------------------------------------------------------------------------
240 // ---------------------------------------------------------------------------
242 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
244 #ifdef __WXUNIVERSAL__
245 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW
, wxWindowBase
)
247 #if wxUSE_EXTENDED_RTTI
249 // windows that are created from a parent window during its Create method, eg. spin controls in a calendar controls
250 // must never been streamed out separately otherwise chaos occurs. Right now easiest is to test for negative ids, as
251 // windows with negative ids never can be recreated anyway
253 bool wxWindowStreamingCallback( const wxObject
*object
, wxWriter
* , wxPersister
* , wxxVariantArray
& )
255 const wxWindow
* win
= dynamic_cast<const wxWindow
*>(object
) ;
256 if ( win
&& win
->GetId() < 0 )
261 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
,"wx/window.h", wxWindowStreamingCallback
)
263 // make wxWindowList known before the property is used
265 wxCOLLECTION_TYPE_INFO( wxWindow
* , wxWindowList
) ;
267 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
, wxxVariantArray
&value
)
269 wxListCollectionToVariantArray
<wxWindowList
::compatibility_iterator
>( theList
, value
) ;
272 WX_DEFINE_FLAGS( wxWindowStyle
)
274 wxBEGIN_FLAGS( wxWindowStyle
)
275 // new style border flags, we put them first to
276 // use them for streaming out
278 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
279 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
280 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
281 wxFLAGS_MEMBER(wxBORDER_RAISED
)
282 wxFLAGS_MEMBER(wxBORDER_STATIC
)
283 wxFLAGS_MEMBER(wxBORDER_NONE
)
285 // old style border flags
286 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
287 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
288 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
289 wxFLAGS_MEMBER(wxRAISED_BORDER
)
290 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
291 wxFLAGS_MEMBER(wxBORDER
)
293 // standard window styles
294 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
295 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
296 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
297 wxFLAGS_MEMBER(wxWANTS_CHARS
)
298 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
299 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
300 wxFLAGS_MEMBER(wxVSCROLL
)
301 wxFLAGS_MEMBER(wxHSCROLL
)
303 wxEND_FLAGS( wxWindowStyle
)
305 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
306 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
307 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
308 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
309 // Always constructor Properties first
311 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
312 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/ , 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
313 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // pos
314 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // size
315 wxPROPERTY( WindowStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
317 // Then all relations of the object graph
319 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
* , GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/ , wxT("Helpstring") , wxT("group"))
321 // and finally all other properties
323 wxPROPERTY( ExtraStyle
, long , SetExtraStyle
, GetExtraStyle
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // extstyle
324 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // bg
325 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // fg
326 wxPROPERTY( Enabled
, bool , Enable
, IsEnabled
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
327 wxPROPERTY( Shown
, bool , Show
, IsShown
, wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
329 // possible property candidates (not in xrc) or not valid in all subclasses
330 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
331 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
332 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
333 // MaxHeight, Width , MinHeight , Width
334 // TODO switch label to control and title to toplevels
336 wxPROPERTY( ThemeEnabled
, bool , SetThemeEnabled
, GetThemeEnabled
, )
337 //wxPROPERTY( Cursor , wxCursor , SetCursor , GetCursor , )
338 // wxPROPERTY( ToolTip , wxString , SetToolTip , GetToolTipText , )
339 wxPROPERTY( AutoLayout
, bool , SetAutoLayout
, GetAutoLayout
, )
344 wxEND_PROPERTIES_TABLE()
346 wxBEGIN_HANDLERS_TABLE(wxWindow
)
347 wxEND_HANDLERS_TABLE()
349 wxCONSTRUCTOR_DUMMY(wxWindow
)
352 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
354 #endif // __WXUNIVERSAL__/__WXMSW__
356 BEGIN_EVENT_TABLE(wxWindowMSW
, wxWindowBase
)
357 EVT_SYS_COLOUR_CHANGED(wxWindowMSW
::OnSysColourChanged
)
358 EVT_ERASE_BACKGROUND(wxWindowMSW
::OnEraseBackground
)
360 EVT_INIT_DIALOG(wxWindowMSW
::OnInitDialog
)
364 // ===========================================================================
366 // ===========================================================================
368 // ---------------------------------------------------------------------------
369 // wxWindow utility functions
370 // ---------------------------------------------------------------------------
372 // Find an item given the MS Windows id
373 wxWindow
*wxWindowMSW
::FindItem(long id
) const
376 wxControl
*item
= wxDynamicCastThis(wxControl
);
379 // is it we or one of our "internal" children?
380 if ( item
->GetId() == id
381 #ifndef __WXUNIVERSAL__
382 || (item
->GetSubcontrols().Index(id
) != wxNOT_FOUND
)
383 #endif // __WXUNIVERSAL__
389 #endif // wxUSE_CONTROLS
391 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
394 wxWindow
*childWin
= current
->GetData();
396 wxWindow
*wnd
= childWin
->FindItem(id
);
400 current
= current
->GetNext();
406 // Find an item given the MS Windows handle
407 wxWindow
*wxWindowMSW
::FindItemByHWND(WXHWND hWnd
, bool controlOnly
) const
409 wxWindowList
::compatibility_iterator current
= GetChildren().GetFirst();
412 wxWindow
*parent
= current
->GetData();
414 // Do a recursive search.
415 wxWindow
*wnd
= parent
->FindItemByHWND(hWnd
);
421 || parent
->IsKindOf(CLASSINFO(wxControl
))
422 #endif // wxUSE_CONTROLS
425 wxWindow
*item
= current
->GetData();
426 if ( item
->GetHWND() == hWnd
)
430 if ( item
->ContainsHWND(hWnd
) )
435 current
= current
->GetNext();
440 // Default command handler
441 bool wxWindowMSW
::MSWCommand(WXUINT
WXUNUSED(param
), WXWORD
WXUNUSED(id
))
446 // ----------------------------------------------------------------------------
447 // constructors and such
448 // ----------------------------------------------------------------------------
450 void wxWindowMSW
::Init()
453 m_isBeingDeleted
= false;
455 m_mouseInWindow
= false;
456 m_lastKeydownProcessed
= false;
458 m_childrenDisabled
= NULL
;
467 #if wxUSE_MOUSEEVENT_HACK
470 m_lastMouseEvent
= -1;
471 #endif // wxUSE_MOUSEEVENT_HACK
473 m_pendingPosition
= wxDefaultPosition
;
474 m_pendingSize
= wxDefaultSize
;
478 wxWindowMSW
::~wxWindowMSW()
480 m_isBeingDeleted
= true;
482 #ifndef __WXUNIVERSAL__
483 // VS: make sure there's no wxFrame with last focus set to us:
484 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
486 wxTopLevelWindow
*frame
= wxDynamicCast(win
, wxTopLevelWindow
);
489 if ( frame
->GetLastFocus() == this )
491 frame
->SetLastFocus(NULL
);
494 // apparently sometimes we can end up with our grand parent
495 // pointing to us as well: this is surely a bug in focus handling
496 // code but it's not clear where it happens so for now just try to
497 // fix it here by not breaking out of the loop
501 #endif // __WXUNIVERSAL__
503 // VS: destroy children first and _then_ detach *this from its parent.
504 // If we'd do it the other way around, children wouldn't be able
505 // find their parent frame (see above).
510 // VZ: test temp removed to understand what really happens here
511 //if (::IsWindow(GetHwnd()))
513 if ( !::DestroyWindow(GetHwnd()) )
514 wxLogLastError(wxT("DestroyWindow"));
517 // remove hWnd <-> wxWindow association
518 wxRemoveHandleAssociation(this);
521 delete m_childrenDisabled
;
525 // real construction (Init() must have been called before!)
526 bool wxWindowMSW
::Create(wxWindow
*parent
,
531 const wxString
& name
)
533 wxCHECK_MSG( parent
, false, wxT("can't create wxWindow without parent") );
535 if ( !CreateBase(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
538 parent
->AddChild(this);
541 DWORD msflags
= MSWGetCreateWindowFlags(&exstyle
);
543 #ifdef __WXUNIVERSAL__
544 // no borders, we draw them ourselves
545 exstyle
&= ~(WS_EX_DLGMODALFRAME
|
549 msflags
&= ~WS_BORDER
;
550 #endif // wxUniversal
554 msflags
|= WS_VISIBLE
;
557 if ( !MSWCreate(wxCanvasClassName
, NULL
, pos
, size
, msflags
, exstyle
) )
565 // ---------------------------------------------------------------------------
567 // ---------------------------------------------------------------------------
569 void wxWindowMSW
::SetFocus()
571 HWND hWnd
= GetHwnd();
572 wxCHECK_RET( hWnd
, _T("can't set focus to invalid window") );
574 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
578 if ( !::SetFocus(hWnd
) )
580 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
581 // was there really an error?
582 DWORD dwRes
= ::GetLastError();
585 HWND hwndFocus
= ::GetFocus();
586 if ( hwndFocus
!= hWnd
)
588 wxLogApiError(_T("SetFocus"), dwRes
);
595 void wxWindowMSW
::SetFocusFromKbd()
597 // when the focus is given to the control with DLGC_HASSETSEL style from
598 // keyboard its contents should be entirely selected: this is what
599 // ::IsDialogMessage() does and so we should do it as well to provide the
600 // same LNF as the native programs
601 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE
, 0, 0) & DLGC_HASSETSEL
)
603 ::SendMessage(GetHwnd(), EM_SETSEL
, 0, -1);
606 // do this after (maybe) setting the selection as like this when
607 // wxEVT_SET_FOCUS handler is called, the selection would have been already
608 // set correctly -- this may be important
609 wxWindowBase
::SetFocusFromKbd();
612 // Get the window with the focus
613 wxWindow
*wxWindowBase
::DoFindFocus()
615 HWND hWnd
= ::GetFocus();
618 return wxGetWindowFromHWND((WXHWND
)hWnd
);
624 bool wxWindowMSW
::Enable(bool enable
)
626 if ( !wxWindowBase
::Enable(enable
) )
629 HWND hWnd
= GetHwnd();
631 ::EnableWindow(hWnd
, (BOOL
)enable
);
633 // the logic below doesn't apply to the top level windows -- otherwise
634 // showing a modal dialog would result in total greying out (and ungreying
635 // out later) of everything which would be really ugly
639 // when the parent is disabled, all of its children should be disabled as
640 // well but when it is enabled back, only those of the children which
641 // hadn't been already disabled in the beginning should be enabled again,
642 // so we have to keep the list of those children
643 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
645 node
= node
->GetNext() )
647 wxWindow
*child
= node
->GetData();
648 if ( child
->IsTopLevel() )
650 // the logic below doesn't apply to top level children
656 // enable the child back unless it had been disabled before us
657 if ( !m_childrenDisabled
|| !m_childrenDisabled
->Find(child
) )
660 else // we're being disabled
662 if ( child
->IsEnabled() )
664 // disable it as children shouldn't stay enabled while the
668 else // child already disabled, remember it
670 // have we created the list of disabled children already?
671 if ( !m_childrenDisabled
)
672 m_childrenDisabled
= new wxWindowList
;
674 m_childrenDisabled
->Append(child
);
679 if ( enable
&& m_childrenDisabled
)
681 // we don't need this list any more, don't keep unused memory
682 delete m_childrenDisabled
;
683 m_childrenDisabled
= NULL
;
689 bool wxWindowMSW
::Show(bool show
)
691 if ( !wxWindowBase
::Show(show
) )
694 HWND hWnd
= GetHwnd();
695 int cshow
= show ? SW_SHOW
: SW_HIDE
;
696 ::ShowWindow(hWnd
, cshow
);
698 if ( show
&& IsTopLevel() )
700 wxBringWindowToTop(hWnd
);
706 // Raise the window to the top of the Z order
707 void wxWindowMSW
::Raise()
709 wxBringWindowToTop(GetHwnd());
712 // Lower the window to the bottom of the Z order
713 void wxWindowMSW
::Lower()
715 ::SetWindowPos(GetHwnd(), HWND_BOTTOM
, 0, 0, 0, 0,
716 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
719 void wxWindowMSW
::SetTitle( const wxString
& title
)
721 SetWindowText(GetHwnd(), title
.c_str());
724 wxString wxWindowMSW
::GetTitle() const
726 return wxGetWindowText(GetHWND());
729 void wxWindowMSW
::DoCaptureMouse()
731 HWND hWnd
= GetHwnd();
738 void wxWindowMSW
::DoReleaseMouse()
740 if ( !::ReleaseCapture() )
742 wxLogLastError(_T("ReleaseCapture"));
746 /* static */ wxWindow
*wxWindowBase
::GetCapture()
748 HWND hwnd
= ::GetCapture();
749 return hwnd ?
wxFindWinFromHandle((WXHWND
)hwnd
) : (wxWindow
*)NULL
;
752 bool wxWindowMSW
::SetFont(const wxFont
& font
)
754 if ( !wxWindowBase
::SetFont(font
) )
760 HWND hWnd
= GetHwnd();
763 WXHANDLE hFont
= m_font
.GetResourceHandle();
765 wxASSERT_MSG( hFont
, wxT("should have valid font") );
767 ::SendMessage(hWnd
, WM_SETFONT
, (WPARAM
)hFont
, MAKELPARAM(TRUE
, 0));
772 bool wxWindowMSW
::SetCursor(const wxCursor
& cursor
)
774 if ( !wxWindowBase
::SetCursor(cursor
) )
782 HWND hWnd
= GetHwnd();
784 // Change the cursor NOW if we're within the correct window
787 ::GetCursorPosWinCE(&point
);
789 ::GetCursorPos(&point
);
792 RECT rect
= wxGetWindowRect(hWnd
);
794 if ( ::PtInRect(&rect
, point
) && !wxIsBusy() )
795 ::SetCursor(GetHcursorOf(m_cursor
));
801 void wxWindowMSW
::WarpPointer (int x
, int y
)
803 ClientToScreen(&x
, &y
);
805 if ( !::SetCursorPos(x
, y
) )
807 wxLogLastError(_T("SetCursorPos"));
811 // ---------------------------------------------------------------------------
813 // ---------------------------------------------------------------------------
815 inline int GetScrollPosition(HWND hWnd
, int wOrient
)
817 #ifdef __WXMICROWIN__
818 return ::GetScrollPosWX(hWnd
, wOrient
);
820 WinStruct
<SCROLLINFO
> scrollInfo
;
821 scrollInfo
.cbSize
= sizeof(SCROLLINFO
);
822 scrollInfo
.fMask
= SIF_POS
;
823 if ( !::GetScrollInfo(hWnd
,
827 // Not necessarily an error, if there are no scrollbars yet.
828 // wxLogLastError(_T("GetScrollInfo"));
830 return scrollInfo
.nPos
;
831 // return ::GetScrollPos(hWnd, wOrient);
835 int wxWindowMSW
::GetScrollPos(int orient
) const
837 HWND hWnd
= GetHwnd();
838 wxCHECK_MSG( hWnd
, 0, _T("no HWND in GetScrollPos") );
840 return GetScrollPosition(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
);
843 // This now returns the whole range, not just the number
844 // of positions that we can scroll.
845 int wxWindowMSW
::GetScrollRange(int orient
) const
848 HWND hWnd
= GetHwnd();
852 ::GetScrollRange(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
855 WinStruct
<SCROLLINFO
> scrollInfo
;
856 scrollInfo
.fMask
= SIF_RANGE
;
857 if ( !::GetScrollInfo(hWnd
,
858 orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
861 // Most of the time this is not really an error, since the return
862 // value can also be zero when there is no scrollbar yet.
863 // wxLogLastError(_T("GetScrollInfo"));
865 maxPos
= scrollInfo
.nMax
;
867 // undo "range - 1" done in SetScrollbar()
871 int wxWindowMSW
::GetScrollThumb(int orient
) const
873 return orient
== wxHORIZONTAL ? m_xThumbSize
: m_yThumbSize
;
876 void wxWindowMSW
::SetScrollPos(int orient
, int pos
, bool refresh
)
878 HWND hWnd
= GetHwnd();
879 wxCHECK_RET( hWnd
, _T("SetScrollPos: no HWND") );
881 WinStruct
<SCROLLINFO
> info
;
885 info
.fMask
= SIF_POS
;
886 if ( HasFlag(wxALWAYS_SHOW_SB
) )
888 // disable scrollbar instead of removing it then
889 info
.fMask
|= SIF_DISABLENOSCROLL
;
892 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
896 // New function that will replace some of the above.
897 void wxWindowMSW
::SetScrollbar(int orient
,
903 WinStruct
<SCROLLINFO
> info
;
904 info
.nPage
= pageSize
;
905 info
.nMin
= 0; // range is nMax - nMin + 1
906 info
.nMax
= range
- 1; // as both nMax and nMax are inclusive
908 info
.fMask
= SIF_RANGE
| SIF_PAGE
| SIF_POS
;
909 if ( HasFlag(wxALWAYS_SHOW_SB
) )
911 // disable scrollbar instead of removing it then
912 info
.fMask
|= SIF_DISABLENOSCROLL
;
915 HWND hWnd
= GetHwnd();
918 ::SetScrollInfo(hWnd
, orient
== wxHORIZONTAL ? SB_HORZ
: SB_VERT
,
922 *(orient
== wxHORIZONTAL ?
&m_xThumbSize
: &m_yThumbSize
) = pageSize
;
925 void wxWindowMSW
::ScrollWindow(int dx
, int dy
, const wxRect
*prect
)
931 rect
.left
= prect
->x
;
933 rect
.right
= prect
->x
+ prect
->width
;
934 rect
.bottom
= prect
->y
+ prect
->height
;
944 // FIXME: is this the exact equivalent of the line below?
945 ::ScrollWindowEx(GetHwnd(), dx
, dy
, pr
, pr
, 0, 0, SW_SCROLLCHILDREN
|SW_ERASE
|SW_INVALIDATE
);
947 ::ScrollWindow(GetHwnd(), dx
, dy
, pr
, pr
);
951 static bool ScrollVertically(HWND hwnd
, int kind
, int count
)
953 int posStart
= GetScrollPosition(hwnd
, SB_VERT
);
956 for ( int n
= 0; n
< count
; n
++ )
958 ::SendMessage(hwnd
, WM_VSCROLL
, kind
, 0);
960 int posNew
= GetScrollPosition(hwnd
, SB_VERT
);
963 // don't bother to continue, we're already at top/bottom
970 return pos
!= posStart
;
973 bool wxWindowMSW
::ScrollLines(int lines
)
975 bool down
= lines
> 0;
977 return ScrollVertically(GetHwnd(),
978 down ? SB_LINEDOWN
: SB_LINEUP
,
979 down ? lines
: -lines
);
982 bool wxWindowMSW
::ScrollPages(int pages
)
984 bool down
= pages
> 0;
986 return ScrollVertically(GetHwnd(),
987 down ? SB_PAGEDOWN
: SB_PAGEUP
,
988 down ? pages
: -pages
);
991 // ---------------------------------------------------------------------------
993 // ---------------------------------------------------------------------------
995 void wxWindowMSW
::SubclassWin(WXHWND hWnd
)
997 wxASSERT_MSG( !m_oldWndProc
, wxT("subclassing window twice?") );
999 HWND hwnd
= (HWND
)hWnd
;
1000 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in SubclassWin") );
1002 wxAssociateWinWithHandle(hwnd
, this);
1004 m_oldWndProc
= (WXFARPROC
)wxGetWindowProc((HWND
)hWnd
);
1006 // we don't need to subclass the window of our own class (in the Windows
1007 // sense of the word)
1008 if ( !wxCheckWindowWndProc(hWnd
, (WXFARPROC
)wxWndProc
) )
1010 wxSetWindowProc(hwnd
, wxWndProc
);
1014 // don't bother restoring it neither: this also makes it easy to
1015 // implement IsOfStandardClass() method which returns true for the
1016 // standard controls and false for the wxWidgets own windows as it can
1017 // simply check m_oldWndProc
1018 m_oldWndProc
= NULL
;
1022 void wxWindowMSW
::UnsubclassWin()
1024 wxRemoveHandleAssociation(this);
1026 // Restore old Window proc
1027 HWND hwnd
= GetHwnd();
1032 wxCHECK_RET( ::IsWindow(hwnd
), wxT("invalid HWND in UnsubclassWin") );
1036 if ( !wxCheckWindowWndProc((WXHWND
)hwnd
, m_oldWndProc
) )
1038 wxSetWindowProc(hwnd
, (WNDPROC
)m_oldWndProc
);
1041 m_oldWndProc
= NULL
;
1046 void wxWindowMSW
::AssociateHandle(WXWidget handle
)
1050 if ( !::DestroyWindow(GetHwnd()) )
1051 wxLogLastError(wxT("DestroyWindow"));
1054 WXHWND wxhwnd
= (WXHWND
)handle
;
1057 SubclassWin(wxhwnd
);
1060 void wxWindowMSW
::DissociateHandle()
1062 // this also calls SetHWND(0) for us
1067 bool wxCheckWindowWndProc(WXHWND hWnd
,
1068 WXFARPROC
WXUNUSED_IN_WINCE(wndProc
))
1070 // Unicows note: the code below works, but only because WNDCLASS contains
1071 // original window handler rather that the unicows fake one. This may not
1072 // be on purpose, though; if it stops working with future versions of
1073 // unicows.dll, we can override unicows hooks by setting
1074 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
1075 // versions that keep track of fake<->real wnd proc mapping.
1077 // On WinCE (at least), the wndproc comparison doesn't work,
1078 // so have to use something like this.
1080 extern wxChar
*wxCanvasClassName
;
1081 extern wxChar
*wxCanvasClassNameNR
;
1082 extern const wxChar
*wxMDIFrameClassName
;
1083 extern const wxChar
*wxMDIFrameClassNameNoRedraw
;
1084 extern const wxChar
*wxMDIChildFrameClassName
;
1085 extern const wxChar
*wxMDIChildFrameClassNameNoRedraw
;
1086 wxString
str(wxGetWindowClass(hWnd
));
1087 if (str
== wxCanvasClassName
||
1088 str
== wxCanvasClassNameNR
||
1089 str
== wxMDIFrameClassName
||
1090 str
== wxMDIFrameClassNameNoRedraw
||
1091 str
== wxMDIChildFrameClassName
||
1092 str
== wxMDIChildFrameClassNameNoRedraw
||
1093 str
== _T("wxTLWHiddenParent"))
1094 return true; // Effectively means don't subclass
1099 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd
), &cls
) )
1101 wxLogLastError(_T("GetClassInfo"));
1106 return wndProc
== (WXFARPROC
)cls
.lpfnWndProc
;
1110 // ----------------------------------------------------------------------------
1112 // ----------------------------------------------------------------------------
1114 void wxWindowMSW
::SetWindowStyleFlag(long flags
)
1116 long flagsOld
= GetWindowStyleFlag();
1117 if ( flags
== flagsOld
)
1120 // update the internal variable
1121 wxWindowBase
::SetWindowStyleFlag(flags
);
1123 // now update the Windows style as well if needed - and if the window had
1124 // been already created
1128 WXDWORD exstyle
, exstyleOld
;
1129 long style
= MSWGetStyle(flags
, &exstyle
),
1130 styleOld
= MSWGetStyle(flagsOld
, &exstyleOld
);
1132 if ( style
!= styleOld
)
1134 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1135 // this function so instead of simply setting the style to the new
1136 // value we clear the bits which were set in styleOld but are set in
1137 // the new one and set the ones which were not set before
1138 long styleReal
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
1139 styleReal
&= ~styleOld
;
1142 ::SetWindowLong(GetHwnd(), GWL_STYLE
, styleReal
);
1145 // and the extended style
1146 if ( exstyle
!= exstyleOld
)
1148 long exstyleReal
= ::GetWindowLong(GetHwnd(), GWL_EXSTYLE
);
1149 exstyleReal
&= ~exstyleOld
;
1150 exstyleReal
|= exstyle
;
1152 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE
, exstyleReal
);
1154 // we must call SetWindowPos() to flush the cached extended style and
1155 // also to make the change to wxSTAY_ON_TOP style take effect: just
1156 // setting the style simply doesn't work
1157 if ( !::SetWindowPos(GetHwnd(),
1158 exstyleReal
& WS_EX_TOPMOST ? HWND_TOPMOST
1161 SWP_NOMOVE
| SWP_NOSIZE
) )
1163 wxLogLastError(_T("SetWindowPos"));
1168 WXDWORD wxWindowMSW
::MSWGetStyle(long flags
, WXDWORD
*exstyle
) const
1170 // translate common wxWidgets styles to Windows ones
1172 // most of windows are child ones, those which are not (such as
1173 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1174 WXDWORD style
= WS_CHILD
;
1176 // using this flag results in very significant reduction in flicker,
1177 // especially with controls inside the static boxes (as the interior of the
1178 // box is not redrawn twice).but sometimes results in redraw problems, so
1179 // optionally allow the old code to continue to use it provided a special
1180 // system option is turned on
1181 if ( !wxSystemOptions
::GetOptionInt(wxT("msw.window.no-clip-children"))
1182 || (flags
& wxCLIP_CHILDREN
) )
1183 style
|= WS_CLIPCHILDREN
;
1185 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1186 // don't support overlapping windows and it only makes sense for them and,
1187 // presumably, gives the system some extra work (to manage more clipping
1188 // regions), so avoid it alltogether
1191 if ( flags
& wxVSCROLL
)
1192 style
|= WS_VSCROLL
;
1194 if ( flags
& wxHSCROLL
)
1195 style
|= WS_HSCROLL
;
1197 const wxBorder border
= GetBorder(flags
);
1199 // WS_BORDER is only required for wxBORDER_SIMPLE
1200 if ( border
== wxBORDER_SIMPLE
)
1203 // now deal with ext style if the caller wants it
1209 if ( flags
& wxTRANSPARENT_WINDOW
)
1210 *exstyle
|= WS_EX_TRANSPARENT
;
1216 case wxBORDER_DEFAULT
:
1217 wxFAIL_MSG( _T("unknown border style") );
1221 case wxBORDER_SIMPLE
:
1224 case wxBORDER_STATIC
:
1225 *exstyle
|= WS_EX_STATICEDGE
;
1228 case wxBORDER_RAISED
:
1229 *exstyle
|= WS_EX_DLGMODALFRAME
;
1232 case wxBORDER_SUNKEN
:
1233 *exstyle
|= WS_EX_CLIENTEDGE
;
1234 style
&= ~WS_BORDER
;
1237 case wxBORDER_DOUBLE
:
1238 *exstyle
|= WS_EX_DLGMODALFRAME
;
1242 // wxUniv doesn't use Windows dialog navigation functions at all
1243 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1244 // to make the dialog navigation work with the nested panels we must
1245 // use this style (top level windows such as dialogs don't need it)
1246 if ( (flags
& wxTAB_TRAVERSAL
) && !IsTopLevel() )
1248 *exstyle
|= WS_EX_CONTROLPARENT
;
1250 #endif // __WXUNIVERSAL__
1256 // Setup background and foreground colours correctly
1257 void wxWindowMSW
::SetupColours()
1260 SetBackgroundColour(GetParent()->GetBackgroundColour());
1263 bool wxWindowMSW
::IsMouseInWindow() const
1265 // get the mouse position
1268 ::GetCursorPosWinCE(&pt
);
1270 ::GetCursorPos(&pt
);
1273 // find the window which currently has the cursor and go up the window
1274 // chain until we find this window - or exhaust it
1275 HWND hwnd
= ::WindowFromPoint(pt
);
1276 while ( hwnd
&& (hwnd
!= GetHwnd()) )
1277 hwnd
= ::GetParent(hwnd
);
1279 return hwnd
!= NULL
;
1282 void wxWindowMSW
::OnInternalIdle()
1284 #ifndef HAVE_TRACKMOUSEEVENT
1285 // Check if we need to send a LEAVE event
1286 if ( m_mouseInWindow
)
1288 // note that we should generate the leave event whether the window has
1289 // or doesn't have mouse capture
1290 if ( !IsMouseInWindow() )
1292 GenerateMouseLeave();
1295 #endif // !HAVE_TRACKMOUSEEVENT
1297 if (wxUpdateUIEvent
::CanUpdate(this))
1298 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
1301 // Set this window to be the child of 'parent'.
1302 bool wxWindowMSW
::Reparent(wxWindowBase
*parent
)
1304 if ( !wxWindowBase
::Reparent(parent
) )
1307 HWND hWndChild
= GetHwnd();
1308 HWND hWndParent
= GetParent() ?
GetWinHwnd(GetParent()) : (HWND
)0;
1310 ::SetParent(hWndChild
, hWndParent
);
1313 if ( ::GetWindowLong(hWndChild
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
1315 EnsureParentHasControlParentStyle(GetParent());
1317 #endif // !__WXWINCE__
1322 static inline void SendSetRedraw(HWND hwnd
, bool on
)
1324 #ifndef __WXMICROWIN__
1325 ::SendMessage(hwnd
, WM_SETREDRAW
, (WPARAM
)on
, 0);
1329 void wxWindowMSW
::Freeze()
1331 if ( !m_frozenness
++ )
1334 SendSetRedraw(GetHwnd(), false);
1338 void wxWindowMSW
::Thaw()
1340 wxASSERT_MSG( m_frozenness
> 0, _T("Thaw() without matching Freeze()") );
1342 if ( !--m_frozenness
)
1346 SendSetRedraw(GetHwnd(), true);
1348 // we need to refresh everything or otherwise the invalidated area
1349 // is not going to be repainted
1355 void wxWindowMSW
::Refresh(bool eraseBack
, const wxRect
*rect
)
1357 HWND hWnd
= GetHwnd();
1364 mswRect
.left
= rect
->x
;
1365 mswRect
.top
= rect
->y
;
1366 mswRect
.right
= rect
->x
+ rect
->width
;
1367 mswRect
.bottom
= rect
->y
+ rect
->height
;
1376 // RedrawWindow not available on SmartPhone or eVC++ 3
1377 #if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1378 UINT flags
= RDW_INVALIDATE
| RDW_ALLCHILDREN
;
1382 ::RedrawWindow(hWnd
, pRect
, NULL
, flags
);
1384 ::InvalidateRect(hWnd
, pRect
, eraseBack
);
1389 void wxWindowMSW
::Update()
1391 if ( !::UpdateWindow(GetHwnd()) )
1393 wxLogLastError(_T("UpdateWindow"));
1396 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1397 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1398 // handler needs to be really drawn right now
1403 // ---------------------------------------------------------------------------
1405 // ---------------------------------------------------------------------------
1408 #if wxUSE_DRAG_AND_DROP
1409 void wxWindowMSW
::SetDropTarget(wxDropTarget
*pDropTarget
)
1411 if ( m_dropTarget
!= 0 ) {
1412 m_dropTarget
->Revoke(m_hWnd
);
1413 delete m_dropTarget
;
1416 m_dropTarget
= pDropTarget
;
1417 if ( m_dropTarget
!= 0 )
1418 m_dropTarget
->Register(m_hWnd
);
1420 #endif // wxUSE_DRAG_AND_DROP
1422 // old style file-manager drag&drop support: we retain the old-style
1423 // DragAcceptFiles in parallel with SetDropTarget.
1424 void wxWindowMSW
::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept
))
1427 HWND hWnd
= GetHwnd();
1429 ::DragAcceptFiles(hWnd
, (BOOL
)accept
);
1433 // ----------------------------------------------------------------------------
1435 // ----------------------------------------------------------------------------
1439 void wxWindowMSW
::DoSetToolTip(wxToolTip
*tooltip
)
1441 wxWindowBase
::DoSetToolTip(tooltip
);
1444 m_tooltip
->SetWindow((wxWindow
*)this);
1447 #endif // wxUSE_TOOLTIPS
1449 // ---------------------------------------------------------------------------
1450 // moving and resizing
1451 // ---------------------------------------------------------------------------
1454 void wxWindowMSW
::DoGetSize(int *x
, int *y
) const
1456 RECT rect
= wxGetWindowRect(GetHwnd());
1459 *x
= rect
.right
- rect
.left
;
1461 *y
= rect
.bottom
- rect
.top
;
1464 // Get size *available for subwindows* i.e. excluding menu bar etc.
1465 void wxWindowMSW
::DoGetClientSize(int *x
, int *y
) const
1467 RECT rect
= wxGetClientRect(GetHwnd());
1475 void wxWindowMSW
::DoGetPosition(int *x
, int *y
) const
1477 RECT rect
= wxGetWindowRect(GetHwnd());
1480 point
.x
= rect
.left
;
1483 // we do the adjustments with respect to the parent only for the "real"
1484 // children, not for the dialogs/frames
1485 if ( !IsTopLevel() )
1487 HWND hParentWnd
= 0;
1488 wxWindow
*parent
= GetParent();
1490 hParentWnd
= GetWinHwnd(parent
);
1492 // Since we now have the absolute screen coords, if there's a
1493 // parent we must subtract its top left corner
1496 ::ScreenToClient(hParentWnd
, &point
);
1501 // We may be faking the client origin. So a window that's
1502 // really at (0, 30) may appear (to wxWin apps) to be at (0, 0).
1503 wxPoint
pt(parent
->GetClientAreaOrigin());
1515 void wxWindowMSW
::DoScreenToClient(int *x
, int *y
) const
1523 ::ScreenToClient(GetHwnd(), &pt
);
1531 void wxWindowMSW
::DoClientToScreen(int *x
, int *y
) const
1539 ::ClientToScreen(GetHwnd(), &pt
);
1548 wxWindowMSW
::DoMoveSibling(WXHWND hwnd
, int x
, int y
, int width
, int height
)
1550 #if USE_DEFERRED_SIZING
1551 // if our parent had prepared a defer window handle for us, use it (unless
1552 // we are a top level window)
1553 wxWindowMSW
* const parent
= IsTopLevel() ? NULL
: GetParent();
1555 HDWP hdwp
= parent ?
(HDWP
)parent
->m_hDWP
: NULL
;
1558 hdwp
= ::DeferWindowPos(hdwp
, (HWND
)hwnd
, NULL
, x
, y
, width
, height
,
1562 wxLogLastError(_T("DeferWindowPos"));
1568 // hdwp must be updated as it may have been changed
1569 parent
->m_hDWP
= (WXHANDLE
)hdwp
;
1572 // otherwise (or if deferring failed) move the window in place immediately
1574 #endif // USE_DEFERRED_SIZING
1576 if ( !::MoveWindow((HWND
)hwnd
, x
, y
, width
, height
, IsShown()) )
1578 wxLogLastError(wxT("MoveWindow"));
1583 void wxWindowMSW
::DoMoveWindow(int x
, int y
, int width
, int height
)
1585 // TODO: is this consistent with other platforms?
1586 // Still, negative width or height shouldn't be allowed
1592 DoMoveSibling(m_hWnd
, x
, y
, width
, height
);
1595 // set the size of the window: if the dimensions are positive, just use them,
1596 // but if any of them is equal to -1, it means that we must find the value for
1597 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1598 // which case -1 is a valid value for x and y)
1600 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1601 // the width/height to best suit our contents, otherwise we reuse the current
1603 void wxWindowMSW
::DoSetSize(int x
, int y
, int width
, int height
, int sizeFlags
)
1605 // get the current size and position...
1606 int currentX
, currentY
;
1607 int currentW
, currentH
;
1609 GetPosition(¤tX
, ¤tY
);
1610 GetSize(¤tW
, ¤tH
);
1612 // ... and don't do anything (avoiding flicker) if it's already ok
1613 if ( x
== currentX
&& y
== currentY
&&
1614 width
== currentW
&& height
== currentH
)
1619 if ( x
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1621 if ( y
== wxDefaultCoord
&& !(sizeFlags
& wxSIZE_ALLOW_MINUS_ONE
) )
1624 AdjustForParentClientOrigin(x
, y
, sizeFlags
);
1626 wxSize size
= wxDefaultSize
;
1627 if ( width
== wxDefaultCoord
)
1629 if ( sizeFlags
& wxSIZE_AUTO_WIDTH
)
1631 size
= DoGetBestSize();
1636 // just take the current one
1641 if ( height
== wxDefaultCoord
)
1643 if ( sizeFlags
& wxSIZE_AUTO_HEIGHT
)
1645 if ( size
.x
== wxDefaultCoord
)
1647 size
= DoGetBestSize();
1649 //else: already called DoGetBestSize() above
1655 // just take the current one
1660 m_pendingPosition
= wxPoint(x
, y
);
1661 m_pendingSize
= wxSize(width
, height
);
1662 DoMoveWindow(x
, y
, width
, height
);
1665 void wxWindowMSW
::DoSetClientSize(int width
, int height
)
1667 // setting the client size is less obvious than it it could have been
1668 // because in the result of changing the total size the window scrollbar
1669 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1670 // will not be correct as the difference between the total and client size
1671 // changes - so we keep changing it until we get it right
1673 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1674 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1675 // may become 3 if the window had 0 size originally and so we didn't
1676 // calculate the scrollbar correction correctly during the first iteration)
1677 // but just to be on the safe side we check for it instead of making it an
1678 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1679 for ( int i
= 0; i
< 4; i
++ )
1682 ::GetClientRect(GetHwnd(), &rectClient
);
1684 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
1685 if ( (rectClient
.right
== width
|| width
== wxDefaultCoord
) &&
1686 (rectClient
.bottom
== height
|| height
== wxDefaultCoord
) )
1691 // Find the difference between the entire window (title bar and all)
1692 // and the client area; add this to the new client size to move the
1695 ::GetWindowRect(GetHwnd(), &rectWin
);
1697 const int widthWin
= rectWin
.right
- rectWin
.left
,
1698 heightWin
= rectWin
.bottom
- rectWin
.top
;
1700 // MoveWindow positions the child windows relative to the parent, so
1701 // adjust if necessary
1702 if ( !IsTopLevel() )
1704 wxWindow
*parent
= GetParent();
1707 ::ScreenToClient(GetHwndOf(parent
), (POINT
*)&rectWin
);
1711 // don't call DoMoveWindow() because we want to move window immediately
1712 // and not defer it here
1713 if ( !::MoveWindow(GetHwnd(),
1716 width
+ widthWin
- rectClient
.right
,
1717 height
+ heightWin
- rectClient
.bottom
,
1720 wxLogLastError(_T("MoveWindow"));
1725 // ---------------------------------------------------------------------------
1727 // ---------------------------------------------------------------------------
1729 int wxWindowMSW
::GetCharHeight() const
1731 return wxGetTextMetrics(this).tmHeight
;
1734 int wxWindowMSW
::GetCharWidth() const
1736 // +1 is needed because Windows apparently adds it when calculating the
1737 // dialog units size in pixels
1738 #if wxDIALOG_UNIT_COMPATIBILITY
1739 return wxGetTextMetrics(this).tmAveCharWidth
;
1741 return wxGetTextMetrics(this).tmAveCharWidth
+ 1;
1745 void wxWindowMSW
::GetTextExtent(const wxString
& string
,
1747 int *descent
, int *externalLeading
,
1748 const wxFont
*theFont
) const
1750 wxASSERT_MSG( !theFont
|| theFont
->Ok(),
1751 _T("invalid font in GetTextExtent()") );
1755 fontToUse
= *theFont
;
1757 fontToUse
= GetFont();
1759 WindowHDC
hdc(GetHwnd());
1760 SelectInHDC
selectFont(hdc
, GetHfontOf(fontToUse
));
1764 ::GetTextExtentPoint32(hdc
, string
, string
.length(), &sizeRect
);
1765 GetTextMetrics(hdc
, &tm
);
1772 *descent
= tm
.tmDescent
;
1773 if ( externalLeading
)
1774 *externalLeading
= tm
.tmExternalLeading
;
1777 // ---------------------------------------------------------------------------
1779 // ---------------------------------------------------------------------------
1781 #if wxUSE_MENUS_NATIVE
1783 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1784 // immediately, without waiting for the next event loop iteration
1786 // NB: this function should probably be made public later as it can almost
1787 // surely replace wxYield() elsewhere as well
1788 static void wxYieldForCommandsOnly()
1790 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1791 // want to process it here)
1793 while ( ::PeekMessage(&msg
, (HWND
)0, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
) )
1795 if ( msg
.message
== WM_QUIT
)
1797 // if we retrieved a WM_QUIT, insert back into the message queue.
1798 ::PostQuitMessage(0);
1802 // luckily (as we don't have access to wxEventLoopImpl method from here
1803 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
1805 ::TranslateMessage(&msg
);
1806 ::DispatchMessage(&msg
);
1810 bool wxWindowMSW
::DoPopupMenu(wxMenu
*menu
, int x
, int y
)
1812 menu
->SetInvokingWindow(this);
1815 if ( x
== wxDefaultCoord
&& y
== wxDefaultCoord
)
1817 wxPoint mouse
= ScreenToClient(wxGetMousePosition());
1818 x
= mouse
.x
; y
= mouse
.y
;
1821 HWND hWnd
= GetHwnd();
1822 HMENU hMenu
= GetHmenuOf(menu
);
1826 ::ClientToScreen(hWnd
, &point
);
1827 wxCurrentPopupMenu
= menu
;
1828 #if defined(__WXWINCE__)
1831 UINT flags
= TPM_RIGHTBUTTON
;
1833 ::TrackPopupMenu(hMenu
, flags
, point
.x
, point
.y
, 0, hWnd
, NULL
);
1835 // we need to do it righ now as otherwise the events are never going to be
1836 // sent to wxCurrentPopupMenu from HandleCommand()
1838 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1839 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1840 // destroyed as soon as we return (it can be a local variable in the caller
1841 // for example) and so we do need to process the event immediately
1842 wxYieldForCommandsOnly();
1844 wxCurrentPopupMenu
= NULL
;
1846 menu
->SetInvokingWindow(NULL
);
1851 #endif // wxUSE_MENUS_NATIVE
1853 // ===========================================================================
1854 // pre/post message processing
1855 // ===========================================================================
1857 WXLRESULT wxWindowMSW
::MSWDefWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1860 return ::CallWindowProc(CASTWNDPROC m_oldWndProc
, GetHwnd(), (UINT
) nMsg
, (WPARAM
) wParam
, (LPARAM
) lParam
);
1862 return ::DefWindowProc(GetHwnd(), nMsg
, wParam
, lParam
);
1865 bool wxWindowMSW
::MSWProcessMessage(WXMSG
* pMsg
)
1867 // wxUniversal implements tab traversal itself
1868 #ifndef __WXUNIVERSAL__
1869 if ( m_hWnd
!= 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL
) )
1871 // intercept dialog navigation keys
1872 MSG
*msg
= (MSG
*)pMsg
;
1874 // here we try to do all the job which ::IsDialogMessage() usually does
1876 if ( msg
->message
== WM_KEYDOWN
)
1878 bool bCtrlDown
= wxIsCtrlDown();
1879 bool bShiftDown
= wxIsShiftDown();
1881 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1882 // don't process it if it's the case (except for Ctrl-Tab/Enter
1883 // combinations which are always processed)
1887 lDlgCode
= ::SendMessage(msg
->hwnd
, WM_GETDLGCODE
, 0, 0);
1889 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1890 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1891 // it, of course, implies them
1892 if ( lDlgCode
& DLGC_WANTALLKEYS
)
1894 lDlgCode
|= DLGC_WANTTAB
| DLGC_WANTARROWS
;
1898 bool bForward
= true,
1899 bWindowChange
= false,
1902 // should we process this message specially?
1903 bool bProcess
= true;
1904 switch ( msg
->wParam
)
1907 if ( lDlgCode
& DLGC_WANTTAB
) {
1911 // Ctrl-Tab cycles thru notebook pages
1912 bWindowChange
= bCtrlDown
;
1913 bForward
= !bShiftDown
;
1920 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1928 if ( (lDlgCode
& DLGC_WANTARROWS
) || bCtrlDown
)
1934 if ( (lDlgCode
& DLGC_WANTMESSAGE
) && !bCtrlDown
)
1936 // control wants to process Enter itself, don't
1937 // call IsDialogMessage() which would interpret
1941 else if ( lDlgCode
& DLGC_BUTTON
)
1943 // let IsDialogMessage() handle this for all
1944 // buttons except the owner-drawn ones which it
1945 // just seems to ignore
1946 long style
= ::GetWindowLong(msg
->hwnd
, GWL_STYLE
);
1947 if ( (style
& BS_OWNERDRAW
) == BS_OWNERDRAW
)
1949 // emulate the button click
1950 wxWindow
*btn
= wxFindWinFromHandle((WXHWND
)msg
->hwnd
);
1952 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1957 // FIXME: this should be handled by
1958 // wxNavigationKeyEvent handler and not here!
1962 wxButton
*btn
= wxDynamicCast(GetDefaultItem(),
1964 if ( btn
&& btn
->IsEnabled() )
1966 // if we do have a default button, do press it
1967 btn
->MSWCommand(BN_CLICKED
, 0 /* unused */);
1971 else // no default button
1972 #endif // wxUSE_BUTTON
1974 // this is a quick and dirty test for a text
1976 if ( !(lDlgCode
& DLGC_HASSETSEL
) )
1978 // don't process Enter, the control might
1979 // need it for itself and don't let
1980 // ::IsDialogMessage() have it as it can
1981 // eat the Enter events sometimes
1984 else if (!IsTopLevel())
1986 // if not a top level window, let parent
1990 //else: treat Enter as TAB: pass to the next
1991 // control as this is the best thing to do
1992 // if the text doesn't handle Enter itself
2004 wxNavigationKeyEvent event
;
2005 event
.SetDirection(bForward
);
2006 event
.SetWindowChange(bWindowChange
);
2007 event
.SetFromTab(bFromTab
);
2008 event
.SetEventObject(this);
2010 if ( GetEventHandler()->ProcessEvent(event
) )
2017 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2018 // message even when there is no cancel button and when the message is
2019 // needed by the control itself: in particular, it prevents the tree in
2020 // place edit control from being closed with Escape in a dialog
2021 if ( msg
->message
!= WM_KEYDOWN
|| msg
->wParam
!= VK_ESCAPE
)
2023 // ::IsDialogMessage() is broken and may sometimes hang the
2024 // application by going into an infinite loop, so we try to detect
2025 // [some of] the situatations when this may happen and not call it
2028 // assume we can call it by default
2029 bool canSafelyCallIsDlgMsg
= true;
2031 HWND hwndFocus
= ::GetFocus();
2033 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
2034 // an infinite loop, because it will recursively check the child
2035 // windows but not the window itself and so if none of the children
2036 // accepts focus it loops forever (as it only stops when it gets
2037 // back to the window it started from)
2039 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2040 // style has the focus, it can happen. One such possibility is if
2041 // all windows are either toplevel, wxDialog, wxPanel or static
2042 // controls and no window can actually accept keyboard input.
2043 #if !defined(__WXWINCE__)
2044 if ( ::GetWindowLong(hwndFocus
, GWL_EXSTYLE
) & WS_EX_CONTROLPARENT
)
2046 // passimistic by default
2047 canSafelyCallIsDlgMsg
= false;
2048 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
2050 node
= node
->GetNext() )
2052 wxWindow
* const win
= node
->GetData();
2053 if ( win
->AcceptsFocus() &&
2054 !(::GetWindowLong(GetHwndOf(win
), GWL_EXSTYLE
) &
2055 WS_EX_CONTROLPARENT
) )
2057 // it shouldn't hang...
2058 canSafelyCallIsDlgMsg
= true;
2064 #endif // !__WXWINCE__
2066 if ( canSafelyCallIsDlgMsg
)
2068 // ::IsDialogMessage() can enter in an infinite loop when the
2069 // currently focused window is disabled or hidden and its
2070 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2074 if ( !::IsWindowEnabled(hwndFocus
) ||
2075 !::IsWindowVisible(hwndFocus
) )
2077 // it would enter an infinite loop if we do this!
2078 canSafelyCallIsDlgMsg
= false;
2083 if ( !(::GetWindowLong(hwndFocus
, GWL_STYLE
) & WS_CHILD
) )
2085 // it's a top level window, don't go further -- e.g. even
2086 // if the parent of a dialog is disabled, this doesn't
2087 // break navigation inside the dialog
2091 hwndFocus
= ::GetParent(hwndFocus
);
2095 // let IsDialogMessage() have the message if it's safe to call it
2096 if ( canSafelyCallIsDlgMsg
&& ::IsDialogMessage(GetHwnd(), msg
) )
2098 // IsDialogMessage() did something...
2103 #endif // __WXUNIVERSAL__
2108 // relay mouse move events to the tooltip control
2109 MSG
*msg
= (MSG
*)pMsg
;
2110 if ( msg
->message
== WM_MOUSEMOVE
)
2111 m_tooltip
->RelayEvent(pMsg
);
2113 #endif // wxUSE_TOOLTIPS
2118 bool wxWindowMSW
::MSWTranslateMessage(WXMSG
* pMsg
)
2120 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2121 return m_acceleratorTable
.Translate(this, pMsg
);
2125 #endif // wxUSE_ACCEL
2128 bool wxWindowMSW
::MSWShouldPreProcessMessage(WXMSG
* WXUNUSED(pMsg
))
2130 // preprocess all messages by default
2134 // ---------------------------------------------------------------------------
2135 // message params unpackers
2136 // ---------------------------------------------------------------------------
2138 void wxWindowMSW
::UnpackCommand(WXWPARAM wParam
, WXLPARAM lParam
,
2139 WORD
*id
, WXHWND
*hwnd
, WORD
*cmd
)
2141 *id
= LOWORD(wParam
);
2142 *hwnd
= (WXHWND
)lParam
;
2143 *cmd
= HIWORD(wParam
);
2146 void wxWindowMSW
::UnpackActivate(WXWPARAM wParam
, WXLPARAM lParam
,
2147 WXWORD
*state
, WXWORD
*minimized
, WXHWND
*hwnd
)
2149 *state
= LOWORD(wParam
);
2150 *minimized
= HIWORD(wParam
);
2151 *hwnd
= (WXHWND
)lParam
;
2154 void wxWindowMSW
::UnpackScroll(WXWPARAM wParam
, WXLPARAM lParam
,
2155 WXWORD
*code
, WXWORD
*pos
, WXHWND
*hwnd
)
2157 *code
= LOWORD(wParam
);
2158 *pos
= HIWORD(wParam
);
2159 *hwnd
= (WXHWND
)lParam
;
2162 void wxWindowMSW
::UnpackCtlColor(WXWPARAM wParam
, WXLPARAM lParam
,
2163 WXHDC
*hdc
, WXHWND
*hwnd
)
2165 *hwnd
= (WXHWND
)lParam
;
2166 *hdc
= (WXHDC
)wParam
;
2169 void wxWindowMSW
::UnpackMenuSelect(WXWPARAM wParam
, WXLPARAM lParam
,
2170 WXWORD
*item
, WXWORD
*flags
, WXHMENU
*hmenu
)
2172 *item
= (WXWORD
)wParam
;
2173 *flags
= HIWORD(wParam
);
2174 *hmenu
= (WXHMENU
)lParam
;
2177 // ---------------------------------------------------------------------------
2178 // Main wxWidgets window proc and the window proc for wxWindow
2179 // ---------------------------------------------------------------------------
2181 // Hook for new window just as it's being created, when the window isn't yet
2182 // associated with the handle
2183 static wxWindowMSW
*gs_winBeingCreated
= NULL
;
2185 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2186 // window being created and insures that it's always unset back later
2187 wxWindowCreationHook
::wxWindowCreationHook(wxWindowMSW
*winBeingCreated
)
2189 gs_winBeingCreated
= winBeingCreated
;
2192 wxWindowCreationHook
::~wxWindowCreationHook()
2194 gs_winBeingCreated
= NULL
;
2198 LRESULT WXDLLEXPORT APIENTRY _EXPORT
wxWndProc(HWND hWnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
2200 // trace all messages - useful for the debugging
2202 wxLogTrace(wxTraceMessages
,
2203 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2204 wxGetMessageName(message
), (long)hWnd
, (long)wParam
, lParam
);
2205 #endif // __WXDEBUG__
2207 wxWindowMSW
*wnd
= wxFindWinFromHandle((WXHWND
) hWnd
);
2209 // when we get the first message for the HWND we just created, we associate
2210 // it with wxWindow stored in gs_winBeingCreated
2211 if ( !wnd
&& gs_winBeingCreated
)
2213 wxAssociateWinWithHandle(hWnd
, gs_winBeingCreated
);
2214 wnd
= gs_winBeingCreated
;
2215 gs_winBeingCreated
= NULL
;
2216 wnd
->SetHWND((WXHWND
)hWnd
);
2221 if ( wnd
&& wxEventLoop
::AllowProcessing(wnd
) )
2222 rc
= wnd
->MSWWindowProc(message
, wParam
, lParam
);
2224 rc
= ::DefWindowProc(hWnd
, message
, wParam
, lParam
);
2229 WXLRESULT wxWindowMSW
::MSWWindowProc(WXUINT message
, WXWPARAM wParam
, WXLPARAM lParam
)
2231 // did we process the message?
2232 bool processed
= false;
2242 // for most messages we should return 0 when we do process the message
2250 processed
= HandleCreate((WXLPCREATESTRUCT
)lParam
, &mayCreate
);
2253 // return 0 to allow window creation
2254 rc
.result
= mayCreate ?
0 : -1;
2260 // never set processed to true and *always* pass WM_DESTROY to
2261 // DefWindowProc() as Windows may do some internal cleanup when
2262 // processing it and failing to pass the message along may cause
2263 // memory and resource leaks!
2264 (void)HandleDestroy();
2268 processed
= HandleSize(LOWORD(lParam
), HIWORD(lParam
), wParam
);
2272 processed
= HandleMove(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2275 #if !defined(__WXWINCE__)
2278 LPRECT pRect
= (LPRECT
)lParam
;
2280 rc
.SetLeft(pRect
->left
);
2281 rc
.SetTop(pRect
->top
);
2282 rc
.SetRight(pRect
->right
);
2283 rc
.SetBottom(pRect
->bottom
);
2284 processed
= HandleMoving(rc
);
2286 pRect
->left
= rc
.GetLeft();
2287 pRect
->top
= rc
.GetTop();
2288 pRect
->right
= rc
.GetRight();
2289 pRect
->bottom
= rc
.GetBottom();
2296 LPRECT pRect
= (LPRECT
)lParam
;
2298 rc
.SetLeft(pRect
->left
);
2299 rc
.SetTop(pRect
->top
);
2300 rc
.SetRight(pRect
->right
);
2301 rc
.SetBottom(pRect
->bottom
);
2302 processed
= HandleSizing(rc
);
2304 pRect
->left
= rc
.GetLeft();
2305 pRect
->top
= rc
.GetTop();
2306 pRect
->right
= rc
.GetRight();
2307 pRect
->bottom
= rc
.GetBottom();
2311 #endif // !__WXWINCE__
2313 #if !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
2314 case WM_WINDOWPOSCHANGED
:
2316 WINDOWPOS
*lpPos
= (WINDOWPOS
*)lParam
;
2318 if ( !(lpPos
->flags
& SWP_NOSIZE
) )
2321 ::GetClientRect(GetHwnd(), &rc
);
2323 AutoHRGN
hrgnClient(::CreateRectRgnIndirect(&rc
));
2324 AutoHRGN
hrgnNew(::CreateRectRgn(lpPos
->x
, lpPos
->y
,
2325 lpPos
->cx
, lpPos
->cy
));
2327 // we need to invalidate any new exposed areas here
2328 // to force them to repaint
2329 if ( ::CombineRgn(hrgnNew
, hrgnNew
, hrgnClient
, RGN_DIFF
) != NULLREGION
)
2330 ::InvalidateRgn(GetHwnd(), hrgnNew
, TRUE
);
2335 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2336 case WM_ACTIVATEAPP
:
2337 // This implicitly sends a wxEVT_ACTIVATE_APP event
2338 wxTheApp
->SetActive(wParam
!= 0, FindFocus());
2344 WXWORD state
, minimized
;
2346 UnpackActivate(wParam
, lParam
, &state
, &minimized
, &hwnd
);
2348 processed
= HandleActivate(state
, minimized
!= 0, (WXHWND
)hwnd
);
2353 processed
= HandleSetFocus((WXHWND
)(HWND
)wParam
);
2357 processed
= HandleKillFocus((WXHWND
)(HWND
)wParam
);
2360 case WM_PRINTCLIENT
:
2361 processed
= HandlePrintClient((WXHDC
)wParam
);
2367 wxPaintDCEx
dc((wxWindow
*)this, (WXHDC
)wParam
);
2369 processed
= HandlePaint();
2373 processed
= HandlePaint();
2378 #ifdef __WXUNIVERSAL__
2379 // Universal uses its own wxFrame/wxDialog, so we don't receive
2380 // close events unless we have this.
2382 #endif // __WXUNIVERSAL__
2384 // don't let the DefWindowProc() destroy our window - we'll do it
2385 // ourselves in ~wxWindow
2391 processed
= HandleShow(wParam
!= 0, (int)lParam
);
2395 processed
= HandleMouseMove(GET_X_LPARAM(lParam
),
2396 GET_Y_LPARAM(lParam
),
2400 #ifdef HAVE_TRACKMOUSEEVENT
2402 // filter out excess WM_MOUSELEAVE events sent after PopupMenu() (on XP at least)
2403 if ( m_mouseInWindow
)
2405 GenerateMouseLeave();
2408 // always pass processed back as false, this allows the window
2409 // manager to process the message too. This is needed to
2410 // ensure windows XP themes work properly as the mouse moves
2411 // over widgets like buttons. So don't set processed to true here.
2413 #endif // HAVE_TRACKMOUSEEVENT
2415 #if wxUSE_MOUSEWHEEL
2417 processed
= HandleMouseWheel(wParam
, lParam
);
2421 case WM_LBUTTONDOWN
:
2423 case WM_LBUTTONDBLCLK
:
2424 case WM_RBUTTONDOWN
:
2426 case WM_RBUTTONDBLCLK
:
2427 case WM_MBUTTONDOWN
:
2429 case WM_MBUTTONDBLCLK
:
2431 #ifdef __WXMICROWIN__
2432 // MicroWindows seems to ignore the fact that a window is
2433 // disabled. So catch mouse events and throw them away if
2435 wxWindowMSW
* win
= this;
2438 if (!win
->IsEnabled())
2444 win
= win
->GetParent();
2445 if ( !win
|| win
->IsTopLevel() )
2452 #endif // __WXMICROWIN__
2453 int x
= GET_X_LPARAM(lParam
),
2454 y
= GET_Y_LPARAM(lParam
);
2456 // redirect the event to a static control if necessary by
2457 // finding one under mouse
2459 if ( GetCapture() == this )
2461 // but don't do it if the mouse is captured by this window
2462 // because then it should really get this event itself
2467 win
= FindWindowForMouseEvent(this, &x
, &y
);
2469 // this should never happen
2470 wxCHECK_MSG( win
, 0,
2471 _T("FindWindowForMouseEvent() returned NULL") );
2474 processed
= win
->HandleMouseEvent(message
, x
, y
, wParam
);
2476 // if the app didn't eat the event, handle it in the default
2477 // way, that is by giving this window the focus
2480 // for the standard classes their WndProc sets the focus to
2481 // them anyhow and doing it from here results in some weird
2482 // problems, so don't do it for them (unnecessary anyhow)
2483 if ( !win
->IsOfStandardClass() )
2485 if ( message
== WM_LBUTTONDOWN
&& win
->AcceptsFocus() )
2497 case MM_JOY1BUTTONDOWN
:
2498 case MM_JOY2BUTTONDOWN
:
2499 case MM_JOY1BUTTONUP
:
2500 case MM_JOY2BUTTONUP
:
2501 processed
= HandleJoystickEvent(message
,
2502 GET_X_LPARAM(lParam
),
2503 GET_Y_LPARAM(lParam
),
2506 #endif // __WXMICROWIN__
2512 UnpackCommand(wParam
, lParam
, &id
, &hwnd
, &cmd
);
2514 processed
= HandleCommand(id
, cmd
, hwnd
);
2519 processed
= HandleNotify((int)wParam
, lParam
, &rc
.result
);
2522 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
2523 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
2524 // apparently doesn't always behave properly and needs some help
2525 #if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
2526 case WM_NOTIFYFORMAT
:
2527 if ( lParam
== NF_QUERY
)
2530 rc
.result
= NFR_UNICODE
;
2533 #endif // wxUSE_UNICODE_MSLU
2535 // for these messages we must return true if process the message
2538 case WM_MEASUREITEM
:
2540 int idCtrl
= (UINT
)wParam
;
2541 if ( message
== WM_DRAWITEM
)
2543 processed
= MSWOnDrawItem(idCtrl
,
2544 (WXDRAWITEMSTRUCT
*)lParam
);
2548 processed
= MSWOnMeasureItem(idCtrl
,
2549 (WXMEASUREITEMSTRUCT
*)lParam
);
2556 #endif // defined(WM_DRAWITEM)
2559 if ( !IsOfStandardClass() )
2561 // we always want to get the char events
2562 rc
.result
= DLGC_WANTCHARS
;
2564 if ( GetWindowStyleFlag() & wxWANTS_CHARS
)
2566 // in fact, we want everything
2567 rc
.result
|= DLGC_WANTARROWS
|
2574 //else: get the dlg code from the DefWindowProc()
2579 // If this has been processed by an event handler, return 0 now
2580 // (we've handled it).
2581 m_lastKeydownProcessed
= HandleKeyDown((WORD
) wParam
, lParam
);
2582 if ( m_lastKeydownProcessed
)
2591 // we consider these message "not interesting" to OnChar, so
2592 // just don't do anything more with them
2602 // avoid duplicate messages to OnChar for these ASCII keys:
2603 // they will be translated by TranslateMessage() and received
2625 // but set processed to false, not true to still pass them
2626 // to the control's default window proc - otherwise
2627 // built-in keyboard handling won't work
2632 // special case of VK_APPS: treat it the same as right mouse
2633 // click because both usually pop up a context menu
2635 processed
= HandleMouseEvent(WM_RBUTTONDOWN
, -1, -1, 0);
2640 // do generate a CHAR event
2641 processed
= HandleChar((WORD
)wParam
, lParam
);
2644 if (message
== WM_SYSKEYDOWN
) // Let Windows still handle the SYSKEYs
2651 // special case of VK_APPS: treat it the same as right mouse button
2652 if ( wParam
== VK_APPS
)
2654 processed
= HandleMouseEvent(WM_RBUTTONUP
, -1, -1, 0);
2659 processed
= HandleKeyUp((WORD
) wParam
, lParam
);
2664 case WM_CHAR
: // Always an ASCII character
2665 if ( m_lastKeydownProcessed
)
2667 // The key was handled in the EVT_KEY_DOWN and handling
2668 // a key in an EVT_KEY_DOWN handler is meant, by
2669 // design, to prevent EVT_CHARs from happening
2670 m_lastKeydownProcessed
= false;
2675 processed
= HandleChar((WORD
)wParam
, lParam
, true);
2681 processed
= HandleHotKey((WORD
)wParam
, lParam
);
2683 #endif // wxUSE_HOTKEY
2690 UnpackScroll(wParam
, lParam
, &code
, &pos
, &hwnd
);
2692 processed
= MSWOnScroll(message
== WM_HSCROLL ? wxHORIZONTAL
2698 // CTLCOLOR messages are sent by children to query the parent for their
2700 #ifndef __WXMICROWIN__
2701 case WM_CTLCOLORMSGBOX
:
2702 case WM_CTLCOLOREDIT
:
2703 case WM_CTLCOLORLISTBOX
:
2704 case WM_CTLCOLORBTN
:
2705 case WM_CTLCOLORDLG
:
2706 case WM_CTLCOLORSCROLLBAR
:
2707 case WM_CTLCOLORSTATIC
:
2711 UnpackCtlColor(wParam
, lParam
, &hdc
, &hwnd
);
2713 processed
= HandleCtlColor(&rc
.hBrush
, (WXHDC
)hdc
, (WXHWND
)hwnd
);
2716 #endif // !__WXMICROWIN__
2718 case WM_SYSCOLORCHANGE
:
2719 // the return value for this message is ignored
2720 processed
= HandleSysColorChange();
2723 #if !defined(__WXWINCE__)
2724 case WM_DISPLAYCHANGE
:
2725 processed
= HandleDisplayChange();
2729 case WM_PALETTECHANGED
:
2730 processed
= HandlePaletteChanged((WXHWND
) (HWND
) wParam
);
2733 case WM_CAPTURECHANGED
:
2734 processed
= HandleCaptureChanged((WXHWND
) (HWND
) lParam
);
2737 case WM_QUERYNEWPALETTE
:
2738 processed
= HandleQueryNewPalette();
2742 processed
= HandleEraseBkgnd((WXHDC
)(HDC
)wParam
);
2745 // we processed the message, i.e. erased the background
2750 #if !defined(__WXWINCE__)
2752 processed
= HandleDropFiles(wParam
);
2757 processed
= HandleInitDialog((WXHWND
)(HWND
)wParam
);
2761 // we never set focus from here
2766 #if !defined(__WXWINCE__)
2767 case WM_QUERYENDSESSION
:
2768 processed
= HandleQueryEndSession(lParam
, &rc
.allow
);
2772 processed
= HandleEndSession(wParam
!= 0, lParam
);
2775 case WM_GETMINMAXINFO
:
2776 processed
= HandleGetMinMaxInfo((MINMAXINFO
*)lParam
);
2781 processed
= HandleSetCursor((WXHWND
)(HWND
)wParam
,
2782 LOWORD(lParam
), // hit test
2783 HIWORD(lParam
)); // mouse msg
2787 // returning TRUE stops the DefWindowProc() from further
2788 // processing this message - exactly what we need because we've
2789 // just set the cursor.
2794 #if wxUSE_ACCESSIBILITY
2797 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2798 LPARAM dwObjId
= (LPARAM
) (DWORD
) lParam
;
2800 if (dwObjId
== (LPARAM
)OBJID_CLIENT
&& GetOrCreateAccessible())
2802 return LresultFromObject(IID_IAccessible
, wParam
, (IUnknown
*) GetAccessible()->GetIAccessible());
2808 #if defined(WM_HELP)
2811 // HELPINFO doesn't seem to be supported on WinCE.
2813 HELPINFO
* info
= (HELPINFO
*) lParam
;
2814 // Don't yet process menu help events, just windows
2815 if (info
->iContextType
== HELPINFO_WINDOW
)
2818 wxWindowMSW
* subjectOfHelp
= this;
2819 bool eventProcessed
= false;
2820 while (subjectOfHelp
&& !eventProcessed
)
2822 wxHelpEvent
helpEvent(wxEVT_HELP
,
2823 subjectOfHelp
->GetId(),
2827 wxPoint(info
->MousePos
.x
, info
->MousePos
.y
)
2831 helpEvent
.SetEventObject(this);
2833 GetEventHandler()->ProcessEvent(helpEvent
);
2835 // Go up the window hierarchy until the event is
2837 subjectOfHelp
= subjectOfHelp
->GetParent();
2840 processed
= eventProcessed
;
2843 else if (info
->iContextType
== HELPINFO_MENUITEM
)
2845 wxHelpEvent
helpEvent(wxEVT_HELP
, info
->iCtrlId
);
2846 helpEvent
.SetEventObject(this);
2847 processed
= GetEventHandler()->ProcessEvent(helpEvent
);
2850 //else: processed is already false
2856 #if !defined(__WXWINCE__)
2857 case WM_CONTEXTMENU
:
2859 // we don't convert from screen to client coordinates as
2860 // the event may be handled by a parent window
2861 wxPoint
pt(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
));
2863 wxContextMenuEvent
evtCtx(wxEVT_CONTEXT_MENU
, GetId(), pt
);
2865 // we could have got an event from our child, reflect it back
2866 // to it if this is the case
2867 wxWindowMSW
*win
= NULL
;
2868 if ( (WXHWND
)wParam
!= m_hWnd
)
2870 win
= FindItemByHWND((WXHWND
)wParam
);
2876 evtCtx
.SetEventObject(win
);
2877 processed
= win
->GetEventHandler()->ProcessEvent(evtCtx
);
2883 // we're only interested in our own menus, not MF_SYSMENU
2884 if ( HIWORD(wParam
) == MF_POPUP
)
2886 // handle menu chars for ownerdrawn menu items
2887 int i
= HandleMenuChar(toupper(LOWORD(wParam
)), lParam
);
2888 if ( i
!= wxNOT_FOUND
)
2890 rc
.result
= MAKELRESULT(i
, MNC_EXECUTE
);
2900 wxLogTrace(wxTraceMessages
, wxT("Forwarding %s to DefWindowProc."),
2901 wxGetMessageName(message
));
2902 #endif // __WXDEBUG__
2903 rc
.result
= MSWDefWindowProc(message
, wParam
, lParam
);
2909 // ----------------------------------------------------------------------------
2910 // wxWindow <-> HWND map
2911 // ----------------------------------------------------------------------------
2913 wxWinHashTable
*wxWinHandleHash
= NULL
;
2915 wxWindow
*wxFindWinFromHandle(WXHWND hWnd
)
2917 return (wxWindow
*)wxWinHandleHash
->Get((long)hWnd
);
2920 void wxAssociateWinWithHandle(HWND hWnd
, wxWindowMSW
*win
)
2922 // adding NULL hWnd is (first) surely a result of an error and
2923 // (secondly) breaks menu command processing
2924 wxCHECK_RET( hWnd
!= (HWND
)NULL
,
2925 wxT("attempt to add a NULL hWnd to window list ignored") );
2927 wxWindow
*oldWin
= wxFindWinFromHandle((WXHWND
) hWnd
);
2929 if ( oldWin
&& (oldWin
!= win
) )
2931 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2932 (int) hWnd
, win
->GetClassInfo()->GetClassName());
2935 #endif // __WXDEBUG__
2938 wxWinHandleHash
->Put((long)hWnd
, (wxWindow
*)win
);
2942 void wxRemoveHandleAssociation(wxWindowMSW
*win
)
2944 wxWinHandleHash
->Delete((long)win
->GetHWND());
2947 // ----------------------------------------------------------------------------
2948 // various MSW speciic class dependent functions
2949 // ----------------------------------------------------------------------------
2951 // Default destroyer - override if you destroy it in some other way
2952 // (e.g. with MDI child windows)
2953 void wxWindowMSW
::MSWDestroyWindow()
2957 bool wxWindowMSW
::MSWGetCreateWindowCoords(const wxPoint
& pos
,
2960 int& w
, int& h
) const
2962 // yes, those are just some arbitrary hardcoded numbers
2963 static const int DEFAULT_Y
= 200;
2965 bool nonDefault
= false;
2967 if ( pos
.x
== wxDefaultCoord
)
2969 // if x is set to CW_USEDEFAULT, y parameter is ignored anyhow so we
2970 // can just as well set it to CW_USEDEFAULT as well
2976 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2977 // neither because it is not handled as a special value by Windows then
2978 // and so we have to choose some default value for it
2980 y
= pos
.y
== wxDefaultCoord ? DEFAULT_Y
: pos
.y
;
2986 NB: there used to be some code here which set the initial size of the
2987 window to the client size of the parent if no explicit size was
2988 specified. This was wrong because wxWidgets programs often assume
2989 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2990 it. To see why, you should understand that Windows sends WM_SIZE from
2991 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2992 from some base class ctor and so this WM_SIZE is not processed in the
2993 real class' OnSize() (because it's not fully constructed yet and the
2994 event goes to some base class OnSize() instead). So the WM_SIZE we
2995 rely on is the one sent when the parent frame resizes its children
2996 but here is the problem: if the child already has just the right
2997 size, nothing will happen as both wxWidgets and Windows check for
2998 this and ignore any attempts to change the window size to the size it
2999 already has - so no WM_SIZE would be sent.
3003 // we don't use CW_USEDEFAULT here for several reasons:
3005 // 1. it results in huge frames on modern screens (1000*800 is not
3006 // uncommon on my 1280*1024 screen) which is way too big for a half
3007 // empty frame of most of wxWidgets samples for example)
3009 // 2. it is buggy for frames with wxFRAME_TOOL_WINDOW style for which
3010 // the default is for whatever reason 8*8 which breaks client <->
3011 // window size calculations (it would be nice if it didn't, but it
3012 // does and the simplest way to fix it seemed to change the broken
3013 // default size anyhow)
3015 // 3. there is just no advantage in doing it: with x and y it is
3016 // possible that [future versions of] Windows position the new top
3017 // level window in some smart way which we can't do, but we can
3018 // guess a reasonably good size for a new window just as well
3021 // However, on PocketPC devices, we must use the default
3022 // size if possible.
3024 if (size
.x
== wxDefaultCoord
)
3028 if (size
.y
== wxDefaultCoord
)
3033 if ( size
.x
== wxDefaultCoord
|| size
.y
== wxDefaultCoord
)
3037 w
= WidthDefault(size
.x
);
3038 h
= HeightDefault(size
.y
);
3041 AdjustForParentClientOrigin(x
, y
);
3046 WXHWND wxWindowMSW
::MSWGetParent() const
3048 return m_parent ? m_parent
->GetHWND() : WXHWND(NULL
);
3051 bool wxWindowMSW
::MSWCreate(const wxChar
*wclass
,
3052 const wxChar
*title
,
3056 WXDWORD extendedStyle
)
3058 // choose the position/size for the new window
3060 (void)MSWGetCreateWindowCoords(pos
, size
, x
, y
, w
, h
);
3062 // controlId is menu handle for the top level windows, so set it to 0
3063 // unless we're creating a child window
3064 int controlId
= style
& WS_CHILD ?
GetId() : 0;
3066 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3067 // which is the same but without CS_[HV]REDRAW class styles so using it
3068 // ensures that the window is not fully repainted on each resize
3069 wxString
className(wclass
);
3070 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
3072 className
+= wxT("NR");
3075 // do create the window
3076 wxWindowCreationHook
hook(this);
3078 m_hWnd
= (WXHWND
)::CreateWindowEx
3082 title ? title
: m_windowName
.c_str(),
3085 (HWND
)MSWGetParent(),
3088 NULL
// no extra data
3093 wxLogSysError(_("Can't create window of class %s"), className
.c_str());
3098 SubclassWin(m_hWnd
);
3103 // ===========================================================================
3104 // MSW message handlers
3105 // ===========================================================================
3107 // ---------------------------------------------------------------------------
3109 // ---------------------------------------------------------------------------
3113 bool wxWindowMSW
::HandleNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
3115 #ifndef __WXMICROWIN__
3116 LPNMHDR hdr
= (LPNMHDR
)lParam
;
3117 HWND hWnd
= hdr
->hwndFrom
;
3118 wxWindow
*win
= wxFindWinFromHandle((WXHWND
)hWnd
);
3120 // if the control is one of our windows, let it handle the message itself
3123 return win
->MSWOnNotify(idCtrl
, lParam
, result
);
3126 // VZ: why did we do it? normally this is unnecessary and, besides, it
3127 // breaks the message processing for the toolbars because the tooltip
3128 // notifications were being forwarded to the toolbar child controls
3129 // (if it had any) before being passed to the toolbar itself, so in my
3130 // example the tooltip for the combobox was always shown instead of the
3131 // correct button tooltips
3133 // try all our children
3134 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3137 wxWindow
*child
= node
->GetData();
3138 if ( child
->MSWOnNotify(idCtrl
, lParam
, result
) )
3143 node
= node
->GetNext();
3147 // by default, handle it ourselves
3148 return MSWOnNotify(idCtrl
, lParam
, result
);
3149 #else // __WXMICROWIN__
3156 bool wxWindowMSW
::HandleTooltipNotify(WXUINT code
,
3158 const wxString
& ttip
)
3160 // I don't know why it happens, but the versions of comctl32.dll starting
3161 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3162 // this message is supposed to be sent to Unicode programs only) -- hence
3163 // we need to handle it as well, otherwise no tooltips will be shown in
3166 if ( !(code
== (WXUINT
) TTN_NEEDTEXTA
|| code
== (WXUINT
) TTN_NEEDTEXTW
)
3169 // not a tooltip message or no tooltip to show anyhow
3174 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
3176 // We don't want to use the szText buffer because it has a limit of 80
3177 // bytes and this is not enough, especially for Unicode build where it
3178 // limits the tooltip string length to only 40 characters
3180 // The best would be, of course, to not impose any length limitations at
3181 // all but then the buffer would have to be dynamic and someone would have
3182 // to free it and we don't have the tooltip owner object here any more, so
3183 // for now use our own static buffer with a higher fixed max length.
3185 // Note that using a static buffer should not be a problem as only a single
3186 // tooltip can be shown at the same time anyhow.
3188 if ( code
== (WXUINT
) TTN_NEEDTEXTW
)
3190 // We need to convert tooltip from multi byte to Unicode on the fly.
3191 static wchar_t buf
[513];
3193 // Truncate tooltip length if needed as otherwise we might not have
3194 // enough space for it in the buffer and MultiByteToWideChar() would
3196 size_t tipLength
= wxMin(ttip
.Len(), WXSIZEOF(buf
) - 1);
3198 // Convert to WideChar without adding the NULL character. The NULL
3199 // character is added afterwards (this is more efficient).
3200 int len
= ::MultiByteToWideChar
3212 wxLogLastError(_T("MultiByteToWideChar()"));
3216 ttText
->lpszText
= (LPSTR
) buf
;
3218 else // TTN_NEEDTEXTA
3219 #endif // !wxUSE_UNICODE
3221 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3222 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3223 // to copy the string we have into the buffer
3224 static wxChar buf
[513];
3225 wxStrncpy(buf
, ttip
.c_str(), WXSIZEOF(buf
) - 1);
3226 buf
[WXSIZEOF(buf
) - 1] = _T('\0');
3227 ttText
->lpszText
= buf
;
3233 #endif // wxUSE_TOOLTIPS
3235 bool wxWindowMSW
::MSWOnNotify(int WXUNUSED(idCtrl
),
3237 WXLPARAM
* WXUNUSED(result
))
3242 NMHDR
* hdr
= (NMHDR
*)lParam
;
3243 if ( HandleTooltipNotify(hdr
->code
, lParam
, m_tooltip
->GetTip()))
3250 wxUnusedVar(lParam
);
3251 #endif // wxUSE_TOOLTIPS
3258 // ---------------------------------------------------------------------------
3259 // end session messages
3260 // ---------------------------------------------------------------------------
3262 bool wxWindowMSW
::HandleQueryEndSession(long logOff
, bool *mayEnd
)
3264 #ifdef ENDSESSION_LOGOFF
3265 wxCloseEvent
event(wxEVT_QUERY_END_SESSION
, wxID_ANY
);
3266 event
.SetEventObject(wxTheApp
);
3267 event
.SetCanVeto(true);
3268 event
.SetLoggingOff(logOff
== (long)ENDSESSION_LOGOFF
);
3270 bool rc
= wxTheApp
->ProcessEvent(event
);
3274 // we may end only if the app didn't veto session closing (double
3276 *mayEnd
= !event
.GetVeto();
3281 wxUnusedVar(logOff
);
3282 wxUnusedVar(mayEnd
);
3287 bool wxWindowMSW
::HandleEndSession(bool endSession
, long logOff
)
3289 #ifdef ENDSESSION_LOGOFF
3290 // do nothing if the session isn't ending
3295 if ( (this != wxTheApp
->GetTopWindow()) )
3298 wxCloseEvent
event(wxEVT_END_SESSION
, wxID_ANY
);
3299 event
.SetEventObject(wxTheApp
);
3300 event
.SetCanVeto(false);
3301 event
.SetLoggingOff( (logOff
== (long)ENDSESSION_LOGOFF
) );
3303 return wxTheApp
->ProcessEvent(event
);
3305 wxUnusedVar(endSession
);
3306 wxUnusedVar(logOff
);
3311 // ---------------------------------------------------------------------------
3312 // window creation/destruction
3313 // ---------------------------------------------------------------------------
3315 bool wxWindowMSW
::HandleCreate(WXLPCREATESTRUCT
WXUNUSED_IN_WINCE(cs
),
3318 // VZ: why is this commented out for WinCE? If it doesn't support
3319 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3320 // not with multiple #ifdef's!
3322 if ( ((CREATESTRUCT
*)cs
)->dwExStyle
& WS_EX_CONTROLPARENT
)
3323 EnsureParentHasControlParentStyle(GetParent());
3324 #endif // !__WXWINCE__
3326 // TODO: should generate this event from WM_NCCREATE
3327 wxWindowCreateEvent
event((wxWindow
*)this);
3328 (void)GetEventHandler()->ProcessEvent(event
);
3335 bool wxWindowMSW
::HandleDestroy()
3339 // delete our drop target if we've got one
3340 #if wxUSE_DRAG_AND_DROP
3341 if ( m_dropTarget
!= NULL
)
3343 m_dropTarget
->Revoke(m_hWnd
);
3345 delete m_dropTarget
;
3346 m_dropTarget
= NULL
;
3348 #endif // wxUSE_DRAG_AND_DROP
3350 // WM_DESTROY handled
3354 // ---------------------------------------------------------------------------
3356 // ---------------------------------------------------------------------------
3358 bool wxWindowMSW
::HandleActivate(int state
,
3359 bool WXUNUSED(minimized
),
3360 WXHWND
WXUNUSED(activate
))
3362 wxActivateEvent
event(wxEVT_ACTIVATE
,
3363 (state
== WA_ACTIVE
) || (state
== WA_CLICKACTIVE
),
3365 event
.SetEventObject(this);
3367 return GetEventHandler()->ProcessEvent(event
);
3370 bool wxWindowMSW
::HandleSetFocus(WXHWND hwnd
)
3372 // Strangly enough, some controls get set focus events when they are being
3373 // deleted, even if they already had focus before.
3374 if ( m_isBeingDeleted
)
3379 // notify the parent keeping track of focus for the kbd navigation
3380 // purposes that we got it
3381 wxChildFocusEvent
eventFocus((wxWindow
*)this);
3382 (void)GetEventHandler()->ProcessEvent(eventFocus
);
3388 m_caret
->OnSetFocus();
3390 #endif // wxUSE_CARET
3393 // If it's a wxTextCtrl don't send the event as it will be done
3394 // after the control gets to process it from EN_FOCUS handler
3395 if ( wxDynamicCastThis(wxTextCtrl
) )
3399 #endif // wxUSE_TEXTCTRL
3401 wxFocusEvent
event(wxEVT_SET_FOCUS
, m_windowId
);
3402 event
.SetEventObject(this);
3404 // wxFindWinFromHandle() may return NULL, it is ok
3405 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3407 return GetEventHandler()->ProcessEvent(event
);
3410 bool wxWindowMSW
::HandleKillFocus(WXHWND hwnd
)
3416 m_caret
->OnKillFocus();
3418 #endif // wxUSE_CARET
3421 // If it's a wxTextCtrl don't send the event as it will be done
3422 // after the control gets to process it.
3423 wxTextCtrl
*ctrl
= wxDynamicCastThis(wxTextCtrl
);
3430 // Don't send the event when in the process of being deleted. This can
3431 // only cause problems if the event handler tries to access the object.
3432 if ( m_isBeingDeleted
)
3437 wxFocusEvent
event(wxEVT_KILL_FOCUS
, m_windowId
);
3438 event
.SetEventObject(this);
3440 // wxFindWinFromHandle() may return NULL, it is ok
3441 event
.SetWindow(wxFindWinFromHandle(hwnd
));
3443 return GetEventHandler()->ProcessEvent(event
);
3446 // ---------------------------------------------------------------------------
3448 // ---------------------------------------------------------------------------
3450 bool wxWindowMSW
::HandleShow(bool show
, int WXUNUSED(status
))
3452 wxShowEvent
event(GetId(), show
);
3453 event
.SetEventObject(this);
3455 return GetEventHandler()->ProcessEvent(event
);
3458 bool wxWindowMSW
::HandleInitDialog(WXHWND
WXUNUSED(hWndFocus
))
3460 wxInitDialogEvent
event(GetId());
3461 event
.SetEventObject(this);
3463 return GetEventHandler()->ProcessEvent(event
);
3466 bool wxWindowMSW
::HandleDropFiles(WXWPARAM wParam
)
3468 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3469 wxUnusedVar(wParam
);
3471 #else // __WXMICROWIN__
3472 HDROP hFilesInfo
= (HDROP
) wParam
;
3474 // Get the total number of files dropped
3475 UINT gwFilesDropped
= ::DragQueryFile
3483 wxString
*files
= new wxString
[gwFilesDropped
];
3484 for ( UINT wIndex
= 0; wIndex
< gwFilesDropped
; wIndex
++ )
3486 // first get the needed buffer length (+1 for terminating NUL)
3487 size_t len
= ::DragQueryFile(hFilesInfo
, wIndex
, NULL
, 0) + 1;
3489 // and now get the file name
3490 ::DragQueryFile(hFilesInfo
, wIndex
,
3491 wxStringBuffer(files
[wIndex
], len
), len
);
3493 DragFinish (hFilesInfo
);
3495 wxDropFilesEvent
event(wxEVT_DROP_FILES
, gwFilesDropped
, files
);
3496 event
.SetEventObject(this);
3499 DragQueryPoint(hFilesInfo
, (LPPOINT
) &dropPoint
);
3500 event
.m_pos
.x
= dropPoint
.x
;
3501 event
.m_pos
.y
= dropPoint
.y
;
3503 return GetEventHandler()->ProcessEvent(event
);
3508 bool wxWindowMSW
::HandleSetCursor(WXHWND
WXUNUSED(hWnd
),
3510 int WXUNUSED(mouseMsg
))
3512 #ifndef __WXMICROWIN__
3513 // the logic is as follows:
3514 // -1. don't set cursor for non client area, including but not limited to
3515 // the title bar, scrollbars, &c
3516 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3517 // 1. if we have the cursor set it unless wxIsBusy()
3518 // 2. if we're a top level window, set some cursor anyhow
3519 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3521 if ( nHitTest
!= HTCLIENT
)
3526 HCURSOR hcursor
= 0;
3528 // first ask the user code - it may wish to set the cursor in some very
3529 // specific way (for example, depending on the current position)
3532 if ( !::GetCursorPosWinCE(&pt
))
3534 if ( !::GetCursorPos(&pt
) )
3537 wxLogLastError(wxT("GetCursorPos"));
3542 ScreenToClient(&x
, &y
);
3543 wxSetCursorEvent
event(x
, y
);
3545 bool processedEvtSetCursor
= GetEventHandler()->ProcessEvent(event
);
3546 if ( processedEvtSetCursor
&& event
.HasCursor() )
3548 hcursor
= GetHcursorOf(event
.GetCursor());
3553 bool isBusy
= wxIsBusy();
3555 // the test for processedEvtSetCursor is here to prevent using m_cursor
3556 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3557 // it - this is a way to say that our cursor shouldn't be used for this
3559 if ( !processedEvtSetCursor
&& m_cursor
.Ok() )
3561 hcursor
= GetHcursorOf(m_cursor
);
3568 hcursor
= wxGetCurrentBusyCursor();
3570 else if ( !hcursor
)
3572 const wxCursor
*cursor
= wxGetGlobalCursor();
3573 if ( cursor
&& cursor
->Ok() )
3575 hcursor
= GetHcursorOf(*cursor
);
3583 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3585 ::SetCursor(hcursor
);
3587 // cursor set, stop here
3590 #endif // __WXMICROWIN__
3592 // pass up the window chain
3596 // ---------------------------------------------------------------------------
3597 // owner drawn stuff
3598 // ---------------------------------------------------------------------------
3600 #if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
3601 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
3602 #define WXUNUSED_UNLESS_ODRAWN(param) param
3604 #define WXUNUSED_UNLESS_ODRAWN(param)
3608 wxWindowMSW
::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id
),
3609 WXDRAWITEMSTRUCT
* WXUNUSED_UNLESS_ODRAWN(itemStruct
))
3611 #if wxUSE_OWNER_DRAWN
3613 #if wxUSE_MENUS_NATIVE
3614 // is it a menu item?
3615 DRAWITEMSTRUCT
*pDrawStruct
= (DRAWITEMSTRUCT
*)itemStruct
;
3616 if ( id
== 0 && pDrawStruct
->CtlType
== ODT_MENU
)
3618 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pDrawStruct
->itemData
);
3620 // see comment before the same test in MSWOnMeasureItem() below
3624 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3625 false, _T("MSWOnDrawItem: bad wxMenuItem pointer") );
3627 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3628 // the DC from being released
3629 wxDCTemp
dc((WXHDC
)pDrawStruct
->hDC
);
3630 wxRect
rect(pDrawStruct
->rcItem
.left
, pDrawStruct
->rcItem
.top
,
3631 pDrawStruct
->rcItem
.right
- pDrawStruct
->rcItem
.left
,
3632 pDrawStruct
->rcItem
.bottom
- pDrawStruct
->rcItem
.top
);
3634 return pMenuItem
->OnDrawItem
3638 (wxOwnerDrawn
::wxODAction
)pDrawStruct
->itemAction
,
3639 (wxOwnerDrawn
::wxODStatus
)pDrawStruct
->itemState
3642 #endif // wxUSE_MENUS_NATIVE
3644 #endif // USE_OWNER_DRAWN
3646 #if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
3648 #if wxUSE_OWNER_DRAWN
3649 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3650 #else // !wxUSE_OWNER_DRAWN
3651 // we may still have owner-drawn buttons internally because we have to make
3652 // them owner-drawn to support colour change
3655 wxDynamicCast(FindItem(id
), wxButton
)
3660 #endif // USE_OWNER_DRAWN
3664 return item
->MSWOnDraw(itemStruct
);
3667 #endif // wxUSE_CONTROLS
3673 wxWindowMSW
::MSWOnMeasureItem(int id
, WXMEASUREITEMSTRUCT
*itemStruct
)
3675 #if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3676 // is it a menu item?
3677 MEASUREITEMSTRUCT
*pMeasureStruct
= (MEASUREITEMSTRUCT
*)itemStruct
;
3678 if ( id
== 0 && pMeasureStruct
->CtlType
== ODT_MENU
)
3680 wxMenuItem
*pMenuItem
= (wxMenuItem
*)(pMeasureStruct
->itemData
);
3682 // according to Carsten Fuchs the pointer may be NULL under XP if an
3683 // MDI child frame is initially maximized, see this for more info:
3684 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
3686 // so silently ignore it instead of asserting
3690 wxCHECK_MSG( wxDynamicCast(pMenuItem
, wxMenuItem
),
3691 false, _T("MSWOnMeasureItem: bad wxMenuItem pointer") );
3694 bool rc
= pMenuItem
->OnMeasureItem(&w
, &h
);
3696 pMeasureStruct
->itemWidth
= w
;
3697 pMeasureStruct
->itemHeight
= h
;
3702 wxControl
*item
= wxDynamicCast(FindItem(id
), wxControl
);
3705 return item
->MSWOnMeasure(itemStruct
);
3709 wxUnusedVar(itemStruct
);
3710 #endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
3715 // ---------------------------------------------------------------------------
3716 // colours and palettes
3717 // ---------------------------------------------------------------------------
3719 bool wxWindowMSW
::HandleSysColorChange()
3721 wxSysColourChangedEvent event
;
3722 event
.SetEventObject(this);
3724 (void)GetEventHandler()->ProcessEvent(event
);
3726 // always let the system carry on the default processing to allow the
3727 // native controls to react to the colours update
3731 bool wxWindowMSW
::HandleDisplayChange()
3733 wxDisplayChangedEvent event
;
3734 event
.SetEventObject(this);
3736 return GetEventHandler()->ProcessEvent(event
);
3739 #ifndef __WXMICROWIN__
3741 bool wxWindowMSW
::HandleCtlColor(WXHBRUSH
*brush
, WXHDC hDC
, WXHWND hWnd
)
3743 #if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
3747 wxControl
*item
= wxDynamicCast(FindItemByHWND(hWnd
, true), wxControl
);
3750 *brush
= item
->MSWControlColor(hDC
, hWnd
);
3752 #endif // wxUSE_CONTROLS
3755 return *brush
!= NULL
;
3758 #endif // __WXMICROWIN__
3760 bool wxWindowMSW
::HandlePaletteChanged(WXHWND hWndPalChange
)
3763 // same as below except we don't respond to our own messages
3764 if ( hWndPalChange
!= GetHWND() )
3766 // check to see if we our our parents have a custom palette
3767 wxWindowMSW
*win
= this;
3768 while ( win
&& !win
->HasCustomPalette() )
3770 win
= win
->GetParent();
3773 if ( win
&& win
->HasCustomPalette() )
3775 // realize the palette to see whether redrawing is needed
3776 HDC hdc
= ::GetDC((HWND
) hWndPalChange
);
3777 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3778 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3780 int result
= ::RealizePalette(hdc
);
3782 // restore the palette (before releasing the DC)
3783 win
->m_palette
.SetHPALETTE((WXHPALETTE
)
3784 ::SelectPalette(hdc
, GetHpaletteOf(win
->m_palette
), FALSE
));
3785 ::RealizePalette(hdc
);
3786 ::ReleaseDC((HWND
) hWndPalChange
, hdc
);
3788 // now check for the need to redraw
3790 ::InvalidateRect((HWND
) hWndPalChange
, NULL
, TRUE
);
3794 #endif // wxUSE_PALETTE
3796 wxPaletteChangedEvent
event(GetId());
3797 event
.SetEventObject(this);
3798 event
.SetChangedWindow(wxFindWinFromHandle(hWndPalChange
));
3800 return GetEventHandler()->ProcessEvent(event
);
3803 bool wxWindowMSW
::HandleCaptureChanged(WXHWND hWndGainedCapture
)
3805 wxMouseCaptureChangedEvent
event(GetId(), wxFindWinFromHandle(hWndGainedCapture
));
3806 event
.SetEventObject(this);
3808 return GetEventHandler()->ProcessEvent(event
);
3811 bool wxWindowMSW
::HandleQueryNewPalette()
3815 // check to see if we our our parents have a custom palette
3816 wxWindowMSW
*win
= this;
3817 while (!win
->HasCustomPalette() && win
->GetParent()) win
= win
->GetParent();
3818 if (win
->HasCustomPalette()) {
3819 /* realize the palette to see whether redrawing is needed */
3820 HDC hdc
= ::GetDC((HWND
) GetHWND());
3821 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3822 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), FALSE
) );
3824 int result
= ::RealizePalette(hdc
);
3825 /* restore the palette (before releasing the DC) */
3826 win
->m_palette
.SetHPALETTE( (WXHPALETTE
)
3827 ::SelectPalette(hdc
, (HPALETTE
) win
->m_palette
.GetHPALETTE(), TRUE
) );
3828 ::RealizePalette(hdc
);
3829 ::ReleaseDC((HWND
) GetHWND(), hdc
);
3830 /* now check for the need to redraw */
3832 ::InvalidateRect((HWND
) GetHWND(), NULL
, TRUE
);
3834 #endif // wxUSE_PALETTE
3836 wxQueryNewPaletteEvent
event(GetId());
3837 event
.SetEventObject(this);
3839 return GetEventHandler()->ProcessEvent(event
) && event
.GetPaletteRealized();
3842 // Responds to colour changes: passes event on to children.
3843 void wxWindowMSW
::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
3845 // the top level window also reset the standard colour map as it might have
3846 // changed (there is no need to do it for the non top level windows as we
3847 // only have to do it once)
3851 gs_hasStdCmap
= false;
3853 wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
3856 // Only propagate to non-top-level windows because Windows already
3857 // sends this event to all top-level ones
3858 wxWindow
*win
= node
->GetData();
3859 if ( !win
->IsTopLevel() )
3861 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3862 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3863 // the standard controls
3864 ::SendMessage(GetHwndOf(win
), WM_SYSCOLORCHANGE
, 0, 0);
3867 node
= node
->GetNext();
3871 extern wxCOLORMAP
*wxGetStdColourMap()
3873 static COLORREF s_stdColours
[wxSTD_COL_MAX
];
3874 static wxCOLORMAP s_cmap
[wxSTD_COL_MAX
];
3876 if ( !gs_hasStdCmap
)
3878 static bool s_coloursInit
= false;
3880 if ( !s_coloursInit
)
3882 // When a bitmap is loaded, the RGB values can change (apparently
3883 // because Windows adjusts them to care for the old programs always
3884 // using 0xc0c0c0 while the transparent colour for the new Windows
3885 // versions is different). But we do this adjustment ourselves so
3886 // we want to avoid Windows' "help" and for this we need to have a
3887 // reference bitmap which can tell us what the RGB values change
3889 wxLogNull logNo
; // suppress error if we couldn't load the bitmap
3890 wxBitmap
stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3891 if ( stdColourBitmap
.Ok() )
3893 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3894 wxASSERT_MSG( stdColourBitmap
.GetWidth() == wxSTD_COL_MAX
,
3895 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3898 memDC
.SelectObject(stdColourBitmap
);
3901 for ( size_t i
= 0; i
< WXSIZEOF(s_stdColours
); i
++ )
3903 memDC
.GetPixel(i
, 0, &colour
);
3904 s_stdColours
[i
] = wxColourToRGB(colour
);
3907 else // wxBITMAP_STD_COLOURS couldn't be loaded
3909 s_stdColours
[0] = RGB(000,000,000); // black
3910 s_stdColours
[1] = RGB(128,128,128); // dark grey
3911 s_stdColours
[2] = RGB(192,192,192); // light grey
3912 s_stdColours
[3] = RGB(255,255,255); // white
3913 //s_stdColours[4] = RGB(000,000,255); // blue
3914 //s_stdColours[5] = RGB(255,000,255); // magenta
3917 s_coloursInit
= true;
3920 gs_hasStdCmap
= true;
3922 // create the colour map
3923 #define INIT_CMAP_ENTRY(col) \
3924 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3925 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3927 INIT_CMAP_ENTRY(BTNTEXT
);
3928 INIT_CMAP_ENTRY(BTNSHADOW
);
3929 INIT_CMAP_ENTRY(BTNFACE
);
3930 INIT_CMAP_ENTRY(BTNHIGHLIGHT
);
3932 #undef INIT_CMAP_ENTRY
3938 // ---------------------------------------------------------------------------
3940 // ---------------------------------------------------------------------------
3942 bool wxWindowMSW
::HandlePaint()
3944 HRGN hRegion
= ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3946 wxLogLastError(wxT("CreateRectRgn"));
3947 if ( ::GetUpdateRgn(GetHwnd(), hRegion
, FALSE
) == ERROR
)
3948 wxLogLastError(wxT("GetUpdateRgn"));
3950 m_updateRegion
= wxRegion((WXHRGN
) hRegion
);
3952 wxPaintEvent
event(m_windowId
);
3953 event
.SetEventObject(this);
3955 bool processed
= GetEventHandler()->ProcessEvent(event
);
3957 // note that we must generate NC event after the normal one as otherwise
3958 // BeginPaint() will happily overwrite our decorations with the background
3960 wxNcPaintEvent
eventNc(m_windowId
);
3961 eventNc
.SetEventObject(this);
3962 GetEventHandler()->ProcessEvent(eventNc
);
3967 // Can be called from an application's OnPaint handler
3968 void wxWindowMSW
::OnPaint(wxPaintEvent
& event
)
3970 #ifdef __WXUNIVERSAL__
3973 HDC hDC
= (HDC
) wxPaintDC
::FindDCInCache((wxWindow
*) event
.GetEventObject());
3976 MSWDefWindowProc(WM_PAINT
, (WPARAM
) hDC
, 0);
3981 bool wxWindowMSW
::HandleEraseBkgnd(WXHDC hdc
)
3986 dc
.SetWindow((wxWindow
*)this);
3989 wxEraseEvent
event(m_windowId
, &dc
);
3990 event
.SetEventObject(this);
3991 bool rc
= GetEventHandler()->ProcessEvent(event
);
3995 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3996 dc
.SelectOldObjects(hdc
);
4001 void wxWindowMSW
::OnEraseBackground(wxEraseEvent
& event
)
4003 // standard non top level controls (i.e. except the dialogs) always erase
4004 // their background themselves in HandleCtlColor() or have some control-
4005 // specific ways to set the colours (common controls)
4006 if ( IsOfStandardClass() && !IsTopLevel() )
4012 if ( GetBackgroundStyle() == wxBG_STYLE_CUSTOM
)
4014 // don't skip the event here, custom background means that the app
4015 // is drawing it itself in its OnPaint(), so don't draw it at all
4016 // now to avoid flicker
4021 // do default background painting
4022 if ( !DoEraseBackground(GetHdcOf(*event
.GetDC())) )
4024 // let the system paint the background
4029 bool wxWindowMSW
::DoEraseBackground(WXHDC hDC
)
4031 HBRUSH hbr
= (HBRUSH
)MSWGetBgBrush(hDC
);
4035 wxFillRect(GetHwnd(), (HDC
)hDC
, hbr
);
4041 wxWindowMSW
::MSWGetBgBrushForChild(WXHDC
WXUNUSED(hDC
), WXHWND hWnd
)
4045 // our background colour applies to:
4046 // 1. this window itself, always
4047 // 2. all children unless the colour is "not inheritable"
4048 // 3. even if it is not inheritable, our immediate transparent
4049 // children should still inherit it -- but not any transparent
4050 // children because it would look wrong if a child of non
4051 // transparent child would show our bg colour when the child itself
4053 wxWindow
*win
= wxFindWinFromHandle(hWnd
);
4056 (win
&& win
->HasTransparentBackground() &&
4057 win
->GetParent() == this) )
4059 // draw children with the same colour as the parent
4061 brush
= wxTheBrushList
->FindOrCreateBrush(GetBackgroundColour());
4063 return (WXHBRUSH
)GetHbrushOf(*brush
);
4070 WXHBRUSH wxWindowMSW
::MSWGetBgBrush(WXHDC hDC
, WXHWND hWndToPaint
)
4073 hWndToPaint
= GetHWND();
4075 for ( wxWindowMSW
*win
= this; win
; win
= win
->GetParent() )
4077 WXHBRUSH hBrush
= win
->MSWGetBgBrushForChild(hDC
, hWndToPaint
);
4081 // background is not inherited beyond top level windows
4082 if ( win
->IsTopLevel() )
4089 bool wxWindowMSW
::HandlePrintClient(WXHDC hDC
)
4091 // we receive this message when DrawThemeParentBackground() is
4092 // called from def window proc of several controls under XP and we
4093 // must draw properly themed background here
4095 // note that naively I'd expect filling the client rect with the
4096 // brush returned by MSWGetBgBrush() work -- but for some reason it
4097 // doesn't and we have to call parents MSWPrintChild() which is
4098 // supposed to call DrawThemeBackground() with appropriate params
4100 // also note that in this case lParam == PRF_CLIENT but we're
4101 // clearly expected to paint the background and nothing else!
4103 if ( IsTopLevel() || InheritsBackgroundColour() )
4106 // sometimes we don't want the parent to handle it at all, instead
4107 // return whatever value this window wants
4108 if ( !MSWShouldPropagatePrintChild() )
4109 return MSWPrintChild(hDC
, (wxWindow
*)this);
4111 for ( wxWindow
*win
= GetParent(); win
; win
= win
->GetParent() )
4113 if ( win
->MSWPrintChild(hDC
, (wxWindow
*)this) )
4116 if ( win
->IsTopLevel() || win
->InheritsBackgroundColour() )
4123 // ---------------------------------------------------------------------------
4124 // moving and resizing
4125 // ---------------------------------------------------------------------------
4127 bool wxWindowMSW
::HandleMinimize()
4129 wxIconizeEvent
event(m_windowId
);
4130 event
.SetEventObject(this);
4132 return GetEventHandler()->ProcessEvent(event
);
4135 bool wxWindowMSW
::HandleMaximize()
4137 wxMaximizeEvent
event(m_windowId
);
4138 event
.SetEventObject(this);
4140 return GetEventHandler()->ProcessEvent(event
);
4143 bool wxWindowMSW
::HandleMove(int x
, int y
)
4146 wxMoveEvent
event(point
, m_windowId
);
4147 event
.SetEventObject(this);
4149 return GetEventHandler()->ProcessEvent(event
);
4152 bool wxWindowMSW
::HandleMoving(wxRect
& rect
)
4154 wxMoveEvent
event(rect
, m_windowId
);
4155 event
.SetEventObject(this);
4157 bool rc
= GetEventHandler()->ProcessEvent(event
);
4159 rect
= event
.GetRect();
4163 bool wxWindowMSW
::HandleSize(int WXUNUSED(w
), int WXUNUSED(h
), WXUINT wParam
)
4165 #if USE_DEFERRED_SIZING
4166 // when we resize this window, its children are probably going to be
4167 // repositioned as well, prepare to use DeferWindowPos() for them
4168 int numChildren
= 0;
4169 for ( HWND child
= ::GetWindow(GetHwndOf(this), GW_CHILD
);
4171 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
4176 // Protect against valid m_hDWP being overwritten
4177 bool useDefer
= false;
4179 if ( numChildren
> 1 )
4183 m_hDWP
= (WXHANDLE
)::BeginDeferWindowPos(numChildren
);
4186 wxLogLastError(_T("BeginDeferWindowPos"));
4194 // update this window size
4195 bool processed
= false;
4199 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
4200 // fall through nevertheless
4204 // we're not interested in these messages at all
4207 case SIZE_MINIMIZED
:
4208 processed
= HandleMinimize();
4211 case SIZE_MAXIMIZED
:
4212 /* processed = */ HandleMaximize();
4213 // fall through to send a normal size event as well
4216 // don't use w and h parameters as they specify the client size
4217 // while according to the docs EVT_SIZE handler is supposed to
4218 // receive the total size
4219 wxSizeEvent
event(GetSize(), m_windowId
);
4220 event
.SetEventObject(this);
4222 processed
= GetEventHandler()->ProcessEvent(event
);
4225 #if USE_DEFERRED_SIZING
4226 // and finally change the positions of all child windows at once
4227 if ( useDefer
&& m_hDWP
)
4229 // reset m_hDWP to NULL so that child windows don't try to use our
4230 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
4231 // happen anyhow normally but who knows what weird flow of control we
4232 // may have depending on what the users EVT_SIZE handler does...)
4233 HDWP hDWP
= (HDWP
)m_hDWP
;
4236 // do put all child controls in place at once
4237 if ( !::EndDeferWindowPos(hDWP
) )
4239 wxLogLastError(_T("EndDeferWindowPos"));
4242 // Reset our children's pending pos/size values.
4243 for ( wxWindowList
::compatibility_iterator node
= GetChildren().GetFirst();
4245 node
= node
->GetNext() )
4247 wxWindowMSW
*child
= node
->GetData();
4248 child
->m_pendingPosition
= wxDefaultPosition
;
4249 child
->m_pendingSize
= wxDefaultSize
;
4252 #endif // USE_DEFERRED_SIZING
4257 bool wxWindowMSW
::HandleSizing(wxRect
& rect
)
4259 wxSizeEvent
event(rect
, m_windowId
);
4260 event
.SetEventObject(this);
4262 bool rc
= GetEventHandler()->ProcessEvent(event
);
4264 rect
= event
.GetRect();
4268 bool wxWindowMSW
::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo
))
4273 MINMAXINFO
*info
= (MINMAXINFO
*)mmInfo
;
4277 int minWidth
= GetMinWidth(),
4278 minHeight
= GetMinHeight(),
4279 maxWidth
= GetMaxWidth(),
4280 maxHeight
= GetMaxHeight();
4282 if ( minWidth
!= wxDefaultCoord
)
4284 info
->ptMinTrackSize
.x
= minWidth
;
4288 if ( minHeight
!= wxDefaultCoord
)
4290 info
->ptMinTrackSize
.y
= minHeight
;
4294 if ( maxWidth
!= wxDefaultCoord
)
4296 info
->ptMaxTrackSize
.x
= maxWidth
;
4300 if ( maxHeight
!= wxDefaultCoord
)
4302 info
->ptMaxTrackSize
.y
= maxHeight
;
4310 // ---------------------------------------------------------------------------
4312 // ---------------------------------------------------------------------------
4314 bool wxWindowMSW
::HandleCommand(WXWORD id
, WXWORD cmd
, WXHWND control
)
4316 #if wxUSE_MENUS_NATIVE
4317 if ( !cmd
&& wxCurrentPopupMenu
)
4319 wxMenu
*popupMenu
= wxCurrentPopupMenu
;
4320 wxCurrentPopupMenu
= NULL
;
4322 return popupMenu
->MSWCommand(cmd
, id
);
4324 #endif // wxUSE_MENUS_NATIVE
4326 wxWindow
*win
= NULL
;
4328 // first try to find it from HWND - this works even with the broken
4329 // programs using the same ids for different controls
4332 win
= wxFindWinFromHandle(control
);
4338 // must cast to a signed type before comparing with other ids!
4339 win
= FindItem((signed short)id
);
4344 return win
->MSWCommand(cmd
, id
);
4347 // the messages sent from the in-place edit control used by the treectrl
4348 // for label editing have id == 0, but they should _not_ be treated as menu
4349 // messages (they are EN_XXX ones, in fact) so don't translate anything
4350 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4353 // If no child window, it may be an accelerator, e.g. for a popup menu
4356 wxCommandEvent
event(wxEVT_COMMAND_MENU_SELECTED
);
4357 event
.SetEventObject(this);
4361 return GetEventHandler()->ProcessEvent(event
);
4365 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4366 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4367 // notifications to its parent which we want to reflect back to
4369 wxSpinCtrl
*spin
= wxSpinCtrl
::GetSpinForTextCtrl(control
);
4370 if ( spin
&& spin
->ProcessTextCommand(cmd
, id
) )
4372 #endif // wxUSE_SPINCTRL
4374 #if wxUSE_CHOICE && defined(__SMARTPHONE__)
4375 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
4376 // notifications to its parent which we want to reflect back to
4378 wxChoice
*choice
= wxChoice
::GetChoiceForListBox(control
);
4379 if ( choice
&& choice
->MSWCommand(cmd
, id
) )
4387 // ---------------------------------------------------------------------------
4389 // ---------------------------------------------------------------------------
4391 void wxWindowMSW
::InitMouseEvent(wxMouseEvent
& event
,
4395 // our client coords are not quite the same as Windows ones
4396 wxPoint pt
= GetClientAreaOrigin();
4397 event
.m_x
= x
- pt
.x
;
4398 event
.m_y
= y
- pt
.y
;
4400 event
.m_shiftDown
= (flags
& MK_SHIFT
) != 0;
4401 event
.m_controlDown
= (flags
& MK_CONTROL
) != 0;
4402 event
.m_leftDown
= (flags
& MK_LBUTTON
) != 0;
4403 event
.m_middleDown
= (flags
& MK_MBUTTON
) != 0;
4404 event
.m_rightDown
= (flags
& MK_RBUTTON
) != 0;
4405 event
.m_altDown
= ::GetKeyState(VK_MENU
) < 0;
4408 event
.SetTimestamp(::GetMessageTime());
4411 event
.SetEventObject(this);
4412 event
.SetId(GetId());
4414 #if wxUSE_MOUSEEVENT_HACK
4417 m_lastMouseEvent
= event
.GetEventType();
4418 #endif // wxUSE_MOUSEEVENT_HACK
4421 // Windows doesn't send the mouse events to the static controls (which are
4422 // transparent in the sense that their WM_NCHITTEST handler returns
4423 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4424 // and so we manually check if we don't have a child window under mouse and if
4425 // we do, send the event to it instead of the window Windows had sent WM_XXX
4428 // Notice that this is not done for the mouse move events because this could
4429 // (would?) be too slow, but only for clicks which means that the static texts
4430 // still don't get move, enter nor leave events.
4431 static wxWindowMSW
*FindWindowForMouseEvent(wxWindowMSW
*win
, int *x
, int *y
) //TW:REQ:Univ
4433 wxCHECK_MSG( x
&& y
, win
, _T("NULL pointer in FindWindowForMouseEvent") );
4435 // first try to find a non transparent child: this allows us to send events
4436 // to a static text which is inside a static box, for example
4437 POINT pt
= { *x
, *y
};
4438 HWND hwnd
= GetHwndOf(win
),
4442 hwndUnderMouse
= ::ChildWindowFromPoint
4448 hwndUnderMouse
= ::ChildWindowFromPointEx
4458 if ( !hwndUnderMouse
|| hwndUnderMouse
== hwnd
)
4460 // now try any child window at all
4461 hwndUnderMouse
= ::ChildWindowFromPoint(hwnd
, pt
);
4464 // check that we have a child window which is susceptible to receive mouse
4465 // events: for this it must be shown and enabled
4466 if ( hwndUnderMouse
&&
4467 hwndUnderMouse
!= hwnd
&&
4468 ::IsWindowVisible(hwndUnderMouse
) &&
4469 ::IsWindowEnabled(hwndUnderMouse
) )
4471 wxWindow
*winUnderMouse
= wxFindWinFromHandle((WXHWND
)hwndUnderMouse
);
4472 if ( winUnderMouse
)
4474 // translate the mouse coords to the other window coords
4475 win
->ClientToScreen(x
, y
);
4476 winUnderMouse
->ScreenToClient(x
, y
);
4478 win
= winUnderMouse
;
4485 bool wxWindowMSW
::HandleMouseEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4487 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4488 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
4489 // from the message id and take the value in the table to get wxWin event
4491 static const wxEventType eventsMouse
[] =
4505 wxMouseEvent
event(eventsMouse
[msg
- WM_MOUSEMOVE
]);
4506 InitMouseEvent(event
, x
, y
, flags
);
4508 return GetEventHandler()->ProcessEvent(event
);
4511 bool wxWindowMSW
::HandleMouseMove(int x
, int y
, WXUINT flags
)
4513 if ( !m_mouseInWindow
)
4515 // it would be wrong to assume that just because we get a mouse move
4516 // event that the mouse is inside the window: although this is usually
4517 // true, it is not if we had captured the mouse, so we need to check
4518 // the mouse coordinates here
4519 if ( !HasCapture() || IsMouseInWindow() )
4521 // Generate an ENTER event
4522 m_mouseInWindow
= true;
4524 #ifdef HAVE_TRACKMOUSEEVENT
4525 WinStruct
<TRACKMOUSEEVENT
> trackinfo
;
4527 trackinfo
.dwFlags
= TME_LEAVE
;
4528 trackinfo
.hwndTrack
= GetHwnd();
4530 // Use the commctrl.h _TrackMouseEvent(), which will call the real
4531 // TrackMouseEvent() if available or emulate it
4532 _TrackMouseEvent(&trackinfo
);
4533 #endif // HAVE_TRACKMOUSEEVENT
4535 wxMouseEvent
event(wxEVT_ENTER_WINDOW
);
4536 InitMouseEvent(event
, x
, y
, flags
);
4538 (void)GetEventHandler()->ProcessEvent(event
);
4542 #if wxUSE_MOUSEEVENT_HACK
4543 // Window gets a click down message followed by a mouse move message even
4544 // if position isn't changed! We want to discard the trailing move event
4545 // if x and y are the same.
4546 if ( (m_lastMouseEvent
== wxEVT_RIGHT_DOWN
||
4547 m_lastMouseEvent
== wxEVT_LEFT_DOWN
||
4548 m_lastMouseEvent
== wxEVT_MIDDLE_DOWN
) &&
4549 (m_lastMouseX
== x
&& m_lastMouseY
== y
) )
4551 m_lastMouseEvent
= wxEVT_MOTION
;
4555 #endif // wxUSE_MOUSEEVENT_HACK
4557 return HandleMouseEvent(WM_MOUSEMOVE
, x
, y
, flags
);
4561 bool wxWindowMSW
::HandleMouseWheel(WXWPARAM wParam
, WXLPARAM lParam
)
4563 #if wxUSE_MOUSEWHEEL
4564 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
4565 // forwarded up to the parent by DefWindowProc()) and not in the client
4566 // ones as all the other messages, translate them to the client coords for
4569 pt
= ScreenToClient(wxPoint(GET_X_LPARAM(lParam
), GET_Y_LPARAM(lParam
)));
4570 wxMouseEvent
event(wxEVT_MOUSEWHEEL
);
4571 InitMouseEvent(event
, pt
.x
, pt
.y
, LOWORD(wParam
));
4572 event
.m_wheelRotation
= (short)HIWORD(wParam
);
4573 event
.m_wheelDelta
= WHEEL_DELTA
;
4575 static int s_linesPerRotation
= -1;
4576 if ( s_linesPerRotation
== -1 )
4578 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES
, 0,
4579 &s_linesPerRotation
, 0))
4581 // this is not supposed to happen
4582 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4584 // the default is 3, so use it if SystemParametersInfo() failed
4585 s_linesPerRotation
= 3;
4589 event
.m_linesPerAction
= s_linesPerRotation
;
4590 return GetEventHandler()->ProcessEvent(event
);
4592 #else // !wxUSE_MOUSEWHEEL
4593 wxUnusedVar(wParam
);
4594 wxUnusedVar(lParam
);
4597 #endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
4600 void wxWindowMSW
::GenerateMouseLeave()
4602 m_mouseInWindow
= false;
4605 if ( wxIsShiftDown() )
4607 if ( wxIsCtrlDown() )
4608 state
|= MK_CONTROL
;
4610 // Only the high-order bit should be tested
4611 if ( GetKeyState( VK_LBUTTON
) & (1<<15) )
4612 state
|= MK_LBUTTON
;
4613 if ( GetKeyState( VK_MBUTTON
) & (1<<15) )
4614 state
|= MK_MBUTTON
;
4615 if ( GetKeyState( VK_RBUTTON
) & (1<<15) )
4616 state
|= MK_RBUTTON
;
4620 if ( !::GetCursorPosWinCE(&pt
) )
4622 if ( !::GetCursorPos(&pt
) )
4625 wxLogLastError(_T("GetCursorPos"));
4628 // we need to have client coordinates here for symmetry with
4629 // wxEVT_ENTER_WINDOW
4630 RECT rect
= wxGetWindowRect(GetHwnd());
4634 wxMouseEvent
event(wxEVT_LEAVE_WINDOW
);
4635 InitMouseEvent(event
, pt
.x
, pt
.y
, state
);
4637 (void)GetEventHandler()->ProcessEvent(event
);
4640 // ---------------------------------------------------------------------------
4641 // keyboard handling
4642 // ---------------------------------------------------------------------------
4644 // create the key event of the given type for the given key - used by
4645 // HandleChar and HandleKeyDown/Up
4646 wxKeyEvent wxWindowMSW
::CreateKeyEvent(wxEventType evType
,
4649 WXWPARAM wParam
) const
4651 wxKeyEvent
event(evType
);
4652 event
.SetId(GetId());
4653 event
.m_shiftDown
= wxIsShiftDown();
4654 event
.m_controlDown
= wxIsCtrlDown();
4655 event
.m_altDown
= (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
;
4657 event
.SetEventObject((wxWindow
*)this); // const_cast
4658 event
.m_keyCode
= id
;
4660 event
.m_uniChar
= (wxChar
) wParam
;
4662 event
.m_rawCode
= (wxUint32
) wParam
;
4663 event
.m_rawFlags
= (wxUint32
) lParam
;
4665 event
.SetTimestamp(::GetMessageTime());
4668 // translate the position to client coords
4671 GetCursorPosWinCE(&pt
);
4676 GetWindowRect(GetHwnd(),&rect
);
4686 // isASCII is true only when we're called from WM_CHAR handler and not from
4688 bool wxWindowMSW
::HandleChar(WXWPARAM wParam
, WXLPARAM lParam
, bool isASCII
)
4693 // If 1 -> 26, translate to either special keycode or just set
4694 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4695 // ControlDown() == true.
4697 if ( (id
> 0) && (id
< 27) )
4719 else // we're called from WM_KEYDOWN
4721 id
= wxCharCodeMSWToWX(wParam
, lParam
);
4724 // it's ASCII and will be processed here only when called from
4725 // WM_CHAR (i.e. when isASCII = true), don't process it now
4730 wxKeyEvent
event(CreateKeyEvent(wxEVT_CHAR
, id
, lParam
, wParam
));
4732 // the alphanumeric keys produced by pressing AltGr+something on European
4733 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4734 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4735 // alphanumeric, so pretend that there are no modifiers at all (the
4736 // KEY_DOWN event would still have the correct modifiers if they're really
4738 if ( event
.m_controlDown
&& event
.m_altDown
&&
4739 (id
>= 32 && id
< 256) )
4741 event
.m_controlDown
=
4742 event
.m_altDown
= false;
4745 return GetEventHandler()->ProcessEvent(event
);
4748 bool wxWindowMSW
::HandleKeyDown(WXWPARAM wParam
, WXLPARAM lParam
)
4750 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4754 // normal ASCII char
4758 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4760 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_DOWN
, id
, lParam
, wParam
));
4761 if ( GetEventHandler()->ProcessEvent(event
) )
4770 bool wxWindowMSW
::HandleKeyUp(WXWPARAM wParam
, WXLPARAM lParam
)
4772 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
4776 // normal ASCII char
4780 if ( id
!= -1 ) // VZ: does this ever happen (FIXME)?
4782 wxKeyEvent
event(CreateKeyEvent(wxEVT_KEY_UP
, id
, lParam
, wParam
));
4783 if ( GetEventHandler()->ProcessEvent(event
) )
4790 int wxWindowMSW
::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel
),
4791 WXLPARAM
WXUNUSED_IN_WINCE(lParam
))
4793 // FIXME: implement GetMenuItemCount for WinCE, possibly
4794 // in terms of GetMenuItemInfo
4796 const HMENU hmenu
= (HMENU
)lParam
;
4800 mii
.cbSize
= sizeof(MENUITEMINFO
);
4801 mii
.fMask
= MIIM_TYPE
| MIIM_DATA
;
4803 // find if we have this letter in any owner drawn item
4804 const int count
= ::GetMenuItemCount(hmenu
);
4805 for ( int i
= 0; i
< count
; i
++ )
4807 if ( ::GetMenuItemInfo(hmenu
, i
, TRUE
, &mii
) )
4809 if ( mii
.fType
== MFT_OWNERDRAW
)
4811 // dwItemData member of the MENUITEMINFO is a
4812 // pointer to the associated wxMenuItem -- see the
4813 // menu creation code
4814 wxMenuItem
*item
= (wxMenuItem
*)mii
.dwItemData
;
4816 const wxChar
*p
= wxStrchr(item
->GetText(), _T('&'));
4819 if ( *p
== _T('&') )
4821 // this is not the accel char, find the real one
4822 p
= wxStrchr(p
+ 1, _T('&'));
4824 else // got the accel char
4826 // FIXME-UNICODE: this comparison doesn't risk to work
4827 // for non ASCII accelerator characters I'm afraid, but
4829 if ( (wchar_t)wxToupper(*p
) == (wchar_t)chAccel
)
4835 // this one doesn't match
4842 else // failed to get the menu text?
4844 // it's not fatal, so don't show error, but still log
4846 wxLogLastError(_T("GetMenuItemInfo"));
4853 // ---------------------------------------------------------------------------
4855 // ---------------------------------------------------------------------------
4857 bool wxWindowMSW
::HandleJoystickEvent(WXUINT msg
, int x
, int y
, WXUINT flags
)
4861 if ( flags
& JOY_BUTTON1CHG
)
4862 change
= wxJOY_BUTTON1
;
4863 if ( flags
& JOY_BUTTON2CHG
)
4864 change
= wxJOY_BUTTON2
;
4865 if ( flags
& JOY_BUTTON3CHG
)
4866 change
= wxJOY_BUTTON3
;
4867 if ( flags
& JOY_BUTTON4CHG
)
4868 change
= wxJOY_BUTTON4
;
4871 if ( flags
& JOY_BUTTON1
)
4872 buttons
|= wxJOY_BUTTON1
;
4873 if ( flags
& JOY_BUTTON2
)
4874 buttons
|= wxJOY_BUTTON2
;
4875 if ( flags
& JOY_BUTTON3
)
4876 buttons
|= wxJOY_BUTTON3
;
4877 if ( flags
& JOY_BUTTON4
)
4878 buttons
|= wxJOY_BUTTON4
;
4880 // the event ids aren't consecutive so we can't use table based lookup
4882 wxEventType eventType
;
4887 eventType
= wxEVT_JOY_MOVE
;
4892 eventType
= wxEVT_JOY_MOVE
;
4897 eventType
= wxEVT_JOY_ZMOVE
;
4902 eventType
= wxEVT_JOY_ZMOVE
;
4905 case MM_JOY1BUTTONDOWN
:
4907 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4910 case MM_JOY2BUTTONDOWN
:
4912 eventType
= wxEVT_JOY_BUTTON_DOWN
;
4915 case MM_JOY1BUTTONUP
:
4917 eventType
= wxEVT_JOY_BUTTON_UP
;
4920 case MM_JOY2BUTTONUP
:
4922 eventType
= wxEVT_JOY_BUTTON_UP
;
4926 wxFAIL_MSG(wxT("no such joystick event"));
4931 wxJoystickEvent
event(eventType
, buttons
, joystick
, change
);
4932 event
.SetPosition(wxPoint(x
, y
));
4933 event
.SetEventObject(this);
4935 return GetEventHandler()->ProcessEvent(event
);
4945 // ---------------------------------------------------------------------------
4947 // ---------------------------------------------------------------------------
4949 bool wxWindowMSW
::MSWOnScroll(int orientation
, WXWORD wParam
,
4950 WXWORD pos
, WXHWND control
)
4952 if ( control
&& control
!= m_hWnd
) // Prevent infinite recursion
4954 wxWindow
*child
= wxFindWinFromHandle(control
);
4956 return child
->MSWOnScroll(orientation
, wParam
, pos
, control
);
4959 wxScrollWinEvent event
;
4960 event
.SetPosition(pos
);
4961 event
.SetOrientation(orientation
);
4962 event
.SetEventObject(this);
4967 event
.SetEventType(wxEVT_SCROLLWIN_TOP
);
4971 event
.SetEventType(wxEVT_SCROLLWIN_BOTTOM
);
4975 event
.SetEventType(wxEVT_SCROLLWIN_LINEUP
);
4979 event
.SetEventType(wxEVT_SCROLLWIN_LINEDOWN
);
4983 event
.SetEventType(wxEVT_SCROLLWIN_PAGEUP
);
4987 event
.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN
);
4990 case SB_THUMBPOSITION
:
4992 // under Win32, the scrollbar range and position are 32 bit integers,
4993 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4994 // explicitly query the scrollbar for the correct position (this must
4995 // be done only for these two SB_ events as they are the only one
4996 // carrying the scrollbar position)
4998 WinStruct
<SCROLLINFO
> scrollInfo
;
4999 scrollInfo
.fMask
= SIF_TRACKPOS
;
5001 if ( !::GetScrollInfo(GetHwnd(),
5002 orientation
== wxHORIZONTAL ? SB_HORZ
5006 // Not necessarily an error, if there are no scrollbars yet.
5007 // wxLogLastError(_T("GetScrollInfo"));
5010 event
.SetPosition(scrollInfo
.nTrackPos
);
5013 event
.SetEventType( wParam
== SB_THUMBPOSITION
5014 ? wxEVT_SCROLLWIN_THUMBRELEASE
5015 : wxEVT_SCROLLWIN_THUMBTRACK
);
5022 return GetEventHandler()->ProcessEvent(event
);
5025 // ===========================================================================
5027 // ===========================================================================
5029 void wxGetCharSize(WXHWND wnd
, int *x
, int *y
, const wxFont
& the_font
)
5032 HDC dc
= ::GetDC((HWND
) wnd
);
5035 // the_font.UseResource();
5036 // the_font.RealizeResource();
5037 HFONT fnt
= (HFONT
)the_font
.GetResourceHandle(); // const_cast
5039 was
= (HFONT
) SelectObject(dc
,fnt
);
5041 GetTextMetrics(dc
, &tm
);
5044 SelectObject(dc
,was
);
5046 ReleaseDC((HWND
)wnd
, dc
);
5049 *x
= tm
.tmAveCharWidth
;
5051 *y
= tm
.tmHeight
+ tm
.tmExternalLeading
;
5053 // the_font.ReleaseResource();
5056 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
5057 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
5058 int wxCharCodeMSWToWX(int keySym
, WXLPARAM lParam
)
5063 case VK_CANCEL
: id
= WXK_CANCEL
; break;
5064 case VK_BACK
: id
= WXK_BACK
; break;
5065 case VK_TAB
: id
= WXK_TAB
; break;
5066 case VK_CLEAR
: id
= WXK_CLEAR
; break;
5067 case VK_SHIFT
: id
= WXK_SHIFT
; break;
5068 case VK_CONTROL
: id
= WXK_CONTROL
; break;
5069 case VK_MENU
: id
= WXK_ALT
; break;
5070 case VK_PAUSE
: id
= WXK_PAUSE
; break;
5071 case VK_CAPITAL
: id
= WXK_CAPITAL
; break;
5072 case VK_SPACE
: id
= WXK_SPACE
; break;
5073 case VK_ESCAPE
: id
= WXK_ESCAPE
; break;
5074 case VK_PRIOR
: id
= WXK_PRIOR
; break;
5075 case VK_NEXT
: id
= WXK_NEXT
; break;
5076 case VK_END
: id
= WXK_END
; break;
5077 case VK_HOME
: id
= WXK_HOME
; break;
5078 case VK_LEFT
: id
= WXK_LEFT
; break;
5079 case VK_UP
: id
= WXK_UP
; break;
5080 case VK_RIGHT
: id
= WXK_RIGHT
; break;
5081 case VK_DOWN
: id
= WXK_DOWN
; break;
5082 case VK_SELECT
: id
= WXK_SELECT
; break;
5083 case VK_PRINT
: id
= WXK_PRINT
; break;
5084 case VK_EXECUTE
: id
= WXK_EXECUTE
; break;
5085 case VK_INSERT
: id
= WXK_INSERT
; break;
5086 case VK_DELETE
: id
= WXK_DELETE
; break;
5087 case VK_HELP
: id
= WXK_HELP
; break;
5088 case VK_NUMPAD0
: id
= WXK_NUMPAD0
; break;
5089 case VK_NUMPAD1
: id
= WXK_NUMPAD1
; break;
5090 case VK_NUMPAD2
: id
= WXK_NUMPAD2
; break;
5091 case VK_NUMPAD3
: id
= WXK_NUMPAD3
; break;
5092 case VK_NUMPAD4
: id
= WXK_NUMPAD4
; break;
5093 case VK_NUMPAD5
: id
= WXK_NUMPAD5
; break;
5094 case VK_NUMPAD6
: id
= WXK_NUMPAD6
; break;
5095 case VK_NUMPAD7
: id
= WXK_NUMPAD7
; break;
5096 case VK_NUMPAD8
: id
= WXK_NUMPAD8
; break;
5097 case VK_NUMPAD9
: id
= WXK_NUMPAD9
; break;
5098 case VK_MULTIPLY
: id
= WXK_NUMPAD_MULTIPLY
; break;
5099 case VK_ADD
: id
= WXK_NUMPAD_ADD
; break;
5100 case VK_SUBTRACT
: id
= WXK_NUMPAD_SUBTRACT
; break;
5101 case VK_DECIMAL
: id
= WXK_NUMPAD_DECIMAL
; break;
5102 case VK_DIVIDE
: id
= WXK_NUMPAD_DIVIDE
; break;
5103 case VK_F1
: id
= WXK_F1
; break;
5104 case VK_F2
: id
= WXK_F2
; break;
5105 case VK_F3
: id
= WXK_F3
; break;
5106 case VK_F4
: id
= WXK_F4
; break;
5107 case VK_F5
: id
= WXK_F5
; break;
5108 case VK_F6
: id
= WXK_F6
; break;
5109 case VK_F7
: id
= WXK_F7
; break;
5110 case VK_F8
: id
= WXK_F8
; break;
5111 case VK_F9
: id
= WXK_F9
; break;
5112 case VK_F10
: id
= WXK_F10
; break;
5113 case VK_F11
: id
= WXK_F11
; break;
5114 case VK_F12
: id
= WXK_F12
; break;
5115 case VK_F13
: id
= WXK_F13
; break;
5116 case VK_F14
: id
= WXK_F14
; break;
5117 case VK_F15
: id
= WXK_F15
; break;
5118 case VK_F16
: id
= WXK_F16
; break;
5119 case VK_F17
: id
= WXK_F17
; break;
5120 case VK_F18
: id
= WXK_F18
; break;
5121 case VK_F19
: id
= WXK_F19
; break;
5122 case VK_F20
: id
= WXK_F20
; break;
5123 case VK_F21
: id
= WXK_F21
; break;
5124 case VK_F22
: id
= WXK_F22
; break;
5125 case VK_F23
: id
= WXK_F23
; break;
5126 case VK_F24
: id
= WXK_F24
; break;
5127 case VK_NUMLOCK
: id
= WXK_NUMLOCK
; break;
5128 case VK_SCROLL
: id
= WXK_SCROLL
; break;
5130 // the mapping for these keys may be incorrect on non-US keyboards so
5131 // maybe we shouldn't map them to ASCII values at all
5132 case VK_OEM_1
: id
= ';'; break;
5133 case VK_OEM_PLUS
: id
= '+'; break;
5134 case VK_OEM_COMMA
: id
= ','; break;
5135 case VK_OEM_MINUS
: id
= '-'; break;
5136 case VK_OEM_PERIOD
: id
= '.'; break;
5137 case VK_OEM_2
: id
= '/'; break;
5138 case VK_OEM_3
: id
= '~'; break;
5139 case VK_OEM_4
: id
= '['; break;
5140 case VK_OEM_5
: id
= '\\'; break;
5141 case VK_OEM_6
: id
= ']'; break;
5142 case VK_OEM_7
: id
= '\''; break;
5145 case VK_LWIN
: id
= WXK_WINDOWS_LEFT
; break;
5146 case VK_RWIN
: id
= WXK_WINDOWS_RIGHT
; break;
5147 case VK_APPS
: id
= WXK_WINDOWS_MENU
; break;
5148 #endif // VK_APPS defined
5151 // the same key is sent for both the "return" key on the main
5152 // keyboard and the numeric keypad but we want to distinguish
5153 // between them: we do this using the "extended" bit (24) of lParam
5154 id
= lParam
& (1 << 24) ? WXK_NUMPAD_ENTER
: WXK_RETURN
;
5164 WXWORD
wxCharCodeWXToMSW(int id
, bool *isVirtual
)
5170 case WXK_CANCEL
: keySym
= VK_CANCEL
; break;
5171 case WXK_CLEAR
: keySym
= VK_CLEAR
; break;
5172 case WXK_SHIFT
: keySym
= VK_SHIFT
; break;
5173 case WXK_CONTROL
: keySym
= VK_CONTROL
; break;
5174 case WXK_ALT
: keySym
= VK_MENU
; break;
5175 case WXK_PAUSE
: keySym
= VK_PAUSE
; break;
5176 case WXK_CAPITAL
: keySym
= VK_CAPITAL
; break;
5177 case WXK_PRIOR
: keySym
= VK_PRIOR
; break;
5178 case WXK_NEXT
: keySym
= VK_NEXT
; break;
5179 case WXK_END
: keySym
= VK_END
; break;
5180 case WXK_HOME
: keySym
= VK_HOME
; break;
5181 case WXK_LEFT
: keySym
= VK_LEFT
; break;
5182 case WXK_UP
: keySym
= VK_UP
; break;
5183 case WXK_RIGHT
: keySym
= VK_RIGHT
; break;
5184 case WXK_DOWN
: keySym
= VK_DOWN
; break;
5185 case WXK_SELECT
: keySym
= VK_SELECT
; break;
5186 case WXK_PRINT
: keySym
= VK_PRINT
; break;
5187 case WXK_EXECUTE
: keySym
= VK_EXECUTE
; break;
5188 case WXK_INSERT
: keySym
= VK_INSERT
; break;
5189 case WXK_DELETE
: keySym
= VK_DELETE
; break;
5190 case WXK_HELP
: keySym
= VK_HELP
; break;
5191 case WXK_NUMPAD0
: keySym
= VK_NUMPAD0
; break;
5192 case WXK_NUMPAD1
: keySym
= VK_NUMPAD1
; break;
5193 case WXK_NUMPAD2
: keySym
= VK_NUMPAD2
; break;
5194 case WXK_NUMPAD3
: keySym
= VK_NUMPAD3
; break;
5195 case WXK_NUMPAD4
: keySym
= VK_NUMPAD4
; break;
5196 case WXK_NUMPAD5
: keySym
= VK_NUMPAD5
; break;
5197 case WXK_NUMPAD6
: keySym
= VK_NUMPAD6
; break;
5198 case WXK_NUMPAD7
: keySym
= VK_NUMPAD7
; break;
5199 case WXK_NUMPAD8
: keySym
= VK_NUMPAD8
; break;
5200 case WXK_NUMPAD9
: keySym
= VK_NUMPAD9
; break;
5201 case WXK_NUMPAD_MULTIPLY
: keySym
= VK_MULTIPLY
; break;
5202 case WXK_NUMPAD_ADD
: keySym
= VK_ADD
; break;
5203 case WXK_NUMPAD_SUBTRACT
: keySym
= VK_SUBTRACT
; break;
5204 case WXK_NUMPAD_DECIMAL
: keySym
= VK_DECIMAL
; break;
5205 case WXK_NUMPAD_DIVIDE
: keySym
= VK_DIVIDE
; break;
5206 case WXK_F1
: keySym
= VK_F1
; break;
5207 case WXK_F2
: keySym
= VK_F2
; break;
5208 case WXK_F3
: keySym
= VK_F3
; break;
5209 case WXK_F4
: keySym
= VK_F4
; break;
5210 case WXK_F5
: keySym
= VK_F5
; break;
5211 case WXK_F6
: keySym
= VK_F6
; break;
5212 case WXK_F7
: keySym
= VK_F7
; break;
5213 case WXK_F8
: keySym
= VK_F8
; break;
5214 case WXK_F9
: keySym
= VK_F9
; break;
5215 case WXK_F10
: keySym
= VK_F10
; break;
5216 case WXK_F11
: keySym
= VK_F11
; break;
5217 case WXK_F12
: keySym
= VK_F12
; break;
5218 case WXK_F13
: keySym
= VK_F13
; break;
5219 case WXK_F14
: keySym
= VK_F14
; break;
5220 case WXK_F15
: keySym
= VK_F15
; break;
5221 case WXK_F16
: keySym
= VK_F16
; break;
5222 case WXK_F17
: keySym
= VK_F17
; break;
5223 case WXK_F18
: keySym
= VK_F18
; break;
5224 case WXK_F19
: keySym
= VK_F19
; break;
5225 case WXK_F20
: keySym
= VK_F20
; break;
5226 case WXK_F21
: keySym
= VK_F21
; break;
5227 case WXK_F22
: keySym
= VK_F22
; break;
5228 case WXK_F23
: keySym
= VK_F23
; break;
5229 case WXK_F24
: keySym
= VK_F24
; break;
5230 case WXK_NUMLOCK
: keySym
= VK_NUMLOCK
; break;
5231 case WXK_SCROLL
: keySym
= VK_SCROLL
; break;
5242 bool wxGetKeyState(wxKeyCode key
)
5246 wxASSERT_MSG(key
!= WXK_LBUTTON
&& key
!= WXK_RBUTTON
&& key
!=
5247 WXK_MBUTTON
, wxT("can't use wxGetKeyState() for mouse buttons"));
5249 //High order with GetAsyncKeyState only available on WIN32
5251 //If the requested key is a LED key, return
5252 //true if the led is pressed
5253 if (key
== WXK_NUMLOCK
||
5254 key
== WXK_CAPITAL
||
5258 //low order bit means LED is highlighted,
5259 //high order means key is down
5260 //Here, for compat with other ports we want both
5261 return GetKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) != 0;
5268 //low order bit means key pressed since last call
5269 //high order means key is down
5270 //We want only the high order bit - the key may not be down if only low order
5271 return ( GetAsyncKeyState( wxCharCodeWXToMSW(key
, &bVirtual
) ) & (1<<15) ) != 0;
5276 wxWindow
*wxGetActiveWindow()
5278 HWND hWnd
= GetActiveWindow();
5281 return wxFindWinFromHandle((WXHWND
) hWnd
);
5286 extern wxWindow
*wxGetWindowFromHWND(WXHWND hWnd
)
5288 HWND hwnd
= (HWND
)hWnd
;
5290 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
5291 // by code in msw/radiobox.cpp), for all the others we just search up the
5293 wxWindow
*win
= (wxWindow
*)NULL
;
5296 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5300 // native radiobuttons return DLGC_RADIOBUTTON here and for any
5301 // wxWindow class which overrides WM_GETDLGCODE processing to
5302 // do it as well, win would be already non NULL
5303 if ( ::SendMessage(hwnd
, WM_GETDLGCODE
, 0, 0) & DLGC_RADIOBUTTON
)
5305 win
= (wxWindow
*)wxGetWindowUserData(hwnd
);
5307 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
5308 #endif // wxUSE_RADIOBOX
5310 // spin control text buddy window should be mapped to spin ctrl
5311 // itself so try it too
5312 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5315 win
= wxSpinCtrl
::GetSpinForTextCtrl((WXHWND
)hwnd
);
5317 #endif // wxUSE_SPINCTRL
5321 while ( hwnd
&& !win
)
5323 // this is a really ugly hack needed to avoid mistakenly returning the
5324 // parent frame wxWindow for the find/replace modeless dialog HWND -
5325 // this, in turn, is needed to call IsDialogMessage() from
5326 // wxApp::ProcessMessage() as for this we must return NULL from here
5328 // FIXME: this is clearly not the best way to do it but I think we'll
5329 // need to change HWND <-> wxWindow code more heavily than I can
5330 // do it now to fix it
5331 #ifndef __WXMICROWIN__
5332 if ( ::GetWindow(hwnd
, GW_OWNER
) )
5334 // it's a dialog box, don't go upwards
5339 hwnd
= ::GetParent(hwnd
);
5340 win
= wxFindWinFromHandle((WXHWND
)hwnd
);
5346 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
5348 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
5349 // in active frames and dialogs, regardless of where the focus is.
5350 static HHOOK wxTheKeyboardHook
= 0;
5351 static FARPROC wxTheKeyboardHookProc
= 0;
5352 int APIENTRY _EXPORT
5353 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
);
5355 void wxSetKeyboardHook(bool doIt
)
5359 wxTheKeyboardHookProc
= MakeProcInstance((FARPROC
) wxKeyboardHook
, wxGetInstance());
5360 wxTheKeyboardHook
= SetWindowsHookEx(WH_KEYBOARD
, (HOOKPROC
) wxTheKeyboardHookProc
, wxGetInstance(),
5362 GetCurrentThreadId()
5363 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5368 UnhookWindowsHookEx(wxTheKeyboardHook
);
5372 int APIENTRY _EXPORT
5373 wxKeyboardHook(int nCode
, WORD wParam
, DWORD lParam
)
5375 DWORD hiWord
= HIWORD(lParam
);
5376 if ( nCode
!= HC_NOREMOVE
&& ((hiWord
& KF_UP
) == 0) )
5378 int id
= wxCharCodeMSWToWX(wParam
, lParam
);
5381 wxKeyEvent
event(wxEVT_CHAR_HOOK
);
5382 if ( (HIWORD(lParam
) & KF_ALTDOWN
) == KF_ALTDOWN
)
5383 event
.m_altDown
= true;
5385 event
.SetEventObject(NULL
);
5386 event
.m_keyCode
= id
;
5387 event
.m_shiftDown
= wxIsShiftDown();
5388 event
.m_controlDown
= wxIsCtrlDown();
5390 event
.SetTimestamp(::GetMessageTime());
5392 wxWindow
*win
= wxGetActiveWindow();
5393 wxEvtHandler
*handler
;
5396 handler
= win
->GetEventHandler();
5397 event
.SetId(win
->GetId());
5402 event
.SetId(wxID_ANY
);
5405 if ( handler
&& handler
->ProcessEvent(event
) )
5413 return (int)CallNextHookEx(wxTheKeyboardHook
, nCode
, wParam
, lParam
);
5416 #endif // !__WXMICROWIN__
5419 const char *wxGetMessageName(int message
)
5423 case 0x0000: return "WM_NULL";
5424 case 0x0001: return "WM_CREATE";
5425 case 0x0002: return "WM_DESTROY";
5426 case 0x0003: return "WM_MOVE";
5427 case 0x0005: return "WM_SIZE";
5428 case 0x0006: return "WM_ACTIVATE";
5429 case 0x0007: return "WM_SETFOCUS";
5430 case 0x0008: return "WM_KILLFOCUS";
5431 case 0x000A: return "WM_ENABLE";
5432 case 0x000B: return "WM_SETREDRAW";
5433 case 0x000C: return "WM_SETTEXT";
5434 case 0x000D: return "WM_GETTEXT";
5435 case 0x000E: return "WM_GETTEXTLENGTH";
5436 case 0x000F: return "WM_PAINT";
5437 case 0x0010: return "WM_CLOSE";
5438 case 0x0011: return "WM_QUERYENDSESSION";
5439 case 0x0012: return "WM_QUIT";
5440 case 0x0013: return "WM_QUERYOPEN";
5441 case 0x0014: return "WM_ERASEBKGND";
5442 case 0x0015: return "WM_SYSCOLORCHANGE";
5443 case 0x0016: return "WM_ENDSESSION";
5444 case 0x0017: return "WM_SYSTEMERROR";
5445 case 0x0018: return "WM_SHOWWINDOW";
5446 case 0x0019: return "WM_CTLCOLOR";
5447 case 0x001A: return "WM_WININICHANGE";
5448 case 0x001B: return "WM_DEVMODECHANGE";
5449 case 0x001C: return "WM_ACTIVATEAPP";
5450 case 0x001D: return "WM_FONTCHANGE";
5451 case 0x001E: return "WM_TIMECHANGE";
5452 case 0x001F: return "WM_CANCELMODE";
5453 case 0x0020: return "WM_SETCURSOR";
5454 case 0x0021: return "WM_MOUSEACTIVATE";
5455 case 0x0022: return "WM_CHILDACTIVATE";
5456 case 0x0023: return "WM_QUEUESYNC";
5457 case 0x0024: return "WM_GETMINMAXINFO";
5458 case 0x0026: return "WM_PAINTICON";
5459 case 0x0027: return "WM_ICONERASEBKGND";
5460 case 0x0028: return "WM_NEXTDLGCTL";
5461 case 0x002A: return "WM_SPOOLERSTATUS";
5462 case 0x002B: return "WM_DRAWITEM";
5463 case 0x002C: return "WM_MEASUREITEM";
5464 case 0x002D: return "WM_DELETEITEM";
5465 case 0x002E: return "WM_VKEYTOITEM";
5466 case 0x002F: return "WM_CHARTOITEM";
5467 case 0x0030: return "WM_SETFONT";
5468 case 0x0031: return "WM_GETFONT";
5469 case 0x0037: return "WM_QUERYDRAGICON";
5470 case 0x0039: return "WM_COMPAREITEM";
5471 case 0x0041: return "WM_COMPACTING";
5472 case 0x0044: return "WM_COMMNOTIFY";
5473 case 0x0046: return "WM_WINDOWPOSCHANGING";
5474 case 0x0047: return "WM_WINDOWPOSCHANGED";
5475 case 0x0048: return "WM_POWER";
5477 case 0x004A: return "WM_COPYDATA";
5478 case 0x004B: return "WM_CANCELJOURNAL";
5479 case 0x004E: return "WM_NOTIFY";
5480 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5481 case 0x0051: return "WM_INPUTLANGCHANGE";
5482 case 0x0052: return "WM_TCARD";
5483 case 0x0053: return "WM_HELP";
5484 case 0x0054: return "WM_USERCHANGED";
5485 case 0x0055: return "WM_NOTIFYFORMAT";
5486 case 0x007B: return "WM_CONTEXTMENU";
5487 case 0x007C: return "WM_STYLECHANGING";
5488 case 0x007D: return "WM_STYLECHANGED";
5489 case 0x007E: return "WM_DISPLAYCHANGE";
5490 case 0x007F: return "WM_GETICON";
5491 case 0x0080: return "WM_SETICON";
5493 case 0x0081: return "WM_NCCREATE";
5494 case 0x0082: return "WM_NCDESTROY";
5495 case 0x0083: return "WM_NCCALCSIZE";
5496 case 0x0084: return "WM_NCHITTEST";
5497 case 0x0085: return "WM_NCPAINT";
5498 case 0x0086: return "WM_NCACTIVATE";
5499 case 0x0087: return "WM_GETDLGCODE";
5500 case 0x00A0: return "WM_NCMOUSEMOVE";
5501 case 0x00A1: return "WM_NCLBUTTONDOWN";
5502 case 0x00A2: return "WM_NCLBUTTONUP";
5503 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5504 case 0x00A4: return "WM_NCRBUTTONDOWN";
5505 case 0x00A5: return "WM_NCRBUTTONUP";
5506 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5507 case 0x00A7: return "WM_NCMBUTTONDOWN";
5508 case 0x00A8: return "WM_NCMBUTTONUP";
5509 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5510 case 0x0100: return "WM_KEYDOWN";
5511 case 0x0101: return "WM_KEYUP";
5512 case 0x0102: return "WM_CHAR";
5513 case 0x0103: return "WM_DEADCHAR";
5514 case 0x0104: return "WM_SYSKEYDOWN";
5515 case 0x0105: return "WM_SYSKEYUP";
5516 case 0x0106: return "WM_SYSCHAR";
5517 case 0x0107: return "WM_SYSDEADCHAR";
5518 case 0x0108: return "WM_KEYLAST";
5520 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5521 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5522 case 0x010F: return "WM_IME_COMPOSITION";
5524 case 0x0110: return "WM_INITDIALOG";
5525 case 0x0111: return "WM_COMMAND";
5526 case 0x0112: return "WM_SYSCOMMAND";
5527 case 0x0113: return "WM_TIMER";
5528 case 0x0114: return "WM_HSCROLL";
5529 case 0x0115: return "WM_VSCROLL";
5530 case 0x0116: return "WM_INITMENU";
5531 case 0x0117: return "WM_INITMENUPOPUP";
5532 case 0x011F: return "WM_MENUSELECT";
5533 case 0x0120: return "WM_MENUCHAR";
5534 case 0x0121: return "WM_ENTERIDLE";
5535 case 0x0200: return "WM_MOUSEMOVE";
5536 case 0x0201: return "WM_LBUTTONDOWN";
5537 case 0x0202: return "WM_LBUTTONUP";
5538 case 0x0203: return "WM_LBUTTONDBLCLK";
5539 case 0x0204: return "WM_RBUTTONDOWN";
5540 case 0x0205: return "WM_RBUTTONUP";
5541 case 0x0206: return "WM_RBUTTONDBLCLK";
5542 case 0x0207: return "WM_MBUTTONDOWN";
5543 case 0x0208: return "WM_MBUTTONUP";
5544 case 0x0209: return "WM_MBUTTONDBLCLK";
5545 case 0x020A: return "WM_MOUSEWHEEL";
5546 case 0x0210: return "WM_PARENTNOTIFY";
5547 case 0x0211: return "WM_ENTERMENULOOP";
5548 case 0x0212: return "WM_EXITMENULOOP";
5550 case 0x0213: return "WM_NEXTMENU";
5551 case 0x0214: return "WM_SIZING";
5552 case 0x0215: return "WM_CAPTURECHANGED";
5553 case 0x0216: return "WM_MOVING";
5554 case 0x0218: return "WM_POWERBROADCAST";
5555 case 0x0219: return "WM_DEVICECHANGE";
5557 case 0x0220: return "WM_MDICREATE";
5558 case 0x0221: return "WM_MDIDESTROY";
5559 case 0x0222: return "WM_MDIACTIVATE";
5560 case 0x0223: return "WM_MDIRESTORE";
5561 case 0x0224: return "WM_MDINEXT";
5562 case 0x0225: return "WM_MDIMAXIMIZE";
5563 case 0x0226: return "WM_MDITILE";
5564 case 0x0227: return "WM_MDICASCADE";
5565 case 0x0228: return "WM_MDIICONARRANGE";
5566 case 0x0229: return "WM_MDIGETACTIVE";
5567 case 0x0230: return "WM_MDISETMENU";
5568 case 0x0233: return "WM_DROPFILES";
5570 case 0x0281: return "WM_IME_SETCONTEXT";
5571 case 0x0282: return "WM_IME_NOTIFY";
5572 case 0x0283: return "WM_IME_CONTROL";
5573 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5574 case 0x0285: return "WM_IME_SELECT";
5575 case 0x0286: return "WM_IME_CHAR";
5576 case 0x0290: return "WM_IME_KEYDOWN";
5577 case 0x0291: return "WM_IME_KEYUP";
5579 case 0x0300: return "WM_CUT";
5580 case 0x0301: return "WM_COPY";
5581 case 0x0302: return "WM_PASTE";
5582 case 0x0303: return "WM_CLEAR";
5583 case 0x0304: return "WM_UNDO";
5584 case 0x0305: return "WM_RENDERFORMAT";
5585 case 0x0306: return "WM_RENDERALLFORMATS";
5586 case 0x0307: return "WM_DESTROYCLIPBOARD";
5587 case 0x0308: return "WM_DRAWCLIPBOARD";
5588 case 0x0309: return "WM_PAINTCLIPBOARD";
5589 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5590 case 0x030B: return "WM_SIZECLIPBOARD";
5591 case 0x030C: return "WM_ASKCBFORMATNAME";
5592 case 0x030D: return "WM_CHANGECBCHAIN";
5593 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5594 case 0x030F: return "WM_QUERYNEWPALETTE";
5595 case 0x0310: return "WM_PALETTEISCHANGING";
5596 case 0x0311: return "WM_PALETTECHANGED";
5598 case 0x0312: return "WM_HOTKEY";
5601 // common controls messages - although they're not strictly speaking
5602 // standard, it's nice to decode them nevertheless
5605 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5606 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5607 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5608 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5609 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5610 case 0x1000 + 5: return "LVM_GETITEMA";
5611 case 0x1000 + 75: return "LVM_GETITEMW";
5612 case 0x1000 + 6: return "LVM_SETITEMA";
5613 case 0x1000 + 76: return "LVM_SETITEMW";
5614 case 0x1000 + 7: return "LVM_INSERTITEMA";
5615 case 0x1000 + 77: return "LVM_INSERTITEMW";
5616 case 0x1000 + 8: return "LVM_DELETEITEM";
5617 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5618 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5619 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5620 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5621 case 0x1000 + 13: return "LVM_FINDITEMA";
5622 case 0x1000 + 83: return "LVM_FINDITEMW";
5623 case 0x1000 + 14: return "LVM_GETITEMRECT";
5624 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5625 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5626 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5627 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5628 case 0x1000 + 18: return "LVM_HITTEST";
5629 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5630 case 0x1000 + 20: return "LVM_SCROLL";
5631 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5632 case 0x1000 + 22: return "LVM_ARRANGE";
5633 case 0x1000 + 23: return "LVM_EDITLABELA";
5634 case 0x1000 + 118: return "LVM_EDITLABELW";
5635 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5636 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5637 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5638 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5639 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5640 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5641 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5642 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5643 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5644 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5645 case 0x1000 + 31: return "LVM_GETHEADER";
5646 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5647 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5648 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5649 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5650 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5651 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5652 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5653 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5654 case 0x1000 + 41: return "LVM_GETORIGIN";
5655 case 0x1000 + 42: return "LVM_UPDATE";
5656 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5657 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5658 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5659 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5660 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5661 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5662 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5663 case 0x1000 + 48: return "LVM_SORTITEMS";
5664 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5665 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5666 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5667 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5668 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5669 case 0x1000 + 53: return "LVM_SETICONSPACING";
5670 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5671 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5672 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5673 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5674 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5675 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5676 case 0x1000 + 60: return "LVM_SETHOTITEM";
5677 case 0x1000 + 61: return "LVM_GETHOTITEM";
5678 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5679 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5680 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5681 case 0x1000 + 65: return "LVM_SETWORKAREA";
5684 case 0x1100 + 0: return "TVM_INSERTITEMA";
5685 case 0x1100 + 50: return "TVM_INSERTITEMW";
5686 case 0x1100 + 1: return "TVM_DELETEITEM";
5687 case 0x1100 + 2: return "TVM_EXPAND";
5688 case 0x1100 + 4: return "TVM_GETITEMRECT";
5689 case 0x1100 + 5: return "TVM_GETCOUNT";
5690 case 0x1100 + 6: return "TVM_GETINDENT";
5691 case 0x1100 + 7: return "TVM_SETINDENT";
5692 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5693 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5694 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5695 case 0x1100 + 11: return "TVM_SELECTITEM";
5696 case 0x1100 + 12: return "TVM_GETITEMA";
5697 case 0x1100 + 62: return "TVM_GETITEMW";
5698 case 0x1100 + 13: return "TVM_SETITEMA";
5699 case 0x1100 + 63: return "TVM_SETITEMW";
5700 case 0x1100 + 14: return "TVM_EDITLABELA";
5701 case 0x1100 + 65: return "TVM_EDITLABELW";
5702 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5703 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5704 case 0x1100 + 17: return "TVM_HITTEST";
5705 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5706 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5707 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5708 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5709 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5710 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5711 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5712 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5713 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5716 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5717 case 0x1200 + 1: return "HDM_INSERTITEMA";
5718 case 0x1200 + 10: return "HDM_INSERTITEMW";
5719 case 0x1200 + 2: return "HDM_DELETEITEM";
5720 case 0x1200 + 3: return "HDM_GETITEMA";
5721 case 0x1200 + 11: return "HDM_GETITEMW";
5722 case 0x1200 + 4: return "HDM_SETITEMA";
5723 case 0x1200 + 12: return "HDM_SETITEMW";
5724 case 0x1200 + 5: return "HDM_LAYOUT";
5725 case 0x1200 + 6: return "HDM_HITTEST";
5726 case 0x1200 + 7: return "HDM_GETITEMRECT";
5727 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5728 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5729 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5730 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5731 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5732 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5733 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5736 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5737 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5738 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5739 case 0x1300 + 5: return "TCM_GETITEMA";
5740 case 0x1300 + 60: return "TCM_GETITEMW";
5741 case 0x1300 + 6: return "TCM_SETITEMA";
5742 case 0x1300 + 61: return "TCM_SETITEMW";
5743 case 0x1300 + 7: return "TCM_INSERTITEMA";
5744 case 0x1300 + 62: return "TCM_INSERTITEMW";
5745 case 0x1300 + 8: return "TCM_DELETEITEM";
5746 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5747 case 0x1300 + 10: return "TCM_GETITEMRECT";
5748 case 0x1300 + 11: return "TCM_GETCURSEL";
5749 case 0x1300 + 12: return "TCM_SETCURSEL";
5750 case 0x1300 + 13: return "TCM_HITTEST";
5751 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5752 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5753 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5754 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5755 case 0x1300 + 43: return "TCM_SETPADDING";
5756 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5757 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5758 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5759 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5760 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5761 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5762 case 0x1300 + 50: return "TCM_DESELECTALL";
5765 case WM_USER
+1: return "TB_ENABLEBUTTON";
5766 case WM_USER
+2: return "TB_CHECKBUTTON";
5767 case WM_USER
+3: return "TB_PRESSBUTTON";
5768 case WM_USER
+4: return "TB_HIDEBUTTON";
5769 case WM_USER
+5: return "TB_INDETERMINATE";
5770 case WM_USER
+9: return "TB_ISBUTTONENABLED";
5771 case WM_USER
+10: return "TB_ISBUTTONCHECKED";
5772 case WM_USER
+11: return "TB_ISBUTTONPRESSED";
5773 case WM_USER
+12: return "TB_ISBUTTONHIDDEN";
5774 case WM_USER
+13: return "TB_ISBUTTONINDETERMINATE";
5775 case WM_USER
+17: return "TB_SETSTATE";
5776 case WM_USER
+18: return "TB_GETSTATE";
5777 case WM_USER
+19: return "TB_ADDBITMAP";
5778 case WM_USER
+20: return "TB_ADDBUTTONS";
5779 case WM_USER
+21: return "TB_INSERTBUTTON";
5780 case WM_USER
+22: return "TB_DELETEBUTTON";
5781 case WM_USER
+23: return "TB_GETBUTTON";
5782 case WM_USER
+24: return "TB_BUTTONCOUNT";
5783 case WM_USER
+25: return "TB_COMMANDTOINDEX";
5784 case WM_USER
+26: return "TB_SAVERESTOREA";
5785 case WM_USER
+76: return "TB_SAVERESTOREW";
5786 case WM_USER
+27: return "TB_CUSTOMIZE";
5787 case WM_USER
+28: return "TB_ADDSTRINGA";
5788 case WM_USER
+77: return "TB_ADDSTRINGW";
5789 case WM_USER
+29: return "TB_GETITEMRECT";
5790 case WM_USER
+30: return "TB_BUTTONSTRUCTSIZE";
5791 case WM_USER
+31: return "TB_SETBUTTONSIZE";
5792 case WM_USER
+32: return "TB_SETBITMAPSIZE";
5793 case WM_USER
+33: return "TB_AUTOSIZE";
5794 case WM_USER
+35: return "TB_GETTOOLTIPS";
5795 case WM_USER
+36: return "TB_SETTOOLTIPS";
5796 case WM_USER
+37: return "TB_SETPARENT";
5797 case WM_USER
+39: return "TB_SETROWS";
5798 case WM_USER
+40: return "TB_GETROWS";
5799 case WM_USER
+42: return "TB_SETCMDID";
5800 case WM_USER
+43: return "TB_CHANGEBITMAP";
5801 case WM_USER
+44: return "TB_GETBITMAP";
5802 case WM_USER
+45: return "TB_GETBUTTONTEXTA";
5803 case WM_USER
+75: return "TB_GETBUTTONTEXTW";
5804 case WM_USER
+46: return "TB_REPLACEBITMAP";
5805 case WM_USER
+47: return "TB_SETINDENT";
5806 case WM_USER
+48: return "TB_SETIMAGELIST";
5807 case WM_USER
+49: return "TB_GETIMAGELIST";
5808 case WM_USER
+50: return "TB_LOADIMAGES";
5809 case WM_USER
+51: return "TB_GETRECT";
5810 case WM_USER
+52: return "TB_SETHOTIMAGELIST";
5811 case WM_USER
+53: return "TB_GETHOTIMAGELIST";
5812 case WM_USER
+54: return "TB_SETDISABLEDIMAGELIST";
5813 case WM_USER
+55: return "TB_GETDISABLEDIMAGELIST";
5814 case WM_USER
+56: return "TB_SETSTYLE";
5815 case WM_USER
+57: return "TB_GETSTYLE";
5816 case WM_USER
+58: return "TB_GETBUTTONSIZE";
5817 case WM_USER
+59: return "TB_SETBUTTONWIDTH";
5818 case WM_USER
+60: return "TB_SETMAXTEXTROWS";
5819 case WM_USER
+61: return "TB_GETTEXTROWS";
5820 case WM_USER
+41: return "TB_GETBITMAPFLAGS";
5823 static char s_szBuf
[128];
5824 sprintf(s_szBuf
, "<unknown message = %d>", message
);
5828 #endif //__WXDEBUG__
5830 static TEXTMETRIC
wxGetTextMetrics(const wxWindowMSW
*win
)
5834 HWND hwnd
= GetHwndOf(win
);
5835 HDC hdc
= ::GetDC(hwnd
);
5837 #if !wxDIALOG_UNIT_COMPATIBILITY
5838 // and select the current font into it
5839 HFONT hfont
= GetHfontOf(win
->GetFont());
5842 hfont
= (HFONT
)::SelectObject(hdc
, hfont
);
5846 // finally retrieve the text metrics from it
5847 GetTextMetrics(hdc
, &tm
);
5849 #if !wxDIALOG_UNIT_COMPATIBILITY
5853 (void)::SelectObject(hdc
, hfont
);
5857 ::ReleaseDC(hwnd
, hdc
);
5862 // Find the wxWindow at the current mouse position, returning the mouse
5864 wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
)
5866 pt
= wxGetMousePosition();
5867 return wxFindWindowAtPoint(pt
);
5870 wxWindow
* wxFindWindowAtPoint(const wxPoint
& pt
)
5875 HWND hWndHit
= ::WindowFromPoint(pt2
);
5877 wxWindow
* win
= wxFindWinFromHandle((WXHWND
) hWndHit
) ;
5878 HWND hWnd
= hWndHit
;
5880 // Try to find a window with a wxWindow associated with it
5881 while (!win
&& (hWnd
!= 0))
5883 hWnd
= ::GetParent(hWnd
);
5884 win
= wxFindWinFromHandle((WXHWND
) hWnd
) ;
5889 // Get the current mouse position.
5890 wxPoint
wxGetMousePosition()
5894 GetCursorPosWinCE(&pt
);
5896 GetCursorPos( & pt
);
5899 return wxPoint(pt
.x
, pt
.y
);
5904 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
5905 static void WinCEUnregisterHotKey(int modifiers
, int id
)
5907 // Register hotkeys for the hardware buttons
5909 typedef BOOL (WINAPI
*UnregisterFunc1Proc
)(UINT
, UINT
);
5911 UnregisterFunc1Proc procUnregisterFunc
;
5912 hCoreDll
= LoadLibrary(_T("coredll.dll"));
5915 procUnregisterFunc
= (UnregisterFunc1Proc
)GetProcAddress(hCoreDll
, _T("UnregisterFunc1"));
5916 if (procUnregisterFunc
)
5917 procUnregisterFunc(modifiers
, id
);
5918 FreeLibrary(hCoreDll
);
5923 bool wxWindowMSW
::RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
)
5925 UINT win_modifiers
=0;
5926 if ( modifiers
& wxMOD_ALT
)
5927 win_modifiers
|= MOD_ALT
;
5928 if ( modifiers
& wxMOD_SHIFT
)
5929 win_modifiers
|= MOD_SHIFT
;
5930 if ( modifiers
& wxMOD_CONTROL
)
5931 win_modifiers
|= MOD_CONTROL
;
5932 if ( modifiers
& wxMOD_WIN
)
5933 win_modifiers
|= MOD_WIN
;
5935 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
5936 // Required for PPC and Smartphone hardware buttons
5937 if (keycode
>= WXK_SPECIAL1
&& keycode
<= WXK_SPECIAL20
)
5938 WinCEUnregisterHotKey(win_modifiers
, hotkeyId
);
5941 if ( !::RegisterHotKey(GetHwnd(), hotkeyId
, win_modifiers
, keycode
) )
5943 wxLogLastError(_T("RegisterHotKey"));
5951 bool wxWindowMSW
::UnregisterHotKey(int hotkeyId
)
5953 #if defined(__SMARTPHONE__) || defined(__POCKETPC__)
5954 WinCEUnregisterHotKey(MOD_WIN
, hotkeyId
);
5957 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId
) )
5959 wxLogLastError(_T("UnregisterHotKey"));
5969 bool wxWindowMSW
::HandleHotKey(WXWPARAM wParam
, WXLPARAM lParam
)
5971 int hotkeyId
= wParam
;
5972 int virtualKey
= HIWORD(lParam
);
5973 int win_modifiers
= LOWORD(lParam
);
5975 wxKeyEvent
event(CreateKeyEvent(wxEVT_HOTKEY
, virtualKey
, wParam
, lParam
));
5976 event
.SetId(hotkeyId
);
5977 event
.m_shiftDown
= (win_modifiers
& MOD_SHIFT
) != 0;
5978 event
.m_controlDown
= (win_modifiers
& MOD_CONTROL
) != 0;
5979 event
.m_altDown
= (win_modifiers
& MOD_ALT
) != 0;
5980 event
.m_metaDown
= (win_modifiers
& MOD_WIN
) != 0;
5982 return GetEventHandler()->ProcessEvent(event
);
5985 #endif // wxUSE_ACCEL
5987 #endif // wxUSE_HOTKEY
5989 // Not tested under WinCE
5992 // this class installs a message hook which really wakes up our idle processing
5993 // each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
5994 // sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
5995 // being dragged or even inside ::MessageBox()) and so don't control message
5996 // dispatching otherwise
5997 class wxIdleWakeUpModule
: public wxModule
6000 virtual bool OnInit()
6002 ms_hMsgHookProc
= ::SetWindowsHookEx
6005 &wxIdleWakeUpModule
::MsgHookProc
,
6007 GetCurrentThreadId()
6010 if ( !ms_hMsgHookProc
)
6012 wxLogLastError(_T("SetWindowsHookEx(WH_GETMESSAGE)"));
6020 virtual void OnExit()
6022 ::UnhookWindowsHookEx(wxIdleWakeUpModule
::ms_hMsgHookProc
);
6025 static LRESULT CALLBACK
MsgHookProc(int nCode
, WPARAM wParam
, LPARAM lParam
)
6027 MSG
*msg
= (MSG
*)lParam
;
6029 // only process the message if it is actually going to be removed from
6030 // the message queue, this prevents that the same event from being
6031 // processed multiple times if now someone just called PeekMessage()
6032 if ( msg
->message
== WM_NULL
&& wParam
== PM_REMOVE
)
6034 wxTheApp
->ProcessPendingEvents();
6037 return CallNextHookEx(ms_hMsgHookProc
, nCode
, wParam
, lParam
);
6041 static HHOOK ms_hMsgHookProc
;
6043 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule
)
6046 HHOOK wxIdleWakeUpModule
::ms_hMsgHookProc
= 0;
6048 IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule
, wxModule
)
6050 #endif // __WXWINCE__
6055 static void wxAdjustZOrder(wxWindow
* parent
)
6057 if (parent
->IsKindOf(CLASSINFO(wxStaticBox
)))
6059 // Set the z-order correctly
6060 SetWindowPos((HWND
) parent
->GetHWND(), HWND_BOTTOM
, 0, 0, 0, 0, SWP_NOMOVE
|SWP_NOSIZE
);
6063 wxWindowList
::compatibility_iterator current
= parent
->GetChildren().GetFirst();
6066 wxWindow
*childWin
= current
->GetData();
6067 wxAdjustZOrder(childWin
);
6068 current
= current
->GetNext();
6073 // We need to adjust the z-order of static boxes in WinCE, to
6074 // make 'contained' controls visible
6075 void wxWindowMSW
::OnInitDialog( wxInitDialogEvent
& event
)
6078 wxAdjustZOrder(this);