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