]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/window.cpp
Added ability to switch off more components of the size page UI
[wxWidgets.git] / src / msw / window.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/msw/window.cpp
3// Purpose: wxWindowMSW
4// Author: Julian Smart
5// Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
6// Created: 04/01/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ===========================================================================
13// declarations
14// ===========================================================================
15
16// ---------------------------------------------------------------------------
17// headers
18// ---------------------------------------------------------------------------
19
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#include "wx/window.h"
28
29#ifndef WX_PRECOMP
30 #include "wx/msw/wrapwin.h"
31 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
32 #include "wx/msw/missing.h"
33 #include "wx/accel.h"
34 #include "wx/menu.h"
35 #include "wx/dc.h"
36 #include "wx/dcclient.h"
37 #include "wx/dcmemory.h"
38 #include "wx/utils.h"
39 #include "wx/app.h"
40 #include "wx/layout.h"
41 #include "wx/dialog.h"
42 #include "wx/frame.h"
43 #include "wx/listbox.h"
44 #include "wx/button.h"
45 #include "wx/msgdlg.h"
46 #include "wx/settings.h"
47 #include "wx/statbox.h"
48 #include "wx/sizer.h"
49 #include "wx/intl.h"
50 #include "wx/log.h"
51 #include "wx/textctrl.h"
52 #include "wx/menuitem.h"
53 #include "wx/module.h"
54#endif
55
56#if wxUSE_OWNER_DRAWN && !defined(__WXUNIVERSAL__)
57 #include "wx/ownerdrw.h"
58#endif
59
60#include "wx/hashmap.h"
61#include "wx/evtloop.h"
62#include "wx/power.h"
63#include "wx/sysopt.h"
64
65#if wxUSE_DRAG_AND_DROP
66 #include "wx/dnd.h"
67#endif
68
69#if wxUSE_ACCESSIBILITY
70 #include "wx/access.h"
71 #include <ole2.h>
72 #include <oleacc.h>
73 #ifndef WM_GETOBJECT
74 #define WM_GETOBJECT 0x003D
75 #endif
76 #ifndef OBJID_CLIENT
77 #define OBJID_CLIENT 0xFFFFFFFC
78 #endif
79#endif
80
81#include "wx/msw/private.h"
82#include "wx/msw/private/keyboard.h"
83#include "wx/msw/dcclient.h"
84#include "wx/private/textmeasure.h"
85
86#if wxUSE_TOOLTIPS
87 #include "wx/tooltip.h"
88#endif
89
90#if wxUSE_CARET
91 #include "wx/caret.h"
92#endif // wxUSE_CARET
93
94#if wxUSE_RADIOBOX
95 #include "wx/radiobox.h"
96#endif // wxUSE_RADIOBOX
97
98#if wxUSE_SPINCTRL
99 #include "wx/spinctrl.h"
100#endif // wxUSE_SPINCTRL
101
102#include "wx/notebook.h"
103#include "wx/listctrl.h"
104#include "wx/dynlib.h"
105
106#include <string.h>
107
108#if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) /* && !defined(__WXWINCE__) */ ) || defined(__CYGWIN10__)
109 #include <shellapi.h>
110 #include <mmsystem.h>
111#endif
112
113#ifdef __WIN32__
114 #include <windowsx.h>
115#endif
116
117#if defined(__WXWINCE__)
118 #include "wx/msw/wince/missing.h"
119#ifdef __POCKETPC__
120 #include <windows.h>
121 #include <shellapi.h>
122 #include <ole2.h>
123 #include <aygshell.h>
124#endif
125#endif
126
127#if wxUSE_UXTHEME
128 #include "wx/msw/uxtheme.h"
129 #define EP_EDITTEXT 1
130 #define ETS_NORMAL 1
131 #define ETS_HOT 2
132 #define ETS_SELECTED 3
133 #define ETS_DISABLED 4
134 #define ETS_FOCUSED 5
135 #define ETS_READONLY 6
136 #define ETS_ASSIST 7
137#endif
138
139// define the constants used by AnimateWindow() if our SDK doesn't have them
140#ifndef AW_CENTER
141 #define AW_HOR_POSITIVE 0x00000001
142 #define AW_HOR_NEGATIVE 0x00000002
143 #define AW_VER_POSITIVE 0x00000004
144 #define AW_VER_NEGATIVE 0x00000008
145 #define AW_CENTER 0x00000010
146 #define AW_HIDE 0x00010000
147 #define AW_ACTIVATE 0x00020000
148 #define AW_SLIDE 0x00040000
149 #define AW_BLEND 0x00080000
150#endif
151
152#if defined(TME_LEAVE) && defined(WM_MOUSELEAVE) && wxUSE_DYNLIB_CLASS
153 #define HAVE_TRACKMOUSEEVENT
154#endif // everything needed for TrackMouseEvent()
155
156// set this to 1 to filter out duplicate mouse events, e.g. mouse move events
157// when mouse position didnd't change
158#ifdef __WXWINCE__
159 #define wxUSE_MOUSEEVENT_HACK 0
160#else
161 #define wxUSE_MOUSEEVENT_HACK 1
162#endif
163
164// not all compilers/platforms have X button related declarations (notably
165// Windows CE doesn't, and probably some old SDKs don't neither)
166#ifdef WM_XBUTTONDOWN
167 #define wxHAS_XBUTTON
168#endif
169
170#ifndef MAPVK_VK_TO_CHAR
171 #define MAPVK_VK_TO_CHAR 2
172#endif
173
174// ---------------------------------------------------------------------------
175// global variables
176// ---------------------------------------------------------------------------
177
178#if wxUSE_MENUS_NATIVE
179extern wxMenu *wxCurrentPopupMenu;
180#endif
181
182#if wxUSE_UXTHEME
183// This is a hack used by the owner-drawn wxButton implementation to ensure
184// that the brush used for erasing its background is correctly aligned with the
185// control.
186wxWindowMSW *wxWindowBeingErased = NULL;
187#endif // wxUSE_UXTHEME
188
189namespace
190{
191
192// true if we had already created the std colour map, used by
193// wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
194bool gs_hasStdCmap = false;
195
196// last mouse event information we need to filter out the duplicates
197#if wxUSE_MOUSEEVENT_HACK
198struct MouseEventInfoDummy
199{
200 // mouse position (in screen coordinates)
201 wxPoint pos;
202
203 // last mouse event type
204 wxEventType type;
205} gs_lastMouseEvent;
206#endif // wxUSE_MOUSEEVENT_HACK
207
208// hash containing the registered handlers for the custom messages
209WX_DECLARE_HASH_MAP(int, wxWindow::MSWMessageHandler,
210 wxIntegerHash, wxIntegerEqual,
211 MSWMessageHandlers);
212
213MSWMessageHandlers gs_messageHandlers;
214
215// hash containing all our windows, it uses HWND keys and wxWindow* values
216WX_DECLARE_HASH_MAP(HWND, wxWindow *,
217 wxPointerHash, wxPointerEqual,
218 WindowHandles);
219
220WindowHandles gs_windowHandles;
221
222#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
223
224// temporary override for WM_ERASEBKGND processing: we don't store this in
225// wxWindow itself as we don't need it during most of the time so don't
226// increase the size of all window objects unnecessarily
227WX_DECLARE_HASH_MAP(wxWindow *, wxWindow *,
228 wxPointerHash, wxPointerEqual,
229 EraseBgHooks);
230
231EraseBgHooks gs_eraseBgHooks;
232
233#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
234
235// If this variable is strictly positive, EVT_CHAR_HOOK is not generated for
236// Escape key presses as it can't be intercepted because it's needed by some
237// currently shown window, e.g. IME entry.
238//
239// This is currently global as we allow using UI from the main thread only
240// anyhow but could be replaced with a thread-specific value in the future if
241// needed.
242int gs_modalEntryWindowCount = 0;
243
244} // anonymous namespace
245
246// ---------------------------------------------------------------------------
247// private functions
248// ---------------------------------------------------------------------------
249
250// the window proc for all our windows
251LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
252 WPARAM wParam, LPARAM lParam);
253
254
255#if wxDEBUG_LEVEL >= 2
256 const wxChar *wxGetMessageName(int message);
257#endif // wxDEBUG_LEVEL >= 2
258
259void wxRemoveHandleAssociation(wxWindowMSW *win);
260extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
261
262// get the text metrics for the current font
263static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
264
265#ifdef __WXWINCE__
266// find the window for the mouse event at the specified position
267static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y);
268#endif // __WXWINCE__
269
270// wrapper around BringWindowToTop() API
271static inline void wxBringWindowToTop(HWND hwnd)
272{
273#ifdef __WXMICROWIN__
274 // It seems that MicroWindows brings the _parent_ of the window to the top,
275 // which can be the wrong one.
276
277 // activate (set focus to) specified window
278 ::SetFocus(hwnd);
279#endif
280
281 // raise top level parent to top of z order
282 if (!::SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE))
283 {
284 wxLogLastError(wxT("SetWindowPos"));
285 }
286}
287
288#ifndef __WXWINCE__
289
290// ensure that all our parent windows have WS_EX_CONTROLPARENT style
291static void EnsureParentHasControlParentStyle(wxWindow *parent)
292{
293 /*
294 If we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
295 parent as well as otherwise several Win32 functions using
296 GetNextDlgTabItem() to iterate over all controls such as
297 IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
298 all of them iterate over all the controls starting from the currently
299 focused one and stop iterating when they get back to the focus but
300 unless all parents have WS_EX_CONTROLPARENT bit set, they would never
301 get back to the initial (focused) window: as we do have this style,
302 GetNextDlgTabItem() will leave this window and continue in its parent,
303 but if the parent doesn't have it, it wouldn't recurse inside it later
304 on and so wouldn't have a chance of getting back to this window either.
305 */
306 while ( parent && !parent->IsTopLevel() )
307 {
308 LONG exStyle = wxGetWindowExStyle(parent);
309 if ( !(exStyle & WS_EX_CONTROLPARENT) )
310 {
311 // force the parent to have this style
312 wxSetWindowExStyle(parent, exStyle | WS_EX_CONTROLPARENT);
313 }
314
315 parent = parent->GetParent();
316 }
317}
318
319#endif // !__WXWINCE__
320
321// GetCursorPos can return an error, so use this function
322// instead.
323// Error originally observed with WinCE, but later using Remote Desktop
324// to connect to XP.
325void wxGetCursorPosMSW(POINT* pt)
326{
327 if (!GetCursorPos(pt))
328 {
329#ifdef __WXWINCE__
330 wxLogLastError(wxT("GetCursorPos"));
331#endif
332 DWORD pos = GetMessagePos();
333 // the coordinates may be negative in multi-monitor systems
334 pt->x = GET_X_LPARAM(pos);
335 pt->y = GET_Y_LPARAM(pos);
336 }
337}
338
339// ---------------------------------------------------------------------------
340// event tables
341// ---------------------------------------------------------------------------
342
343// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
344// method
345#ifdef __WXUNIVERSAL__
346 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW, wxWindowBase)
347#endif // __WXUNIVERSAL__
348
349BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
350 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
351#ifdef __WXWINCE__
352 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
353#endif
354END_EVENT_TABLE()
355
356// ===========================================================================
357// implementation
358// ===========================================================================
359
360// ---------------------------------------------------------------------------
361// wxWindow utility functions
362// ---------------------------------------------------------------------------
363
364// Find an item given the MS Windows id
365wxWindow *wxWindowMSW::FindItem(long id) const
366{
367#if wxUSE_CONTROLS
368 wxControl *item = wxDynamicCastThis(wxControl);
369 if ( item )
370 {
371 // is it us or one of our "internal" children?
372 if ( item->GetId() == id
373#ifndef __WXUNIVERSAL__
374 || (item->GetSubcontrols().Index(id) != wxNOT_FOUND)
375#endif // __WXUNIVERSAL__
376 )
377 {
378 return item;
379 }
380 }
381#endif // wxUSE_CONTROLS
382
383 wxWindowList::compatibility_iterator current = GetChildren().GetFirst();
384 while (current)
385 {
386 wxWindow *childWin = current->GetData();
387
388 wxWindow *wnd = childWin->FindItem(id);
389 if ( wnd )
390 return wnd;
391
392 current = current->GetNext();
393 }
394
395 return NULL;
396}
397
398// Find an item given the MS Windows handle
399wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
400{
401 wxWindowList::compatibility_iterator current = GetChildren().GetFirst();
402 while (current)
403 {
404 wxWindow *parent = current->GetData();
405
406 // Do a recursive search.
407 wxWindow *wnd = parent->FindItemByHWND(hWnd);
408 if ( wnd )
409 return wnd;
410
411 if ( !controlOnly
412#if wxUSE_CONTROLS
413 || wxDynamicCast(parent, wxControl)
414#endif // wxUSE_CONTROLS
415 )
416 {
417 wxWindow *item = current->GetData();
418 if ( item->GetHWND() == hWnd )
419 return item;
420 else
421 {
422 if ( item->ContainsHWND(hWnd) )
423 return item;
424 }
425 }
426
427 current = current->GetNext();
428 }
429 return NULL;
430}
431
432// Default command handler
433bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
434{
435 return false;
436}
437
438// ----------------------------------------------------------------------------
439// constructors and such
440// ----------------------------------------------------------------------------
441
442void wxWindowMSW::Init()
443{
444 // MSW specific
445 m_oldWndProc = NULL;
446 m_mouseInWindow = false;
447 m_lastKeydownProcessed = false;
448
449 m_hWnd = 0;
450
451 m_xThumbSize = 0;
452 m_yThumbSize = 0;
453
454#if wxUSE_DEFERRED_SIZING
455 m_hDWP = 0;
456 m_pendingPosition = wxDefaultPosition;
457 m_pendingSize = wxDefaultSize;
458#endif // wxUSE_DEFERRED_SIZING
459
460#ifdef __POCKETPC__
461 m_contextMenuEnabled = false;
462#endif
463}
464
465// Destructor
466wxWindowMSW::~wxWindowMSW()
467{
468 SendDestroyEvent();
469
470#ifndef __WXUNIVERSAL__
471 // VS: make sure there's no wxFrame with last focus set to us:
472 for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
473 {
474 wxTopLevelWindow *frame = wxDynamicCast(win, wxTopLevelWindow);
475 if ( frame )
476 {
477 if ( frame->GetLastFocus() == this )
478 {
479 frame->SetLastFocus(NULL);
480 }
481
482 // apparently sometimes we can end up with our grand parent
483 // pointing to us as well: this is surely a bug in focus handling
484 // code but it's not clear where it happens so for now just try to
485 // fix it here by not breaking out of the loop
486 //break;
487 }
488 }
489#endif // __WXUNIVERSAL__
490
491 // VS: destroy children first and _then_ detach *this from its parent.
492 // If we did it the other way around, children wouldn't be able
493 // find their parent frame (see above).
494 DestroyChildren();
495
496 if ( m_hWnd )
497 {
498 // VZ: test temp removed to understand what really happens here
499 //if (::IsWindow(GetHwnd()))
500 {
501 if ( !::DestroyWindow(GetHwnd()) )
502 {
503 wxLogLastError(wxT("DestroyWindow"));
504 }
505 }
506
507 // remove hWnd <-> wxWindow association
508 wxRemoveHandleAssociation(this);
509 }
510
511}
512
513/* static */
514const wxChar *wxWindowMSW::MSWGetRegisteredClassName()
515{
516 return wxApp::GetRegisteredClassName(wxT("wxWindow"), COLOR_BTNFACE);
517}
518
519// real construction (Init() must have been called before!)
520bool wxWindowMSW::Create(wxWindow *parent,
521 wxWindowID id,
522 const wxPoint& pos,
523 const wxSize& size,
524 long style,
525 const wxString& name)
526{
527 wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
528
529 if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
530 return false;
531
532 parent->AddChild(this);
533
534 WXDWORD exstyle;
535 DWORD msflags = MSWGetCreateWindowFlags(&exstyle);
536
537#ifdef __WXUNIVERSAL__
538 // no borders, we draw them ourselves
539 exstyle &= ~(WS_EX_DLGMODALFRAME |
540 WS_EX_STATICEDGE |
541 WS_EX_CLIENTEDGE |
542 WS_EX_WINDOWEDGE);
543 msflags &= ~WS_BORDER;
544#endif // wxUniversal
545
546 if ( IsShown() )
547 {
548 msflags |= WS_VISIBLE;
549 }
550
551 if ( !MSWCreate(MSWGetRegisteredClassName(),
552 NULL, pos, size, msflags, exstyle) )
553 return false;
554
555 InheritAttributes();
556
557 return true;
558}
559
560// ---------------------------------------------------------------------------
561// basic operations
562// ---------------------------------------------------------------------------
563
564void wxWindowMSW::SetFocus()
565{
566 HWND hWnd = GetHwnd();
567 wxCHECK_RET( hWnd, wxT("can't set focus to invalid window") );
568
569#if !defined(__WXWINCE__)
570 ::SetLastError(0);
571#endif
572
573 if ( !::SetFocus(hWnd) )
574 {
575 // was there really an error?
576 DWORD dwRes = ::GetLastError();
577 if ( dwRes )
578 {
579 HWND hwndFocus = ::GetFocus();
580 if ( hwndFocus != hWnd )
581 {
582 wxLogApiError(wxT("SetFocus"), dwRes);
583 }
584 }
585 }
586}
587
588void wxWindowMSW::SetFocusFromKbd()
589{
590 // when the focus is given to the control with DLGC_HASSETSEL style from
591 // keyboard its contents should be entirely selected: this is what
592 // ::IsDialogMessage() does and so we should do it as well to provide the
593 // same LNF as the native programs
594 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE, 0, 0) & DLGC_HASSETSEL )
595 {
596 ::SendMessage(GetHwnd(), EM_SETSEL, 0, -1);
597 }
598
599 // do this after (maybe) setting the selection as like this when
600 // wxEVT_SET_FOCUS handler is called, the selection would have been already
601 // set correctly -- this may be important
602 wxWindowBase::SetFocusFromKbd();
603}
604
605// Get the window with the focus
606wxWindow *wxWindowBase::DoFindFocus()
607{
608 HWND hWnd = ::GetFocus();
609 if ( hWnd )
610 {
611 return wxGetWindowFromHWND((WXHWND)hWnd);
612 }
613
614 return NULL;
615}
616
617void wxWindowMSW::DoEnable( bool enable )
618{
619 MSWEnableHWND(GetHwnd(), enable);
620}
621
622bool wxWindowMSW::MSWEnableHWND(WXHWND hWnd, bool enable)
623{
624 if ( !hWnd )
625 return false;
626
627 // If disabling focused control, we move focus to the next one, as if the
628 // user pressed Tab. That's because we can't keep focus on a disabled
629 // control, Tab-navigation would stop working then.
630 if ( !enable && ::GetFocus() == hWnd )
631 Navigate();
632
633 return ::EnableWindow(hWnd, (BOOL)enable) != 0;
634}
635
636bool wxWindowMSW::Show(bool show)
637{
638 if ( !wxWindowBase::Show(show) )
639 return false;
640
641 HWND hWnd = GetHwnd();
642
643 // we could be called before the underlying window is created (this is
644 // actually useful to prevent it from being initially shown), e.g.
645 //
646 // wxFoo *foo = new wxFoo;
647 // foo->Hide();
648 // foo->Create(parent, ...);
649 //
650 // should work without errors
651 if ( hWnd )
652 {
653 ::ShowWindow(hWnd, show ? SW_SHOW : SW_HIDE);
654 }
655
656 if ( IsFrozen() )
657 {
658 // DoFreeze/DoThaw don't do anything if the window is not shown, so
659 // we have to call them from here now
660 if ( show )
661 DoFreeze();
662 else
663 DoThaw();
664 }
665
666 return true;
667}
668
669bool
670wxWindowMSW::MSWShowWithEffect(bool show,
671 wxShowEffect effect,
672 unsigned timeout)
673{
674#if wxUSE_DYNLIB_CLASS
675 if ( effect == wxSHOW_EFFECT_NONE )
676 return Show(show);
677
678 if ( !wxWindowBase::Show(show) )
679 return false;
680
681 typedef BOOL (WINAPI *AnimateWindow_t)(HWND, DWORD, DWORD);
682
683 static AnimateWindow_t s_pfnAnimateWindow = NULL;
684 static bool s_initDone = false;
685 if ( !s_initDone )
686 {
687 wxDynamicLibrary dllUser32(wxT("user32.dll"), wxDL_VERBATIM | wxDL_QUIET);
688 wxDL_INIT_FUNC(s_pfn, AnimateWindow, dllUser32);
689
690 s_initDone = true;
691
692 // notice that it's ok to unload user32.dll here as it won't be really
693 // unloaded, being still in use because we link to it statically too
694 }
695
696 if ( !s_pfnAnimateWindow )
697 return Show(show);
698
699 // Show() has a side effect of sending a WM_SIZE to the window, which helps
700 // ensuring that it's laid out correctly, but AnimateWindow() doesn't do
701 // this so send the event ourselves
702 SendSizeEvent();
703
704 // prepare to use AnimateWindow()
705
706 if ( !timeout )
707 timeout = 200; // this is the default animation timeout, per MSDN
708
709 DWORD dwFlags = show ? 0 : AW_HIDE;
710
711 switch ( effect )
712 {
713 case wxSHOW_EFFECT_ROLL_TO_LEFT:
714 dwFlags |= AW_HOR_NEGATIVE;
715 break;
716
717 case wxSHOW_EFFECT_ROLL_TO_RIGHT:
718 dwFlags |= AW_HOR_POSITIVE;
719 break;
720
721 case wxSHOW_EFFECT_ROLL_TO_TOP:
722 dwFlags |= AW_VER_NEGATIVE;
723 break;
724
725 case wxSHOW_EFFECT_ROLL_TO_BOTTOM:
726 dwFlags |= AW_VER_POSITIVE;
727 break;
728
729 case wxSHOW_EFFECT_SLIDE_TO_LEFT:
730 dwFlags |= AW_SLIDE | AW_HOR_NEGATIVE;
731 break;
732
733 case wxSHOW_EFFECT_SLIDE_TO_RIGHT:
734 dwFlags |= AW_SLIDE | AW_HOR_POSITIVE;
735 break;
736
737 case wxSHOW_EFFECT_SLIDE_TO_TOP:
738 dwFlags |= AW_SLIDE | AW_VER_NEGATIVE;
739 break;
740
741 case wxSHOW_EFFECT_SLIDE_TO_BOTTOM:
742 dwFlags |= AW_SLIDE | AW_VER_POSITIVE;
743 break;
744
745 case wxSHOW_EFFECT_BLEND:
746 dwFlags |= AW_BLEND;
747 break;
748
749 case wxSHOW_EFFECT_EXPAND:
750 dwFlags |= AW_CENTER;
751 break;
752
753
754 case wxSHOW_EFFECT_MAX:
755 wxFAIL_MSG( wxT("invalid window show effect") );
756 return false;
757
758 default:
759 wxFAIL_MSG( wxT("unknown window show effect") );
760 return false;
761 }
762
763 if ( !(*s_pfnAnimateWindow)(GetHwnd(), timeout, dwFlags) )
764 {
765 wxLogLastError(wxT("AnimateWindow"));
766
767 return false;
768 }
769
770 return true;
771#else // wxUSE_DYNLIB_CLASS
772 return Show(show);
773#endif
774}
775
776// Raise the window to the top of the Z order
777void wxWindowMSW::Raise()
778{
779 wxBringWindowToTop(GetHwnd());
780}
781
782// Lower the window to the bottom of the Z order
783void wxWindowMSW::Lower()
784{
785 ::SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0,
786 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
787}
788
789void wxWindowMSW::DoCaptureMouse()
790{
791 HWND hWnd = GetHwnd();
792 if ( hWnd )
793 {
794 ::SetCapture(hWnd);
795 }
796}
797
798void wxWindowMSW::DoReleaseMouse()
799{
800 if ( !::ReleaseCapture() )
801 {
802 wxLogLastError(wxT("ReleaseCapture"));
803 }
804}
805
806/* static */ wxWindow *wxWindowBase::GetCapture()
807{
808 HWND hwnd = ::GetCapture();
809 return hwnd ? wxFindWinFromHandle(hwnd) : NULL;
810}
811
812bool wxWindowMSW::SetFont(const wxFont& font)
813{
814 if ( !wxWindowBase::SetFont(font) )
815 {
816 // nothing to do
817 return false;
818 }
819
820 HWND hWnd = GetHwnd();
821 if ( hWnd != 0 )
822 {
823 // note the use of GetFont() instead of m_font: our own font could have
824 // just been reset and in this case we need to change the font used by
825 // the native window to the default for this class, i.e. exactly what
826 // GetFont() returns
827 WXHANDLE hFont = GetFont().GetResourceHandle();
828
829 wxASSERT_MSG( hFont, wxT("should have valid font") );
830
831 ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
832 }
833
834 return true;
835}
836
837bool wxWindowMSW::SetCursor(const wxCursor& cursor)
838{
839 if ( !wxWindowBase::SetCursor(cursor) )
840 {
841 // no change
842 return false;
843 }
844
845 // don't "overwrite" busy cursor
846 if ( wxIsBusy() )
847 return true;
848
849 if ( m_cursor.IsOk() )
850 {
851 // normally we should change the cursor only if it's over this window
852 // but we should do it always if we capture the mouse currently
853 bool set = HasCapture();
854 if ( !set )
855 {
856 HWND hWnd = GetHwnd();
857
858 POINT point;
859 ::wxGetCursorPosMSW(&point);
860
861 RECT rect = wxGetWindowRect(hWnd);
862
863 set = ::PtInRect(&rect, point) != 0;
864 }
865
866 if ( set )
867 {
868 ::SetCursor(GetHcursorOf(m_cursor));
869 }
870 //else: will be set later when the mouse enters this window
871 }
872 else // Invalid cursor: this means reset to the default one.
873 {
874 // To revert to the correct cursor we need to find the window currently
875 // under the cursor and ask it to set its cursor itself as only it
876 // knows what it is.
877 POINT pt;
878 wxGetCursorPosMSW(&pt);
879
880 const wxWindowMSW* win = wxFindWindowAtPoint(wxPoint(pt.x, pt.y));
881 if ( !win )
882 win = this;
883
884 ::SendMessage(GetHwndOf(win), WM_SETCURSOR,
885 (WPARAM)GetHwndOf(win),
886 MAKELPARAM(HTCLIENT, WM_MOUSEMOVE));
887 }
888
889 return true;
890}
891
892void wxWindowMSW::WarpPointer(int x, int y)
893{
894 ClientToScreen(&x, &y);
895
896 if ( !::SetCursorPos(x, y) )
897 {
898 wxLogLastError(wxT("SetCursorPos"));
899 }
900}
901
902void wxWindowMSW::MSWUpdateUIState(int action, int state)
903{
904 // WM_CHANGEUISTATE only appeared in Windows 2000 so it can do us no good
905 // to use it on older systems -- and could possibly do some harm
906 static int s_needToUpdate = -1;
907 if ( s_needToUpdate == -1 )
908 {
909 int verMaj, verMin;
910 s_needToUpdate = wxGetOsVersion(&verMaj, &verMin) == wxOS_WINDOWS_NT &&
911 verMaj >= 5;
912 }
913
914 if ( s_needToUpdate )
915 {
916 // we send WM_CHANGEUISTATE so if nothing needs changing then the system
917 // won't send WM_UPDATEUISTATE
918 ::SendMessage(GetHwnd(), WM_CHANGEUISTATE, MAKEWPARAM(action, state), 0);
919 }
920}
921
922// ---------------------------------------------------------------------------
923// scrolling stuff
924// ---------------------------------------------------------------------------
925
926namespace
927{
928
929inline int GetScrollPosition(HWND hWnd, int wOrient)
930{
931#ifdef __WXMICROWIN__
932 return ::GetScrollPosWX(hWnd, wOrient);
933#else
934 WinStruct<SCROLLINFO> scrollInfo;
935 scrollInfo.cbSize = sizeof(SCROLLINFO);
936 scrollInfo.fMask = SIF_POS;
937 ::GetScrollInfo(hWnd, wOrient, &scrollInfo );
938
939 return scrollInfo.nPos;
940
941#endif
942}
943
944inline UINT WXOrientToSB(int orient)
945{
946 return orient == wxHORIZONTAL ? SB_HORZ : SB_VERT;
947}
948
949} // anonymous namespace
950
951int wxWindowMSW::GetScrollPos(int orient) const
952{
953 HWND hWnd = GetHwnd();
954 wxCHECK_MSG( hWnd, 0, wxT("no HWND in GetScrollPos") );
955
956 return GetScrollPosition(hWnd, WXOrientToSB(orient));
957}
958
959// This now returns the whole range, not just the number
960// of positions that we can scroll.
961int wxWindowMSW::GetScrollRange(int orient) const
962{
963 int maxPos;
964 HWND hWnd = GetHwnd();
965 if ( !hWnd )
966 return 0;
967 WinStruct<SCROLLINFO> scrollInfo;
968 scrollInfo.fMask = SIF_RANGE;
969 if ( !::GetScrollInfo(hWnd, WXOrientToSB(orient), &scrollInfo) )
970 {
971 // Most of the time this is not really an error, since the return
972 // value can also be zero when there is no scrollbar yet.
973 // wxLogLastError(wxT("GetScrollInfo"));
974 }
975 maxPos = scrollInfo.nMax;
976
977 // undo "range - 1" done in SetScrollbar()
978 return maxPos + 1;
979}
980
981int wxWindowMSW::GetScrollThumb(int orient) const
982{
983 return orient == wxHORIZONTAL ? m_xThumbSize : m_yThumbSize;
984}
985
986void wxWindowMSW::SetScrollPos(int orient, int pos, bool refresh)
987{
988 HWND hWnd = GetHwnd();
989 wxCHECK_RET( hWnd, wxT("SetScrollPos: no HWND") );
990
991 WinStruct<SCROLLINFO> info;
992 info.nPage = 0;
993 info.nMin = 0;
994 info.nPos = pos;
995 info.fMask = SIF_POS;
996 if ( HasFlag(wxALWAYS_SHOW_SB) )
997 {
998 // disable scrollbar instead of removing it then
999 info.fMask |= SIF_DISABLENOSCROLL;
1000 }
1001
1002 ::SetScrollInfo(hWnd, WXOrientToSB(orient), &info, refresh);
1003}
1004
1005// New function that will replace some of the above.
1006void wxWindowMSW::SetScrollbar(int orient,
1007 int pos,
1008 int pageSize,
1009 int range,
1010 bool refresh)
1011{
1012 // We have to set the variables here to make them valid in events
1013 // triggered by ::SetScrollInfo()
1014 *(orient == wxHORIZONTAL ? &m_xThumbSize : &m_yThumbSize) = pageSize;
1015
1016 HWND hwnd = GetHwnd();
1017 if ( !hwnd )
1018 return;
1019
1020 WinStruct<SCROLLINFO> info;
1021 if ( range != -1 )
1022 {
1023 info.nPage = pageSize;
1024 info.nMin = 0; // range is nMax - nMin + 1
1025 info.nMax = range - 1; // as both nMax and nMax are inclusive
1026 info.nPos = pos;
1027
1028 // We normally also reenable scrollbar in case it had been previously
1029 // disabled by specifying SIF_DISABLENOSCROLL below but we should only
1030 // do this if it has valid range, otherwise it would be enabled but not
1031 // do anything.
1032 if ( range >= pageSize )
1033 {
1034 ::EnableScrollBar(hwnd, WXOrientToSB(orient), ESB_ENABLE_BOTH);
1035 }
1036 }
1037 //else: leave all the fields to be 0
1038
1039 info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
1040 if ( HasFlag(wxALWAYS_SHOW_SB) || range == -1 )
1041 {
1042 // disable scrollbar instead of removing it then
1043 info.fMask |= SIF_DISABLENOSCROLL;
1044 }
1045
1046 ::SetScrollInfo(hwnd, WXOrientToSB(orient), &info, refresh);
1047}
1048
1049void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
1050{
1051 RECT rect;
1052 RECT *pr;
1053 if ( prect )
1054 {
1055 wxCopyRectToRECT(*prect, rect);
1056 pr = &rect;
1057 }
1058 else
1059 {
1060 pr = NULL;
1061
1062 }
1063
1064#ifdef __WXWINCE__
1065 // FIXME: is this the exact equivalent of the line below?
1066 ::ScrollWindowEx(GetHwnd(), dx, dy, pr, pr, 0, 0, SW_SCROLLCHILDREN|SW_ERASE|SW_INVALIDATE);
1067#else
1068 ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
1069#endif
1070}
1071
1072static bool ScrollVertically(HWND hwnd, int kind, int count)
1073{
1074 int posStart = GetScrollPosition(hwnd, SB_VERT);
1075
1076 int pos = posStart;
1077 for ( int n = 0; n < count; n++ )
1078 {
1079 ::SendMessage(hwnd, WM_VSCROLL, kind, 0);
1080
1081 int posNew = GetScrollPosition(hwnd, SB_VERT);
1082 if ( posNew == pos )
1083 {
1084 // don't bother to continue, we're already at top/bottom
1085 break;
1086 }
1087
1088 pos = posNew;
1089 }
1090
1091 return pos != posStart;
1092}
1093
1094bool wxWindowMSW::ScrollLines(int lines)
1095{
1096 bool down = lines > 0;
1097
1098 return ScrollVertically(GetHwnd(),
1099 down ? SB_LINEDOWN : SB_LINEUP,
1100 down ? lines : -lines);
1101}
1102
1103bool wxWindowMSW::ScrollPages(int pages)
1104{
1105 bool down = pages > 0;
1106
1107 return ScrollVertically(GetHwnd(),
1108 down ? SB_PAGEDOWN : SB_PAGEUP,
1109 down ? pages : -pages);
1110}
1111
1112// ----------------------------------------------------------------------------
1113// RTL support
1114// ----------------------------------------------------------------------------
1115
1116void wxWindowMSW::SetLayoutDirection(wxLayoutDirection dir)
1117{
1118#ifdef __WXWINCE__
1119 wxUnusedVar(dir);
1120#else
1121 wxCHECK_RET( GetHwnd(),
1122 wxT("layout direction must be set after window creation") );
1123
1124 LONG styleOld = wxGetWindowExStyle(this);
1125
1126 LONG styleNew = styleOld;
1127 switch ( dir )
1128 {
1129 case wxLayout_LeftToRight:
1130 styleNew &= ~WS_EX_LAYOUTRTL;
1131 break;
1132
1133 case wxLayout_RightToLeft:
1134 styleNew |= WS_EX_LAYOUTRTL;
1135 break;
1136
1137 default:
1138 wxFAIL_MSG(wxT("unsupported layout direction"));
1139 break;
1140 }
1141
1142 if ( styleNew != styleOld )
1143 {
1144 wxSetWindowExStyle(this, styleNew);
1145 }
1146#endif
1147}
1148
1149wxLayoutDirection wxWindowMSW::GetLayoutDirection() const
1150{
1151#ifdef __WXWINCE__
1152 return wxLayout_Default;
1153#else
1154 wxCHECK_MSG( GetHwnd(), wxLayout_Default, wxT("invalid window") );
1155
1156 return wxHasWindowExStyle(this, WS_EX_LAYOUTRTL) ? wxLayout_RightToLeft
1157 : wxLayout_LeftToRight;
1158#endif
1159}
1160
1161wxCoord
1162wxWindowMSW::AdjustForLayoutDirection(wxCoord x,
1163 wxCoord WXUNUSED(width),
1164 wxCoord WXUNUSED(widthTotal)) const
1165{
1166 // Win32 mirrors the coordinates of RTL windows automatically, so don't
1167 // redo it ourselves
1168 return x;
1169}
1170
1171// ---------------------------------------------------------------------------
1172// subclassing
1173// ---------------------------------------------------------------------------
1174
1175void wxWindowMSW::SubclassWin(WXHWND hWnd)
1176{
1177 wxASSERT_MSG( !m_oldWndProc, wxT("subclassing window twice?") );
1178
1179 HWND hwnd = (HWND)hWnd;
1180 wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in SubclassWin") );
1181
1182 SetHWND(hWnd);
1183
1184 wxAssociateWinWithHandle(hwnd, this);
1185
1186 m_oldWndProc = (WXFARPROC)wxGetWindowProc((HWND)hWnd);
1187
1188 // we don't need to subclass the window of our own class (in the Windows
1189 // sense of the word)
1190 if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )
1191 {
1192 wxSetWindowProc(hwnd, wxWndProc);
1193 }
1194 else
1195 {
1196 // don't bother restoring it either: this also makes it easy to
1197 // implement IsOfStandardClass() method which returns true for the
1198 // standard controls and false for the wxWidgets own windows as it can
1199 // simply check m_oldWndProc
1200 m_oldWndProc = NULL;
1201 }
1202
1203 // we're officially created now, send the event
1204 wxWindowCreateEvent event((wxWindow *)this);
1205 (void)HandleWindowEvent(event);
1206}
1207
1208void wxWindowMSW::UnsubclassWin()
1209{
1210 wxRemoveHandleAssociation(this);
1211
1212 // Restore old Window proc
1213 HWND hwnd = GetHwnd();
1214 if ( hwnd )
1215 {
1216 SetHWND(0);
1217
1218 wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
1219
1220 if ( m_oldWndProc )
1221 {
1222 if ( !wxCheckWindowWndProc((WXHWND)hwnd, m_oldWndProc) )
1223 {
1224 wxSetWindowProc(hwnd, (WNDPROC)m_oldWndProc);
1225 }
1226
1227 m_oldWndProc = NULL;
1228 }
1229 }
1230}
1231
1232void wxWindowMSW::AssociateHandle(WXWidget handle)
1233{
1234 if ( m_hWnd )
1235 {
1236 if ( !::DestroyWindow(GetHwnd()) )
1237 {
1238 wxLogLastError(wxT("DestroyWindow"));
1239 }
1240 }
1241
1242 WXHWND wxhwnd = (WXHWND)handle;
1243
1244 // this also calls SetHWND(wxhwnd)
1245 SubclassWin(wxhwnd);
1246}
1247
1248void wxWindowMSW::DissociateHandle()
1249{
1250 // this also calls SetHWND(0) for us
1251 UnsubclassWin();
1252}
1253
1254
1255bool wxCheckWindowWndProc(WXHWND hWnd,
1256 WXFARPROC WXUNUSED(wndProc))
1257{
1258 const wxString str(wxGetWindowClass(hWnd));
1259
1260 // TODO: get rid of wxTLWHiddenParent special case (currently it's not
1261 // registered by wxApp but using ad hoc code in msw/toplevel.cpp);
1262 // there is also a hidden window class used by sockets &c
1263 return wxApp::IsRegisteredClassName(str) || str == wxT("wxTLWHiddenParent");
1264}
1265
1266// ----------------------------------------------------------------------------
1267// Style handling
1268// ----------------------------------------------------------------------------
1269
1270void wxWindowMSW::SetWindowStyleFlag(long flags)
1271{
1272 long flagsOld = GetWindowStyleFlag();
1273 if ( flags == flagsOld )
1274 return;
1275
1276 // update the internal variable
1277 wxWindowBase::SetWindowStyleFlag(flags);
1278
1279 // and the real window flags
1280 MSWUpdateStyle(flagsOld, GetExtraStyle());
1281}
1282
1283void wxWindowMSW::SetExtraStyle(long exflags)
1284{
1285 long exflagsOld = GetExtraStyle();
1286 if ( exflags == exflagsOld )
1287 return;
1288
1289 // update the internal variable
1290 wxWindowBase::SetExtraStyle(exflags);
1291
1292 // and the real window flags
1293 MSWUpdateStyle(GetWindowStyleFlag(), exflagsOld);
1294}
1295
1296void wxWindowMSW::MSWUpdateStyle(long flagsOld, long exflagsOld)
1297{
1298 // now update the Windows style as well if needed - and if the window had
1299 // been already created
1300 if ( !GetHwnd() )
1301 return;
1302
1303 // we may need to call SetWindowPos() when we change some styles
1304 bool callSWP = false;
1305
1306 WXDWORD exstyle;
1307 long style = MSWGetStyle(GetWindowStyleFlag(), &exstyle);
1308
1309 // this is quite a horrible hack but we need it because MSWGetStyle()
1310 // doesn't take exflags as parameter but uses GetExtraStyle() internally
1311 // and so we have to modify the window exflags temporarily to get the
1312 // correct exstyleOld
1313 long exflagsNew = GetExtraStyle();
1314 wxWindowBase::SetExtraStyle(exflagsOld);
1315
1316 WXDWORD exstyleOld;
1317 long styleOld = MSWGetStyle(flagsOld, &exstyleOld);
1318
1319 wxWindowBase::SetExtraStyle(exflagsNew);
1320
1321
1322 if ( style != styleOld )
1323 {
1324 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1325 // this function so instead of simply setting the style to the new
1326 // value we clear the bits which were set in styleOld but are set in
1327 // the new one and set the ones which were not set before
1328 long styleReal = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1329 styleReal &= ~styleOld;
1330 styleReal |= style;
1331
1332 ::SetWindowLong(GetHwnd(), GWL_STYLE, styleReal);
1333
1334 // we need to call SetWindowPos() if any of the styles affecting the
1335 // frame appearance have changed
1336 callSWP = ((styleOld ^ style ) & (WS_BORDER |
1337 WS_THICKFRAME |
1338 WS_CAPTION |
1339 WS_DLGFRAME |
1340 WS_MAXIMIZEBOX |
1341 WS_MINIMIZEBOX |
1342 WS_SYSMENU) ) != 0;
1343 }
1344
1345 // and the extended style
1346 long exstyleReal = wxGetWindowExStyle(this);
1347
1348 if ( exstyle != exstyleOld )
1349 {
1350 exstyleReal &= ~exstyleOld;
1351 exstyleReal |= exstyle;
1352
1353 wxSetWindowExStyle(this, exstyleReal);
1354
1355 // ex style changes don't take effect without calling SetWindowPos
1356 callSWP = true;
1357 }
1358
1359 if ( callSWP )
1360 {
1361 // we must call SetWindowPos() to flush the cached extended style and
1362 // also to make the change to wxSTAY_ON_TOP style take effect: just
1363 // setting the style simply doesn't work
1364 if ( !::SetWindowPos(GetHwnd(),
1365 exstyleReal & WS_EX_TOPMOST ? HWND_TOPMOST
1366 : HWND_NOTOPMOST,
1367 0, 0, 0, 0,
1368 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE |
1369 SWP_FRAMECHANGED) )
1370 {
1371 wxLogLastError(wxT("SetWindowPos"));
1372 }
1373 }
1374}
1375
1376wxBorder wxWindowMSW::GetDefaultBorderForControl() const
1377{
1378 return wxBORDER_THEME;
1379}
1380
1381wxBorder wxWindowMSW::GetDefaultBorder() const
1382{
1383 return wxWindowBase::GetDefaultBorder();
1384}
1385
1386// Translate wxBORDER_THEME (and other border styles if necessary) to the value
1387// that makes most sense for this Windows environment
1388wxBorder wxWindowMSW::TranslateBorder(wxBorder border) const
1389{
1390#if defined(__POCKETPC__) || defined(__SMARTPHONE__)
1391 if (border == wxBORDER_THEME || border == wxBORDER_SUNKEN || border == wxBORDER_SIMPLE)
1392 return wxBORDER_SIMPLE;
1393 else
1394 return wxBORDER_NONE;
1395#else
1396#if wxUSE_UXTHEME
1397 if (border == wxBORDER_THEME)
1398 {
1399 if (CanApplyThemeBorder())
1400 {
1401 wxUxThemeEngine* theme = wxUxThemeEngine::GetIfActive();
1402 if (theme)
1403 return wxBORDER_THEME;
1404 }
1405 return wxBORDER_SUNKEN;
1406 }
1407#endif
1408 return border;
1409#endif
1410}
1411
1412
1413WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
1414{
1415 // translate common wxWidgets styles to Windows ones
1416
1417 // most of windows are child ones, those which are not (such as
1418 // wxTopLevelWindow) should remove WS_CHILD in their MSWGetStyle()
1419 WXDWORD style = WS_CHILD;
1420
1421 // using this flag results in very significant reduction in flicker,
1422 // especially with controls inside the static boxes (as the interior of the
1423 // box is not redrawn twice), but sometimes results in redraw problems, so
1424 // optionally allow the old code to continue to use it provided a special
1425 // system option is turned on
1426 if ( !wxSystemOptions::GetOptionInt(wxT("msw.window.no-clip-children"))
1427 || (flags & wxCLIP_CHILDREN) )
1428 style |= WS_CLIPCHILDREN;
1429
1430 // it doesn't seem useful to use WS_CLIPSIBLINGS here as we officially
1431 // don't support overlapping windows and it only makes sense for them and,
1432 // presumably, gives the system some extra work (to manage more clipping
1433 // regions), so avoid it altogether
1434
1435
1436 if ( flags & wxVSCROLL )
1437 style |= WS_VSCROLL;
1438
1439 if ( flags & wxHSCROLL )
1440 style |= WS_HSCROLL;
1441
1442 const wxBorder border = TranslateBorder(GetBorder(flags));
1443
1444 // After translation, border is now optimized for the specific version of Windows
1445 // and theme engine presence.
1446
1447 // WS_BORDER is only required for wxBORDER_SIMPLE
1448 if ( border == wxBORDER_SIMPLE )
1449 style |= WS_BORDER;
1450
1451 // now deal with ext style if the caller wants it
1452 if ( exstyle )
1453 {
1454 *exstyle = 0;
1455
1456#ifndef __WXWINCE__
1457 if ( flags & wxTRANSPARENT_WINDOW )
1458 *exstyle |= WS_EX_TRANSPARENT;
1459#endif
1460
1461 switch ( border )
1462 {
1463 default:
1464 case wxBORDER_DEFAULT:
1465 wxFAIL_MSG( wxT("unknown border style") );
1466 // fall through
1467
1468 case wxBORDER_NONE:
1469 case wxBORDER_SIMPLE:
1470 case wxBORDER_THEME:
1471 break;
1472
1473 case wxBORDER_STATIC:
1474 *exstyle |= WS_EX_STATICEDGE;
1475 break;
1476
1477 case wxBORDER_RAISED:
1478 *exstyle |= WS_EX_DLGMODALFRAME;
1479 break;
1480
1481 case wxBORDER_SUNKEN:
1482 *exstyle |= WS_EX_CLIENTEDGE;
1483 style &= ~WS_BORDER;
1484 break;
1485
1486// case wxBORDER_DOUBLE:
1487// *exstyle |= WS_EX_DLGMODALFRAME;
1488// break;
1489 }
1490
1491 // wxUniv doesn't use Windows dialog navigation functions at all
1492#if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1493 // to make the dialog navigation work with the nested panels we must
1494 // use this style (top level windows such as dialogs don't need it)
1495 if ( (flags & wxTAB_TRAVERSAL) && !IsTopLevel() )
1496 {
1497 *exstyle |= WS_EX_CONTROLPARENT;
1498 }
1499#endif // __WXUNIVERSAL__
1500 }
1501
1502 return style;
1503}
1504
1505// Setup background and foreground colours correctly
1506void wxWindowMSW::SetupColours()
1507{
1508 if ( GetParent() )
1509 SetBackgroundColour(GetParent()->GetBackgroundColour());
1510}
1511
1512bool wxWindowMSW::IsMouseInWindow() const
1513{
1514 // get the mouse position
1515 POINT pt;
1516 wxGetCursorPosMSW(&pt);
1517
1518 // find the window which currently has the cursor and go up the window
1519 // chain until we find this window - or exhaust it
1520 HWND hwnd = ::WindowFromPoint(pt);
1521 while ( hwnd && (hwnd != GetHwnd()) )
1522 hwnd = ::GetParent(hwnd);
1523
1524 return hwnd != NULL;
1525}
1526
1527void wxWindowMSW::OnInternalIdle()
1528{
1529#ifndef HAVE_TRACKMOUSEEVENT
1530 // Check if we need to send a LEAVE event
1531 if ( m_mouseInWindow )
1532 {
1533 // note that we should generate the leave event whether the window has
1534 // or doesn't have mouse capture
1535 if ( !IsMouseInWindow() )
1536 {
1537 GenerateMouseLeave();
1538 }
1539 }
1540#endif // !HAVE_TRACKMOUSEEVENT
1541
1542 wxWindowBase::OnInternalIdle();
1543}
1544
1545// Set this window to be the child of 'parent'.
1546bool wxWindowMSW::Reparent(wxWindowBase *parent)
1547{
1548 if ( !wxWindowBase::Reparent(parent) )
1549 return false;
1550
1551 HWND hWndChild = GetHwnd();
1552 HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
1553
1554 ::SetParent(hWndChild, hWndParent);
1555
1556#ifndef __WXWINCE__
1557 if ( wxHasWindowExStyle(this, WS_EX_CONTROLPARENT) )
1558 {
1559 EnsureParentHasControlParentStyle(GetParent());
1560 }
1561#endif // !__WXWINCE__
1562
1563 return true;
1564}
1565
1566static inline void SendSetRedraw(HWND hwnd, bool on)
1567{
1568#ifndef __WXMICROWIN__
1569 ::SendMessage(hwnd, WM_SETREDRAW, (WPARAM)on, 0);
1570#endif
1571}
1572
1573void wxWindowMSW::DoFreeze()
1574{
1575 if ( !IsShown() )
1576 return; // no point in freezing hidden window
1577
1578 SendSetRedraw(GetHwnd(), false);
1579}
1580
1581void wxWindowMSW::DoThaw()
1582{
1583 if ( !IsShown() )
1584 return; // hidden windows aren't frozen by DoFreeze
1585
1586 SendSetRedraw(GetHwnd(), true);
1587
1588 // we need to refresh everything or otherwise the invalidated area
1589 // is not going to be repainted
1590 Refresh();
1591}
1592
1593void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
1594{
1595 HWND hWnd = GetHwnd();
1596 if ( hWnd )
1597 {
1598 RECT mswRect;
1599 const RECT *pRect;
1600 if ( rect )
1601 {
1602 wxCopyRectToRECT(*rect, mswRect);
1603 pRect = &mswRect;
1604 }
1605 else
1606 {
1607 pRect = NULL;
1608 }
1609
1610 // RedrawWindow not available on SmartPhone or eVC++ 3
1611#if !defined(__SMARTPHONE__) && !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1612 UINT flags = RDW_INVALIDATE | RDW_ALLCHILDREN;
1613 if ( eraseBack )
1614 flags |= RDW_ERASE;
1615
1616 ::RedrawWindow(hWnd, pRect, NULL, flags);
1617#else
1618 ::InvalidateRect(hWnd, pRect, eraseBack);
1619#endif
1620 }
1621}
1622
1623void wxWindowMSW::Update()
1624{
1625 if ( !::UpdateWindow(GetHwnd()) )
1626 {
1627 wxLogLastError(wxT("UpdateWindow"));
1628 }
1629
1630#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1631 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1632 // handler needs to be really drawn right now
1633 (void)::GdiFlush();
1634#endif // __WIN32__
1635}
1636
1637// ---------------------------------------------------------------------------
1638// drag and drop
1639// ---------------------------------------------------------------------------
1640
1641#if wxUSE_DRAG_AND_DROP || !defined(__WXWINCE__)
1642
1643#if wxUSE_STATBOX
1644
1645// we need to lower the sibling static boxes so controls contained within can be
1646// a drop target
1647static void AdjustStaticBoxZOrder(wxWindow *parent)
1648{
1649 // no sibling static boxes if we have no parent (ie TLW)
1650 if ( !parent )
1651 return;
1652
1653 for ( wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();
1654 node;
1655 node = node->GetNext() )
1656 {
1657 wxStaticBox *statbox = wxDynamicCast(node->GetData(), wxStaticBox);
1658 if ( statbox )
1659 {
1660 ::SetWindowPos(GetHwndOf(statbox), HWND_BOTTOM, 0, 0, 0, 0,
1661 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
1662 }
1663 }
1664}
1665
1666#else // !wxUSE_STATBOX
1667
1668static inline void AdjustStaticBoxZOrder(wxWindow * WXUNUSED(parent))
1669{
1670}
1671
1672#endif // wxUSE_STATBOX/!wxUSE_STATBOX
1673
1674#endif // drag and drop is used
1675
1676#if wxUSE_DRAG_AND_DROP
1677void wxWindowMSW::SetDropTarget(wxDropTarget *pDropTarget)
1678{
1679 if ( m_dropTarget != 0 ) {
1680 m_dropTarget->Revoke(m_hWnd);
1681 delete m_dropTarget;
1682 }
1683
1684 m_dropTarget = pDropTarget;
1685 if ( m_dropTarget != 0 )
1686 {
1687 AdjustStaticBoxZOrder(GetParent());
1688 m_dropTarget->Register(m_hWnd);
1689 }
1690}
1691#endif // wxUSE_DRAG_AND_DROP
1692
1693// old-style file manager drag&drop support: we retain the old-style
1694// DragAcceptFiles in parallel with SetDropTarget.
1695void wxWindowMSW::DragAcceptFiles(bool WXUNUSED_IN_WINCE(accept))
1696{
1697#ifndef __WXWINCE__
1698 HWND hWnd = GetHwnd();
1699 if ( hWnd )
1700 {
1701 AdjustStaticBoxZOrder(GetParent());
1702 ::DragAcceptFiles(hWnd, (BOOL)accept);
1703 }
1704#endif
1705}
1706
1707// ----------------------------------------------------------------------------
1708// tooltips
1709// ----------------------------------------------------------------------------
1710
1711#if wxUSE_TOOLTIPS
1712
1713void wxWindowMSW::DoSetToolTip(wxToolTip *tooltip)
1714{
1715 wxWindowBase::DoSetToolTip(tooltip);
1716
1717 if ( m_tooltip )
1718 m_tooltip->SetWindow((wxWindow *)this);
1719}
1720
1721#endif // wxUSE_TOOLTIPS
1722
1723// ---------------------------------------------------------------------------
1724// moving and resizing
1725// ---------------------------------------------------------------------------
1726
1727bool wxWindowMSW::IsSizeDeferred() const
1728{
1729#if wxUSE_DEFERRED_SIZING
1730 if ( m_pendingPosition != wxDefaultPosition ||
1731 m_pendingSize != wxDefaultSize )
1732 return true;
1733#endif // wxUSE_DEFERRED_SIZING
1734
1735 return false;
1736}
1737
1738// Get total size
1739void wxWindowMSW::DoGetSize(int *x, int *y) const
1740{
1741#if wxUSE_DEFERRED_SIZING
1742 // if SetSize() had been called at wx level but not realized at Windows
1743 // level yet (i.e. EndDeferWindowPos() not called), we still should return
1744 // the new and not the old position to the other wx code
1745 if ( m_pendingSize != wxDefaultSize )
1746 {
1747 if ( x )
1748 *x = m_pendingSize.x;
1749 if ( y )
1750 *y = m_pendingSize.y;
1751 }
1752 else // use current size
1753#endif // wxUSE_DEFERRED_SIZING
1754 {
1755 RECT rect = wxGetWindowRect(GetHwnd());
1756
1757 if ( x )
1758 *x = rect.right - rect.left;
1759 if ( y )
1760 *y = rect.bottom - rect.top;
1761 }
1762}
1763
1764// Get size *available for subwindows* i.e. excluding menu bar etc.
1765void wxWindowMSW::DoGetClientSize(int *x, int *y) const
1766{
1767#if wxUSE_DEFERRED_SIZING
1768 if ( m_pendingSize != wxDefaultSize )
1769 {
1770 // we need to calculate the client size corresponding to pending size
1771 //
1772 // FIXME: Unfortunately this doesn't work correctly for the maximized
1773 // top level windows, the returned values are too small (e.g.
1774 // under Windows 7 on a 1600*1200 screen with task bar on the
1775 // right the pending size for a maximized window is 1538*1200
1776 // and WM_NCCALCSIZE returns 1528*1172 even though the correct
1777 // client size of such window is 1538*1182). No idea how to fix
1778 // it though, setting WS_MAXIMIZE in GWL_STYLE before calling
1779 // WM_NCCALCSIZE doesn't help and AdjustWindowRectEx() doesn't
1780 // work in this direction neither. So we just have to live with
1781 // the slightly wrong results and relayout the window when it
1782 // gets finally shown in its maximized state (see #11762).
1783 RECT rect;
1784 rect.left = m_pendingPosition.x;
1785 rect.top = m_pendingPosition.y;
1786 rect.right = rect.left + m_pendingSize.x;
1787 rect.bottom = rect.top + m_pendingSize.y;
1788
1789 ::SendMessage(GetHwnd(), WM_NCCALCSIZE, FALSE, (LPARAM)&rect);
1790
1791 if ( x )
1792 *x = rect.right - rect.left;
1793 if ( y )
1794 *y = rect.bottom - rect.top;
1795 }
1796 else
1797#endif // wxUSE_DEFERRED_SIZING
1798 {
1799 RECT rect = wxGetClientRect(GetHwnd());
1800
1801 if ( x )
1802 *x = rect.right;
1803 if ( y )
1804 *y = rect.bottom;
1805 }
1806
1807 // The size of the client window can't be negative but ::GetClientRect()
1808 // can return negative size for an extremely small (1x1) window with
1809 // borders so ensure that we correct it here as having negative sizes is
1810 // completely unexpected.
1811 if ( x && *x < 0 )
1812 *x = 0;
1813 if ( y && *y < 0 )
1814 *y = 0;
1815}
1816
1817void wxWindowMSW::DoGetPosition(int *x, int *y) const
1818{
1819 wxWindow * const parent = GetParent();
1820
1821 wxPoint pos;
1822#if wxUSE_DEFERRED_SIZING
1823 if ( m_pendingPosition != wxDefaultPosition )
1824 {
1825 pos = m_pendingPosition;
1826 }
1827 else // use current position
1828#endif // wxUSE_DEFERRED_SIZING
1829 {
1830 RECT rect = wxGetWindowRect(GetHwnd());
1831
1832 POINT point;
1833 point.x = rect.left;
1834 point.y = rect.top;
1835
1836 // we do the adjustments with respect to the parent only for the "real"
1837 // children, not for the dialogs/frames
1838 if ( !IsTopLevel() )
1839 {
1840 if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
1841 {
1842 // In RTL mode, we want the logical left x-coordinate,
1843 // which would be the physical right x-coordinate.
1844 point.x = rect.right;
1845 }
1846
1847 // Since we now have the absolute screen coords, if there's a
1848 // parent we must subtract its top left corner
1849 if ( parent )
1850 {
1851 ::ScreenToClient(GetHwndOf(parent), &point);
1852 }
1853 }
1854
1855 pos.x = point.x;
1856 pos.y = point.y;
1857 }
1858
1859 // we also must adjust by the client area offset: a control which is just
1860 // under a toolbar could be at (0, 30) in Windows but at (0, 0) in wx
1861 if ( parent && !IsTopLevel() )
1862 {
1863 const wxPoint pt(parent->GetClientAreaOrigin());
1864 pos.x -= pt.x;
1865 pos.y -= pt.y;
1866 }
1867
1868 if ( x )
1869 *x = pos.x;
1870 if ( y )
1871 *y = pos.y;
1872}
1873
1874void wxWindowMSW::DoScreenToClient(int *x, int *y) const
1875{
1876 POINT pt;
1877 if ( x )
1878 pt.x = *x;
1879 if ( y )
1880 pt.y = *y;
1881
1882 ::ScreenToClient(GetHwnd(), &pt);
1883
1884 if ( x )
1885 *x = pt.x;
1886 if ( y )
1887 *y = pt.y;
1888}
1889
1890void wxWindowMSW::DoClientToScreen(int *x, int *y) const
1891{
1892 POINT pt;
1893 if ( x )
1894 pt.x = *x;
1895 if ( y )
1896 pt.y = *y;
1897
1898 ::ClientToScreen(GetHwnd(), &pt);
1899
1900 if ( x )
1901 *x = pt.x;
1902 if ( y )
1903 *y = pt.y;
1904}
1905
1906bool
1907wxWindowMSW::DoMoveSibling(WXHWND hwnd, int x, int y, int width, int height)
1908{
1909#if wxUSE_DEFERRED_SIZING
1910 // if our parent had prepared a defer window handle for us, use it (unless
1911 // we are a top level window)
1912 wxWindowMSW * const parent = IsTopLevel() ? NULL : GetParent();
1913
1914 HDWP hdwp = parent ? (HDWP)parent->m_hDWP : NULL;
1915 if ( hdwp )
1916 {
1917 hdwp = ::DeferWindowPos(hdwp, (HWND)hwnd, NULL, x, y, width, height,
1918 SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_NOACTIVATE);
1919 if ( !hdwp )
1920 {
1921 wxLogLastError(wxT("DeferWindowPos"));
1922 }
1923 }
1924
1925 if ( parent )
1926 {
1927 // hdwp must be updated as it may have been changed
1928 parent->m_hDWP = (WXHANDLE)hdwp;
1929 }
1930
1931 if ( hdwp )
1932 {
1933 // did deferred move, remember new coordinates of the window as they're
1934 // different from what Windows would return for it
1935 return true;
1936 }
1937
1938 // otherwise (or if deferring failed) move the window in place immediately
1939#endif // wxUSE_DEFERRED_SIZING
1940 if ( !::MoveWindow((HWND)hwnd, x, y, width, height, IsShown()) )
1941 {
1942 wxLogLastError(wxT("MoveWindow"));
1943 }
1944
1945 // if wxUSE_DEFERRED_SIZING, indicates that we didn't use deferred move,
1946 // ignored otherwise
1947 return false;
1948}
1949
1950void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
1951{
1952 // TODO: is this consistent with other platforms?
1953 // Still, negative width or height shouldn't be allowed
1954 if (width < 0)
1955 width = 0;
1956 if (height < 0)
1957 height = 0;
1958
1959 if ( DoMoveSibling(m_hWnd, x, y, width, height) )
1960 {
1961#if wxUSE_DEFERRED_SIZING
1962 m_pendingPosition = wxPoint(x, y);
1963 m_pendingSize = wxSize(width, height);
1964 }
1965 else // window was moved immediately, without deferring it
1966 {
1967 m_pendingPosition = wxDefaultPosition;
1968 m_pendingSize = wxDefaultSize;
1969#endif // wxUSE_DEFERRED_SIZING
1970 }
1971}
1972
1973// set the size of the window: if the dimensions are positive, just use them,
1974// but if any of them is equal to -1, it means that we must find the value for
1975// it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1976// which case -1 is a valid value for x and y)
1977//
1978// If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1979// the width/height to best suit our contents, otherwise we reuse the current
1980// width/height
1981void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1982{
1983 // get the current size and position...
1984 int currentX, currentY;
1985 int currentW, currentH;
1986
1987 GetPosition(&currentX, &currentY);
1988 GetSize(&currentW, &currentH);
1989
1990 // ... and don't do anything (avoiding flicker) if it's already ok unless
1991 // we're forced to resize the window
1992 if ( x == currentX && y == currentY &&
1993 width == currentW && height == currentH &&
1994 !(sizeFlags & wxSIZE_FORCE) )
1995 {
1996 if (sizeFlags & wxSIZE_FORCE_EVENT)
1997 {
1998 wxSizeEvent event( wxSize(width,height), GetId() );
1999 event.SetEventObject( this );
2000 HandleWindowEvent( event );
2001 }
2002 return;
2003 }
2004
2005 if ( x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
2006 x = currentX;
2007 if ( y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
2008 y = currentY;
2009
2010 AdjustForParentClientOrigin(x, y, sizeFlags);
2011
2012 wxSize size = wxDefaultSize;
2013 if ( width == wxDefaultCoord )
2014 {
2015 if ( sizeFlags & wxSIZE_AUTO_WIDTH )
2016 {
2017 size = GetBestSize();
2018 width = size.x;
2019 }
2020 else
2021 {
2022 // just take the current one
2023 width = currentW;
2024 }
2025 }
2026
2027 if ( height == wxDefaultCoord )
2028 {
2029 if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
2030 {
2031 if ( size.x == wxDefaultCoord )
2032 {
2033 size = GetBestSize();
2034 }
2035 //else: already called GetBestSize() above
2036
2037 height = size.y;
2038 }
2039 else
2040 {
2041 // just take the current one
2042 height = currentH;
2043 }
2044 }
2045
2046 DoMoveWindow(x, y, width, height);
2047}
2048
2049void wxWindowMSW::DoSetClientSize(int width, int height)
2050{
2051 // setting the client size is less obvious than it could have been
2052 // because in the result of changing the total size the window scrollbar
2053 // may [dis]appear and/or its menubar may [un]wrap (and AdjustWindowRect()
2054 // doesn't take neither into account) and so the client size will not be
2055 // correct as the difference between the total and client size changes --
2056 // so we keep changing it until we get it right
2057 //
2058 // normally this loop shouldn't take more than 3 iterations (usually 1 but
2059 // if scrollbars [dis]appear as the result of the first call, then 2 and it
2060 // may become 3 if the window had 0 size originally and so we didn't
2061 // calculate the scrollbar correction correctly during the first iteration)
2062 // but just to be on the safe side we check for it instead of making it an
2063 // "infinite" loop (i.e. leaving break inside as the only way to get out)
2064 for ( int i = 0; i < 4; i++ )
2065 {
2066 RECT rectClient;
2067 ::GetClientRect(GetHwnd(), &rectClient);
2068
2069 // if the size is already ok, stop here (NB: rectClient.left = top = 0)
2070 if ( (rectClient.right == width || width == wxDefaultCoord) &&
2071 (rectClient.bottom == height || height == wxDefaultCoord) )
2072 {
2073 break;
2074 }
2075
2076 // Find the difference between the entire window (title bar and all)
2077 // and the client area; add this to the new client size to move the
2078 // window
2079 RECT rectWin;
2080 ::GetWindowRect(GetHwnd(), &rectWin);
2081
2082 const int widthWin = rectWin.right - rectWin.left,
2083 heightWin = rectWin.bottom - rectWin.top;
2084
2085 // MoveWindow positions the child windows relative to the parent, so
2086 // adjust if necessary
2087 if ( !IsTopLevel() )
2088 {
2089 wxWindow *parent = GetParent();
2090 if ( parent )
2091 {
2092 ::ScreenToClient(GetHwndOf(parent), (POINT *)&rectWin);
2093 }
2094 }
2095
2096 // don't call DoMoveWindow() because we want to move window immediately
2097 // and not defer it here as otherwise the value returned by
2098 // GetClient/WindowRect() wouldn't change as the window wouldn't be
2099 // really resized
2100 if ( !::MoveWindow(GetHwnd(),
2101 rectWin.left,
2102 rectWin.top,
2103 width + widthWin - rectClient.right,
2104 height + heightWin - rectClient.bottom,
2105 TRUE) )
2106 {
2107 wxLogLastError(wxT("MoveWindow"));
2108 }
2109 }
2110}
2111
2112wxSize wxWindowMSW::DoGetBorderSize() const
2113{
2114 wxCoord border;
2115 switch ( GetBorder() )
2116 {
2117 case wxBORDER_STATIC:
2118 case wxBORDER_SIMPLE:
2119 border = 1;
2120 break;
2121
2122 case wxBORDER_SUNKEN:
2123 border = 2;
2124 break;
2125
2126 case wxBORDER_RAISED:
2127 case wxBORDER_DOUBLE:
2128 border = 3;
2129 break;
2130
2131 default:
2132 wxFAIL_MSG( wxT("unknown border style") );
2133 // fall through
2134
2135 case wxBORDER_NONE:
2136 border = 0;
2137 }
2138
2139 return 2*wxSize(border, border);
2140}
2141
2142// ---------------------------------------------------------------------------
2143// text metrics
2144// ---------------------------------------------------------------------------
2145
2146int wxWindowMSW::GetCharHeight() const
2147{
2148 return wxGetTextMetrics(this).tmHeight;
2149}
2150
2151int wxWindowMSW::GetCharWidth() const
2152{
2153 // +1 is needed because Windows apparently adds it when calculating the
2154 // dialog units size in pixels
2155#if wxDIALOG_UNIT_COMPATIBILITY
2156 return wxGetTextMetrics(this).tmAveCharWidth;
2157#else
2158 return wxGetTextMetrics(this).tmAveCharWidth + 1;
2159#endif
2160}
2161
2162void wxWindowMSW::DoGetTextExtent(const wxString& string,
2163 int *x, int *y,
2164 int *descent,
2165 int *externalLeading,
2166 const wxFont *fontToUse) const
2167{
2168 // ensure we work with a valid font
2169 wxFont font;
2170 if ( !fontToUse || !fontToUse->IsOk() )
2171 font = GetFont();
2172 else
2173 font = *fontToUse;
2174
2175 wxCHECK_RET( font.IsOk(), wxT("invalid font in GetTextExtent()") );
2176
2177 const wxWindow* win = static_cast<const wxWindow*>(this);
2178 wxTextMeasure txm(win, &font);
2179 txm.GetTextExtent(string, x, y, descent, externalLeading);
2180}
2181
2182// ---------------------------------------------------------------------------
2183// popup menu
2184// ---------------------------------------------------------------------------
2185
2186#if wxUSE_MENUS_NATIVE
2187
2188// yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
2189// immediately, without waiting for the next event loop iteration
2190//
2191// NB: this function should probably be made public later as it can almost
2192// surely replace wxYield() elsewhere as well
2193static void wxYieldForCommandsOnly()
2194{
2195 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
2196 // want to process it here)
2197 MSG msg;
2198 while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE) )
2199 {
2200 if ( msg.message == WM_QUIT )
2201 {
2202 // if we retrieved a WM_QUIT, insert back into the message queue.
2203 ::PostQuitMessage(0);
2204 break;
2205 }
2206
2207 // luckily (as we don't have access to wxEventLoopImpl method from here
2208 // anyhow...) we don't need to pre process WM_COMMANDs so dispatch it
2209 // immediately
2210 ::TranslateMessage(&msg);
2211 ::DispatchMessage(&msg);
2212 }
2213}
2214
2215bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
2216{
2217 menu->UpdateUI();
2218
2219 wxPoint pt;
2220 if ( x == wxDefaultCoord && y == wxDefaultCoord )
2221 {
2222 pt = wxGetMousePosition();
2223 }
2224 else
2225 {
2226 pt = ClientToScreen(wxPoint(x, y));
2227 }
2228
2229#if defined(__WXWINCE__)
2230 static const UINT flags = 0;
2231#else // !__WXWINCE__
2232 UINT flags = TPM_RIGHTBUTTON;
2233 // NT4 doesn't support TPM_RECURSE and simply doesn't show the menu at all
2234 // when it's use, I'm not sure about Win95/98 but prefer to err on the safe
2235 // side and not to use it there neither -- modify the test if it does work
2236 // on these systems
2237 if ( wxGetWinVersion() >= wxWinVersion_5 )
2238 {
2239 // using TPM_RECURSE allows us to show a popup menu while another menu
2240 // is opened which can be useful and is supported by the other
2241 // platforms, so allow it under Windows too
2242 flags |= TPM_RECURSE;
2243 }
2244#endif // __WXWINCE__/!__WXWINCE__
2245
2246 ::TrackPopupMenu(GetHmenuOf(menu), flags, pt.x, pt.y, 0, GetHwnd(), NULL);
2247
2248 // we need to do it right now as otherwise the events are never going to be
2249 // sent to wxCurrentPopupMenu from HandleCommand()
2250 //
2251 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
2252 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
2253 // destroyed as soon as we return (it can be a local variable in the caller
2254 // for example) and so we do need to process the event immediately
2255 wxYieldForCommandsOnly();
2256
2257 return true;
2258}
2259
2260#endif // wxUSE_MENUS_NATIVE
2261
2262// ===========================================================================
2263// pre/post message processing
2264// ===========================================================================
2265
2266WXLRESULT wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2267{
2268 WXLRESULT rc;
2269 if ( m_oldWndProc )
2270 rc = ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
2271 else
2272 rc = ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
2273
2274 // Special hack used by wxTextEntry auto-completion only: this event is
2275 // sent after the normal keyboard processing so that its handler could use
2276 // the updated contents of the text control, after taking the key that was
2277 // pressed into account.
2278 if ( nMsg == WM_CHAR )
2279 {
2280 wxKeyEvent event(CreateCharEvent(wxEVT_AFTER_CHAR, wParam, lParam));
2281 HandleWindowEvent(event);
2282 }
2283
2284 return rc;
2285}
2286
2287bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
2288{
2289 // wxUniversal implements tab traversal itself
2290#ifndef __WXUNIVERSAL__
2291 if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
2292 {
2293 // intercept dialog navigation keys
2294 MSG *msg = (MSG *)pMsg;
2295
2296 // here we try to do all the job which ::IsDialogMessage() usually does
2297 // internally
2298 if ( msg->message == WM_KEYDOWN )
2299 {
2300 bool bCtrlDown = wxIsCtrlDown();
2301 bool bShiftDown = wxIsShiftDown();
2302
2303 // WM_GETDLGCODE: ask the control if it wants the key for itself,
2304 // don't process it if it's the case (except for Ctrl-Tab/Enter
2305 // combinations which are always processed)
2306 LONG lDlgCode = ::SendMessage(msg->hwnd, WM_GETDLGCODE, 0, 0);
2307
2308 // surprisingly, DLGC_WANTALLKEYS bit mask doesn't contain the
2309 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
2310 // it, of course, implies them
2311 if ( lDlgCode & DLGC_WANTALLKEYS )
2312 {
2313 lDlgCode |= DLGC_WANTTAB | DLGC_WANTARROWS;
2314 }
2315
2316 bool bForward = true,
2317 bWindowChange = false,
2318 bFromTab = false;
2319
2320 // should we process this message specially?
2321 bool bProcess = true;
2322 switch ( msg->wParam )
2323 {
2324 case VK_TAB:
2325 if ( (lDlgCode & DLGC_WANTTAB) && !bCtrlDown )
2326 {
2327 // let the control have the TAB
2328 bProcess = false;
2329 }
2330 else // use it for navigation
2331 {
2332 // Ctrl-Tab cycles thru notebook pages
2333 bWindowChange = bCtrlDown;
2334 bForward = !bShiftDown;
2335 bFromTab = true;
2336 }
2337 break;
2338
2339 case VK_UP:
2340 case VK_LEFT:
2341 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
2342 bProcess = false;
2343 else
2344 bForward = false;
2345 break;
2346
2347 case VK_DOWN:
2348 case VK_RIGHT:
2349 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
2350 bProcess = false;
2351 break;
2352
2353 case VK_PRIOR:
2354 bForward = false;
2355 // fall through
2356
2357 case VK_NEXT:
2358 // we treat PageUp/Dn as arrows because chances are that
2359 // a control which needs arrows also needs them for
2360 // navigation (e.g. wxTextCtrl, wxListCtrl, ...)
2361 if ( (lDlgCode & DLGC_WANTARROWS) && !bCtrlDown )
2362 bProcess = false;
2363 else // OTOH Ctrl-PageUp/Dn works as [Shift-]Ctrl-Tab
2364 bWindowChange = true;
2365 break;
2366
2367 case VK_RETURN:
2368 {
2369#if wxUSE_BUTTON
2370 // currently active button should get enter press even
2371 // if there is a default button elsewhere so check if
2372 // this window is a button first
2373 wxWindow *btn = NULL;
2374 if ( lDlgCode & DLGC_DEFPUSHBUTTON )
2375 {
2376 // let IsDialogMessage() handle this for all
2377 // buttons except the owner-drawn ones which it
2378 // just seems to ignore
2379 long style = ::GetWindowLong(msg->hwnd, GWL_STYLE);
2380 if ( (style & BS_OWNERDRAW) == BS_OWNERDRAW )
2381 {
2382 // emulate the button click
2383 btn = wxFindWinFromHandle(msg->hwnd);
2384 }
2385 }
2386 else // not a button itself, do we have default button?
2387 {
2388 // check if this window or any of its ancestors
2389 // wants the message for itself (we always reserve
2390 // Ctrl-Enter for dialog navigation though)
2391 wxWindow *win = this;
2392 if ( !bCtrlDown )
2393 {
2394 // this will contain the dialog code of this
2395 // window and all of its parent windows in turn
2396 LONG lDlgCode2 = lDlgCode;
2397
2398 while ( win )
2399 {
2400 if ( lDlgCode2 & DLGC_WANTMESSAGE )
2401 {
2402 // as it wants to process Enter itself,
2403 // don't call IsDialogMessage() which
2404 // would consume it
2405 return false;
2406 }
2407
2408 // don't propagate keyboard messages beyond
2409 // the first top level window parent
2410 if ( win->IsTopLevel() )
2411 break;
2412
2413 win = win->GetParent();
2414
2415 lDlgCode2 = ::SendMessage
2416 (
2417 GetHwndOf(win),
2418 WM_GETDLGCODE,
2419 0,
2420 0
2421 );
2422 }
2423 }
2424 else // bCtrlDown
2425 {
2426 win = wxGetTopLevelParent(win);
2427 }
2428
2429 wxTopLevelWindow * const
2430 tlw = wxDynamicCast(win, wxTopLevelWindow);
2431 if ( tlw )
2432 {
2433 btn = wxDynamicCast(tlw->GetDefaultItem(),
2434 wxButton);
2435 }
2436 }
2437
2438 if ( btn && btn->IsEnabled() )
2439 {
2440 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
2441 return true;
2442 }
2443
2444 // This "Return" key press won't be actually used for
2445 // navigation so don't generate wxNavigationKeyEvent
2446 // for it but still pass it to IsDialogMessage() as it
2447 // may handle it in some other way (e.g. by playing the
2448 // default error sound).
2449 bProcess = false;
2450
2451#endif // wxUSE_BUTTON
2452
2453#ifdef __WXWINCE__
2454 // map Enter presses into button presses on PDAs
2455 wxJoystickEvent event(wxEVT_JOY_BUTTON_DOWN);
2456 event.SetEventObject(this);
2457 if ( HandleWindowEvent(event) )
2458 return true;
2459#endif // __WXWINCE__
2460 }
2461 break;
2462
2463 default:
2464 bProcess = false;
2465 }
2466
2467 if ( bProcess )
2468 {
2469 wxNavigationKeyEvent event;
2470 event.SetDirection(bForward);
2471 event.SetWindowChange(bWindowChange);
2472 event.SetFromTab(bFromTab);
2473 event.SetEventObject(this);
2474
2475 if ( HandleWindowEvent(event) )
2476 {
2477 // as we don't call IsDialogMessage(), which would take of
2478 // this by default, we need to manually send this message
2479 // so that controls can change their UI state if needed
2480 MSWUpdateUIState(UIS_CLEAR, UISF_HIDEFOCUS);
2481
2482 return true;
2483 }
2484 }
2485 }
2486
2487 if ( ::IsDialogMessage(GetHwnd(), msg) )
2488 {
2489 // IsDialogMessage() did something...
2490 return true;
2491 }
2492 }
2493#endif // __WXUNIVERSAL__
2494
2495#if wxUSE_TOOLTIPS
2496 if ( m_tooltip )
2497 {
2498 // relay mouse move events to the tooltip control
2499 MSG *msg = (MSG *)pMsg;
2500 if ( msg->message == WM_MOUSEMOVE )
2501 wxToolTip::RelayEvent(pMsg);
2502 }
2503#endif // wxUSE_TOOLTIPS
2504
2505 return false;
2506}
2507
2508bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
2509{
2510#if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2511 return m_acceleratorTable.Translate(this, pMsg);
2512#else
2513 (void) pMsg;
2514 return false;
2515#endif // wxUSE_ACCEL
2516}
2517
2518bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* msg)
2519{
2520 // all tests below have to deal with various bugs/misfeatures of
2521 // IsDialogMessage(): we have to prevent it from being called from our
2522 // MSWProcessMessage() in some situations
2523
2524 // don't let IsDialogMessage() get VK_ESCAPE as it _always_ eats the
2525 // message even when there is no cancel button and when the message is
2526 // needed by the control itself: in particular, it prevents the tree in
2527 // place edit control from being closed with Escape in a dialog
2528 if ( msg->message == WM_KEYDOWN && msg->wParam == VK_ESCAPE )
2529 {
2530 return false;
2531 }
2532
2533 // ::IsDialogMessage() is broken and may sometimes hang the application by
2534 // going into an infinite loop when it tries to find the control to give
2535 // focus to when Alt-<key> is pressed, so we try to detect [some of] the
2536 // situations when this may happen and not call it then
2537 if ( msg->message != WM_SYSCHAR )
2538 return true;
2539
2540 // assume we can call it by default
2541 bool canSafelyCallIsDlgMsg = true;
2542
2543 HWND hwndFocus = ::GetFocus();
2544
2545 // if the currently focused window itself has WS_EX_CONTROLPARENT style,
2546 // ::IsDialogMessage() will also enter an infinite loop, because it will
2547 // recursively check the child windows but not the window itself and so if
2548 // none of the children accepts focus it loops forever (as it only stops
2549 // when it gets back to the window it started from)
2550 //
2551 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2552 // style has the focus, it can happen. One such possibility is if
2553 // all windows are either toplevel, wxDialog, wxPanel or static
2554 // controls and no window can actually accept keyboard input.
2555#if !defined(__WXWINCE__)
2556 if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
2557 {
2558 // pessimistic by default
2559 canSafelyCallIsDlgMsg = false;
2560 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2561 node;
2562 node = node->GetNext() )
2563 {
2564 wxWindow * const win = node->GetData();
2565 if ( win->CanAcceptFocus() &&
2566 !wxHasWindowExStyle(win, WS_EX_CONTROLPARENT) )
2567 {
2568 // it shouldn't hang...
2569 canSafelyCallIsDlgMsg = true;
2570
2571 break;
2572 }
2573 }
2574 }
2575#endif // !__WXWINCE__
2576
2577 if ( canSafelyCallIsDlgMsg )
2578 {
2579 // ::IsDialogMessage() can enter in an infinite loop when the
2580 // currently focused window is disabled or hidden and its
2581 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2582 // this case
2583 while ( hwndFocus )
2584 {
2585 if ( !::IsWindowEnabled(hwndFocus) ||
2586 !::IsWindowVisible(hwndFocus) )
2587 {
2588 // it would enter an infinite loop if we do this!
2589 canSafelyCallIsDlgMsg = false;
2590
2591 break;
2592 }
2593
2594 if ( !(::GetWindowLong(hwndFocus, GWL_STYLE) & WS_CHILD) )
2595 {
2596 // it's a top level window, don't go further -- e.g. even
2597 // if the parent of a dialog is disabled, this doesn't
2598 // break navigation inside the dialog
2599 break;
2600 }
2601
2602 hwndFocus = ::GetParent(hwndFocus);
2603 }
2604 }
2605
2606 return canSafelyCallIsDlgMsg;
2607}
2608
2609// ---------------------------------------------------------------------------
2610// message params unpackers
2611// ---------------------------------------------------------------------------
2612
2613void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
2614 WORD *id, WXHWND *hwnd, WORD *cmd)
2615{
2616 *id = LOWORD(wParam);
2617 *hwnd = (WXHWND)lParam;
2618 *cmd = HIWORD(wParam);
2619}
2620
2621void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
2622 WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
2623{
2624 *state = LOWORD(wParam);
2625 *minimized = HIWORD(wParam);
2626 *hwnd = (WXHWND)lParam;
2627}
2628
2629void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
2630 WXWORD *code, WXWORD *pos, WXHWND *hwnd)
2631{
2632 *code = LOWORD(wParam);
2633 *pos = HIWORD(wParam);
2634 *hwnd = (WXHWND)lParam;
2635}
2636
2637void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
2638 WXHDC *hdc, WXHWND *hwnd)
2639{
2640 *hwnd = (WXHWND)lParam;
2641 *hdc = (WXHDC)wParam;
2642}
2643
2644void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
2645 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
2646{
2647 *item = (WXWORD)wParam;
2648 *flags = HIWORD(wParam);
2649 *hmenu = (WXHMENU)lParam;
2650}
2651
2652// ---------------------------------------------------------------------------
2653// Main wxWidgets window proc and the window proc for wxWindow
2654// ---------------------------------------------------------------------------
2655
2656// Hook for new window just as it's being created, when the window isn't yet
2657// associated with the handle
2658static wxWindowMSW *gs_winBeingCreated = NULL;
2659
2660// implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2661// window being created and insures that it's always unset back later
2662wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW *winBeingCreated)
2663{
2664 gs_winBeingCreated = winBeingCreated;
2665}
2666
2667wxWindowCreationHook::~wxWindowCreationHook()
2668{
2669 gs_winBeingCreated = NULL;
2670}
2671
2672// Main window proc
2673LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2674{
2675 // trace all messages: useful for the debugging but noticeably slows down
2676 // the code so don't do it by default
2677#if wxDEBUG_LEVEL >= 2
2678 // notice that we cast wParam and lParam to long to avoid mismatch with
2679 // format specifiers in 64 bit builds where they are both int64 quantities
2680 //
2681 // casting like this loses information, of course, but it shouldn't matter
2682 // much for this diagnostic code and it keeps the code simple
2683 wxLogTrace("winmsg",
2684 wxT("Processing %s(hWnd=%p, wParam=%08lx, lParam=%08lx)"),
2685 wxGetMessageName(message), hWnd, (long)wParam, (long)lParam);
2686#endif // wxDEBUG_LEVEL >= 2
2687
2688 wxWindowMSW *wnd = wxFindWinFromHandle(hWnd);
2689
2690 // when we get the first message for the HWND we just created, we associate
2691 // it with wxWindow stored in gs_winBeingCreated
2692 if ( !wnd && gs_winBeingCreated )
2693 {
2694 wxAssociateWinWithHandle(hWnd, gs_winBeingCreated);
2695 wnd = gs_winBeingCreated;
2696 gs_winBeingCreated = NULL;
2697 wnd->SetHWND((WXHWND)hWnd);
2698 }
2699
2700 LRESULT rc;
2701
2702 if ( wnd && wxGUIEventLoop::AllowProcessing(wnd) )
2703 rc = wnd->MSWWindowProc(message, wParam, lParam);
2704 else
2705 rc = ::DefWindowProc(hWnd, message, wParam, lParam);
2706
2707 return rc;
2708}
2709
2710bool
2711wxWindowMSW::MSWHandleMessage(WXLRESULT *result,
2712 WXUINT message,
2713 WXWPARAM wParam,
2714 WXLPARAM lParam)
2715{
2716 // did we process the message?
2717 bool processed = false;
2718
2719 // the return value
2720 union
2721 {
2722 bool allow;
2723 WXLRESULT result;
2724 WXHBRUSH hBrush;
2725 } rc;
2726
2727 // for most messages we should return 0 when we do process the message
2728 rc.result = 0;
2729
2730 switch ( message )
2731 {
2732 case WM_CREATE:
2733 {
2734 bool mayCreate;
2735 processed = HandleCreate((WXLPCREATESTRUCT)lParam, &mayCreate);
2736 if ( processed )
2737 {
2738 // return 0 to allow window creation
2739 rc.result = mayCreate ? 0 : -1;
2740 }
2741 }
2742 break;
2743
2744 case WM_DESTROY:
2745 // never set processed to true and *always* pass WM_DESTROY to
2746 // DefWindowProc() as Windows may do some internal cleanup when
2747 // processing it and failing to pass the message along may cause
2748 // memory and resource leaks!
2749 (void)HandleDestroy();
2750 break;
2751
2752 case WM_SIZE:
2753 processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
2754 break;
2755
2756 case WM_MOVE:
2757 processed = HandleMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2758 break;
2759
2760#if !defined(__WXWINCE__)
2761 case WM_MOVING:
2762 {
2763 LPRECT pRect = (LPRECT)lParam;
2764 wxRect rc;
2765 rc.SetLeft(pRect->left);
2766 rc.SetTop(pRect->top);
2767 rc.SetRight(pRect->right);
2768 rc.SetBottom(pRect->bottom);
2769 processed = HandleMoving(rc);
2770 if (processed) {
2771 pRect->left = rc.GetLeft();
2772 pRect->top = rc.GetTop();
2773 pRect->right = rc.GetRight();
2774 pRect->bottom = rc.GetBottom();
2775 }
2776 }
2777 break;
2778
2779 case WM_ENTERSIZEMOVE:
2780 {
2781 processed = HandleEnterSizeMove();
2782 }
2783 break;
2784
2785 case WM_EXITSIZEMOVE:
2786 {
2787 processed = HandleExitSizeMove();
2788 }
2789 break;
2790
2791 case WM_SIZING:
2792 {
2793 LPRECT pRect = (LPRECT)lParam;
2794 wxRect rc;
2795 rc.SetLeft(pRect->left);
2796 rc.SetTop(pRect->top);
2797 rc.SetRight(pRect->right);
2798 rc.SetBottom(pRect->bottom);
2799 processed = HandleSizing(rc);
2800 if (processed) {
2801 pRect->left = rc.GetLeft();
2802 pRect->top = rc.GetTop();
2803 pRect->right = rc.GetRight();
2804 pRect->bottom = rc.GetBottom();
2805 }
2806 }
2807 break;
2808#endif // !__WXWINCE__
2809
2810#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2811 case WM_ACTIVATEAPP:
2812 // This implicitly sends a wxEVT_ACTIVATE_APP event
2813 wxTheApp->SetActive(wParam != 0, FindFocus());
2814 break;
2815#endif
2816
2817 case WM_ACTIVATE:
2818 {
2819 WXWORD state, minimized;
2820 WXHWND hwnd;
2821 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
2822
2823 processed = HandleActivate(state, minimized != 0, (WXHWND)hwnd);
2824 }
2825 break;
2826
2827 case WM_SETFOCUS:
2828 processed = HandleSetFocus((WXHWND)wParam);
2829 break;
2830
2831 case WM_KILLFOCUS:
2832 processed = HandleKillFocus((WXHWND)wParam);
2833 break;
2834
2835 case WM_PRINTCLIENT:
2836 processed = HandlePrintClient((WXHDC)wParam);
2837 break;
2838
2839 case WM_PAINT:
2840 if ( wParam )
2841 {
2842 wxPaintDCEx dc((wxWindow *)this, (WXHDC)wParam);
2843
2844 processed = HandlePaint();
2845 }
2846 else // no DC given
2847 {
2848 processed = HandlePaint();
2849 }
2850 break;
2851
2852 case WM_CLOSE:
2853#ifdef __WXUNIVERSAL__
2854 // Universal uses its own wxFrame/wxDialog, so we don't receive
2855 // close events unless we have this.
2856 Close();
2857#endif // __WXUNIVERSAL__
2858
2859 // don't let the DefWindowProc() destroy our window - we'll do it
2860 // ourselves in ~wxWindow
2861 processed = true;
2862 rc.result = TRUE;
2863 break;
2864
2865 case WM_SHOWWINDOW:
2866 processed = HandleShow(wParam != 0, (int)lParam);
2867 break;
2868
2869 case WM_MOUSEMOVE:
2870 processed = HandleMouseMove(GET_X_LPARAM(lParam),
2871 GET_Y_LPARAM(lParam),
2872 wParam);
2873 break;
2874
2875#ifdef HAVE_TRACKMOUSEEVENT
2876 case WM_MOUSELEAVE:
2877 // filter out excess WM_MOUSELEAVE events sent after PopupMenu()
2878 // (on XP at least)
2879 if ( m_mouseInWindow )
2880 {
2881 GenerateMouseLeave();
2882 }
2883
2884 // always pass processed back as false, this allows the window
2885 // manager to process the message too. This is needed to
2886 // ensure windows XP themes work properly as the mouse moves
2887 // over widgets like buttons. So don't set processed to true here.
2888 break;
2889#endif // HAVE_TRACKMOUSEEVENT
2890
2891#if wxUSE_MOUSEWHEEL
2892 case WM_MOUSEWHEEL:
2893 processed = HandleMouseWheel(wxMOUSE_WHEEL_VERTICAL, wParam, lParam);
2894 break;
2895
2896 case WM_MOUSEHWHEEL:
2897 processed = HandleMouseWheel(wxMOUSE_WHEEL_HORIZONTAL, wParam, lParam);
2898 break;
2899#endif // wxUSE_MOUSEWHEEL
2900
2901 case WM_LBUTTONDOWN:
2902 case WM_LBUTTONUP:
2903 case WM_LBUTTONDBLCLK:
2904 case WM_RBUTTONDOWN:
2905 case WM_RBUTTONUP:
2906 case WM_RBUTTONDBLCLK:
2907 case WM_MBUTTONDOWN:
2908 case WM_MBUTTONUP:
2909 case WM_MBUTTONDBLCLK:
2910#ifdef wxHAS_XBUTTON
2911 case WM_XBUTTONDOWN:
2912 case WM_XBUTTONUP:
2913 case WM_XBUTTONDBLCLK:
2914#endif // wxHAS_XBUTTON
2915 {
2916#ifdef __WXMICROWIN__
2917 // MicroWindows seems to ignore the fact that a window is
2918 // disabled. So catch mouse events and throw them away if
2919 // necessary.
2920 wxWindowMSW* win = this;
2921 for ( ;; )
2922 {
2923 if (!win->IsEnabled())
2924 {
2925 processed = true;
2926 break;
2927 }
2928
2929 win = win->GetParent();
2930 if ( !win || win->IsTopLevel() )
2931 break;
2932 }
2933
2934 if ( processed )
2935 break;
2936
2937#endif // __WXMICROWIN__
2938 int x = GET_X_LPARAM(lParam),
2939 y = GET_Y_LPARAM(lParam);
2940
2941#ifdef __WXWINCE__
2942 // redirect the event to a static control if necessary by
2943 // finding one under mouse because under CE the static controls
2944 // don't generate mouse events (even with SS_NOTIFY)
2945 wxWindowMSW *win;
2946 if ( GetCapture() == this )
2947 {
2948 // but don't do it if the mouse is captured by this window
2949 // because then it should really get this event itself
2950 win = this;
2951 }
2952 else
2953 {
2954 win = FindWindowForMouseEvent(this, &x, &y);
2955
2956 // this should never happen
2957 wxCHECK_MSG( win, 0,
2958 wxT("FindWindowForMouseEvent() returned NULL") );
2959 }
2960#ifdef __POCKETPC__
2961 if (IsContextMenuEnabled() && message == WM_LBUTTONDOWN)
2962 {
2963 SHRGINFO shrgi = {0};
2964
2965 shrgi.cbSize = sizeof(SHRGINFO);
2966 shrgi.hwndClient = (HWND) GetHWND();
2967 shrgi.ptDown.x = x;
2968 shrgi.ptDown.y = y;
2969
2970 shrgi.dwFlags = SHRG_RETURNCMD;
2971 // shrgi.dwFlags = SHRG_NOTIFYPARENT;
2972
2973 if (GN_CONTEXTMENU == ::SHRecognizeGesture(&shrgi))
2974 {
2975 wxPoint pt(x, y);
2976 pt = ClientToScreen(pt);
2977
2978 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
2979
2980 evtCtx.SetEventObject(this);
2981 if (HandleWindowEvent(evtCtx))
2982 {
2983 processed = true;
2984 return true;
2985 }
2986 }
2987 }
2988#endif
2989
2990#else // !__WXWINCE__
2991 wxWindowMSW *win = this;
2992#endif // __WXWINCE__/!__WXWINCE__
2993
2994 processed = win->HandleMouseEvent(message, x, y, wParam);
2995
2996 // if the app didn't eat the event, handle it in the default
2997 // way, that is by giving this window the focus
2998 if ( !processed )
2999 {
3000 // for the standard classes their WndProc sets the focus to
3001 // them anyhow and doing it from here results in some weird
3002 // problems, so don't do it for them (unnecessary anyhow)
3003 if ( !win->IsOfStandardClass() )
3004 {
3005 if ( message == WM_LBUTTONDOWN && win->IsFocusable() )
3006 win->SetFocus();
3007 }
3008 }
3009 }
3010 break;
3011
3012#ifdef MM_JOY1MOVE
3013 case MM_JOY1MOVE:
3014 case MM_JOY2MOVE:
3015 case MM_JOY1ZMOVE:
3016 case MM_JOY2ZMOVE:
3017 case MM_JOY1BUTTONDOWN:
3018 case MM_JOY2BUTTONDOWN:
3019 case MM_JOY1BUTTONUP:
3020 case MM_JOY2BUTTONUP:
3021 processed = HandleJoystickEvent(message,
3022 LOWORD(lParam),
3023 HIWORD(lParam),
3024 wParam);
3025 break;
3026#endif // __WXMICROWIN__
3027
3028 case WM_COMMAND:
3029 {
3030 WORD id, cmd;
3031 WXHWND hwnd;
3032 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
3033
3034 processed = HandleCommand(id, cmd, hwnd);
3035 }
3036 break;
3037
3038 case WM_NOTIFY:
3039 processed = HandleNotify((int)wParam, lParam, &rc.result);
3040 break;
3041
3042 // we only need to reply to WM_NOTIFYFORMAT manually when using MSLU,
3043 // otherwise DefWindowProc() does it perfectly fine for us, but MSLU
3044 // apparently doesn't always behave properly and needs some help
3045#if wxUSE_UNICODE_MSLU && defined(NF_QUERY)
3046 case WM_NOTIFYFORMAT:
3047 if ( lParam == NF_QUERY )
3048 {
3049 processed = true;
3050 rc.result = NFR_UNICODE;
3051 }
3052 break;
3053#endif // wxUSE_UNICODE_MSLU
3054
3055 // for these messages we must return true if process the message
3056#ifdef WM_DRAWITEM
3057 case WM_DRAWITEM:
3058 processed = MSWOnDrawItem(wParam, (WXDRAWITEMSTRUCT *)lParam);
3059 if ( processed )
3060 rc.result = TRUE;
3061 break;
3062
3063 case WM_MEASUREITEM:
3064 processed = MSWOnMeasureItem(wParam, (WXMEASUREITEMSTRUCT *)lParam);
3065 if ( processed )
3066 rc.result = TRUE;
3067 break;
3068#endif // defined(WM_DRAWITEM)
3069
3070 case WM_GETDLGCODE:
3071 if ( !IsOfStandardClass() || HasFlag(wxWANTS_CHARS) )
3072 {
3073 // we always want to get the char events
3074 rc.result = DLGC_WANTCHARS;
3075
3076 if ( HasFlag(wxWANTS_CHARS) )
3077 {
3078 // in fact, we want everything
3079 rc.result |= DLGC_WANTARROWS |
3080 DLGC_WANTTAB |
3081 DLGC_WANTALLKEYS;
3082 }
3083
3084 processed = true;
3085 }
3086 //else: get the dlg code from the DefWindowProc()
3087 break;
3088
3089 case WM_SYSKEYDOWN:
3090 case WM_KEYDOWN:
3091 // Generate the key down event in any case.
3092 m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
3093 if ( m_lastKeydownProcessed )
3094 {
3095 // If it was processed by an event handler, we stop here,
3096 // notably we intentionally don't generate char event then.
3097 processed = true;
3098 }
3099 else // key down event not handled
3100 {
3101 // Examine the event to decide whether we need to generate a
3102 // char event for it ourselves or let Windows do it. Window
3103 // mostly only does it for the keys which produce printable
3104 // characters (although there are exceptions, e.g. VK_ESCAPE or
3105 // VK_BACK (but not VK_DELETE)) while we do it for all keys
3106 // except the modifier ones (the wisdom of this is debatable
3107 // but by now this decision is enshrined forever due to
3108 // backwards compatibility).
3109 switch ( wParam )
3110 {
3111 // No wxEVT_CHAR events are generated for these keys at all.
3112 case VK_SHIFT:
3113 case VK_CONTROL:
3114 case VK_MENU:
3115 case VK_CAPITAL:
3116 case VK_NUMLOCK:
3117 case VK_SCROLL:
3118
3119 // Windows will send us WM_CHAR for these ones so we'll
3120 // generate wxEVT_CHAR for them later when we get it.
3121 case VK_ESCAPE:
3122 case VK_SPACE:
3123 case VK_RETURN:
3124 case VK_BACK:
3125 case VK_TAB:
3126 case VK_ADD:
3127 case VK_SUBTRACT:
3128 case VK_MULTIPLY:
3129 case VK_DIVIDE:
3130 case VK_DECIMAL:
3131 case VK_NUMPAD0:
3132 case VK_NUMPAD1:
3133 case VK_NUMPAD2:
3134 case VK_NUMPAD3:
3135 case VK_NUMPAD4:
3136 case VK_NUMPAD5:
3137 case VK_NUMPAD6:
3138 case VK_NUMPAD7:
3139 case VK_NUMPAD8:
3140 case VK_NUMPAD9:
3141 case VK_OEM_1:
3142 case VK_OEM_2:
3143 case VK_OEM_3:
3144 case VK_OEM_4:
3145 case VK_OEM_5:
3146 case VK_OEM_6:
3147 case VK_OEM_7:
3148 case VK_OEM_102:
3149 case VK_OEM_PLUS:
3150 case VK_OEM_COMMA:
3151 case VK_OEM_MINUS:
3152 case VK_OEM_PERIOD:
3153 break;
3154
3155#ifdef VK_APPS
3156 // special case of VK_APPS: treat it the same as right mouse
3157 // click because both usually pop up a context menu
3158 case VK_APPS:
3159 processed = HandleMouseEvent(WM_RBUTTONDOWN, -1, -1, 0);
3160 break;
3161#endif // VK_APPS
3162
3163 default:
3164 if ( (wParam >= '0' && wParam <= '9') ||
3165 (wParam >= 'A' && wParam <= 'Z') )
3166 {
3167 // We'll get WM_CHAR for those later too.
3168 break;
3169 }
3170
3171 // But for the rest we won't get WM_CHAR later so we do
3172 // need to generate the event right now.
3173 wxKeyEvent event(wxEVT_CHAR);
3174 InitAnyKeyEvent(event, wParam, lParam);
3175
3176 // Set the "extended" bit in lParam because we want to
3177 // generate CHAR events with WXK_HOME and not
3178 // WXK_NUMPAD_HOME even if the "Home" key on numpad was
3179 // pressed.
3180 event.m_keyCode = wxMSWKeyboard::VKToWX
3181 (
3182 wParam,
3183 lParam | (KF_EXTENDED << 16)
3184 );
3185
3186 // Don't produce events without any valid character
3187 // code (even if this shouldn't normally happen...).
3188 if ( event.m_keyCode != WXK_NONE )
3189 processed = HandleWindowEvent(event);
3190 }
3191 }
3192 if (message == WM_SYSKEYDOWN) // Let Windows still handle the SYSKEYs
3193 processed = false;
3194 break;
3195
3196 case WM_SYSKEYUP:
3197 case WM_KEYUP:
3198#ifdef VK_APPS
3199 // special case of VK_APPS: treat it the same as right mouse button
3200 if ( wParam == VK_APPS )
3201 {
3202 processed = HandleMouseEvent(WM_RBUTTONUP, -1, -1, 0);
3203 }
3204 else
3205#endif // VK_APPS
3206 {
3207 processed = HandleKeyUp((WORD) wParam, lParam);
3208 }
3209 break;
3210
3211 case WM_SYSCHAR:
3212 case WM_CHAR: // Always an ASCII character
3213 if ( m_lastKeydownProcessed )
3214 {
3215 // The key was handled in the EVT_KEY_DOWN and handling
3216 // a key in an EVT_KEY_DOWN handler is meant, by
3217 // design, to prevent EVT_CHARs from happening
3218 m_lastKeydownProcessed = false;
3219 processed = true;
3220 }
3221 else
3222 {
3223 processed = HandleChar((WORD)wParam, lParam);
3224 }
3225 break;
3226
3227 case WM_IME_STARTCOMPOSITION:
3228 // IME popup needs Escape as it should undo the changes in its
3229 // entry window instead of e.g. closing the dialog for which the
3230 // IME is used (and losing all the changes in the IME window).
3231 gs_modalEntryWindowCount++;
3232 break;
3233
3234 case WM_IME_ENDCOMPOSITION:
3235 gs_modalEntryWindowCount--;
3236 break;
3237
3238#if wxUSE_HOTKEY
3239 case WM_HOTKEY:
3240 processed = HandleHotKey((WORD)wParam, lParam);
3241 break;
3242#endif // wxUSE_HOTKEY
3243
3244 case WM_CUT:
3245 case WM_COPY:
3246 case WM_PASTE:
3247 processed = HandleClipboardEvent(message);
3248 break;
3249
3250 case WM_HSCROLL:
3251 case WM_VSCROLL:
3252 {
3253 WXWORD code, pos;
3254 WXHWND hwnd;
3255 UnpackScroll(wParam, lParam, &code, &pos, &hwnd);
3256
3257 processed = MSWOnScroll(message == WM_HSCROLL ? wxHORIZONTAL
3258 : wxVERTICAL,
3259 code, pos, hwnd);
3260 }
3261 break;
3262
3263 // CTLCOLOR messages are sent by children to query the parent for their
3264 // colors
3265#ifndef __WXMICROWIN__
3266 case WM_CTLCOLORMSGBOX:
3267 case WM_CTLCOLOREDIT:
3268 case WM_CTLCOLORLISTBOX:
3269 case WM_CTLCOLORBTN:
3270 case WM_CTLCOLORDLG:
3271 case WM_CTLCOLORSCROLLBAR:
3272 case WM_CTLCOLORSTATIC:
3273 {
3274 WXHDC hdc;
3275 WXHWND hwnd;
3276 UnpackCtlColor(wParam, lParam, &hdc, &hwnd);
3277
3278 processed = HandleCtlColor(&rc.hBrush, (WXHDC)hdc, (WXHWND)hwnd);
3279 }
3280 break;
3281#endif // !__WXMICROWIN__
3282
3283 case WM_SYSCOLORCHANGE:
3284 // the return value for this message is ignored
3285 processed = HandleSysColorChange();
3286 break;
3287
3288#if !defined(__WXWINCE__)
3289 case WM_DISPLAYCHANGE:
3290 processed = HandleDisplayChange();
3291 break;
3292#endif
3293
3294 case WM_PALETTECHANGED:
3295 processed = HandlePaletteChanged((WXHWND)wParam);
3296 break;
3297
3298 case WM_CAPTURECHANGED:
3299 processed = HandleCaptureChanged((WXHWND)lParam);
3300 break;
3301
3302 case WM_SETTINGCHANGE:
3303 processed = HandleSettingChange(wParam, lParam);
3304 break;
3305
3306 case WM_QUERYNEWPALETTE:
3307 processed = HandleQueryNewPalette();
3308 break;
3309
3310 case WM_ERASEBKGND:
3311 {
3312#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
3313 // check if an override was configured for this window
3314 EraseBgHooks::const_iterator it = gs_eraseBgHooks.find(this);
3315 if ( it != gs_eraseBgHooks.end() )
3316 processed = it->second->MSWEraseBgHook((WXHDC)wParam);
3317 else
3318#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
3319 processed = HandleEraseBkgnd((WXHDC)wParam);
3320 }
3321
3322 if ( processed )
3323 {
3324 // we processed the message, i.e. erased the background
3325 rc.result = TRUE;
3326 }
3327 break;
3328
3329#if !defined(__WXWINCE__)
3330 case WM_DROPFILES:
3331 processed = HandleDropFiles(wParam);
3332 break;
3333#endif
3334
3335 case WM_INITDIALOG:
3336 processed = HandleInitDialog((WXHWND)wParam);
3337
3338 if ( processed )
3339 {
3340 // we never set focus from here
3341 rc.result = FALSE;
3342 }
3343 break;
3344
3345#if !defined(__WXWINCE__)
3346 case WM_QUERYENDSESSION:
3347 processed = HandleQueryEndSession(lParam, &rc.allow);
3348 break;
3349
3350 case WM_ENDSESSION:
3351 processed = HandleEndSession(wParam != 0, lParam);
3352 break;
3353
3354 case WM_GETMINMAXINFO:
3355 processed = HandleGetMinMaxInfo((MINMAXINFO*)lParam);
3356 break;
3357#endif
3358
3359 case WM_SETCURSOR:
3360 processed = HandleSetCursor((WXHWND)wParam,
3361 LOWORD(lParam), // hit test
3362 HIWORD(lParam)); // mouse msg
3363
3364 if ( processed )
3365 {
3366 // returning TRUE stops the DefWindowProc() from further
3367 // processing this message - exactly what we need because we've
3368 // just set the cursor.
3369 rc.result = TRUE;
3370 }
3371 break;
3372
3373#if wxUSE_ACCESSIBILITY
3374 case WM_GETOBJECT:
3375 {
3376 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
3377 LPARAM dwObjId = (LPARAM) (DWORD) lParam;
3378
3379 if (dwObjId == (LPARAM)OBJID_CLIENT && GetOrCreateAccessible())
3380 {
3381 return LresultFromObject(IID_IAccessible, wParam, (IUnknown*) GetAccessible()->GetIAccessible());
3382 }
3383 break;
3384 }
3385#endif
3386
3387#if defined(WM_HELP)
3388 case WM_HELP:
3389 {
3390 // by default, WM_HELP is propagated by DefWindowProc() upwards
3391 // to the window parent but as we do it ourselves already
3392 // (wxHelpEvent is derived from wxCommandEvent), we don't want
3393 // to get the other events if we process this message at all
3394 processed = true;
3395
3396 // WM_HELP doesn't use lParam under CE
3397#ifndef __WXWINCE__
3398 HELPINFO* info = (HELPINFO*) lParam;
3399 if ( info->iContextType == HELPINFO_WINDOW )
3400 {
3401#endif // !__WXWINCE__
3402 wxHelpEvent helpEvent
3403 (
3404 wxEVT_HELP,
3405 GetId(),
3406#ifdef __WXWINCE__
3407 wxGetMousePosition() // what else?
3408#else
3409 wxPoint(info->MousePos.x, info->MousePos.y)
3410#endif
3411 );
3412
3413 helpEvent.SetEventObject(this);
3414 HandleWindowEvent(helpEvent);
3415#ifndef __WXWINCE__
3416 }
3417 else if ( info->iContextType == HELPINFO_MENUITEM )
3418 {
3419 wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId);
3420 helpEvent.SetEventObject(this);
3421 HandleWindowEvent(helpEvent);
3422
3423 }
3424 else // unknown help event?
3425 {
3426 processed = false;
3427 }
3428#endif // !__WXWINCE__
3429 }
3430 break;
3431#endif // WM_HELP
3432
3433#if !defined(__WXWINCE__)
3434 case WM_CONTEXTMENU:
3435 {
3436 // we don't convert from screen to client coordinates as
3437 // the event may be handled by a parent window
3438 wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
3439
3440 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
3441
3442 // we could have got an event from our child, reflect it back
3443 // to it if this is the case
3444 wxWindowMSW *win = NULL;
3445 WXHWND hWnd = (WXHWND)wParam;
3446 if ( hWnd != m_hWnd )
3447 {
3448 win = FindItemByHWND(hWnd);
3449 }
3450
3451 if ( !win )
3452 win = this;
3453
3454 evtCtx.SetEventObject(win);
3455 processed = win->HandleWindowEvent(evtCtx);
3456 }
3457 break;
3458#endif
3459
3460#if wxUSE_MENUS
3461 case WM_MENUCHAR:
3462 // we're only interested in our own menus, not MF_SYSMENU
3463 if ( HIWORD(wParam) == MF_POPUP )
3464 {
3465 // handle menu chars for ownerdrawn menu items
3466 int i = HandleMenuChar(toupper(LOWORD(wParam)), lParam);
3467 if ( i != wxNOT_FOUND )
3468 {
3469 rc.result = MAKELRESULT(i, MNC_EXECUTE);
3470 processed = true;
3471 }
3472 }
3473 break;
3474#endif // wxUSE_MENUS
3475
3476#ifndef __WXWINCE__
3477 case WM_POWERBROADCAST:
3478 {
3479 bool vetoed;
3480 processed = HandlePower(wParam, lParam, &vetoed);
3481 rc.result = processed && vetoed ? BROADCAST_QUERY_DENY : TRUE;
3482 }
3483 break;
3484#endif // __WXWINCE__
3485
3486#if wxUSE_UXTHEME
3487 // If we want the default themed border then we need to draw it ourselves
3488 case WM_NCCALCSIZE:
3489 {
3490 wxUxThemeEngine* theme = wxUxThemeEngine::GetIfActive();
3491 const wxBorder border = TranslateBorder(GetBorder());
3492 if (theme && border == wxBORDER_THEME)
3493 {
3494 // first ask the widget to calculate the border size
3495 rc.result = MSWDefWindowProc(message, wParam, lParam);
3496 processed = true;
3497
3498 // now alter the client size making room for drawing a
3499 // themed border
3500 RECT *rect;
3501 NCCALCSIZE_PARAMS *csparam = NULL;
3502 if ( wParam )
3503 {
3504 csparam = (NCCALCSIZE_PARAMS *)lParam;
3505 rect = &csparam->rgrc[0];
3506 }
3507 else
3508 {
3509 rect = (RECT *)lParam;
3510 }
3511
3512 wxUxThemeHandle hTheme((const wxWindow *)this, L"EDIT");
3513 RECT rcClient = { 0, 0, 0, 0 };
3514 wxClientDC dc((wxWindow *)this);
3515 wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl();
3516
3517 if ( theme->GetThemeBackgroundContentRect
3518 (
3519 hTheme,
3520 GetHdcOf(*impl),
3521 EP_EDITTEXT,
3522 ETS_NORMAL,
3523 rect,
3524 &rcClient) == S_OK )
3525 {
3526 InflateRect(&rcClient, -1, -1);
3527 if (wParam)
3528 csparam->rgrc[0] = rcClient;
3529 else
3530 *((RECT*)lParam) = rcClient;
3531
3532 // WVR_REDRAW triggers a bug whereby child windows are moved up and left,
3533 // so don't use.
3534 // rc.result = WVR_REDRAW;
3535 }
3536 }
3537 }
3538 break;
3539
3540 case WM_NCPAINT:
3541 {
3542 wxUxThemeEngine* theme = wxUxThemeEngine::GetIfActive();
3543 const wxBorder border = TranslateBorder(GetBorder());
3544 if (theme && border == wxBORDER_THEME)
3545 {
3546 // first ask the widget to paint its non-client area, such as scrollbars, etc.
3547 rc.result = MSWDefWindowProc(message, wParam, lParam);
3548 processed = true;
3549
3550 wxUxThemeHandle hTheme((const wxWindow *)this, L"EDIT");
3551 wxWindowDC dc((wxWindow *)this);
3552 wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl();
3553
3554 // Clip the DC so that you only draw on the non-client area
3555 RECT rcBorder;
3556 wxCopyRectToRECT(GetSize(), rcBorder);
3557
3558 RECT rcClient;
3559 theme->GetThemeBackgroundContentRect(
3560 hTheme, GetHdcOf(*impl), EP_EDITTEXT, ETS_NORMAL, &rcBorder, &rcClient);
3561 InflateRect(&rcClient, -1, -1);
3562
3563 ::ExcludeClipRect(GetHdcOf(*impl), rcClient.left, rcClient.top,
3564 rcClient.right, rcClient.bottom);
3565
3566 // Make sure the background is in a proper state
3567 if (theme->IsThemeBackgroundPartiallyTransparent(hTheme, EP_EDITTEXT, ETS_NORMAL))
3568 {
3569 theme->DrawThemeParentBackground(GetHwnd(), GetHdcOf(*impl), &rcBorder);
3570 }
3571
3572 // Draw the border
3573 int nState;
3574 if ( !IsEnabled() )
3575 nState = ETS_DISABLED;
3576 // should we check this?
3577 //else if ( ::GetWindowLong(GetHwnd(), GWL_STYLE) & ES_READONLY)
3578 // nState = ETS_READONLY;
3579 else
3580 nState = ETS_NORMAL;
3581 theme->DrawThemeBackground(hTheme, GetHdcOf(*impl), EP_EDITTEXT, nState, &rcBorder, NULL);
3582 }
3583 }
3584 break;
3585
3586#endif // wxUSE_UXTHEME
3587
3588 default:
3589 // try a custom message handler
3590 const MSWMessageHandlers::const_iterator
3591 i = gs_messageHandlers.find(message);
3592 if ( i != gs_messageHandlers.end() )
3593 {
3594 processed = (*i->second)(this, message, wParam, lParam);
3595 }
3596 }
3597
3598 if ( !processed )
3599 return false;
3600
3601 *result = rc.result;
3602
3603 return true;
3604}
3605
3606WXLRESULT wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
3607{
3608 WXLRESULT result;
3609 if ( !MSWHandleMessage(&result, message, wParam, lParam) )
3610 {
3611#if wxDEBUG_LEVEL >= 2
3612 wxLogTrace("winmsg", wxT("Forwarding %s to DefWindowProc."),
3613 wxGetMessageName(message));
3614#endif // wxDEBUG_LEVEL >= 2
3615 result = MSWDefWindowProc(message, wParam, lParam);
3616 }
3617
3618 return result;
3619}
3620
3621// ----------------------------------------------------------------------------
3622// wxWindow <-> HWND map
3623// ----------------------------------------------------------------------------
3624
3625wxWindow *wxFindWinFromHandle(HWND hwnd)
3626{
3627 WindowHandles::const_iterator i = gs_windowHandles.find(hwnd);
3628 return i == gs_windowHandles.end() ? NULL : i->second;
3629}
3630
3631void wxAssociateWinWithHandle(HWND hwnd, wxWindowMSW *win)
3632{
3633 // adding NULL hwnd is (first) surely a result of an error and
3634 // (secondly) breaks menu command processing
3635 wxCHECK_RET( hwnd != (HWND)NULL,
3636 wxT("attempt to add a NULL hwnd to window list ignored") );
3637
3638#if wxDEBUG_LEVEL
3639 WindowHandles::const_iterator i = gs_windowHandles.find(hwnd);
3640 if ( i != gs_windowHandles.end() )
3641 {
3642 if ( i->second != win )
3643 {
3644 wxFAIL_MSG(
3645 wxString::Format(
3646 wxT("HWND %p already associated with another window (%s)"),
3647 hwnd, win->GetClassInfo()->GetClassName()
3648 )
3649 );
3650 }
3651 //else: this actually happens currently because we associate the window
3652 // with its HWND during creation (if we create it) and also when
3653 // SubclassWin() is called later, this is ok
3654 }
3655#endif // wxDEBUG_LEVEL
3656
3657 gs_windowHandles[hwnd] = (wxWindow *)win;
3658}
3659
3660void wxRemoveHandleAssociation(wxWindowMSW *win)
3661{
3662 gs_windowHandles.erase(GetHwndOf(win));
3663}
3664
3665// ----------------------------------------------------------------------------
3666// various MSW speciic class dependent functions
3667// ----------------------------------------------------------------------------
3668
3669// Default destroyer - override if you destroy it in some other way
3670// (e.g. with MDI child windows)
3671void wxWindowMSW::MSWDestroyWindow()
3672{
3673}
3674
3675void wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
3676 const wxSize& size,
3677 int& x, int& y,
3678 int& w, int& h) const
3679{
3680 // CW_USEDEFAULT can't be used for child windows so just position them at
3681 // the origin by default
3682 x = pos.x == wxDefaultCoord ? 0 : pos.x;
3683 y = pos.y == wxDefaultCoord ? 0 : pos.y;
3684
3685 AdjustForParentClientOrigin(x, y);
3686
3687 // We don't have any clearly good choice for the size by default neither
3688 // but we must use something non-zero.
3689 w = WidthDefault(size.x);
3690 h = HeightDefault(size.y);
3691
3692 /*
3693 NB: there used to be some code here which set the initial size of the
3694 window to the client size of the parent if no explicit size was
3695 specified. This was wrong because wxWidgets programs often assume
3696 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
3697 it. To see why, you should understand that Windows sends WM_SIZE from
3698 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
3699 from some base class ctor and so this WM_SIZE is not processed in the
3700 real class' OnSize() (because it's not fully constructed yet and the
3701 event goes to some base class OnSize() instead). So the WM_SIZE we
3702 rely on is the one sent when the parent frame resizes its children
3703 but here is the problem: if the child already has just the right
3704 size, nothing will happen as both wxWidgets and Windows check for
3705 this and ignore any attempts to change the window size to the size it
3706 already has - so no WM_SIZE would be sent.
3707 */
3708}
3709
3710WXHWND wxWindowMSW::MSWGetParent() const
3711{
3712 return m_parent ? m_parent->GetHWND() : WXHWND(NULL);
3713}
3714
3715bool wxWindowMSW::MSWCreate(const wxChar *wclass,
3716 const wxChar *title,
3717 const wxPoint& pos,
3718 const wxSize& size,
3719 WXDWORD style,
3720 WXDWORD extendedStyle)
3721{
3722 // check a common bug in the user code: if the window is created with a
3723 // non-default ctor and Create() is called too, we'd create 2 HWND for a
3724 // single wxWindow object and this results in all sorts of trouble,
3725 // especially for wxTLWs
3726 wxCHECK_MSG( !m_hWnd, true, "window can't be recreated" );
3727
3728 // this can happen if this function is called using the return value of
3729 // wxApp::GetRegisteredClassName() which failed
3730 wxCHECK_MSG( wclass, false, "failed to register window class?" );
3731
3732
3733 // choose the position/size for the new window
3734 int x, y, w, h;
3735 (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
3736
3737 // controlId is menu handle for the top level windows, so set it to 0
3738 // unless we're creating a child window
3739 int controlId = style & WS_CHILD ? GetId() : 0;
3740
3741 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
3742 // which is the same but without CS_[HV]REDRAW class styles so using it
3743 // ensures that the window is not fully repainted on each resize
3744 wxString className(wclass);
3745 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
3746 {
3747 className += wxApp::GetNoRedrawClassSuffix();
3748 }
3749
3750 // do create the window
3751 wxWindowCreationHook hook(this);
3752
3753 m_hWnd = (WXHWND)::CreateWindowEx
3754 (
3755 extendedStyle,
3756 className.t_str(),
3757 title ? title : m_windowName.t_str(),
3758 style,
3759 x, y, w, h,
3760 (HWND)MSWGetParent(),
3761 (HMENU)wxUIntToPtr(controlId),
3762 wxGetInstance(),
3763 NULL // no extra data
3764 );
3765
3766 if ( !m_hWnd )
3767 {
3768 wxLogSysError(_("Can't create window of class %s"), className.c_str());
3769
3770 return false;
3771 }
3772
3773 SubclassWin(m_hWnd);
3774
3775 return true;
3776}
3777
3778// ===========================================================================
3779// MSW message handlers
3780// ===========================================================================
3781
3782// ---------------------------------------------------------------------------
3783// WM_NOTIFY
3784// ---------------------------------------------------------------------------
3785
3786bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
3787{
3788#ifndef __WXMICROWIN__
3789 LPNMHDR hdr = (LPNMHDR)lParam;
3790 HWND hWnd = hdr->hwndFrom;
3791 wxWindow *win = wxFindWinFromHandle(hWnd);
3792
3793 // if the control is one of our windows, let it handle the message itself
3794 if ( win )
3795 {
3796 return win->MSWOnNotify(idCtrl, lParam, result);
3797 }
3798
3799 // VZ: why did we do it? normally this is unnecessary and, besides, it
3800 // breaks the message processing for the toolbars because the tooltip
3801 // notifications were being forwarded to the toolbar child controls
3802 // (if it had any) before being passed to the toolbar itself, so in my
3803 // example the tooltip for the combobox was always shown instead of the
3804 // correct button tooltips
3805#if 0
3806 // try all our children
3807 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3808 while ( node )
3809 {
3810 wxWindow *child = node->GetData();
3811 if ( child->MSWOnNotify(idCtrl, lParam, result) )
3812 {
3813 return true;
3814 }
3815
3816 node = node->GetNext();
3817 }
3818#endif // 0
3819
3820 // by default, handle it ourselves
3821 return MSWOnNotify(idCtrl, lParam, result);
3822#else // __WXMICROWIN__
3823 return false;
3824#endif
3825}
3826
3827#if wxUSE_TOOLTIPS
3828
3829bool wxWindowMSW::HandleTooltipNotify(WXUINT code,
3830 WXLPARAM lParam,
3831 const wxString& ttip)
3832{
3833 // I don't know why it happens, but the versions of comctl32.dll starting
3834 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3835 // this message is supposed to be sent to Unicode programs only) -- hence
3836 // we need to handle it as well, otherwise no tooltips will be shown in
3837 // this case
3838#ifndef __WXWINCE__
3839 if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW)
3840 || ttip.empty() )
3841 {
3842 // not a tooltip message or no tooltip to show anyhow
3843 return false;
3844 }
3845#endif
3846
3847 LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
3848
3849 // We don't want to use the szText buffer because it has a limit of 80
3850 // bytes and this is not enough, especially for Unicode build where it
3851 // limits the tooltip string length to only 40 characters
3852 //
3853 // The best would be, of course, to not impose any length limitations at
3854 // all but then the buffer would have to be dynamic and someone would have
3855 // to free it and we don't have the tooltip owner object here any more, so
3856 // for now use our own static buffer with a higher fixed max length.
3857 //
3858 // Note that using a static buffer should not be a problem as only a single
3859 // tooltip can be shown at the same time anyhow.
3860#if !wxUSE_UNICODE
3861 if ( code == (WXUINT) TTN_NEEDTEXTW )
3862 {
3863 // We need to convert tooltip from multi byte to Unicode on the fly.
3864 static wchar_t buf[513];
3865
3866 // Truncate tooltip length if needed as otherwise we might not have
3867 // enough space for it in the buffer and MultiByteToWideChar() would
3868 // return an error
3869 size_t tipLength = wxMin(ttip.length(), WXSIZEOF(buf) - 1);
3870
3871 // Convert to WideChar without adding the NULL character. The NULL
3872 // character is added afterwards (this is more efficient).
3873 int len = ::MultiByteToWideChar
3874 (
3875 CP_ACP,
3876 0, // no flags
3877 ttip.t_str(),
3878 tipLength,
3879 buf,
3880 WXSIZEOF(buf) - 1
3881 );
3882
3883 if ( !len )
3884 {
3885 wxLogLastError(wxT("MultiByteToWideChar()"));
3886 }
3887
3888 buf[len] = L'\0';
3889 ttText->lpszText = (LPSTR) buf;
3890 }
3891 else // TTN_NEEDTEXTA
3892#endif // !wxUSE_UNICODE
3893 {
3894 // we get here if we got TTN_NEEDTEXTA (only happens in ANSI build) or
3895 // if we got TTN_NEEDTEXTW in Unicode build: in this case we just have
3896 // to copy the string we have into the buffer
3897 static wxChar buf[513];
3898 wxStrlcpy(buf, ttip.c_str(), WXSIZEOF(buf));
3899 ttText->lpszText = buf;
3900 }
3901
3902 return true;
3903}
3904
3905#endif // wxUSE_TOOLTIPS
3906
3907bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
3908 WXLPARAM lParam,
3909 WXLPARAM* WXUNUSED(result))
3910{
3911#if wxUSE_TOOLTIPS
3912 if ( m_tooltip )
3913 {
3914 NMHDR* hdr = (NMHDR *)lParam;
3915 if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
3916 {
3917 // processed
3918 return true;
3919 }
3920 }
3921#else
3922 wxUnusedVar(lParam);
3923#endif // wxUSE_TOOLTIPS
3924
3925 return false;
3926}
3927
3928// ---------------------------------------------------------------------------
3929// end session messages
3930// ---------------------------------------------------------------------------
3931
3932bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
3933{
3934#ifdef ENDSESSION_LOGOFF
3935 wxCloseEvent event(wxEVT_QUERY_END_SESSION, wxID_ANY);
3936 event.SetEventObject(wxTheApp);
3937 event.SetCanVeto(true);
3938 event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
3939
3940 bool rc = wxTheApp->ProcessEvent(event);
3941
3942 if ( rc )
3943 {
3944 // we may end only if the app didn't veto session closing (double
3945 // negation...)
3946 *mayEnd = !event.GetVeto();
3947 }
3948
3949 return rc;
3950#else
3951 wxUnusedVar(logOff);
3952 wxUnusedVar(mayEnd);
3953 return false;
3954#endif
3955}
3956
3957bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
3958{
3959#ifdef ENDSESSION_LOGOFF
3960 // do nothing if the session isn't ending
3961 if ( !endSession )
3962 return false;
3963
3964 // only send once
3965 if ( (this != wxTheApp->GetTopWindow()) )
3966 return false;
3967
3968 wxCloseEvent event(wxEVT_END_SESSION, wxID_ANY);
3969 event.SetEventObject(wxTheApp);
3970 event.SetCanVeto(false);
3971 event.SetLoggingOff((logOff & ENDSESSION_LOGOFF) != 0);
3972
3973 return wxTheApp->ProcessEvent(event);
3974#else
3975 wxUnusedVar(endSession);
3976 wxUnusedVar(logOff);
3977 return false;
3978#endif
3979}
3980
3981// ---------------------------------------------------------------------------
3982// window creation/destruction
3983// ---------------------------------------------------------------------------
3984
3985bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT WXUNUSED_IN_WINCE(cs),
3986 bool *mayCreate)
3987{
3988 // VZ: why is this commented out for WinCE? If it doesn't support
3989 // WS_EX_CONTROLPARENT at all it should be somehow handled globally,
3990 // not with multiple #ifdef's!
3991#ifndef __WXWINCE__
3992 if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
3993 EnsureParentHasControlParentStyle(GetParent());
3994#endif // !__WXWINCE__
3995
3996 *mayCreate = true;
3997
3998 return true;
3999}
4000
4001bool wxWindowMSW::HandleDestroy()
4002{
4003 // delete our drop target if we've got one
4004#if wxUSE_DRAG_AND_DROP
4005 if ( m_dropTarget != NULL )
4006 {
4007 m_dropTarget->Revoke(m_hWnd);
4008
4009 wxDELETE(m_dropTarget);
4010 }
4011#endif // wxUSE_DRAG_AND_DROP
4012
4013 // WM_DESTROY handled
4014 return true;
4015}
4016
4017// ---------------------------------------------------------------------------
4018// activation/focus
4019// ---------------------------------------------------------------------------
4020
4021bool wxWindowMSW::HandleActivate(int state,
4022 bool WXUNUSED(minimized),
4023 WXHWND WXUNUSED(activate))
4024{
4025 wxActivateEvent event(wxEVT_ACTIVATE,
4026 (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
4027 m_windowId);
4028 event.SetEventObject(this);
4029
4030 return HandleWindowEvent(event);
4031}
4032
4033bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
4034{
4035 // Strangly enough, some controls get set focus events when they are being
4036 // deleted, even if they already had focus before.
4037 if ( m_isBeingDeleted )
4038 {
4039 return false;
4040 }
4041
4042 // notify the parent keeping track of focus for the kbd navigation
4043 // purposes that we got it
4044 wxChildFocusEvent eventFocus((wxWindow *)this);
4045 (void)HandleWindowEvent(eventFocus);
4046
4047#if wxUSE_CARET
4048 // Deal with caret
4049 if ( m_caret )
4050 {
4051 m_caret->OnSetFocus();
4052 }
4053#endif // wxUSE_CARET
4054
4055 wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
4056 event.SetEventObject(this);
4057
4058 // wxFindWinFromHandle() may return NULL, it is ok
4059 event.SetWindow(wxFindWinFromHandle(hwnd));
4060
4061 return HandleWindowEvent(event);
4062}
4063
4064bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
4065{
4066#if wxUSE_CARET
4067 // Deal with caret
4068 if ( m_caret )
4069 {
4070 m_caret->OnKillFocus();
4071 }
4072#endif // wxUSE_CARET
4073
4074 // Don't send the event when in the process of being deleted. This can
4075 // only cause problems if the event handler tries to access the object.
4076 if ( m_isBeingDeleted )
4077 {
4078 return false;
4079 }
4080
4081 wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
4082 event.SetEventObject(this);
4083
4084 // wxFindWinFromHandle() may return NULL, it is ok
4085 event.SetWindow(wxFindWinFromHandle(hwnd));
4086
4087 return HandleWindowEvent(event);
4088}
4089
4090// ---------------------------------------------------------------------------
4091// labels
4092// ---------------------------------------------------------------------------
4093
4094void wxWindowMSW::SetLabel( const wxString& label)
4095{
4096 SetWindowText(GetHwnd(), label.c_str());
4097}
4098
4099wxString wxWindowMSW::GetLabel() const
4100{
4101 return wxGetWindowText(GetHWND());
4102}
4103
4104// ---------------------------------------------------------------------------
4105// miscellaneous
4106// ---------------------------------------------------------------------------
4107
4108bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
4109{
4110 wxShowEvent event(GetId(), show);
4111 event.SetEventObject(this);
4112
4113 return HandleWindowEvent(event);
4114}
4115
4116bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
4117{
4118 wxInitDialogEvent event(GetId());
4119 event.SetEventObject(this);
4120
4121 return HandleWindowEvent(event);
4122}
4123
4124bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
4125{
4126#if defined (__WXMICROWIN__) || defined(__WXWINCE__)
4127 wxUnusedVar(wParam);
4128 return false;
4129#else // __WXMICROWIN__
4130 HDROP hFilesInfo = (HDROP) wParam;
4131
4132 // Get the total number of files dropped
4133 UINT gwFilesDropped = ::DragQueryFile
4134 (
4135 (HDROP)hFilesInfo,
4136 (UINT)-1,
4137 (LPTSTR)0,
4138 (UINT)0
4139 );
4140
4141 wxString *files = new wxString[gwFilesDropped];
4142 for ( UINT wIndex = 0; wIndex < gwFilesDropped; wIndex++ )
4143 {
4144 // first get the needed buffer length (+1 for terminating NUL)
4145 size_t len = ::DragQueryFile(hFilesInfo, wIndex, NULL, 0) + 1;
4146
4147 // and now get the file name
4148 ::DragQueryFile(hFilesInfo, wIndex,
4149 wxStringBuffer(files[wIndex], len), len);
4150 }
4151
4152 wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
4153 event.SetEventObject(this);
4154
4155 POINT dropPoint;
4156 DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
4157 event.m_pos.x = dropPoint.x;
4158 event.m_pos.y = dropPoint.y;
4159
4160 DragFinish(hFilesInfo);
4161
4162 return HandleWindowEvent(event);
4163#endif
4164}
4165
4166
4167bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
4168 short nHitTest,
4169 int WXUNUSED(mouseMsg))
4170{
4171#ifndef __WXMICROWIN__
4172 // the logic is as follows:
4173 // 0. if we're busy, set the busy cursor (even for non client elements)
4174 // 1. don't set custom cursor for non client area of enabled windows
4175 // 2. ask user EVT_SET_CURSOR handler for the cursor
4176 // 3. if still no cursor but we're in a TLW, set the global cursor
4177
4178 HCURSOR hcursor = 0;
4179 if ( wxIsBusy() )
4180 {
4181 hcursor = wxGetCurrentBusyCursor();
4182 }
4183 else // not busy
4184 {
4185 if ( nHitTest != HTCLIENT )
4186 return false;
4187
4188 // first ask the user code - it may wish to set the cursor in some very
4189 // specific way (for example, depending on the current position)
4190 POINT pt;
4191 wxGetCursorPosMSW(&pt);
4192
4193 int x = pt.x,
4194 y = pt.y;
4195 ScreenToClient(&x, &y);
4196 wxSetCursorEvent event(x, y);
4197 event.SetId(GetId());
4198 event.SetEventObject(this);
4199
4200 bool processedEvtSetCursor = HandleWindowEvent(event);
4201 if ( processedEvtSetCursor && event.HasCursor() )
4202 {
4203 hcursor = GetHcursorOf(event.GetCursor());
4204 }
4205
4206 if ( !hcursor )
4207 {
4208 // the test for processedEvtSetCursor is here to prevent using
4209 // m_cursor if the user code caught EVT_SET_CURSOR() and returned
4210 // nothing from it - this is a way to say that our cursor shouldn't
4211 // be used for this point
4212 if ( !processedEvtSetCursor && m_cursor.IsOk() )
4213 {
4214 hcursor = GetHcursorOf(m_cursor);
4215 }
4216
4217 if ( !hcursor && !GetParent() )
4218 {
4219 const wxCursor *cursor = wxGetGlobalCursor();
4220 if ( cursor && cursor->IsOk() )
4221 {
4222 hcursor = GetHcursorOf(*cursor);
4223 }
4224 }
4225 }
4226 }
4227
4228
4229 if ( hcursor )
4230 {
4231 ::SetCursor(hcursor);
4232
4233 // cursor set, stop here
4234 return true;
4235 }
4236#endif // __WXMICROWIN__
4237
4238 // pass up the window chain
4239 return false;
4240}
4241
4242bool wxWindowMSW::HandlePower(WXWPARAM WXUNUSED_IN_WINCE(wParam),
4243 WXLPARAM WXUNUSED(lParam),
4244 bool *WXUNUSED_IN_WINCE(vetoed))
4245{
4246#ifdef __WXWINCE__
4247 // FIXME
4248 return false;
4249#else
4250 wxEventType evtType;
4251 switch ( wParam )
4252 {
4253 case PBT_APMQUERYSUSPEND:
4254 evtType = wxEVT_POWER_SUSPENDING;
4255 break;
4256
4257 case PBT_APMQUERYSUSPENDFAILED:
4258 evtType = wxEVT_POWER_SUSPEND_CANCEL;
4259 break;
4260
4261 case PBT_APMSUSPEND:
4262 evtType = wxEVT_POWER_SUSPENDED;
4263 break;
4264
4265 case PBT_APMRESUMESUSPEND:
4266 evtType = wxEVT_POWER_RESUME;
4267 break;
4268
4269 default:
4270 wxLogDebug(wxT("Unknown WM_POWERBROADCAST(%d) event"), wParam);
4271 // fall through
4272
4273 // these messages are currently not mapped to wx events
4274 case PBT_APMQUERYSTANDBY:
4275 case PBT_APMQUERYSTANDBYFAILED:
4276 case PBT_APMSTANDBY:
4277 case PBT_APMRESUMESTANDBY:
4278 case PBT_APMBATTERYLOW:
4279 case PBT_APMPOWERSTATUSCHANGE:
4280 case PBT_APMOEMEVENT:
4281 case PBT_APMRESUMECRITICAL:
4282#ifdef PBT_APMRESUMEAUTOMATIC
4283 case PBT_APMRESUMEAUTOMATIC:
4284#endif
4285 evtType = wxEVT_NULL;
4286 break;
4287 }
4288
4289 // don't handle unknown messages
4290 if ( evtType == wxEVT_NULL )
4291 return false;
4292
4293 // TODO: notify about PBTF_APMRESUMEFROMFAILURE in case of resume events?
4294
4295 wxPowerEvent event(evtType);
4296 if ( !HandleWindowEvent(event) )
4297 return false;
4298
4299 *vetoed = event.IsVetoed();
4300
4301 return true;
4302#endif
4303}
4304
4305bool wxWindowMSW::IsDoubleBuffered() const
4306{
4307 for ( const wxWindowMSW *win = this; win; win = win->GetParent() )
4308 {
4309 if ( wxHasWindowExStyle(win, WS_EX_COMPOSITED) )
4310 return true;
4311
4312 if ( win->IsTopLevel() )
4313 break;
4314 }
4315
4316 return false;
4317}
4318
4319void wxWindowMSW::SetDoubleBuffered(bool on)
4320{
4321 // Get the current extended style bits
4322 long exstyle = wxGetWindowExStyle(this);
4323
4324 // Twiddle the bit as needed
4325 if ( on )
4326 exstyle |= WS_EX_COMPOSITED;
4327 else
4328 exstyle &= ~WS_EX_COMPOSITED;
4329
4330 // put it back
4331 wxSetWindowExStyle(this, exstyle);
4332}
4333
4334// ---------------------------------------------------------------------------
4335// owner drawn stuff
4336// ---------------------------------------------------------------------------
4337
4338#if (wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE) || \
4339 (wxUSE_CONTROLS && !defined(__WXUNIVERSAL__))
4340 #define WXUNUSED_UNLESS_ODRAWN(param) param
4341#else
4342 #define WXUNUSED_UNLESS_ODRAWN(param)
4343#endif
4344
4345bool
4346wxWindowMSW::MSWOnDrawItem(int WXUNUSED_UNLESS_ODRAWN(id),
4347 WXDRAWITEMSTRUCT * WXUNUSED_UNLESS_ODRAWN(itemStruct))
4348{
4349#if wxUSE_OWNER_DRAWN
4350
4351#if wxUSE_MENUS_NATIVE
4352 // is it a menu item?
4353 DRAWITEMSTRUCT *pDrawStruct = (DRAWITEMSTRUCT *)itemStruct;
4354 if ( id == 0 && pDrawStruct->CtlType == ODT_MENU )
4355 {
4356 wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
4357
4358 // see comment before the same test in MSWOnMeasureItem() below
4359 if ( !pMenuItem )
4360 return false;
4361
4362 wxCHECK_MSG( wxDynamicCast(pMenuItem, wxMenuItem),
4363 false, wxT("MSWOnDrawItem: bad wxMenuItem pointer") );
4364
4365 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
4366 // the DC from being released
4367 wxDCTemp dc((WXHDC)pDrawStruct->hDC);
4368 wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
4369 pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
4370 pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
4371
4372 return pMenuItem->OnDrawItem
4373 (
4374 dc,
4375 rect,
4376 (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
4377 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
4378 );
4379 }
4380#endif // wxUSE_MENUS_NATIVE
4381
4382#endif // USE_OWNER_DRAWN
4383
4384#if wxUSE_CONTROLS && !defined(__WXUNIVERSAL__)
4385
4386#if wxUSE_OWNER_DRAWN
4387 wxControl *item = wxDynamicCast(FindItem(id), wxControl);
4388#else // !wxUSE_OWNER_DRAWN
4389 // we may still have owner-drawn buttons internally because we have to make
4390 // them owner-drawn to support colour change
4391 wxControl *item =
4392# if wxUSE_BUTTON
4393 wxDynamicCast(FindItem(id), wxButton)
4394# else
4395 NULL
4396# endif
4397 ;
4398#endif // USE_OWNER_DRAWN
4399
4400 if ( item )
4401 {
4402 return item->MSWOnDraw(itemStruct);
4403 }
4404
4405#endif // wxUSE_CONTROLS
4406
4407 return false;
4408}
4409
4410bool
4411wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
4412{
4413#if wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4414 // is it a menu item?
4415 MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
4416 if ( id == 0 && pMeasureStruct->CtlType == ODT_MENU )
4417 {
4418 wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
4419
4420 // according to Carsten Fuchs the pointer may be NULL under XP if an
4421 // MDI child frame is initially maximized, see this for more info:
4422 // http://article.gmane.org/gmane.comp.lib.wxwidgets.general/27745
4423 //
4424 // so silently ignore it instead of asserting
4425 if ( !pMenuItem )
4426 return false;
4427
4428 wxCHECK_MSG( wxDynamicCast(pMenuItem, wxMenuItem),
4429 false, wxT("MSWOnMeasureItem: bad wxMenuItem pointer") );
4430
4431 size_t w, h;
4432 bool rc = pMenuItem->OnMeasureItem(&w, &h);
4433
4434 pMeasureStruct->itemWidth = w;
4435 pMeasureStruct->itemHeight = h;
4436
4437 return rc;
4438 }
4439
4440 wxControl *item = wxDynamicCast(FindItem(id), wxControl);
4441 if ( item )
4442 {
4443 return item->MSWOnMeasure(itemStruct);
4444 }
4445#else
4446 wxUnusedVar(id);
4447 wxUnusedVar(itemStruct);
4448#endif // wxUSE_OWNER_DRAWN && wxUSE_MENUS_NATIVE
4449
4450 return false;
4451}
4452
4453// ---------------------------------------------------------------------------
4454// colours and palettes
4455// ---------------------------------------------------------------------------
4456
4457bool wxWindowMSW::HandleSysColorChange()
4458{
4459 wxSysColourChangedEvent event;
4460 event.SetEventObject(this);
4461
4462 (void)HandleWindowEvent(event);
4463
4464 // always let the system carry on the default processing to allow the
4465 // native controls to react to the colours update
4466 return false;
4467}
4468
4469bool wxWindowMSW::HandleDisplayChange()
4470{
4471 wxDisplayChangedEvent event;
4472 event.SetEventObject(this);
4473
4474 return HandleWindowEvent(event);
4475}
4476
4477#ifndef __WXMICROWIN__
4478
4479bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush, WXHDC hDC, WXHWND hWnd)
4480{
4481#if !wxUSE_CONTROLS || defined(__WXUNIVERSAL__)
4482 wxUnusedVar(hDC);
4483 wxUnusedVar(hWnd);
4484#else
4485 wxControl *item = wxDynamicCast(FindItemByHWND(hWnd, true), wxControl);
4486
4487 if ( item )
4488 *brush = item->MSWControlColor(hDC, hWnd);
4489 else
4490#endif // wxUSE_CONTROLS
4491 *brush = NULL;
4492
4493 return *brush != NULL;
4494}
4495
4496#endif // __WXMICROWIN__
4497
4498bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
4499{
4500#if wxUSE_PALETTE
4501 // same as below except we don't respond to our own messages
4502 if ( hWndPalChange != GetHWND() )
4503 {
4504 // check to see if we our our parents have a custom palette
4505 wxWindowMSW *win = this;
4506 while ( win && !win->HasCustomPalette() )
4507 {
4508 win = win->GetParent();
4509 }
4510
4511 if ( win && win->HasCustomPalette() )
4512 {
4513 // realize the palette to see whether redrawing is needed
4514 HDC hdc = ::GetDC((HWND) hWndPalChange);
4515 win->m_palette.SetHPALETTE((WXHPALETTE)
4516 ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
4517
4518 int result = ::RealizePalette(hdc);
4519
4520 // restore the palette (before releasing the DC)
4521 win->m_palette.SetHPALETTE((WXHPALETTE)
4522 ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
4523 ::RealizePalette(hdc);
4524 ::ReleaseDC((HWND) hWndPalChange, hdc);
4525
4526 // now check for the need to redraw
4527 if (result > 0)
4528 ::InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
4529 }
4530
4531 }
4532#endif // wxUSE_PALETTE
4533
4534 wxPaletteChangedEvent event(GetId());
4535 event.SetEventObject(this);
4536 event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
4537
4538 return HandleWindowEvent(event);
4539}
4540
4541bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture)
4542{
4543 // notify windows on the capture stack about lost capture
4544 // (see http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863):
4545 wxWindowBase::NotifyCaptureLost();
4546
4547 wxWindow *win = wxFindWinFromHandle(hWndGainedCapture);
4548 wxMouseCaptureChangedEvent event(GetId(), win);
4549 event.SetEventObject(this);
4550 return HandleWindowEvent(event);
4551}
4552
4553bool wxWindowMSW::HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam)
4554{
4555 // despite MSDN saying "(This message cannot be sent directly to a window.)"
4556 // we need to send this to child windows (it is only sent to top-level
4557 // windows) so {list,tree}ctrls can adjust their font size if necessary
4558 // this is exactly how explorer does it to enable the font size changes
4559
4560 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
4561 while ( node )
4562 {
4563 // top-level windows already get this message from the system
4564 wxWindow *win = node->GetData();
4565 if ( !win->IsTopLevel() )
4566 {
4567 ::SendMessage(GetHwndOf(win), WM_SETTINGCHANGE, wParam, lParam);
4568 }
4569
4570 node = node->GetNext();
4571 }
4572
4573 // let the system handle it
4574 return false;
4575}
4576
4577bool wxWindowMSW::HandleQueryNewPalette()
4578{
4579
4580#if wxUSE_PALETTE
4581 // check to see if we our our parents have a custom palette
4582 wxWindowMSW *win = this;
4583 while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
4584 if (win->HasCustomPalette()) {
4585 /* realize the palette to see whether redrawing is needed */
4586 HDC hdc = ::GetDC((HWND) GetHWND());
4587 win->m_palette.SetHPALETTE( (WXHPALETTE)
4588 ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
4589
4590 int result = ::RealizePalette(hdc);
4591 /* restore the palette (before releasing the DC) */
4592 win->m_palette.SetHPALETTE( (WXHPALETTE)
4593 ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), TRUE) );
4594 ::RealizePalette(hdc);
4595 ::ReleaseDC((HWND) GetHWND(), hdc);
4596 /* now check for the need to redraw */
4597 if (result > 0)
4598 ::InvalidateRect((HWND) GetHWND(), NULL, TRUE);
4599 }
4600#endif // wxUSE_PALETTE
4601
4602 wxQueryNewPaletteEvent event(GetId());
4603 event.SetEventObject(this);
4604
4605 return HandleWindowEvent(event) && event.GetPaletteRealized();
4606}
4607
4608// Responds to colour changes: passes event on to children.
4609void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
4610{
4611 // the top level window also reset the standard colour map as it might have
4612 // changed (there is no need to do it for the non top level windows as we
4613 // only have to do it once)
4614 if ( IsTopLevel() )
4615 {
4616 // FIXME-MT
4617 gs_hasStdCmap = false;
4618 }
4619 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
4620 while ( node )
4621 {
4622 // Only propagate to non-top-level windows because Windows already
4623 // sends this event to all top-level ones
4624 wxWindow *win = node->GetData();
4625 if ( !win->IsTopLevel() )
4626 {
4627 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
4628 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
4629 // the standard controls
4630 ::SendMessage(GetHwndOf(win), WM_SYSCOLORCHANGE, 0, 0);
4631 }
4632
4633 node = node->GetNext();
4634 }
4635}
4636
4637extern wxCOLORMAP *wxGetStdColourMap()
4638{
4639 static COLORREF s_stdColours[wxSTD_COL_MAX];
4640 static wxCOLORMAP s_cmap[wxSTD_COL_MAX];
4641
4642 if ( !gs_hasStdCmap )
4643 {
4644 static bool s_coloursInit = false;
4645
4646 if ( !s_coloursInit )
4647 {
4648 // When a bitmap is loaded, the RGB values can change (apparently
4649 // because Windows adjusts them to care for the old programs always
4650 // using 0xc0c0c0 while the transparent colour for the new Windows
4651 // versions is different). But we do this adjustment ourselves so
4652 // we want to avoid Windows' "help" and for this we need to have a
4653 // reference bitmap which can tell us what the RGB values change
4654 // to.
4655 wxLogNull logNo; // suppress error if we couldn't load the bitmap
4656 wxBitmap stdColourBitmap(wxT("wxBITMAP_STD_COLOURS"));
4657 if ( stdColourBitmap.IsOk() )
4658 {
4659 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
4660 wxASSERT_MSG( stdColourBitmap.GetWidth() == wxSTD_COL_MAX,
4661 wxT("forgot to update wxBITMAP_STD_COLOURS!") );
4662
4663 wxMemoryDC memDC;
4664 memDC.SelectObject(stdColourBitmap);
4665
4666 wxColour colour;
4667 for ( size_t i = 0; i < WXSIZEOF(s_stdColours); i++ )
4668 {
4669 memDC.GetPixel(i, 0, &colour);
4670 s_stdColours[i] = wxColourToRGB(colour);
4671 }
4672 }
4673 else // wxBITMAP_STD_COLOURS couldn't be loaded
4674 {
4675 s_stdColours[0] = RGB(000,000,000); // black
4676 s_stdColours[1] = RGB(128,128,128); // dark grey
4677 s_stdColours[2] = RGB(192,192,192); // light grey
4678 s_stdColours[3] = RGB(255,255,255); // white
4679 //s_stdColours[4] = RGB(000,000,255); // blue
4680 //s_stdColours[5] = RGB(255,000,255); // magenta
4681 }
4682
4683 s_coloursInit = true;
4684 }
4685
4686 gs_hasStdCmap = true;
4687
4688 // create the colour map
4689#define INIT_CMAP_ENTRY(col) \
4690 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
4691 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
4692
4693 INIT_CMAP_ENTRY(BTNTEXT);
4694 INIT_CMAP_ENTRY(BTNSHADOW);
4695 INIT_CMAP_ENTRY(BTNFACE);
4696 INIT_CMAP_ENTRY(BTNHIGHLIGHT);
4697
4698#undef INIT_CMAP_ENTRY
4699 }
4700
4701 return s_cmap;
4702}
4703
4704#if wxUSE_UXTHEME && !defined(TMT_FILLCOLOR)
4705 #define TMT_FILLCOLOR 3802
4706 #define TMT_TEXTCOLOR 3803
4707 #define TMT_BORDERCOLOR 3801
4708#endif
4709
4710wxColour wxWindowMSW::MSWGetThemeColour(const wchar_t *themeName,
4711 int themePart,
4712 int themeState,
4713 MSWThemeColour themeColour,
4714 wxSystemColour fallback) const
4715{
4716#if wxUSE_UXTHEME
4717 const wxUxThemeEngine* theme = wxUxThemeEngine::GetIfActive();
4718 if ( theme )
4719 {
4720 int themeProperty = 0;
4721
4722 // TODO: Convert this into a table? Sure would be faster.
4723 switch ( themeColour )
4724 {
4725 case ThemeColourBackground:
4726 themeProperty = TMT_FILLCOLOR;
4727 break;
4728 case ThemeColourText:
4729 themeProperty = TMT_TEXTCOLOR;
4730 break;
4731 case ThemeColourBorder:
4732 themeProperty = TMT_BORDERCOLOR;
4733 break;
4734 default:
4735 wxFAIL_MSG(wxT("unsupported theme colour"));
4736 };
4737
4738 wxUxThemeHandle hTheme((const wxWindow *)this, themeName);
4739 COLORREF col;
4740 HRESULT hr = theme->GetThemeColor
4741 (
4742 hTheme,
4743 themePart,
4744 themeState,
4745 themeProperty,
4746 &col
4747 );
4748
4749 if ( SUCCEEDED(hr) )
4750 return wxRGBToColour(col);
4751
4752 wxLogApiError(
4753 wxString::Format(
4754 "GetThemeColor(%s, %i, %i, %i)",
4755 themeName, themePart, themeState, themeProperty),
4756 hr);
4757 }
4758#else
4759 wxUnusedVar(themeName);
4760 wxUnusedVar(themePart);
4761 wxUnusedVar(themeState);
4762 wxUnusedVar(themeColour);
4763#endif
4764 return wxSystemSettings::GetColour(fallback);
4765}
4766
4767// ---------------------------------------------------------------------------
4768// painting
4769// ---------------------------------------------------------------------------
4770
4771// this variable is used to check that a paint event handler which processed
4772// the event did create a wxPaintDC inside its code and called BeginPaint() to
4773// validate the invalidated window area as otherwise we'd keep getting an
4774// endless stream of WM_PAINT messages for this window resulting in a lot of
4775// difficult to debug problems (e.g. impossibility to repaint other windows,
4776// lack of timer and idle events and so on)
4777extern bool wxDidCreatePaintDC;
4778bool wxDidCreatePaintDC = false;
4779
4780bool wxWindowMSW::HandlePaint()
4781{
4782 HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
4783 if ( !hRegion )
4784 {
4785 wxLogLastError(wxT("CreateRectRgn"));
4786 }
4787 if ( ::GetUpdateRgn(GetHwnd(), hRegion, FALSE) == ERROR )
4788 {
4789 wxLogLastError(wxT("GetUpdateRgn"));
4790 }
4791
4792 m_updateRegion = wxRegion((WXHRGN) hRegion);
4793
4794 wxDidCreatePaintDC = false;
4795
4796 wxPaintEvent event(m_windowId);
4797 event.SetEventObject(this);
4798
4799 bool processed = HandleWindowEvent(event);
4800
4801 if ( processed && !wxDidCreatePaintDC )
4802 {
4803 // do call MSWDefWindowProc() to validate the update region to avoid
4804 // the problems mentioned above
4805 processed = false;
4806 }
4807
4808 // note that we must generate NC event after the normal one as otherwise
4809 // BeginPaint() will happily overwrite our decorations with the background
4810 // colour
4811 wxNcPaintEvent eventNc(m_windowId);
4812 eventNc.SetEventObject(this);
4813 HandleWindowEvent(eventNc);
4814
4815 // don't keep an HRGN we don't need any longer (GetUpdateRegion() can only
4816 // be called from inside the event handlers called above)
4817 m_updateRegion.Clear();
4818
4819 wxPaintDCImpl::EndPaint((wxWindow *)this);
4820
4821 return processed;
4822}
4823
4824// Can be called from an application's OnPaint handler
4825void wxWindowMSW::OnPaint(wxPaintEvent& event)
4826{
4827#ifdef __WXUNIVERSAL__
4828 event.Skip();
4829#else
4830 HDC hDC = (HDC) wxPaintDCImpl::FindDCInCache((wxWindow*) event.GetEventObject());
4831 if (hDC != 0)
4832 {
4833 MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
4834 }
4835#endif
4836}
4837
4838bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
4839{
4840 if ( IsBeingDeleted() )
4841 {
4842 // We can get WM_ERASEBKGND after starting the destruction of our top
4843 // level parent. Handling it in this case is unnecessary and can be
4844 // actually harmful as e.g. wxStaticBox::GetClientSize() doesn't work
4845 // without a valid TLW parent (because it uses dialog units internally
4846 // which use the dialog font), so just don't do anything then.
4847 return false;
4848 }
4849
4850 switch ( GetBackgroundStyle() )
4851 {
4852 case wxBG_STYLE_ERASE:
4853 case wxBG_STYLE_COLOUR:
4854 // we need to generate an erase background event
4855 {
4856 wxDCTemp dc(hdc, GetClientSize());
4857 wxDCTempImpl *impl = (wxDCTempImpl*) dc.GetImpl();
4858
4859 impl->SetHDC(hdc);
4860 impl->SetWindow((wxWindow *)this);
4861
4862 wxEraseEvent event(m_windowId, &dc);
4863 event.SetEventObject(this);
4864 bool rc = HandleWindowEvent(event);
4865
4866 // must be called manually as ~wxDC doesn't do anything for
4867 // wxDCTemp
4868 impl->SelectOldObjects(hdc);
4869
4870 if ( rc )
4871 {
4872 // background erased by the user-defined handler
4873 return true;
4874 }
4875 }
4876 // fall through
4877
4878 case wxBG_STYLE_SYSTEM:
4879 if ( !DoEraseBackground(hdc) )
4880 {
4881 // let the default processing to take place if we didn't erase
4882 // the background ourselves
4883 return false;
4884 }
4885 break;
4886
4887 case wxBG_STYLE_PAINT:
4888 case wxBG_STYLE_TRANSPARENT:
4889 // no need to do anything here at all, background will be entirely
4890 // redrawn in WM_PAINT handler
4891 break;
4892
4893 default:
4894 wxFAIL_MSG( "unknown background style" );
4895 }
4896
4897 return true;
4898}
4899
4900#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
4901
4902bool wxWindowMSW::MSWHasEraseBgHook() const
4903{
4904 return gs_eraseBgHooks.find(const_cast<wxWindowMSW *>(this))
4905 != gs_eraseBgHooks.end();
4906}
4907
4908void wxWindowMSW::MSWSetEraseBgHook(wxWindow *child)
4909{
4910 if ( child )
4911 {
4912 if ( !gs_eraseBgHooks.insert(
4913 EraseBgHooks::value_type(this, child)).second )
4914 {
4915 wxFAIL_MSG( wxT("Setting erase background hook twice?") );
4916 }
4917 }
4918 else // reset the hook
4919 {
4920 if ( gs_eraseBgHooks.erase(this) != 1 )
4921 {
4922 wxFAIL_MSG( wxT("Resetting erase background which was not set?") );
4923 }
4924 }
4925}
4926
4927#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
4928
4929bool wxWindowMSW::DoEraseBackground(WXHDC hDC)
4930{
4931 HBRUSH hbr = (HBRUSH)MSWGetBgBrush(hDC);
4932 if ( !hbr )
4933 return false;
4934
4935 // erase just the client area of the window, this is important for the
4936 // frames to avoid drawing over the toolbar part of the window (you might
4937 // think using WS_CLIPCHILDREN would prevent this from happening, but it
4938 // clearly doesn't)
4939 RECT rc;
4940 wxCopyRectToRECT(GetClientRect(), rc);
4941 ::FillRect((HDC)hDC, &rc, hbr);
4942
4943 return true;
4944}
4945
4946WXHBRUSH
4947wxWindowMSW::MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child)
4948{
4949 // Test for the custom background brush first.
4950 WXHBRUSH hbrush = MSWGetCustomBgBrush();
4951 if ( hbrush )
4952 {
4953 // We assume that this is either a stipple or hatched brush and not a
4954 // solid one as otherwise it would have been enough to set the
4955 // background colour and such brushes need to be positioned correctly
4956 // in order to align when different windows are painted, so do it here.
4957 RECT rc;
4958 ::GetWindowRect(GetHwndOf(child), &rc);
4959
4960 ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
4961
4962 int x = rc.left,
4963 y = rc.top;
4964 MSWAdjustBrushOrg(&x, &y);
4965
4966 if ( !::SetBrushOrgEx((HDC)hDC, -x, -y, NULL) )
4967 {
4968 wxLogLastError(wxT("SetBrushOrgEx(bg brush)"));
4969 }
4970
4971 return hbrush;
4972 }
4973
4974 // Otherwise see if we have a custom background colour.
4975 if ( m_hasBgCol )
4976 {
4977 wxBrush *
4978 brush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour());
4979
4980 return (WXHBRUSH)GetHbrushOf(*brush);
4981 }
4982
4983 return 0;
4984}
4985
4986WXHBRUSH wxWindowMSW::MSWGetBgBrush(WXHDC hDC)
4987{
4988 // Use the special wxWindowBeingErased variable if it is set as the child
4989 // being erased.
4990 wxWindowMSW * const child =
4991#if wxUSE_UXTHEME
4992 wxWindowBeingErased ? wxWindowBeingErased :
4993#endif
4994 this;
4995
4996 for ( wxWindowMSW *win = this; win; win = win->GetParent() )
4997 {
4998 WXHBRUSH hBrush = win->MSWGetBgBrushForChild(hDC, child);
4999 if ( hBrush )
5000 return hBrush;
5001
5002 // don't use the parent background if we're not transparent
5003 if ( !win->HasTransparentBackground() )
5004 break;
5005
5006 // background is not inherited beyond top level windows
5007 if ( win->IsTopLevel() )
5008 break;
5009 }
5010
5011 return 0;
5012}
5013
5014bool wxWindowMSW::HandlePrintClient(WXHDC hDC)
5015{
5016 // we receive this message when DrawThemeParentBackground() is
5017 // called from def window proc of several controls under XP and we
5018 // must draw properly themed background here
5019 //
5020 // note that naively I'd expect filling the client rect with the
5021 // brush returned by MSWGetBgBrush() work -- but for some reason it
5022 // doesn't and we have to call parents MSWPrintChild() which is
5023 // supposed to call DrawThemeBackground() with appropriate params
5024 //
5025 // also note that in this case lParam == PRF_CLIENT but we're
5026 // clearly expected to paint the background and nothing else!
5027
5028 if ( IsTopLevel() || InheritsBackgroundColour() )
5029 return false;
5030
5031 // sometimes we don't want the parent to handle it at all, instead
5032 // return whatever value this window wants
5033 if ( !MSWShouldPropagatePrintChild() )
5034 return MSWPrintChild(hDC, (wxWindow *)this);
5035
5036 for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
5037 {
5038 if ( win->MSWPrintChild(hDC, (wxWindow *)this) )
5039 return true;
5040
5041 if ( win->IsTopLevel() || win->InheritsBackgroundColour() )
5042 break;
5043 }
5044
5045 return false;
5046}
5047
5048// ---------------------------------------------------------------------------
5049// moving and resizing
5050// ---------------------------------------------------------------------------
5051
5052bool wxWindowMSW::HandleMinimize()
5053{
5054 wxIconizeEvent event(m_windowId);
5055 event.SetEventObject(this);
5056
5057 return HandleWindowEvent(event);
5058}
5059
5060bool wxWindowMSW::HandleMaximize()
5061{
5062 wxMaximizeEvent event(m_windowId);
5063 event.SetEventObject(this);
5064
5065 return HandleWindowEvent(event);
5066}
5067
5068bool wxWindowMSW::HandleMove(int x, int y)
5069{
5070 wxPoint point(x,y);
5071 wxMoveEvent event(point, m_windowId);
5072 event.SetEventObject(this);
5073
5074 return HandleWindowEvent(event);
5075}
5076
5077bool wxWindowMSW::HandleMoving(wxRect& rect)
5078{
5079 wxMoveEvent event(rect, m_windowId);
5080 event.SetEventObject(this);
5081
5082 bool rc = HandleWindowEvent(event);
5083 if (rc)
5084 rect = event.GetRect();
5085 return rc;
5086}
5087
5088bool wxWindowMSW::HandleEnterSizeMove()
5089{
5090 wxMoveEvent event(wxPoint(0,0), m_windowId);
5091 event.SetEventType(wxEVT_MOVE_START);
5092 event.SetEventObject(this);
5093
5094 return HandleWindowEvent(event);
5095}
5096
5097bool wxWindowMSW::HandleExitSizeMove()
5098{
5099 wxMoveEvent event(wxPoint(0,0), m_windowId);
5100 event.SetEventType(wxEVT_MOVE_END);
5101 event.SetEventObject(this);
5102
5103 return HandleWindowEvent(event);
5104}
5105
5106bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h), WXUINT wParam)
5107{
5108#if wxUSE_DEFERRED_SIZING
5109 // when we resize this window, its children are probably going to be
5110 // repositioned as well, prepare to use DeferWindowPos() for them
5111 int numChildren = 0;
5112 for ( HWND child = ::GetWindow(GetHwndOf(this), GW_CHILD);
5113 child;
5114 child = ::GetWindow(child, GW_HWNDNEXT) )
5115 {
5116 numChildren ++;
5117 }
5118
5119 // Protect against valid m_hDWP being overwritten
5120 bool useDefer = false;
5121
5122 if ( numChildren > 1 )
5123 {
5124 if (!m_hDWP)
5125 {
5126 m_hDWP = (WXHANDLE)::BeginDeferWindowPos(numChildren);
5127 if ( !m_hDWP )
5128 {
5129 wxLogLastError(wxT("BeginDeferWindowPos"));
5130 }
5131 if (m_hDWP)
5132 useDefer = true;
5133 }
5134 }
5135#endif // wxUSE_DEFERRED_SIZING
5136
5137 // update this window size
5138 bool processed = false;
5139 switch ( wParam )
5140 {
5141 default:
5142 wxFAIL_MSG( wxT("unexpected WM_SIZE parameter") );
5143 // fall through nevertheless
5144
5145 case SIZE_MAXHIDE:
5146 case SIZE_MAXSHOW:
5147 // we're not interested in these messages at all
5148 break;
5149
5150 case SIZE_MINIMIZED:
5151 processed = HandleMinimize();
5152 break;
5153
5154 case SIZE_MAXIMIZED:
5155 /* processed = */ HandleMaximize();
5156 // fall through to send a normal size event as well
5157
5158 case SIZE_RESTORED:
5159 // don't use w and h parameters as they specify the client size
5160 // while according to the docs EVT_SIZE handler is supposed to
5161 // receive the total size
5162 wxSizeEvent event(GetSize(), m_windowId);
5163 event.SetEventObject(this);
5164
5165 processed = HandleWindowEvent(event);
5166 }
5167
5168#if wxUSE_DEFERRED_SIZING
5169 // and finally change the positions of all child windows at once
5170 if ( useDefer && m_hDWP )
5171 {
5172 // reset m_hDWP to NULL so that child windows don't try to use our
5173 // m_hDWP after we call EndDeferWindowPos() on it (this shouldn't
5174 // happen anyhow normally but who knows what weird flow of control we
5175 // may have depending on what the users EVT_SIZE handler does...)
5176 HDWP hDWP = (HDWP)m_hDWP;
5177 m_hDWP = NULL;
5178
5179 // do put all child controls in place at once
5180 if ( !::EndDeferWindowPos(hDWP) )
5181 {
5182 wxLogLastError(wxT("EndDeferWindowPos"));
5183 }
5184
5185 // Reset our children's pending pos/size values.
5186 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
5187 node;
5188 node = node->GetNext() )
5189 {
5190 wxWindowMSW * const child = node->GetData();
5191 child->MSWEndDeferWindowPos();
5192 }
5193 }
5194#endif // wxUSE_DEFERRED_SIZING
5195
5196 return processed;
5197}
5198
5199bool wxWindowMSW::HandleSizing(wxRect& rect)
5200{
5201 wxSizeEvent event(rect, m_windowId);
5202 event.SetEventObject(this);
5203
5204 bool rc = HandleWindowEvent(event);
5205 if (rc)
5206 rect = event.GetRect();
5207 return rc;
5208}
5209
5210bool wxWindowMSW::HandleGetMinMaxInfo(void *WXUNUSED_IN_WINCE(mmInfo))
5211{
5212#ifdef __WXWINCE__
5213 return false;
5214#else
5215 MINMAXINFO *info = (MINMAXINFO *)mmInfo;
5216
5217 bool rc = false;
5218
5219 int minWidth = GetMinWidth(),
5220 minHeight = GetMinHeight(),
5221 maxWidth = GetMaxWidth(),
5222 maxHeight = GetMaxHeight();
5223
5224 if ( minWidth != wxDefaultCoord )
5225 {
5226 info->ptMinTrackSize.x = minWidth;
5227 rc = true;
5228 }
5229
5230 if ( minHeight != wxDefaultCoord )
5231 {
5232 info->ptMinTrackSize.y = minHeight;
5233 rc = true;
5234 }
5235
5236 if ( maxWidth != wxDefaultCoord )
5237 {
5238 info->ptMaxTrackSize.x = maxWidth;
5239 rc = true;
5240 }
5241
5242 if ( maxHeight != wxDefaultCoord )
5243 {
5244 info->ptMaxTrackSize.y = maxHeight;
5245 rc = true;
5246 }
5247
5248 return rc;
5249#endif
5250}
5251
5252// ---------------------------------------------------------------------------
5253// command messages
5254// ---------------------------------------------------------------------------
5255
5256bool wxWindowMSW::HandleCommand(WXWORD id_, WXWORD cmd, WXHWND control)
5257{
5258 // sign extend to int from short before comparing with the other int ids
5259 int id = (signed short)id_;
5260
5261#if wxUSE_MENUS_NATIVE
5262 if ( !cmd && wxCurrentPopupMenu )
5263 {
5264 wxMenu *popupMenu = wxCurrentPopupMenu;
5265 wxCurrentPopupMenu = NULL;
5266
5267 return popupMenu->MSWCommand(cmd, id);
5268 }
5269#endif // wxUSE_MENUS_NATIVE
5270
5271 wxWindow *win = NULL;
5272
5273 // first try to find it from HWND - this works even with the broken
5274 // programs using the same ids for different controls
5275 if ( control )
5276 {
5277 win = wxFindWinFromHandle(control);
5278 }
5279
5280 // try the id
5281 if ( !win )
5282 {
5283 win = FindItem(id);
5284 }
5285
5286 if ( win )
5287 {
5288 return win->MSWCommand(cmd, id);
5289 }
5290
5291 // the messages sent from the in-place edit control used by the treectrl
5292 // for label editing have id == 0, but they should _not_ be treated as menu
5293 // messages (they are EN_XXX ones, in fact) so don't translate anything
5294 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
5295 if ( !control )
5296 {
5297 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED, id);
5298 event.SetEventObject(this);
5299 event.SetInt(id);
5300
5301 return HandleWindowEvent(event);
5302 }
5303 else
5304 {
5305#if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
5306 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
5307 // notifications to its parent which we want to reflect back to
5308 // wxSpinCtrl
5309 wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
5310 if ( spin && spin->ProcessTextCommand(cmd, id) )
5311 return true;
5312#endif // wxUSE_SPINCTRL
5313
5314#if wxUSE_CHOICE && defined(__SMARTPHONE__)
5315 // the listbox ctrl which is logically part of wxChoice sends WM_COMMAND
5316 // notifications to its parent which we want to reflect back to
5317 // wxChoice
5318 wxChoice *choice = wxChoice::GetChoiceForListBox(control);
5319 if ( choice && choice->MSWCommand(cmd, id) )
5320 return true;
5321#endif
5322 }
5323
5324 return false;
5325}
5326
5327// ---------------------------------------------------------------------------
5328// mouse events
5329// ---------------------------------------------------------------------------
5330
5331void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
5332 int x, int y,
5333 WXUINT flags)
5334{
5335 // our client coords are not quite the same as Windows ones
5336 wxPoint pt = GetClientAreaOrigin();
5337 event.m_x = x - pt.x;
5338 event.m_y = y - pt.y;
5339
5340 event.m_shiftDown = (flags & MK_SHIFT) != 0;
5341 event.m_controlDown = (flags & MK_CONTROL) != 0;
5342 event.m_leftDown = (flags & MK_LBUTTON) != 0;
5343 event.m_middleDown = (flags & MK_MBUTTON) != 0;
5344 event.m_rightDown = (flags & MK_RBUTTON) != 0;
5345#ifdef wxHAS_XBUTTON
5346 event.m_aux1Down = (flags & MK_XBUTTON1) != 0;
5347 event.m_aux2Down = (flags & MK_XBUTTON2) != 0;
5348#endif // wxHAS_XBUTTON
5349 event.m_altDown = ::wxIsAltDown();
5350
5351#ifndef __WXWINCE__
5352 event.SetTimestamp(::GetMessageTime());
5353#endif
5354
5355 event.SetEventObject(this);
5356 event.SetId(GetId());
5357
5358#if wxUSE_MOUSEEVENT_HACK
5359 gs_lastMouseEvent.pos = ClientToScreen(wxPoint(x, y));
5360 gs_lastMouseEvent.type = event.GetEventType();
5361#endif // wxUSE_MOUSEEVENT_HACK
5362}
5363
5364#ifdef __WXWINCE__
5365// Windows doesn't send the mouse events to the static controls (which are
5366// transparent in the sense that their WM_NCHITTEST handler returns
5367// HTTRANSPARENT) at all but we want all controls to receive the mouse events
5368// and so we manually check if we don't have a child window under mouse and if
5369// we do, send the event to it instead of the window Windows had sent WM_XXX
5370// to.
5371//
5372// Notice that this is not done for the mouse move events because this could
5373// (would?) be too slow, but only for clicks which means that the static texts
5374// still don't get move, enter nor leave events.
5375static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y)
5376{
5377 wxCHECK_MSG( x && y, win, wxT("NULL pointer in FindWindowForMouseEvent") );
5378
5379 // first try to find a non transparent child: this allows us to send events
5380 // to a static text which is inside a static box, for example
5381 POINT pt = { *x, *y };
5382 HWND hwnd = GetHwndOf(win),
5383 hwndUnderMouse;
5384
5385#ifdef __WXWINCE__
5386 hwndUnderMouse = ::ChildWindowFromPoint
5387 (
5388 hwnd,
5389 pt
5390 );
5391#else
5392 hwndUnderMouse = ::ChildWindowFromPointEx
5393 (
5394 hwnd,
5395 pt,
5396 CWP_SKIPINVISIBLE |
5397 CWP_SKIPDISABLED |
5398 CWP_SKIPTRANSPARENT
5399 );
5400#endif
5401
5402 if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
5403 {
5404 // now try any child window at all
5405 hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
5406 }
5407
5408 // check that we have a child window which is susceptible to receive mouse
5409 // events: for this it must be shown and enabled
5410 if ( hwndUnderMouse &&
5411 hwndUnderMouse != hwnd &&
5412 ::IsWindowVisible(hwndUnderMouse) &&
5413 ::IsWindowEnabled(hwndUnderMouse) )
5414 {
5415 wxWindow *winUnderMouse = wxFindWinFromHandle(hwndUnderMouse);
5416 if ( winUnderMouse )
5417 {
5418 // translate the mouse coords to the other window coords
5419 win->ClientToScreen(x, y);
5420 winUnderMouse->ScreenToClient(x, y);
5421
5422 win = winUnderMouse;
5423 }
5424 }
5425
5426 return win;
5427}
5428#endif // __WXWINCE__
5429
5430bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
5431{
5432 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
5433 // WM_MOUSELAST, so it's enough to subtract WM_MOUSEMOVE == WM_MOUSEFIRST
5434 // from the message id and take the value in the table to get wxWin event
5435 // id
5436 static const wxEventType eventsMouse[] =
5437 {
5438 wxEVT_MOTION,
5439 wxEVT_LEFT_DOWN,
5440 wxEVT_LEFT_UP,
5441 wxEVT_LEFT_DCLICK,
5442 wxEVT_RIGHT_DOWN,
5443 wxEVT_RIGHT_UP,
5444 wxEVT_RIGHT_DCLICK,
5445 wxEVT_MIDDLE_DOWN,
5446 wxEVT_MIDDLE_UP,
5447 wxEVT_MIDDLE_DCLICK,
5448 0, // this one is for wxEVT_MOTION which is not used here
5449 wxEVT_AUX1_DOWN,
5450 wxEVT_AUX1_UP,
5451 wxEVT_AUX1_DCLICK,
5452 wxEVT_AUX2_DOWN,
5453 wxEVT_AUX2_UP,
5454 wxEVT_AUX2_DCLICK
5455 };
5456
5457#ifdef wxHAS_XBUTTON
5458 // the same messages are used for both auxiliary mouse buttons so we need
5459 // to adjust the index manually
5460 switch ( msg )
5461 {
5462 case WM_XBUTTONDOWN:
5463 case WM_XBUTTONUP:
5464 case WM_XBUTTONDBLCLK:
5465 if ( flags & MK_XBUTTON2 )
5466 msg += wxEVT_AUX2_DOWN - wxEVT_AUX1_DOWN;
5467 }
5468#endif // wxHAS_XBUTTON
5469
5470 wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
5471 InitMouseEvent(event, x, y, flags);
5472
5473 return HandleWindowEvent(event);
5474}
5475
5476bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
5477{
5478 if ( !m_mouseInWindow )
5479 {
5480 // it would be wrong to assume that just because we get a mouse move
5481 // event that the mouse is inside the window: although this is usually
5482 // true, it is not if we had captured the mouse, so we need to check
5483 // the mouse coordinates here
5484 if ( !HasCapture() || IsMouseInWindow() )
5485 {
5486 // Generate an ENTER event
5487 m_mouseInWindow = true;
5488
5489#ifdef HAVE_TRACKMOUSEEVENT
5490 typedef BOOL (WINAPI *_TrackMouseEvent_t)(LPTRACKMOUSEEVENT);
5491#ifdef __WXWINCE__
5492 static const _TrackMouseEvent_t
5493 s_pfn_TrackMouseEvent = _TrackMouseEvent;
5494#else // !__WXWINCE__
5495 static _TrackMouseEvent_t s_pfn_TrackMouseEvent;
5496 static bool s_initDone = false;
5497 if ( !s_initDone )
5498 {
5499 // see comment in wxApp::GetComCtl32Version() explaining the
5500 // use of wxLoadedDLL
5501 wxLoadedDLL dllComCtl32(wxT("comctl32.dll"));
5502 if ( dllComCtl32.IsLoaded() )
5503 {
5504 s_pfn_TrackMouseEvent = (_TrackMouseEvent_t)
5505 dllComCtl32.RawGetSymbol(wxT("_TrackMouseEvent"));
5506 }
5507
5508 s_initDone = true;
5509 }
5510
5511 if ( s_pfn_TrackMouseEvent )
5512#endif // __WXWINCE__/!__WXWINCE__
5513 {
5514 WinStruct<TRACKMOUSEEVENT> trackinfo;
5515
5516 trackinfo.dwFlags = TME_LEAVE;
5517 trackinfo.hwndTrack = GetHwnd();
5518
5519 (*s_pfn_TrackMouseEvent)(&trackinfo);
5520 }
5521#endif // HAVE_TRACKMOUSEEVENT
5522
5523 wxMouseEvent event(wxEVT_ENTER_WINDOW);
5524 InitMouseEvent(event, x, y, flags);
5525
5526 (void)HandleWindowEvent(event);
5527 }
5528 }
5529#ifdef HAVE_TRACKMOUSEEVENT
5530 else // mouse not in window
5531 {
5532 // Check if we need to send a LEAVE event
5533 // Windows doesn't send WM_MOUSELEAVE if the mouse has been captured so
5534 // send it here if we are using native mouse leave tracking
5535 if ( HasCapture() && !IsMouseInWindow() )
5536 {
5537 GenerateMouseLeave();
5538 }
5539 }
5540#endif // HAVE_TRACKMOUSEEVENT
5541
5542#if wxUSE_MOUSEEVENT_HACK
5543 // Windows often generates mouse events even if mouse position hasn't
5544 // changed (http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/66576)
5545 //
5546 // Filter this out as it can result in unexpected behaviour compared to
5547 // other platforms
5548 if ( gs_lastMouseEvent.type == wxEVT_RIGHT_DOWN ||
5549 gs_lastMouseEvent.type == wxEVT_LEFT_DOWN ||
5550 gs_lastMouseEvent.type == wxEVT_MIDDLE_DOWN ||
5551 gs_lastMouseEvent.type == wxEVT_MOTION )
5552 {
5553 if ( ClientToScreen(wxPoint(x, y)) == gs_lastMouseEvent.pos )
5554 {
5555 gs_lastMouseEvent.type = wxEVT_MOTION;
5556
5557 return false;
5558 }
5559 }
5560#endif // wxUSE_MOUSEEVENT_HACK
5561
5562 return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
5563}
5564
5565
5566bool
5567wxWindowMSW::HandleMouseWheel(wxMouseWheelAxis axis,
5568 WXWPARAM wParam, WXLPARAM lParam)
5569{
5570#if wxUSE_MOUSEWHEEL
5571 // notice that WM_MOUSEWHEEL position is in screen coords (as it's
5572 // forwarded up to the parent by DefWindowProc()) and not in the client
5573 // ones as all the other messages, translate them to the client coords for
5574 // consistency
5575 const wxPoint
5576 pt = ScreenToClient(wxPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)));
5577 wxMouseEvent event(wxEVT_MOUSEWHEEL);
5578 InitMouseEvent(event, pt.x, pt.y, LOWORD(wParam));
5579 event.m_wheelRotation = (short)HIWORD(wParam);
5580 event.m_wheelDelta = WHEEL_DELTA;
5581 event.m_wheelAxis = axis;
5582
5583 static int s_linesPerRotation = -1;
5584 if ( s_linesPerRotation == -1 )
5585 {
5586 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
5587 &s_linesPerRotation, 0))
5588 {
5589 // this is not supposed to happen
5590 wxLogLastError(wxT("SystemParametersInfo(GETWHEELSCROLLLINES)"));
5591
5592 // the default is 3, so use it if SystemParametersInfo() failed
5593 s_linesPerRotation = 3;
5594 }
5595 }
5596
5597 event.m_linesPerAction = s_linesPerRotation;
5598 return HandleWindowEvent(event);
5599
5600#else // !wxUSE_MOUSEWHEEL
5601 wxUnusedVar(wParam);
5602 wxUnusedVar(lParam);
5603
5604 return false;
5605#endif // wxUSE_MOUSEWHEEL/!wxUSE_MOUSEWHEEL
5606}
5607
5608void wxWindowMSW::GenerateMouseLeave()
5609{
5610 m_mouseInWindow = false;
5611
5612 int state = 0;
5613 if ( wxIsShiftDown() )
5614 state |= MK_SHIFT;
5615 if ( wxIsCtrlDown() )
5616 state |= MK_CONTROL;
5617
5618 // Only the high-order bit should be tested
5619 if ( GetKeyState( VK_LBUTTON ) & (1<<15) )
5620 state |= MK_LBUTTON;
5621 if ( GetKeyState( VK_MBUTTON ) & (1<<15) )
5622 state |= MK_MBUTTON;
5623 if ( GetKeyState( VK_RBUTTON ) & (1<<15) )
5624 state |= MK_RBUTTON;
5625
5626 POINT pt;
5627 wxGetCursorPosMSW(&pt);
5628
5629 // we need to have client coordinates here for symmetry with
5630 // wxEVT_ENTER_WINDOW
5631 RECT rect = wxGetWindowRect(GetHwnd());
5632 pt.x -= rect.left;
5633 pt.y -= rect.top;
5634
5635 wxMouseEvent event(wxEVT_LEAVE_WINDOW);
5636 InitMouseEvent(event, pt.x, pt.y, state);
5637
5638 (void)HandleWindowEvent(event);
5639}
5640
5641// ---------------------------------------------------------------------------
5642// keyboard handling
5643// ---------------------------------------------------------------------------
5644
5645namespace
5646{
5647
5648// Implementation of InitAnyKeyEvent() which can also be used when there is no
5649// associated window: this can happen for the wxEVT_CHAR_HOOK events created by
5650// the global keyboard hook (e.g. the event might have happened in a non-wx
5651// window).
5652void
5653MSWInitAnyKeyEvent(wxKeyEvent& event,
5654 WXWPARAM wParam,
5655 WXLPARAM lParam,
5656 const wxWindowBase *win /* may be NULL */)
5657{
5658 if ( win )
5659 {
5660 event.SetId(win->GetId());
5661 event.SetEventObject(const_cast<wxWindowBase *>(win));
5662 }
5663 else // No associated window.
5664 {
5665 // Use wxID_ANY for compatibility with the old code even if wxID_NONE
5666 // would arguably make more sense.
5667 event.SetId(wxID_ANY);
5668 }
5669
5670 event.m_shiftDown = wxIsShiftDown();
5671 event.m_controlDown = wxIsCtrlDown();
5672 event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
5673
5674 event.m_rawCode = (wxUint32) wParam;
5675 event.m_rawFlags = (wxUint32) lParam;
5676#ifndef __WXWINCE__
5677 event.SetTimestamp(::GetMessageTime());
5678#endif
5679}
5680
5681} // anonymous namespace
5682
5683void
5684wxWindowMSW::InitAnyKeyEvent(wxKeyEvent& event,
5685 WXWPARAM wParam,
5686 WXLPARAM lParam) const
5687{
5688 MSWInitAnyKeyEvent(event, wParam, lParam, this);
5689}
5690
5691wxKeyEvent
5692wxWindowMSW::CreateKeyEvent(wxEventType evType,
5693 WXWPARAM wParam,
5694 WXLPARAM lParam) const
5695{
5696 // Catch any attempts to use this with WM_CHAR, it wouldn't work because
5697 // wParam is supposed to be a virtual key and not a character here.
5698 wxASSERT_MSG( evType != wxEVT_CHAR && evType != wxEVT_CHAR_HOOK,
5699 "CreateKeyEvent() can't be used for char events" );
5700
5701 wxKeyEvent event(evType);
5702 InitAnyKeyEvent(event, wParam, lParam);
5703
5704 event.m_keyCode = wxMSWKeyboard::VKToWX
5705 (
5706 wParam,
5707 lParam
5708#if wxUSE_UNICODE
5709 , &event.m_uniChar
5710#endif // wxUSE_UNICODE
5711 );
5712
5713 return event;
5714}
5715
5716wxKeyEvent
5717wxWindowMSW::CreateCharEvent(wxEventType evType,
5718 WXWPARAM wParam,
5719 WXLPARAM lParam) const
5720{
5721 wxKeyEvent event(evType);
5722 InitAnyKeyEvent(event, wParam, lParam);
5723
5724#if wxUSE_UNICODE
5725 // TODO: wParam uses UTF-16 so this is incorrect for characters outside of
5726 // the BMP, we should use WM_UNICHAR to handle them.
5727 event.m_uniChar = wParam;
5728#endif // wxUSE_UNICODE
5729
5730 // Set non-Unicode key code too for compatibility if possible.
5731 if ( wParam < 0x80 )
5732 {
5733 // It's an ASCII character, no need to translate it.
5734 event.m_keyCode = wParam;
5735 }
5736 else
5737 {
5738 // Check if this key can be represented (as a single character) in the
5739 // current locale.
5740 const wchar_t wc = wParam;
5741 char ch;
5742 if ( wxConvLibc.FromWChar(&ch, 1, &wc, 1) != wxCONV_FAILED )
5743 {
5744 // For compatibility continue to provide the key code in this field
5745 // even though using GetUnicodeKey() is recommended now.
5746 event.m_keyCode = static_cast<unsigned char>(ch);
5747 }
5748 //else: Key can't be represented in the current locale, leave m_keyCode
5749 // as WXK_NONE and use GetUnicodeKey() to access the character.
5750 }
5751
5752 // the alphanumeric keys produced by pressing AltGr+something on European
5753 // keyboards have both Ctrl and Alt modifiers which may confuse the user
5754 // code as, normally, keys with Ctrl and/or Alt don't result in anything
5755 // alphanumeric, so pretend that there are no modifiers at all (the
5756 // KEY_DOWN event would still have the correct modifiers if they're really
5757 // needed)
5758 if ( event.m_controlDown && event.m_altDown &&
5759 (event.m_keyCode >= 32 && event.m_keyCode < 256) )
5760 {
5761 event.m_controlDown =
5762 event.m_altDown = false;
5763 }
5764
5765 return event;
5766}
5767
5768// isASCII is true only when we're called from WM_CHAR handler and not from
5769// WM_KEYDOWN one
5770bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam)
5771{
5772 wxKeyEvent event(CreateCharEvent(wxEVT_CHAR, wParam, lParam));
5773 return HandleWindowEvent(event);
5774}
5775
5776bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
5777{
5778 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, wParam, lParam));
5779 return HandleWindowEvent(event);
5780}
5781
5782bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
5783{
5784 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, wParam, lParam));
5785 return HandleWindowEvent(event);
5786}
5787
5788#if wxUSE_MENUS
5789int wxWindowMSW::HandleMenuChar(int WXUNUSED_IN_WINCE(chAccel),
5790 WXLPARAM WXUNUSED_IN_WINCE(lParam))
5791{
5792 // FIXME: implement GetMenuItemCount for WinCE, possibly
5793 // in terms of GetMenuItemInfo
5794#ifndef __WXWINCE__
5795 const HMENU hmenu = (HMENU)lParam;
5796
5797 WinStruct<MENUITEMINFO> mii;
5798
5799 // we could use MIIM_FTYPE here as we only need to know if the item is
5800 // ownerdrawn or not and not dwTypeData which MIIM_TYPE also returns, but
5801 // MIIM_FTYPE is not supported under Win95
5802 mii.fMask = MIIM_TYPE | MIIM_DATA;
5803
5804 // find if we have this letter in any owner drawn item
5805 const int count = ::GetMenuItemCount(hmenu);
5806 for ( int i = 0; i < count; i++ )
5807 {
5808 // previous loop iteration could modify it, reset it back before
5809 // calling GetMenuItemInfo() to prevent it from overflowing dwTypeData
5810 mii.cch = 0;
5811
5812 if ( ::GetMenuItemInfo(hmenu, i, TRUE, &mii) )
5813 {
5814 if ( mii.fType == MFT_OWNERDRAW )
5815 {
5816 // dwItemData member of the MENUITEMINFO is a
5817 // pointer to the associated wxMenuItem -- see the
5818 // menu creation code
5819 wxMenuItem *item = (wxMenuItem*)mii.dwItemData;
5820
5821 const wxString label(item->GetItemLabel());
5822 const wxChar *p = wxStrchr(label.t_str(), wxT('&'));
5823 while ( p++ )
5824 {
5825 if ( *p == wxT('&') )
5826 {
5827 // this is not the accel char, find the real one
5828 p = wxStrchr(p + 1, wxT('&'));
5829 }
5830 else // got the accel char
5831 {
5832 // FIXME-UNICODE: this comparison doesn't risk to work
5833 // for non ASCII accelerator characters I'm afraid, but
5834 // what can we do?
5835 if ( (wchar_t)wxToupper(*p) == (wchar_t)chAccel )
5836 {
5837 return i;
5838 }
5839 else
5840 {
5841 // this one doesn't match
5842 break;
5843 }
5844 }
5845 }
5846 }
5847 }
5848 else // failed to get the menu text?
5849 {
5850 // it's not fatal, so don't show error, but still log it
5851 wxLogLastError(wxT("GetMenuItemInfo"));
5852 }
5853 }
5854#endif
5855 return wxNOT_FOUND;
5856}
5857
5858#endif // wxUSE_MENUS
5859
5860bool wxWindowMSW::HandleClipboardEvent(WXUINT nMsg)
5861{
5862 const wxEventType type = nMsg == WM_CUT ? wxEVT_COMMAND_TEXT_CUT
5863 : nMsg == WM_COPY ? wxEVT_COMMAND_TEXT_COPY
5864 : /* nMsg == WM_PASTE */ wxEVT_COMMAND_TEXT_PASTE;
5865 wxClipboardTextEvent evt(type, GetId());
5866
5867 evt.SetEventObject(this);
5868
5869 return HandleWindowEvent(evt);
5870}
5871
5872// ---------------------------------------------------------------------------
5873// joystick
5874// ---------------------------------------------------------------------------
5875
5876bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
5877{
5878#ifdef JOY_BUTTON1
5879 int change = 0;
5880 if ( flags & JOY_BUTTON1CHG )
5881 change = wxJOY_BUTTON1;
5882 if ( flags & JOY_BUTTON2CHG )
5883 change = wxJOY_BUTTON2;
5884 if ( flags & JOY_BUTTON3CHG )
5885 change = wxJOY_BUTTON3;
5886 if ( flags & JOY_BUTTON4CHG )
5887 change = wxJOY_BUTTON4;
5888
5889 int buttons = 0;
5890 if ( flags & JOY_BUTTON1 )
5891 buttons |= wxJOY_BUTTON1;
5892 if ( flags & JOY_BUTTON2 )
5893 buttons |= wxJOY_BUTTON2;
5894 if ( flags & JOY_BUTTON3 )
5895 buttons |= wxJOY_BUTTON3;
5896 if ( flags & JOY_BUTTON4 )
5897 buttons |= wxJOY_BUTTON4;
5898
5899 // the event ids aren't consecutive so we can't use table based lookup
5900 int joystick;
5901 wxEventType eventType;
5902 switch ( msg )
5903 {
5904 case MM_JOY1MOVE:
5905 joystick = 1;
5906 eventType = wxEVT_JOY_MOVE;
5907 break;
5908
5909 case MM_JOY2MOVE:
5910 joystick = 2;
5911 eventType = wxEVT_JOY_MOVE;
5912 break;
5913
5914 case MM_JOY1ZMOVE:
5915 joystick = 1;
5916 eventType = wxEVT_JOY_ZMOVE;
5917 break;
5918
5919 case MM_JOY2ZMOVE:
5920 joystick = 2;
5921 eventType = wxEVT_JOY_ZMOVE;
5922 break;
5923
5924 case MM_JOY1BUTTONDOWN:
5925 joystick = 1;
5926 eventType = wxEVT_JOY_BUTTON_DOWN;
5927 break;
5928
5929 case MM_JOY2BUTTONDOWN:
5930 joystick = 2;
5931 eventType = wxEVT_JOY_BUTTON_DOWN;
5932 break;
5933
5934 case MM_JOY1BUTTONUP:
5935 joystick = 1;
5936 eventType = wxEVT_JOY_BUTTON_UP;
5937 break;
5938
5939 case MM_JOY2BUTTONUP:
5940 joystick = 2;
5941 eventType = wxEVT_JOY_BUTTON_UP;
5942 break;
5943
5944 default:
5945 wxFAIL_MSG(wxT("no such joystick event"));
5946
5947 return false;
5948 }
5949
5950 wxJoystickEvent event(eventType, buttons, joystick, change);
5951 if ( eventType == wxEVT_JOY_ZMOVE )
5952 event.SetZPosition(x);
5953 else
5954 event.SetPosition(wxPoint(x, y));
5955 event.SetEventObject(this);
5956
5957 return HandleWindowEvent(event);
5958#else
5959 wxUnusedVar(msg);
5960 wxUnusedVar(x);
5961 wxUnusedVar(y);
5962 wxUnusedVar(flags);
5963 return false;
5964#endif
5965}
5966
5967// ---------------------------------------------------------------------------
5968// scrolling
5969// ---------------------------------------------------------------------------
5970
5971bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
5972 WXWORD pos, WXHWND control)
5973{
5974 if ( control && control != m_hWnd ) // Prevent infinite recursion
5975 {
5976 wxWindow *child = wxFindWinFromHandle(control);
5977 if ( child )
5978 return child->MSWOnScroll(orientation, wParam, pos, control);
5979 }
5980
5981 wxScrollWinEvent event;
5982 event.SetPosition(pos);
5983 event.SetOrientation(orientation);
5984 event.SetEventObject(this);
5985
5986 switch ( wParam )
5987 {
5988 case SB_TOP:
5989 event.SetEventType(wxEVT_SCROLLWIN_TOP);
5990 break;
5991
5992 case SB_BOTTOM:
5993 event.SetEventType(wxEVT_SCROLLWIN_BOTTOM);
5994 break;
5995
5996 case SB_LINEUP:
5997 event.SetEventType(wxEVT_SCROLLWIN_LINEUP);
5998 break;
5999
6000 case SB_LINEDOWN:
6001 event.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);
6002 break;
6003
6004 case SB_PAGEUP:
6005 event.SetEventType(wxEVT_SCROLLWIN_PAGEUP);
6006 break;
6007
6008 case SB_PAGEDOWN:
6009 event.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);
6010 break;
6011
6012 case SB_THUMBPOSITION:
6013 case SB_THUMBTRACK:
6014 // under Win32, the scrollbar range and position are 32 bit integers,
6015 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
6016 // explicitly query the scrollbar for the correct position (this must
6017 // be done only for these two SB_ events as they are the only one
6018 // carrying the scrollbar position)
6019 {
6020 WinStruct<SCROLLINFO> scrollInfo;
6021 scrollInfo.fMask = SIF_TRACKPOS;
6022
6023 if ( !::GetScrollInfo(GetHwnd(),
6024 WXOrientToSB(orientation),
6025 &scrollInfo) )
6026 {
6027 // Not necessarily an error, if there are no scrollbars yet.
6028 // wxLogLastError(wxT("GetScrollInfo"));
6029 }
6030
6031 event.SetPosition(scrollInfo.nTrackPos);
6032 }
6033
6034 event.SetEventType( wParam == SB_THUMBPOSITION
6035 ? wxEVT_SCROLLWIN_THUMBRELEASE
6036 : wxEVT_SCROLLWIN_THUMBTRACK );
6037 break;
6038
6039 default:
6040 return false;
6041 }
6042
6043 return HandleWindowEvent(event);
6044}
6045
6046// ----------------------------------------------------------------------------
6047// custom message handlers
6048// ----------------------------------------------------------------------------
6049
6050/* static */ bool
6051wxWindowMSW::MSWRegisterMessageHandler(int msg, MSWMessageHandler handler)
6052{
6053 wxCHECK_MSG( gs_messageHandlers.find(msg) == gs_messageHandlers.end(),
6054 false, wxT("registering handler for the same message twice") );
6055
6056 gs_messageHandlers[msg] = handler;
6057 return true;
6058}
6059
6060/* static */ void
6061wxWindowMSW::MSWUnregisterMessageHandler(int msg, MSWMessageHandler handler)
6062{
6063 const MSWMessageHandlers::iterator i = gs_messageHandlers.find(msg);
6064 wxCHECK_RET( i != gs_messageHandlers.end() && i->second == handler,
6065 wxT("unregistering non-registered handler?") );
6066
6067 gs_messageHandlers.erase(i);
6068}
6069
6070// ===========================================================================
6071// global functions
6072// ===========================================================================
6073
6074void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont& the_font)
6075{
6076 TEXTMETRIC tm;
6077 HDC dc = ::GetDC((HWND) wnd);
6078 HFONT was = 0;
6079
6080 // the_font.UseResource();
6081 // the_font.RealizeResource();
6082 HFONT fnt = (HFONT)the_font.GetResourceHandle(); // const_cast
6083 if ( fnt )
6084 was = (HFONT) SelectObject(dc,fnt);
6085
6086 GetTextMetrics(dc, &tm);
6087 if ( fnt && was )
6088 {
6089 SelectObject(dc,was);
6090 }
6091 ReleaseDC((HWND)wnd, dc);
6092
6093 if ( x )
6094 *x = tm.tmAveCharWidth;
6095 if ( y )
6096 *y = tm.tmHeight + tm.tmExternalLeading;
6097
6098 // the_font.ReleaseResource();
6099}
6100
6101// ----------------------------------------------------------------------------
6102// keyboard codes
6103// ----------------------------------------------------------------------------
6104
6105namespace wxMSWKeyboard
6106{
6107
6108namespace
6109{
6110
6111// use the "extended" bit of lParam to distinguish extended keys from normal
6112// keys as the same virtual key code is sent for both by Windows
6113inline
6114int ChooseNormalOrExtended(int lParam, int keyNormal, int keyExtended)
6115{
6116 // except that if lParam is 0, it means we don't have real lParam from
6117 // WM_KEYDOWN but are just translating just a VK constant (e.g. done from
6118 // msw/treectrl.cpp when processing TVN_KEYDOWN) -- then assume this is a
6119 // non-numpad (hence extended) key as this is a more common case
6120 return !lParam || (HIWORD(lParam) & KF_EXTENDED) ? keyExtended : keyNormal;
6121}
6122
6123// this array contains the Windows virtual key codes which map one to one to
6124// WXK_xxx constants and is used in wxMSWKeyboard::VKToWX/WXToVK() below
6125//
6126// note that keys having a normal and numpad version (e.g. WXK_HOME and
6127// WXK_NUMPAD_HOME) are not included in this table as the mapping is not 1-to-1
6128const struct wxKeyMapping
6129{
6130 int vk;
6131 wxKeyCode wxk;
6132} gs_specialKeys[] =
6133{
6134 { VK_CANCEL, WXK_CANCEL },
6135 { VK_BACK, WXK_BACK },
6136 { VK_TAB, WXK_TAB },
6137 { VK_CLEAR, WXK_CLEAR },
6138 { VK_SHIFT, WXK_SHIFT },
6139 { VK_CONTROL, WXK_CONTROL },
6140 { VK_MENU , WXK_ALT },
6141 { VK_PAUSE, WXK_PAUSE },
6142 { VK_CAPITAL, WXK_CAPITAL },
6143 { VK_SPACE, WXK_SPACE },
6144 { VK_ESCAPE, WXK_ESCAPE },
6145 { VK_SELECT, WXK_SELECT },
6146 { VK_PRINT, WXK_PRINT },
6147 { VK_EXECUTE, WXK_EXECUTE },
6148 { VK_SNAPSHOT, WXK_SNAPSHOT },
6149 { VK_HELP, WXK_HELP },
6150
6151 { VK_NUMPAD0, WXK_NUMPAD0 },
6152 { VK_NUMPAD1, WXK_NUMPAD1 },
6153 { VK_NUMPAD2, WXK_NUMPAD2 },
6154 { VK_NUMPAD3, WXK_NUMPAD3 },
6155 { VK_NUMPAD4, WXK_NUMPAD4 },
6156 { VK_NUMPAD5, WXK_NUMPAD5 },
6157 { VK_NUMPAD6, WXK_NUMPAD6 },
6158 { VK_NUMPAD7, WXK_NUMPAD7 },
6159 { VK_NUMPAD8, WXK_NUMPAD8 },
6160 { VK_NUMPAD9, WXK_NUMPAD9 },
6161 { VK_MULTIPLY, WXK_NUMPAD_MULTIPLY },
6162 { VK_ADD, WXK_NUMPAD_ADD },
6163 { VK_SUBTRACT, WXK_NUMPAD_SUBTRACT },
6164 { VK_DECIMAL, WXK_NUMPAD_DECIMAL },
6165 { VK_DIVIDE, WXK_NUMPAD_DIVIDE },
6166
6167 { VK_F1, WXK_F1 },
6168 { VK_F2, WXK_F2 },
6169 { VK_F3, WXK_F3 },
6170 { VK_F4, WXK_F4 },
6171 { VK_F5, WXK_F5 },
6172 { VK_F6, WXK_F6 },
6173 { VK_F7, WXK_F7 },
6174 { VK_F8, WXK_F8 },
6175 { VK_F9, WXK_F9 },
6176 { VK_F10, WXK_F10 },
6177 { VK_F11, WXK_F11 },
6178 { VK_F12, WXK_F12 },
6179 { VK_F13, WXK_F13 },
6180 { VK_F14, WXK_F14 },
6181 { VK_F15, WXK_F15 },
6182 { VK_F16, WXK_F16 },
6183 { VK_F17, WXK_F17 },
6184 { VK_F18, WXK_F18 },
6185 { VK_F19, WXK_F19 },
6186 { VK_F20, WXK_F20 },
6187 { VK_F21, WXK_F21 },
6188 { VK_F22, WXK_F22 },
6189 { VK_F23, WXK_F23 },
6190 { VK_F24, WXK_F24 },
6191
6192 { VK_NUMLOCK, WXK_NUMLOCK },
6193 { VK_SCROLL, WXK_SCROLL },
6194
6195#ifdef VK_APPS
6196 { VK_LWIN, WXK_WINDOWS_LEFT },
6197 { VK_RWIN, WXK_WINDOWS_RIGHT },
6198 { VK_APPS, WXK_WINDOWS_MENU },
6199#endif // VK_APPS defined
6200};
6201
6202} // anonymous namespace
6203
6204int VKToWX(WXWORD vk, WXLPARAM lParam, wchar_t *uc)
6205{
6206 int wxk;
6207
6208 // check the table first
6209 for ( size_t n = 0; n < WXSIZEOF(gs_specialKeys); n++ )
6210 {
6211 if ( gs_specialKeys[n].vk == vk )
6212 {
6213 wxk = gs_specialKeys[n].wxk;
6214 if ( wxk < WXK_START )
6215 {
6216 // Unicode code for this key is the same as its ASCII code.
6217 if ( uc )
6218 *uc = wxk;
6219 }
6220
6221 return wxk;
6222 }
6223 }
6224
6225 // keys requiring special handling
6226 switch ( vk )
6227 {
6228 case VK_OEM_1:
6229 case VK_OEM_PLUS:
6230 case VK_OEM_COMMA:
6231 case VK_OEM_MINUS:
6232 case VK_OEM_PERIOD:
6233 case VK_OEM_2:
6234 case VK_OEM_3:
6235 case VK_OEM_4:
6236 case VK_OEM_5:
6237 case VK_OEM_6:
6238 case VK_OEM_7:
6239 case VK_OEM_102:
6240 // MapVirtualKey() returns 0 if it fails to convert the virtual
6241 // key which nicely corresponds to our WXK_NONE.
6242 wxk = ::MapVirtualKey(vk, MAPVK_VK_TO_CHAR);
6243
6244 if ( HIWORD(wxk) & 0x8000 )
6245 {
6246 // It's a dead key and we don't return anything at all for them
6247 // as we simply don't have any way to indicate the difference
6248 // between e.g. a normal "'" and "'" as a dead key -- and
6249 // generating the same events for them just doesn't seem like a
6250 // good idea.
6251 wxk = WXK_NONE;
6252 }
6253
6254 // In any case return this as a Unicode character value.
6255 if ( uc )
6256 *uc = wxk;
6257
6258 // For compatibility with the old non-Unicode code we continue
6259 // returning key codes for Latin-1 characters directly
6260 // (normally it would really only make sense to do it for the
6261 // ASCII characters, not Latin-1 ones).
6262 if ( wxk > 255 )
6263 {
6264 // But for anything beyond this we can only return the key
6265 // value as a real Unicode character, not a wxKeyCode
6266 // because this enum values clash with Unicode characters
6267 // (e.g. WXK_LBUTTON also happens to be U+012C a.k.a.
6268 // "LATIN CAPITAL LETTER I WITH BREVE").
6269 wxk = WXK_NONE;
6270 }
6271 break;
6272
6273 // handle extended keys
6274 case VK_PRIOR:
6275 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_PAGEUP, WXK_PAGEUP);
6276 break;
6277
6278 case VK_NEXT:
6279 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_PAGEDOWN, WXK_PAGEDOWN);
6280 break;
6281
6282 case VK_END:
6283 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_END, WXK_END);
6284 break;
6285
6286 case VK_HOME:
6287 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_HOME, WXK_HOME);
6288 break;
6289
6290 case VK_LEFT:
6291 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_LEFT, WXK_LEFT);
6292 break;
6293
6294 case VK_UP:
6295 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_UP, WXK_UP);
6296 break;
6297
6298 case VK_RIGHT:
6299 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_RIGHT, WXK_RIGHT);
6300 break;
6301
6302 case VK_DOWN:
6303 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_DOWN, WXK_DOWN);
6304 break;
6305
6306 case VK_INSERT:
6307 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_INSERT, WXK_INSERT);
6308 break;
6309
6310 case VK_DELETE:
6311 wxk = ChooseNormalOrExtended(lParam, WXK_NUMPAD_DELETE, WXK_DELETE);
6312 break;
6313
6314 case VK_RETURN:
6315 // don't use ChooseNormalOrExtended() here as the keys are reversed
6316 // here: numpad enter is the extended one
6317 wxk = HIWORD(lParam) & KF_EXTENDED ? WXK_NUMPAD_ENTER : WXK_RETURN;
6318
6319 if ( uc )
6320 *uc = WXK_RETURN;
6321 break;
6322
6323 default:
6324 if ( (vk >= '0' && vk <= '9') || (vk >= 'A' && vk <= 'Z') )
6325 {
6326 // A simple alphanumeric key and the values of them coincide in
6327 // Windows and wx for both ASCII and Unicode codes.
6328 wxk = vk;
6329 }
6330 else // Something we simply don't know about at all.
6331 {
6332 wxk = WXK_NONE;
6333 }
6334
6335 if ( uc )
6336 *uc = vk;
6337 }
6338
6339 return wxk;
6340}
6341
6342WXWORD WXToVK(int wxk, bool *isExtended)
6343{
6344 // check the table first
6345 for ( size_t n = 0; n < WXSIZEOF(gs_specialKeys); n++ )
6346 {
6347 if ( gs_specialKeys[n].wxk == wxk )
6348 {
6349 // All extended keys (i.e. non-numpad versions of the keys that
6350 // exist both in the numpad and outside of it) are dealt with
6351 // below.
6352 if ( isExtended )
6353 *isExtended = false;
6354
6355 return gs_specialKeys[n].vk;
6356 }
6357 }
6358
6359 // and then check for special keys not included in the table
6360 bool extended = false;
6361 WXWORD vk;
6362 switch ( wxk )
6363 {
6364 case WXK_PAGEUP:
6365 extended = true;
6366 case WXK_NUMPAD_PAGEUP:
6367 vk = VK_PRIOR;
6368 break;
6369
6370 case WXK_PAGEDOWN:
6371 extended = true;
6372 case WXK_NUMPAD_PAGEDOWN:
6373 vk = VK_NEXT;
6374 break;
6375
6376 case WXK_END:
6377 extended = true;
6378 case WXK_NUMPAD_END:
6379 vk = VK_END;
6380 break;
6381
6382 case WXK_HOME:
6383 extended = true;
6384 case WXK_NUMPAD_HOME:
6385 vk = VK_HOME;
6386 break;
6387
6388 case WXK_LEFT:
6389 extended = true;
6390 case WXK_NUMPAD_LEFT:
6391 vk = VK_LEFT;
6392 break;
6393
6394 case WXK_UP:
6395 extended = true;
6396 case WXK_NUMPAD_UP:
6397 vk = VK_UP;
6398 break;
6399
6400 case WXK_RIGHT:
6401 extended = true;
6402 case WXK_NUMPAD_RIGHT:
6403 vk = VK_RIGHT;
6404 break;
6405
6406 case WXK_DOWN:
6407 extended = true;
6408 case WXK_NUMPAD_DOWN:
6409 vk = VK_DOWN;
6410 break;
6411
6412 case WXK_INSERT:
6413 extended = true;
6414 case WXK_NUMPAD_INSERT:
6415 vk = VK_INSERT;
6416 break;
6417
6418 case WXK_DELETE:
6419 extended = true;
6420 case WXK_NUMPAD_DELETE:
6421 vk = VK_DELETE;
6422 break;
6423
6424 default:
6425 // no VkKeyScan() under CE unfortunately, we need to test how does
6426 // it handle OEM keys
6427#ifndef __WXWINCE__
6428 // check to see if its one of the OEM key codes.
6429 BYTE vks = LOBYTE(VkKeyScan(wxk));
6430 if ( vks != 0xff )
6431 {
6432 vk = vks;
6433 }
6434 else
6435#endif // !__WXWINCE__
6436 {
6437 vk = (WXWORD)wxk;
6438 }
6439 }
6440
6441 if ( isExtended )
6442 *isExtended = extended;
6443
6444 return vk;
6445}
6446
6447} // namespace wxMSWKeyboard
6448
6449// small helper for wxGetKeyState() and wxGetMouseState()
6450static inline bool wxIsKeyDown(WXWORD vk)
6451{
6452 // SM_SWAPBUTTON is not available under CE, so don't swap buttons there
6453#ifdef SM_SWAPBUTTON
6454 if ( vk == VK_LBUTTON || vk == VK_RBUTTON )
6455 {
6456 if ( ::GetSystemMetrics(SM_SWAPBUTTON) )
6457 {
6458 if ( vk == VK_LBUTTON )
6459 vk = VK_RBUTTON;
6460 else // vk == VK_RBUTTON
6461 vk = VK_LBUTTON;
6462 }
6463 }
6464#endif // SM_SWAPBUTTON
6465
6466 // the low order bit indicates whether the key was pressed since the last
6467 // call and the high order one indicates whether it is down right now and
6468 // we only want that one
6469 return (GetAsyncKeyState(vk) & (1<<15)) != 0;
6470}
6471
6472bool wxGetKeyState(wxKeyCode key)
6473{
6474 // although this does work under Windows, it is not supported under other
6475 // platforms so don't allow it, you must use wxGetMouseState() instead
6476 wxASSERT_MSG( key != VK_LBUTTON &&
6477 key != VK_RBUTTON &&
6478 key != VK_MBUTTON,
6479 wxT("can't use wxGetKeyState() for mouse buttons") );
6480
6481 const WXWORD vk = wxMSWKeyboard::WXToVK(key);
6482
6483 // if the requested key is a LED key, return true if the led is pressed
6484 if ( key == WXK_NUMLOCK || key == WXK_CAPITAL || key == WXK_SCROLL )
6485 {
6486 // low order bit means LED is highlighted and high order one means the
6487 // key is down; for compatibility with the other ports return true if
6488 // either one is set
6489 return GetKeyState(vk) != 0;
6490
6491 }
6492 else // normal key
6493 {
6494 return wxIsKeyDown(vk);
6495 }
6496}
6497
6498
6499wxMouseState wxGetMouseState()
6500{
6501 wxMouseState ms;
6502 POINT pt;
6503 wxGetCursorPosMSW(&pt);
6504
6505 ms.SetX(pt.x);
6506 ms.SetY(pt.y);
6507 ms.SetLeftDown(wxIsKeyDown(VK_LBUTTON));
6508 ms.SetMiddleDown(wxIsKeyDown(VK_MBUTTON));
6509 ms.SetRightDown(wxIsKeyDown(VK_RBUTTON));
6510#ifdef wxHAS_XBUTTON
6511 ms.SetAux1Down(wxIsKeyDown(VK_XBUTTON1));
6512 ms.SetAux2Down(wxIsKeyDown(VK_XBUTTON2));
6513#endif // wxHAS_XBUTTON
6514
6515 ms.SetControlDown(wxIsCtrlDown ());
6516 ms.SetShiftDown (wxIsShiftDown());
6517 ms.SetAltDown (wxIsAltDown ());
6518// ms.SetMetaDown();
6519
6520 return ms;
6521}
6522
6523
6524wxWindow *wxGetActiveWindow()
6525{
6526 HWND hWnd = GetActiveWindow();
6527 if ( hWnd != 0 )
6528 {
6529 return wxFindWinFromHandle(hWnd);
6530 }
6531 return NULL;
6532}
6533
6534extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
6535{
6536 HWND hwnd = (HWND)hWnd;
6537
6538 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
6539 // by code in msw/radiobox.cpp), for all the others we just search up the
6540 // window hierarchy
6541 wxWindow *win = NULL;
6542 if ( hwnd )
6543 {
6544 win = wxFindWinFromHandle(hwnd);
6545 if ( !win )
6546 {
6547#if wxUSE_RADIOBOX && !defined(__WXUNIVERSAL__)
6548 // native radiobuttons return DLGC_RADIOBUTTON here and for any
6549 // wxWindow class which overrides WM_GETDLGCODE processing to
6550 // do it as well, win would be already non NULL
6551 if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
6552 {
6553 win = wxRadioBox::GetFromRadioButtonHWND(hwnd);
6554 }
6555 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
6556#endif // wxUSE_RADIOBOX
6557
6558 // spin control text buddy window should be mapped to spin ctrl
6559 // itself so try it too
6560#if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
6561 if ( !win )
6562 {
6563 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
6564 }
6565#endif // wxUSE_SPINCTRL
6566 }
6567 }
6568
6569 while ( hwnd && !win )
6570 {
6571 // this is a really ugly hack needed to avoid mistakenly returning the
6572 // parent frame wxWindow for the find/replace modeless dialog HWND -
6573 // this, in turn, is needed to call IsDialogMessage() from
6574 // wxApp::ProcessMessage() as for this we must return NULL from here
6575 //
6576 // FIXME: this is clearly not the best way to do it but I think we'll
6577 // need to change HWND <-> wxWindow code more heavily than I can
6578 // do it now to fix it
6579#ifndef __WXMICROWIN__
6580 if ( ::GetWindow(hwnd, GW_OWNER) )
6581 {
6582 // it's a dialog box, don't go upwards
6583 break;
6584 }
6585#endif
6586
6587 hwnd = ::GetParent(hwnd);
6588 win = wxFindWinFromHandle(hwnd);
6589 }
6590
6591 return win;
6592}
6593
6594#if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
6595
6596// Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
6597// in active frames and dialogs, regardless of where the focus is.
6598static HHOOK wxTheKeyboardHook = 0;
6599
6600int APIENTRY
6601wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
6602{
6603 DWORD hiWord = HIWORD(lParam);
6604 if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
6605 {
6606 wchar_t uc;
6607 int id = wxMSWKeyboard::VKToWX(wParam, lParam, &uc);
6608
6609 // Don't intercept keyboard entry (notably Escape) if a modal window
6610 // (not managed by wx, e.g. IME one) is currently opened as more often
6611 // than not it needs all the keys for itself.
6612 //
6613 // Also don't catch it if a window currently captures the mouse as
6614 // Escape is normally used to release the mouse capture and if you
6615 // really need to catch all the keys in the window that has mouse
6616 // capture it can be easily done in its own EVT_CHAR handler as it is
6617 // certain to have focus while it has the capture.
6618 if ( !gs_modalEntryWindowCount && !::GetCapture() )
6619 {
6620 if ( id != WXK_NONE
6621#if wxUSE_UNICODE
6622 || static_cast<int>(uc) != WXK_NONE
6623#endif // wxUSE_UNICODE
6624 )
6625 {
6626 wxWindow const* win = wxWindow::DoFindFocus();
6627 if ( !win )
6628 {
6629 // Even if the focus got lost somehow, still send the event
6630 // to the top level parent to allow a wxDialog to always
6631 // close on Escape.
6632 win = wxGetActiveWindow();
6633 }
6634
6635 wxKeyEvent event(wxEVT_CHAR_HOOK);
6636 MSWInitAnyKeyEvent(event, wParam, lParam, win);
6637
6638 event.m_keyCode = id;
6639#if wxUSE_UNICODE
6640 event.m_uniChar = uc;
6641#endif // wxUSE_UNICODE
6642
6643 wxEvtHandler * const handler = win ? win->GetEventHandler()
6644 : wxTheApp;
6645
6646 if ( handler && handler->ProcessEvent(event) )
6647 {
6648 if ( !event.IsNextEventAllowed() )
6649 {
6650 // Stop processing of this event.
6651 return 1;
6652 }
6653 }
6654 }
6655 }
6656 }
6657
6658 return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
6659}
6660
6661void wxSetKeyboardHook(bool doIt)
6662{
6663 if ( doIt )
6664 {
6665 wxTheKeyboardHook = ::SetWindowsHookEx
6666 (
6667 WH_KEYBOARD,
6668 (HOOKPROC)wxKeyboardHook,
6669 NULL, // must be NULL for process hook
6670 ::GetCurrentThreadId()
6671 );
6672 if ( !wxTheKeyboardHook )
6673 {
6674 wxLogLastError(wxT("SetWindowsHookEx(wxKeyboardHook)"));
6675 }
6676 }
6677 else // uninstall
6678 {
6679 if ( wxTheKeyboardHook )
6680 ::UnhookWindowsHookEx(wxTheKeyboardHook);
6681 }
6682}
6683
6684#endif // !__WXMICROWIN__
6685
6686#if wxDEBUG_LEVEL >= 2
6687const wxChar *wxGetMessageName(int message)
6688{
6689 switch ( message )
6690 {
6691 case 0x0000: return wxT("WM_NULL");
6692 case 0x0001: return wxT("WM_CREATE");
6693 case 0x0002: return wxT("WM_DESTROY");
6694 case 0x0003: return wxT("WM_MOVE");
6695 case 0x0005: return wxT("WM_SIZE");
6696 case 0x0006: return wxT("WM_ACTIVATE");
6697 case 0x0007: return wxT("WM_SETFOCUS");
6698 case 0x0008: return wxT("WM_KILLFOCUS");
6699 case 0x000A: return wxT("WM_ENABLE");
6700 case 0x000B: return wxT("WM_SETREDRAW");
6701 case 0x000C: return wxT("WM_SETTEXT");
6702 case 0x000D: return wxT("WM_GETTEXT");
6703 case 0x000E: return wxT("WM_GETTEXTLENGTH");
6704 case 0x000F: return wxT("WM_PAINT");
6705 case 0x0010: return wxT("WM_CLOSE");
6706 case 0x0011: return wxT("WM_QUERYENDSESSION");
6707 case 0x0012: return wxT("WM_QUIT");
6708 case 0x0013: return wxT("WM_QUERYOPEN");
6709 case 0x0014: return wxT("WM_ERASEBKGND");
6710 case 0x0015: return wxT("WM_SYSCOLORCHANGE");
6711 case 0x0016: return wxT("WM_ENDSESSION");
6712 case 0x0017: return wxT("WM_SYSTEMERROR");
6713 case 0x0018: return wxT("WM_SHOWWINDOW");
6714 case 0x0019: return wxT("WM_CTLCOLOR");
6715 case 0x001A: return wxT("WM_WININICHANGE");
6716 case 0x001B: return wxT("WM_DEVMODECHANGE");
6717 case 0x001C: return wxT("WM_ACTIVATEAPP");
6718 case 0x001D: return wxT("WM_FONTCHANGE");
6719 case 0x001E: return wxT("WM_TIMECHANGE");
6720 case 0x001F: return wxT("WM_CANCELMODE");
6721 case 0x0020: return wxT("WM_SETCURSOR");
6722 case 0x0021: return wxT("WM_MOUSEACTIVATE");
6723 case 0x0022: return wxT("WM_CHILDACTIVATE");
6724 case 0x0023: return wxT("WM_QUEUESYNC");
6725 case 0x0024: return wxT("WM_GETMINMAXINFO");
6726 case 0x0026: return wxT("WM_PAINTICON");
6727 case 0x0027: return wxT("WM_ICONERASEBKGND");
6728 case 0x0028: return wxT("WM_NEXTDLGCTL");
6729 case 0x002A: return wxT("WM_SPOOLERSTATUS");
6730 case 0x002B: return wxT("WM_DRAWITEM");
6731 case 0x002C: return wxT("WM_MEASUREITEM");
6732 case 0x002D: return wxT("WM_DELETEITEM");
6733 case 0x002E: return wxT("WM_VKEYTOITEM");
6734 case 0x002F: return wxT("WM_CHARTOITEM");
6735 case 0x0030: return wxT("WM_SETFONT");
6736 case 0x0031: return wxT("WM_GETFONT");
6737 case 0x0037: return wxT("WM_QUERYDRAGICON");
6738 case 0x0039: return wxT("WM_COMPAREITEM");
6739 case 0x0041: return wxT("WM_COMPACTING");
6740 case 0x0044: return wxT("WM_COMMNOTIFY");
6741 case 0x0046: return wxT("WM_WINDOWPOSCHANGING");
6742 case 0x0047: return wxT("WM_WINDOWPOSCHANGED");
6743 case 0x0048: return wxT("WM_POWER");
6744
6745 case 0x004A: return wxT("WM_COPYDATA");
6746 case 0x004B: return wxT("WM_CANCELJOURNAL");
6747 case 0x004E: return wxT("WM_NOTIFY");
6748 case 0x0050: return wxT("WM_INPUTLANGCHANGEREQUEST");
6749 case 0x0051: return wxT("WM_INPUTLANGCHANGE");
6750 case 0x0052: return wxT("WM_TCARD");
6751 case 0x0053: return wxT("WM_HELP");
6752 case 0x0054: return wxT("WM_USERCHANGED");
6753 case 0x0055: return wxT("WM_NOTIFYFORMAT");
6754 case 0x007B: return wxT("WM_CONTEXTMENU");
6755 case 0x007C: return wxT("WM_STYLECHANGING");
6756 case 0x007D: return wxT("WM_STYLECHANGED");
6757 case 0x007E: return wxT("WM_DISPLAYCHANGE");
6758 case 0x007F: return wxT("WM_GETICON");
6759 case 0x0080: return wxT("WM_SETICON");
6760
6761 case 0x0081: return wxT("WM_NCCREATE");
6762 case 0x0082: return wxT("WM_NCDESTROY");
6763 case 0x0083: return wxT("WM_NCCALCSIZE");
6764 case 0x0084: return wxT("WM_NCHITTEST");
6765 case 0x0085: return wxT("WM_NCPAINT");
6766 case 0x0086: return wxT("WM_NCACTIVATE");
6767 case 0x0087: return wxT("WM_GETDLGCODE");
6768 case 0x00A0: return wxT("WM_NCMOUSEMOVE");
6769 case 0x00A1: return wxT("WM_NCLBUTTONDOWN");
6770 case 0x00A2: return wxT("WM_NCLBUTTONUP");
6771 case 0x00A3: return wxT("WM_NCLBUTTONDBLCLK");
6772 case 0x00A4: return wxT("WM_NCRBUTTONDOWN");
6773 case 0x00A5: return wxT("WM_NCRBUTTONUP");
6774 case 0x00A6: return wxT("WM_NCRBUTTONDBLCLK");
6775 case 0x00A7: return wxT("WM_NCMBUTTONDOWN");
6776 case 0x00A8: return wxT("WM_NCMBUTTONUP");
6777 case 0x00A9: return wxT("WM_NCMBUTTONDBLCLK");
6778
6779 case 0x00B0: return wxT("EM_GETSEL");
6780 case 0x00B1: return wxT("EM_SETSEL");
6781 case 0x00B2: return wxT("EM_GETRECT");
6782 case 0x00B3: return wxT("EM_SETRECT");
6783 case 0x00B4: return wxT("EM_SETRECTNP");
6784 case 0x00B5: return wxT("EM_SCROLL");
6785 case 0x00B6: return wxT("EM_LINESCROLL");
6786 case 0x00B7: return wxT("EM_SCROLLCARET");
6787 case 0x00B8: return wxT("EM_GETMODIFY");
6788 case 0x00B9: return wxT("EM_SETMODIFY");
6789 case 0x00BA: return wxT("EM_GETLINECOUNT");
6790 case 0x00BB: return wxT("EM_LINEINDEX");
6791 case 0x00BC: return wxT("EM_SETHANDLE");
6792 case 0x00BD: return wxT("EM_GETHANDLE");
6793 case 0x00BE: return wxT("EM_GETTHUMB");
6794 case 0x00C1: return wxT("EM_LINELENGTH");
6795 case 0x00C2: return wxT("EM_REPLACESEL");
6796 case 0x00C4: return wxT("EM_GETLINE");
6797 case 0x00C5: return wxT("EM_LIMITTEXT/EM_SETLIMITTEXT"); /* ;win40 Name change */
6798 case 0x00C6: return wxT("EM_CANUNDO");
6799 case 0x00C7: return wxT("EM_UNDO");
6800 case 0x00C8: return wxT("EM_FMTLINES");
6801 case 0x00C9: return wxT("EM_LINEFROMCHAR");
6802 case 0x00CB: return wxT("EM_SETTABSTOPS");
6803 case 0x00CC: return wxT("EM_SETPASSWORDCHAR");
6804 case 0x00CD: return wxT("EM_EMPTYUNDOBUFFER");
6805 case 0x00CE: return wxT("EM_GETFIRSTVISIBLELINE");
6806 case 0x00CF: return wxT("EM_SETREADONLY");
6807 case 0x00D0: return wxT("EM_SETWORDBREAKPROC");
6808 case 0x00D1: return wxT("EM_GETWORDBREAKPROC");
6809 case 0x00D2: return wxT("EM_GETPASSWORDCHAR");
6810 case 0x00D3: return wxT("EM_SETMARGINS");
6811 case 0x00D4: return wxT("EM_GETMARGINS");
6812 case 0x00D5: return wxT("EM_GETLIMITTEXT");
6813 case 0x00D6: return wxT("EM_POSFROMCHAR");
6814 case 0x00D7: return wxT("EM_CHARFROMPOS");
6815 case 0x00D8: return wxT("EM_SETIMESTATUS");
6816 case 0x00D9: return wxT("EM_GETIMESTATUS");
6817
6818 case 0x0100: return wxT("WM_KEYDOWN");
6819 case 0x0101: return wxT("WM_KEYUP");
6820 case 0x0102: return wxT("WM_CHAR");
6821 case 0x0103: return wxT("WM_DEADCHAR");
6822 case 0x0104: return wxT("WM_SYSKEYDOWN");
6823 case 0x0105: return wxT("WM_SYSKEYUP");
6824 case 0x0106: return wxT("WM_SYSCHAR");
6825 case 0x0107: return wxT("WM_SYSDEADCHAR");
6826 case 0x0108: return wxT("WM_KEYLAST");
6827
6828 case 0x010D: return wxT("WM_IME_STARTCOMPOSITION");
6829 case 0x010E: return wxT("WM_IME_ENDCOMPOSITION");
6830 case 0x010F: return wxT("WM_IME_COMPOSITION");
6831
6832 case 0x0110: return wxT("WM_INITDIALOG");
6833 case 0x0111: return wxT("WM_COMMAND");
6834 case 0x0112: return wxT("WM_SYSCOMMAND");
6835 case 0x0113: return wxT("WM_TIMER");
6836 case 0x0114: return wxT("WM_HSCROLL");
6837 case 0x0115: return wxT("WM_VSCROLL");
6838 case 0x0116: return wxT("WM_INITMENU");
6839 case 0x0117: return wxT("WM_INITMENUPOPUP");
6840 case 0x011F: return wxT("WM_MENUSELECT");
6841 case 0x0120: return wxT("WM_MENUCHAR");
6842 case 0x0121: return wxT("WM_ENTERIDLE");
6843
6844 case 0x0127: return wxT("WM_CHANGEUISTATE");
6845 case 0x0128: return wxT("WM_UPDATEUISTATE");
6846 case 0x0129: return wxT("WM_QUERYUISTATE");
6847
6848 case 0x0132: return wxT("WM_CTLCOLORMSGBOX");
6849 case 0x0133: return wxT("WM_CTLCOLOREDIT");
6850 case 0x0134: return wxT("WM_CTLCOLORLISTBOX");
6851 case 0x0135: return wxT("WM_CTLCOLORBTN");
6852 case 0x0136: return wxT("WM_CTLCOLORDLG");
6853 case 0x0137: return wxT("WM_CTLCOLORSCROLLBAR");
6854 case 0x0138: return wxT("WM_CTLCOLORSTATIC");
6855 case 0x01E1: return wxT("MN_GETHMENU");
6856
6857 case 0x0200: return wxT("WM_MOUSEMOVE");
6858 case 0x0201: return wxT("WM_LBUTTONDOWN");
6859 case 0x0202: return wxT("WM_LBUTTONUP");
6860 case 0x0203: return wxT("WM_LBUTTONDBLCLK");
6861 case 0x0204: return wxT("WM_RBUTTONDOWN");
6862 case 0x0205: return wxT("WM_RBUTTONUP");
6863 case 0x0206: return wxT("WM_RBUTTONDBLCLK");
6864 case 0x0207: return wxT("WM_MBUTTONDOWN");
6865 case 0x0208: return wxT("WM_MBUTTONUP");
6866 case 0x0209: return wxT("WM_MBUTTONDBLCLK");
6867 case 0x020A: return wxT("WM_MOUSEWHEEL");
6868 case 0x020B: return wxT("WM_XBUTTONDOWN");
6869 case 0x020C: return wxT("WM_XBUTTONUP");
6870 case 0x020D: return wxT("WM_XBUTTONDBLCLK");
6871 case 0x0210: return wxT("WM_PARENTNOTIFY");
6872 case 0x0211: return wxT("WM_ENTERMENULOOP");
6873 case 0x0212: return wxT("WM_EXITMENULOOP");
6874
6875 case 0x0213: return wxT("WM_NEXTMENU");
6876 case 0x0214: return wxT("WM_SIZING");
6877 case 0x0215: return wxT("WM_CAPTURECHANGED");
6878 case 0x0216: return wxT("WM_MOVING");
6879 case 0x0218: return wxT("WM_POWERBROADCAST");
6880 case 0x0219: return wxT("WM_DEVICECHANGE");
6881
6882 case 0x0220: return wxT("WM_MDICREATE");
6883 case 0x0221: return wxT("WM_MDIDESTROY");
6884 case 0x0222: return wxT("WM_MDIACTIVATE");
6885 case 0x0223: return wxT("WM_MDIRESTORE");
6886 case 0x0224: return wxT("WM_MDINEXT");
6887 case 0x0225: return wxT("WM_MDIMAXIMIZE");
6888 case 0x0226: return wxT("WM_MDITILE");
6889 case 0x0227: return wxT("WM_MDICASCADE");
6890 case 0x0228: return wxT("WM_MDIICONARRANGE");
6891 case 0x0229: return wxT("WM_MDIGETACTIVE");
6892 case 0x0230: return wxT("WM_MDISETMENU");
6893 case 0x0233: return wxT("WM_DROPFILES");
6894
6895 case 0x0281: return wxT("WM_IME_SETCONTEXT");
6896 case 0x0282: return wxT("WM_IME_NOTIFY");
6897 case 0x0283: return wxT("WM_IME_CONTROL");
6898 case 0x0284: return wxT("WM_IME_COMPOSITIONFULL");
6899 case 0x0285: return wxT("WM_IME_SELECT");
6900 case 0x0286: return wxT("WM_IME_CHAR");
6901 case 0x0290: return wxT("WM_IME_KEYDOWN");
6902 case 0x0291: return wxT("WM_IME_KEYUP");
6903
6904 case 0x02A0: return wxT("WM_NCMOUSEHOVER");
6905 case 0x02A1: return wxT("WM_MOUSEHOVER");
6906 case 0x02A2: return wxT("WM_NCMOUSELEAVE");
6907 case 0x02A3: return wxT("WM_MOUSELEAVE");
6908
6909 case 0x0300: return wxT("WM_CUT");
6910 case 0x0301: return wxT("WM_COPY");
6911 case 0x0302: return wxT("WM_PASTE");
6912 case 0x0303: return wxT("WM_CLEAR");
6913 case 0x0304: return wxT("WM_UNDO");
6914 case 0x0305: return wxT("WM_RENDERFORMAT");
6915 case 0x0306: return wxT("WM_RENDERALLFORMATS");
6916 case 0x0307: return wxT("WM_DESTROYCLIPBOARD");
6917 case 0x0308: return wxT("WM_DRAWCLIPBOARD");
6918 case 0x0309: return wxT("WM_PAINTCLIPBOARD");
6919 case 0x030A: return wxT("WM_VSCROLLCLIPBOARD");
6920 case 0x030B: return wxT("WM_SIZECLIPBOARD");
6921 case 0x030C: return wxT("WM_ASKCBFORMATNAME");
6922 case 0x030D: return wxT("WM_CHANGECBCHAIN");
6923 case 0x030E: return wxT("WM_HSCROLLCLIPBOARD");
6924 case 0x030F: return wxT("WM_QUERYNEWPALETTE");
6925 case 0x0310: return wxT("WM_PALETTEISCHANGING");
6926 case 0x0311: return wxT("WM_PALETTECHANGED");
6927 case 0x0312: return wxT("WM_HOTKEY");
6928
6929 case 0x0317: return wxT("WM_PRINT");
6930 case 0x0318: return wxT("WM_PRINTCLIENT");
6931
6932 // common controls messages - although they're not strictly speaking
6933 // standard, it's nice to decode them nevertheless
6934
6935 // listview
6936 case 0x1000 + 0: return wxT("LVM_GETBKCOLOR");
6937 case 0x1000 + 1: return wxT("LVM_SETBKCOLOR");
6938 case 0x1000 + 2: return wxT("LVM_GETIMAGELIST");
6939 case 0x1000 + 3: return wxT("LVM_SETIMAGELIST");
6940 case 0x1000 + 4: return wxT("LVM_GETITEMCOUNT");
6941 case 0x1000 + 5: return wxT("LVM_GETITEMA");
6942 case 0x1000 + 75: return wxT("LVM_GETITEMW");
6943 case 0x1000 + 6: return wxT("LVM_SETITEMA");
6944 case 0x1000 + 76: return wxT("LVM_SETITEMW");
6945 case 0x1000 + 7: return wxT("LVM_INSERTITEMA");
6946 case 0x1000 + 77: return wxT("LVM_INSERTITEMW");
6947 case 0x1000 + 8: return wxT("LVM_DELETEITEM");
6948 case 0x1000 + 9: return wxT("LVM_DELETEALLITEMS");
6949 case 0x1000 + 10: return wxT("LVM_GETCALLBACKMASK");
6950 case 0x1000 + 11: return wxT("LVM_SETCALLBACKMASK");
6951 case 0x1000 + 12: return wxT("LVM_GETNEXTITEM");
6952 case 0x1000 + 13: return wxT("LVM_FINDITEMA");
6953 case 0x1000 + 83: return wxT("LVM_FINDITEMW");
6954 case 0x1000 + 14: return wxT("LVM_GETITEMRECT");
6955 case 0x1000 + 15: return wxT("LVM_SETITEMPOSITION");
6956 case 0x1000 + 16: return wxT("LVM_GETITEMPOSITION");
6957 case 0x1000 + 17: return wxT("LVM_GETSTRINGWIDTHA");
6958 case 0x1000 + 87: return wxT("LVM_GETSTRINGWIDTHW");
6959 case 0x1000 + 18: return wxT("LVM_HITTEST");
6960 case 0x1000 + 19: return wxT("LVM_ENSUREVISIBLE");
6961 case 0x1000 + 20: return wxT("LVM_SCROLL");
6962 case 0x1000 + 21: return wxT("LVM_REDRAWITEMS");
6963 case 0x1000 + 22: return wxT("LVM_ARRANGE");
6964 case 0x1000 + 23: return wxT("LVM_EDITLABELA");
6965 case 0x1000 + 118: return wxT("LVM_EDITLABELW");
6966 case 0x1000 + 24: return wxT("LVM_GETEDITCONTROL");
6967 case 0x1000 + 25: return wxT("LVM_GETCOLUMNA");
6968 case 0x1000 + 95: return wxT("LVM_GETCOLUMNW");
6969 case 0x1000 + 26: return wxT("LVM_SETCOLUMNA");
6970 case 0x1000 + 96: return wxT("LVM_SETCOLUMNW");
6971 case 0x1000 + 27: return wxT("LVM_INSERTCOLUMNA");
6972 case 0x1000 + 97: return wxT("LVM_INSERTCOLUMNW");
6973 case 0x1000 + 28: return wxT("LVM_DELETECOLUMN");
6974 case 0x1000 + 29: return wxT("LVM_GETCOLUMNWIDTH");
6975 case 0x1000 + 30: return wxT("LVM_SETCOLUMNWIDTH");
6976 case 0x1000 + 31: return wxT("LVM_GETHEADER");
6977 case 0x1000 + 33: return wxT("LVM_CREATEDRAGIMAGE");
6978 case 0x1000 + 34: return wxT("LVM_GETVIEWRECT");
6979 case 0x1000 + 35: return wxT("LVM_GETTEXTCOLOR");
6980 case 0x1000 + 36: return wxT("LVM_SETTEXTCOLOR");
6981 case 0x1000 + 37: return wxT("LVM_GETTEXTBKCOLOR");
6982 case 0x1000 + 38: return wxT("LVM_SETTEXTBKCOLOR");
6983 case 0x1000 + 39: return wxT("LVM_GETTOPINDEX");
6984 case 0x1000 + 40: return wxT("LVM_GETCOUNTPERPAGE");
6985 case 0x1000 + 41: return wxT("LVM_GETORIGIN");
6986 case 0x1000 + 42: return wxT("LVM_UPDATE");
6987 case 0x1000 + 43: return wxT("LVM_SETITEMSTATE");
6988 case 0x1000 + 44: return wxT("LVM_GETITEMSTATE");
6989 case 0x1000 + 45: return wxT("LVM_GETITEMTEXTA");
6990 case 0x1000 + 115: return wxT("LVM_GETITEMTEXTW");
6991 case 0x1000 + 46: return wxT("LVM_SETITEMTEXTA");
6992 case 0x1000 + 116: return wxT("LVM_SETITEMTEXTW");
6993 case 0x1000 + 47: return wxT("LVM_SETITEMCOUNT");
6994 case 0x1000 + 48: return wxT("LVM_SORTITEMS");
6995 case 0x1000 + 49: return wxT("LVM_SETITEMPOSITION32");
6996 case 0x1000 + 50: return wxT("LVM_GETSELECTEDCOUNT");
6997 case 0x1000 + 51: return wxT("LVM_GETITEMSPACING");
6998 case 0x1000 + 52: return wxT("LVM_GETISEARCHSTRINGA");
6999 case 0x1000 + 117: return wxT("LVM_GETISEARCHSTRINGW");
7000 case 0x1000 + 53: return wxT("LVM_SETICONSPACING");
7001 case 0x1000 + 54: return wxT("LVM_SETEXTENDEDLISTVIEWSTYLE");
7002 case 0x1000 + 55: return wxT("LVM_GETEXTENDEDLISTVIEWSTYLE");
7003 case 0x1000 + 56: return wxT("LVM_GETSUBITEMRECT");
7004 case 0x1000 + 57: return wxT("LVM_SUBITEMHITTEST");
7005 case 0x1000 + 58: return wxT("LVM_SETCOLUMNORDERARRAY");
7006 case 0x1000 + 59: return wxT("LVM_GETCOLUMNORDERARRAY");
7007 case 0x1000 + 60: return wxT("LVM_SETHOTITEM");
7008 case 0x1000 + 61: return wxT("LVM_GETHOTITEM");
7009 case 0x1000 + 62: return wxT("LVM_SETHOTCURSOR");
7010 case 0x1000 + 63: return wxT("LVM_GETHOTCURSOR");
7011 case 0x1000 + 64: return wxT("LVM_APPROXIMATEVIEWRECT");
7012 case 0x1000 + 65: return wxT("LVM_SETWORKAREA");
7013
7014 // tree view
7015 case 0x1100 + 0: return wxT("TVM_INSERTITEMA");
7016 case 0x1100 + 50: return wxT("TVM_INSERTITEMW");
7017 case 0x1100 + 1: return wxT("TVM_DELETEITEM");
7018 case 0x1100 + 2: return wxT("TVM_EXPAND");
7019 case 0x1100 + 4: return wxT("TVM_GETITEMRECT");
7020 case 0x1100 + 5: return wxT("TVM_GETCOUNT");
7021 case 0x1100 + 6: return wxT("TVM_GETINDENT");
7022 case 0x1100 + 7: return wxT("TVM_SETINDENT");
7023 case 0x1100 + 8: return wxT("TVM_GETIMAGELIST");
7024 case 0x1100 + 9: return wxT("TVM_SETIMAGELIST");
7025 case 0x1100 + 10: return wxT("TVM_GETNEXTITEM");
7026 case 0x1100 + 11: return wxT("TVM_SELECTITEM");
7027 case 0x1100 + 12: return wxT("TVM_GETITEMA");
7028 case 0x1100 + 62: return wxT("TVM_GETITEMW");
7029 case 0x1100 + 13: return wxT("TVM_SETITEMA");
7030 case 0x1100 + 63: return wxT("TVM_SETITEMW");
7031 case 0x1100 + 14: return wxT("TVM_EDITLABELA");
7032 case 0x1100 + 65: return wxT("TVM_EDITLABELW");
7033 case 0x1100 + 15: return wxT("TVM_GETEDITCONTROL");
7034 case 0x1100 + 16: return wxT("TVM_GETVISIBLECOUNT");
7035 case 0x1100 + 17: return wxT("TVM_HITTEST");
7036 case 0x1100 + 18: return wxT("TVM_CREATEDRAGIMAGE");
7037 case 0x1100 + 19: return wxT("TVM_SORTCHILDREN");
7038 case 0x1100 + 20: return wxT("TVM_ENSUREVISIBLE");
7039 case 0x1100 + 21: return wxT("TVM_SORTCHILDRENCB");
7040 case 0x1100 + 22: return wxT("TVM_ENDEDITLABELNOW");
7041 case 0x1100 + 23: return wxT("TVM_GETISEARCHSTRINGA");
7042 case 0x1100 + 64: return wxT("TVM_GETISEARCHSTRINGW");
7043 case 0x1100 + 24: return wxT("TVM_SETTOOLTIPS");
7044 case 0x1100 + 25: return wxT("TVM_GETTOOLTIPS");
7045
7046 // header
7047 case 0x1200 + 0: return wxT("HDM_GETITEMCOUNT");
7048 case 0x1200 + 1: return wxT("HDM_INSERTITEMA");
7049 case 0x1200 + 10: return wxT("HDM_INSERTITEMW");
7050 case 0x1200 + 2: return wxT("HDM_DELETEITEM");
7051 case 0x1200 + 3: return wxT("HDM_GETITEMA");
7052 case 0x1200 + 11: return wxT("HDM_GETITEMW");
7053 case 0x1200 + 4: return wxT("HDM_SETITEMA");
7054 case 0x1200 + 12: return wxT("HDM_SETITEMW");
7055 case 0x1200 + 5: return wxT("HDM_LAYOUT");
7056 case 0x1200 + 6: return wxT("HDM_HITTEST");
7057 case 0x1200 + 7: return wxT("HDM_GETITEMRECT");
7058 case 0x1200 + 8: return wxT("HDM_SETIMAGELIST");
7059 case 0x1200 + 9: return wxT("HDM_GETIMAGELIST");
7060 case 0x1200 + 15: return wxT("HDM_ORDERTOINDEX");
7061 case 0x1200 + 16: return wxT("HDM_CREATEDRAGIMAGE");
7062 case 0x1200 + 17: return wxT("HDM_GETORDERARRAY");
7063 case 0x1200 + 18: return wxT("HDM_SETORDERARRAY");
7064 case 0x1200 + 19: return wxT("HDM_SETHOTDIVIDER");
7065
7066 // tab control
7067 case 0x1300 + 2: return wxT("TCM_GETIMAGELIST");
7068 case 0x1300 + 3: return wxT("TCM_SETIMAGELIST");
7069 case 0x1300 + 4: return wxT("TCM_GETITEMCOUNT");
7070 case 0x1300 + 5: return wxT("TCM_GETITEMA");
7071 case 0x1300 + 60: return wxT("TCM_GETITEMW");
7072 case 0x1300 + 6: return wxT("TCM_SETITEMA");
7073 case 0x1300 + 61: return wxT("TCM_SETITEMW");
7074 case 0x1300 + 7: return wxT("TCM_INSERTITEMA");
7075 case 0x1300 + 62: return wxT("TCM_INSERTITEMW");
7076 case 0x1300 + 8: return wxT("TCM_DELETEITEM");
7077 case 0x1300 + 9: return wxT("TCM_DELETEALLITEMS");
7078 case 0x1300 + 10: return wxT("TCM_GETITEMRECT");
7079 case 0x1300 + 11: return wxT("TCM_GETCURSEL");
7080 case 0x1300 + 12: return wxT("TCM_SETCURSEL");
7081 case 0x1300 + 13: return wxT("TCM_HITTEST");
7082 case 0x1300 + 14: return wxT("TCM_SETITEMEXTRA");
7083 case 0x1300 + 40: return wxT("TCM_ADJUSTRECT");
7084 case 0x1300 + 41: return wxT("TCM_SETITEMSIZE");
7085 case 0x1300 + 42: return wxT("TCM_REMOVEIMAGE");
7086 case 0x1300 + 43: return wxT("TCM_SETPADDING");
7087 case 0x1300 + 44: return wxT("TCM_GETROWCOUNT");
7088 case 0x1300 + 45: return wxT("TCM_GETTOOLTIPS");
7089 case 0x1300 + 46: return wxT("TCM_SETTOOLTIPS");
7090 case 0x1300 + 47: return wxT("TCM_GETCURFOCUS");
7091 case 0x1300 + 48: return wxT("TCM_SETCURFOCUS");
7092 case 0x1300 + 49: return wxT("TCM_SETMINTABWIDTH");
7093 case 0x1300 + 50: return wxT("TCM_DESELECTALL");
7094
7095 // toolbar
7096 case WM_USER+1: return wxT("TB_ENABLEBUTTON");
7097 case WM_USER+2: return wxT("TB_CHECKBUTTON");
7098 case WM_USER+3: return wxT("TB_PRESSBUTTON");
7099 case WM_USER+4: return wxT("TB_HIDEBUTTON");
7100 case WM_USER+5: return wxT("TB_INDETERMINATE");
7101 case WM_USER+9: return wxT("TB_ISBUTTONENABLED");
7102 case WM_USER+10: return wxT("TB_ISBUTTONCHECKED");
7103 case WM_USER+11: return wxT("TB_ISBUTTONPRESSED");
7104 case WM_USER+12: return wxT("TB_ISBUTTONHIDDEN");
7105 case WM_USER+13: return wxT("TB_ISBUTTONINDETERMINATE");
7106 case WM_USER+17: return wxT("TB_SETSTATE");
7107 case WM_USER+18: return wxT("TB_GETSTATE");
7108 case WM_USER+19: return wxT("TB_ADDBITMAP");
7109 case WM_USER+20: return wxT("TB_ADDBUTTONS");
7110 case WM_USER+21: return wxT("TB_INSERTBUTTON");
7111 case WM_USER+22: return wxT("TB_DELETEBUTTON");
7112 case WM_USER+23: return wxT("TB_GETBUTTON");
7113 case WM_USER+24: return wxT("TB_BUTTONCOUNT");
7114 case WM_USER+25: return wxT("TB_COMMANDTOINDEX");
7115 case WM_USER+26: return wxT("TB_SAVERESTOREA");
7116 case WM_USER+76: return wxT("TB_SAVERESTOREW");
7117 case WM_USER+27: return wxT("TB_CUSTOMIZE");
7118 case WM_USER+28: return wxT("TB_ADDSTRINGA");
7119 case WM_USER+77: return wxT("TB_ADDSTRINGW");
7120 case WM_USER+29: return wxT("TB_GETITEMRECT");
7121 case WM_USER+30: return wxT("TB_BUTTONSTRUCTSIZE");
7122 case WM_USER+31: return wxT("TB_SETBUTTONSIZE");
7123 case WM_USER+32: return wxT("TB_SETBITMAPSIZE");
7124 case WM_USER+33: return wxT("TB_AUTOSIZE");
7125 case WM_USER+35: return wxT("TB_GETTOOLTIPS");
7126 case WM_USER+36: return wxT("TB_SETTOOLTIPS");
7127 case WM_USER+37: return wxT("TB_SETPARENT");
7128 case WM_USER+39: return wxT("TB_SETROWS");
7129 case WM_USER+40: return wxT("TB_GETROWS");
7130 case WM_USER+42: return wxT("TB_SETCMDID");
7131 case WM_USER+43: return wxT("TB_CHANGEBITMAP");
7132 case WM_USER+44: return wxT("TB_GETBITMAP");
7133 case WM_USER+45: return wxT("TB_GETBUTTONTEXTA");
7134 case WM_USER+75: return wxT("TB_GETBUTTONTEXTW");
7135 case WM_USER+46: return wxT("TB_REPLACEBITMAP");
7136 case WM_USER+47: return wxT("TB_SETINDENT");
7137 case WM_USER+48: return wxT("TB_SETIMAGELIST");
7138 case WM_USER+49: return wxT("TB_GETIMAGELIST");
7139 case WM_USER+50: return wxT("TB_LOADIMAGES");
7140 case WM_USER+51: return wxT("TB_GETRECT");
7141 case WM_USER+52: return wxT("TB_SETHOTIMAGELIST");
7142 case WM_USER+53: return wxT("TB_GETHOTIMAGELIST");
7143 case WM_USER+54: return wxT("TB_SETDISABLEDIMAGELIST");
7144 case WM_USER+55: return wxT("TB_GETDISABLEDIMAGELIST");
7145 case WM_USER+56: return wxT("TB_SETSTYLE");
7146 case WM_USER+57: return wxT("TB_GETSTYLE");
7147 case WM_USER+58: return wxT("TB_GETBUTTONSIZE");
7148 case WM_USER+59: return wxT("TB_SETBUTTONWIDTH");
7149 case WM_USER+60: return wxT("TB_SETMAXTEXTROWS");
7150 case WM_USER+61: return wxT("TB_GETTEXTROWS");
7151 case WM_USER+41: return wxT("TB_GETBITMAPFLAGS");
7152
7153 default:
7154 static wxString s_szBuf;
7155 s_szBuf.Printf(wxT("<unknown message = %d>"), message);
7156 return s_szBuf.c_str();
7157 }
7158}
7159#endif // wxDEBUG_LEVEL >= 2
7160
7161static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
7162{
7163 // prepare the DC
7164 TEXTMETRIC tm;
7165 HWND hwnd = GetHwndOf(win);
7166 HDC hdc = ::GetDC(hwnd);
7167
7168#if !wxDIALOG_UNIT_COMPATIBILITY
7169 // and select the current font into it
7170 HFONT hfont = GetHfontOf(win->GetFont());
7171 if ( hfont )
7172 {
7173 hfont = (HFONT)::SelectObject(hdc, hfont);
7174 }
7175#endif
7176
7177 // finally retrieve the text metrics from it
7178 GetTextMetrics(hdc, &tm);
7179
7180#if !wxDIALOG_UNIT_COMPATIBILITY
7181 // and clean up
7182 if ( hfont )
7183 {
7184 (void)::SelectObject(hdc, hfont);
7185 }
7186#endif
7187
7188 ::ReleaseDC(hwnd, hdc);
7189
7190 return tm;
7191}
7192
7193// Find the wxWindow at the current mouse position, returning the mouse
7194// position.
7195wxWindow* wxFindWindowAtPointer(wxPoint& pt)
7196{
7197 pt = wxGetMousePosition();
7198 return wxFindWindowAtPoint(pt);
7199}
7200
7201wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
7202{
7203 POINT pt2;
7204 pt2.x = pt.x;
7205 pt2.y = pt.y;
7206
7207 HWND hWnd = ::WindowFromPoint(pt2);
7208 if ( hWnd )
7209 {
7210 // WindowFromPoint() ignores the disabled children but we're supposed
7211 // to take them into account, so check if we have a child at this
7212 // coordinate using ChildWindowFromPointEx().
7213 for ( ;; )
7214 {
7215 pt2.x = pt.x;
7216 pt2.y = pt.y;
7217 ::ScreenToClient(hWnd, &pt2);
7218 HWND child = ::ChildWindowFromPointEx(hWnd, pt2, CWP_SKIPINVISIBLE);
7219 if ( child == hWnd || !child )
7220 break;
7221
7222 // ChildWindowFromPointEx() only examines the immediate children
7223 // but we want to get the deepest (top in Z-order) one, so continue
7224 // iterating for as long as it finds anything.
7225 hWnd = child;
7226 }
7227 }
7228
7229 return wxGetWindowFromHWND((WXHWND)hWnd);
7230}
7231
7232// Get the current mouse position.
7233wxPoint wxGetMousePosition()
7234{
7235 POINT pt;
7236 wxGetCursorPosMSW(&pt);
7237
7238 return wxPoint(pt.x, pt.y);
7239}
7240
7241#if wxUSE_HOTKEY
7242
7243#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7244static void WinCEUnregisterHotKey(int modifiers, int id)
7245{
7246 // Register hotkeys for the hardware buttons
7247 HINSTANCE hCoreDll;
7248 typedef BOOL (WINAPI *UnregisterFunc1Proc)(UINT, UINT);
7249
7250 UnregisterFunc1Proc procUnregisterFunc;
7251 hCoreDll = LoadLibrary(wxT("coredll.dll"));
7252 if (hCoreDll)
7253 {
7254 procUnregisterFunc = (UnregisterFunc1Proc)GetProcAddress(hCoreDll, wxT("UnregisterFunc1"));
7255 if (procUnregisterFunc)
7256 procUnregisterFunc(modifiers, id);
7257 FreeLibrary(hCoreDll);
7258 }
7259}
7260#endif
7261
7262bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
7263{
7264 UINT win_modifiers=0;
7265 if ( modifiers & wxMOD_ALT )
7266 win_modifiers |= MOD_ALT;
7267 if ( modifiers & wxMOD_SHIFT )
7268 win_modifiers |= MOD_SHIFT;
7269 if ( modifiers & wxMOD_CONTROL )
7270 win_modifiers |= MOD_CONTROL;
7271 if ( modifiers & wxMOD_WIN )
7272 win_modifiers |= MOD_WIN;
7273
7274#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7275 // Required for PPC and Smartphone hardware buttons
7276 if (keycode >= WXK_SPECIAL1 && keycode <= WXK_SPECIAL20)
7277 WinCEUnregisterHotKey(win_modifiers, hotkeyId);
7278#endif
7279
7280 if ( !::RegisterHotKey(GetHwnd(), hotkeyId, win_modifiers, keycode) )
7281 {
7282 wxLogLastError(wxT("RegisterHotKey"));
7283
7284 return false;
7285 }
7286
7287 return true;
7288}
7289
7290bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
7291{
7292#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
7293 WinCEUnregisterHotKey(MOD_WIN, hotkeyId);
7294#endif
7295
7296 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId) )
7297 {
7298 wxLogLastError(wxT("UnregisterHotKey"));
7299
7300 return false;
7301 }
7302
7303 return true;
7304}
7305
7306#if wxUSE_ACCEL
7307
7308bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
7309{
7310 int win_modifiers = LOWORD(lParam);
7311
7312 wxKeyEvent event(CreateKeyEvent(wxEVT_HOTKEY, HIWORD(lParam)));
7313 event.SetId(wParam);
7314 event.m_shiftDown = (win_modifiers & MOD_SHIFT) != 0;
7315 event.m_controlDown = (win_modifiers & MOD_CONTROL) != 0;
7316 event.m_altDown = (win_modifiers & MOD_ALT) != 0;
7317 event.m_metaDown = (win_modifiers & MOD_WIN) != 0;
7318
7319 return HandleWindowEvent(event);
7320}
7321
7322#endif // wxUSE_ACCEL
7323
7324#endif // wxUSE_HOTKEY
7325
7326// Not tested under WinCE
7327#ifndef __WXWINCE__
7328
7329// this class installs a message hook which really wakes up our idle processing
7330// each time a WM_NULL is received (wxWakeUpIdle does this), even if we're
7331// sitting inside a local modal loop (e.g. a menu is opened or scrollbar is
7332// being dragged or even inside ::MessageBox()) and so don't control message
7333// dispatching otherwise
7334class wxIdleWakeUpModule : public wxModule
7335{
7336public:
7337 virtual bool OnInit()
7338 {
7339 ms_hMsgHookProc = ::SetWindowsHookEx
7340 (
7341 WH_GETMESSAGE,
7342 &wxIdleWakeUpModule::MsgHookProc,
7343 NULL,
7344 GetCurrentThreadId()
7345 );
7346
7347 if ( !ms_hMsgHookProc )
7348 {
7349 wxLogLastError(wxT("SetWindowsHookEx(WH_GETMESSAGE)"));
7350
7351 return false;
7352 }
7353
7354 return true;
7355 }
7356
7357 virtual void OnExit()
7358 {
7359 ::UnhookWindowsHookEx(wxIdleWakeUpModule::ms_hMsgHookProc);
7360 }
7361
7362 static LRESULT CALLBACK MsgHookProc(int nCode, WPARAM wParam, LPARAM lParam)
7363 {
7364 MSG *msg = (MSG*)lParam;
7365
7366 // only process the message if it is actually going to be removed from
7367 // the message queue, this prevents that the same event from being
7368 // processed multiple times if now someone just called PeekMessage()
7369 if ( msg->message == WM_NULL && wParam == PM_REMOVE )
7370 {
7371 wxTheApp->ProcessPendingEvents();
7372 }
7373
7374 return CallNextHookEx(ms_hMsgHookProc, nCode, wParam, lParam);
7375 }
7376
7377private:
7378 static HHOOK ms_hMsgHookProc;
7379
7380 DECLARE_DYNAMIC_CLASS(wxIdleWakeUpModule)
7381};
7382
7383HHOOK wxIdleWakeUpModule::ms_hMsgHookProc = 0;
7384
7385IMPLEMENT_DYNAMIC_CLASS(wxIdleWakeUpModule, wxModule)
7386
7387#endif // __WXWINCE__
7388
7389#ifdef __WXWINCE__
7390
7391#if wxUSE_STATBOX
7392static void wxAdjustZOrder(wxWindow* parent)
7393{
7394 if (wxDynamicCast(parent, wxStaticBox))
7395 {
7396 // Set the z-order correctly
7397 SetWindowPos((HWND) parent->GetHWND(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
7398 }
7399
7400 wxWindowList::compatibility_iterator current = parent->GetChildren().GetFirst();
7401 while (current)
7402 {
7403 wxWindow *childWin = current->GetData();
7404 wxAdjustZOrder(childWin);
7405 current = current->GetNext();
7406 }
7407}
7408#endif
7409
7410// We need to adjust the z-order of static boxes in WinCE, to
7411// make 'contained' controls visible
7412void wxWindowMSW::OnInitDialog( wxInitDialogEvent& event )
7413{
7414#if wxUSE_STATBOX
7415 wxAdjustZOrder(this);
7416#endif
7417
7418 event.Skip();
7419}
7420#endif