]> git.saurik.com Git - wxWidgets.git/blob - src/msw/window.cpp
prevent IsDialogMessage() from hanging in yet another case
[wxWidgets.git] / src / msw / window.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/windows.cpp
3 // Purpose: wxWindow
4 // Author: Julian Smart
5 // Modified by: VZ on 13.05.99: no more Default(), MSWOnXXX() reorganisation
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "window.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/msw/wrapwin.h"
33 #include "wx/window.h"
34 #include "wx/accel.h"
35 #include "wx/setup.h"
36 #include "wx/menu.h"
37 #include "wx/dc.h"
38 #include "wx/dcclient.h"
39 #include "wx/dcmemory.h"
40 #include "wx/utils.h"
41 #include "wx/app.h"
42 #include "wx/layout.h"
43 #include "wx/dialog.h"
44 #include "wx/frame.h"
45 #include "wx/listbox.h"
46 #include "wx/button.h"
47 #include "wx/msgdlg.h"
48 #include "wx/settings.h"
49 #include "wx/statbox.h"
50 #endif
51
52 #if wxUSE_OWNER_DRAWN
53 #include "wx/ownerdrw.h"
54 #endif
55
56 #if wxUSE_DRAG_AND_DROP
57 #include "wx/dnd.h"
58 #endif
59
60 #if wxUSE_ACCESSIBILITY
61 #include "wx/access.h"
62 #include <ole2.h>
63 #include <oleacc.h>
64 #ifndef WM_GETOBJECT
65 #define WM_GETOBJECT 0x003D
66 #endif
67 #ifndef OBJID_CLIENT
68 #define OBJID_CLIENT 0xFFFFFFFC
69 #endif
70 #endif
71
72 #include "wx/menuitem.h"
73 #include "wx/log.h"
74
75 #include "wx/msw/private.h"
76
77 #if wxUSE_TOOLTIPS
78 #include "wx/tooltip.h"
79 #endif
80
81 #if wxUSE_CARET
82 #include "wx/caret.h"
83 #endif // wxUSE_CARET
84
85 #if wxUSE_SPINCTRL
86 #include "wx/spinctrl.h"
87 #endif // wxUSE_SPINCTRL
88
89 #include "wx/intl.h"
90 #include "wx/log.h"
91
92 #include "wx/textctrl.h"
93 #include "wx/notebook.h"
94
95 #include <string.h>
96
97 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
98 #include <shellapi.h>
99 #include <mmsystem.h>
100 #endif
101
102 #ifdef __WIN32__
103 #include <windowsx.h>
104 #endif
105
106 #if (!defined(__GNUWIN32_OLD__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)) || defined(__CYGWIN10__)
107 #ifdef __WIN95__
108 #include <commctrl.h>
109 #endif
110 #elif !defined(__WXMICROWIN__) && !defined(__WXWINCE__) // broken compiler
111 #include "wx/msw/gnuwin32/extra.h"
112 #endif
113
114 #if defined(__GNUG__)
115 #include "wx/msw/missing.h"
116 #endif
117
118 #if defined(__WXWINCE__)
119 #include "wx/msw/wince/missing.h"
120 #endif
121
122 // ----------------------------------------------------------------------------
123 // standard constants not available with all compilers/headers
124 // ----------------------------------------------------------------------------
125
126 // This didn't appear in mingw until 2.95.2
127 #ifndef SIF_TRACKPOS
128 #define SIF_TRACKPOS 16
129 #endif
130
131 #if wxUSE_MOUSEWHEEL
132 #ifndef WM_MOUSEWHEEL
133 #define WM_MOUSEWHEEL 0x020A
134 #endif
135 #ifndef WHEEL_DELTA
136 #define WHEEL_DELTA 120
137 #endif
138 #ifndef SPI_GETWHEELSCROLLLINES
139 #define SPI_GETWHEELSCROLLLINES 104
140 #endif
141 #endif // wxUSE_MOUSEWHEEL
142
143 #ifndef VK_OEM_1
144 #define VK_OEM_1 0xBA
145 #define VK_OEM_2 0xBF
146 #define VK_OEM_3 0xC0
147 #define VK_OEM_4 0xDB
148 #define VK_OEM_5 0xDC
149 #define VK_OEM_6 0xDD
150 #define VK_OEM_7 0xDE
151 #endif
152
153 #ifndef VK_OEM_COMMA
154 #define VK_OEM_PLUS 0xBB
155 #define VK_OEM_COMMA 0xBC
156 #define VK_OEM_MINUS 0xBD
157 #define VK_OEM_PERIOD 0xBE
158 #endif
159
160 // ---------------------------------------------------------------------------
161 // global variables
162 // ---------------------------------------------------------------------------
163
164 // the last Windows message we got (FIXME-MT)
165 extern MSG s_currentMsg;
166
167 #if wxUSE_MENUS_NATIVE
168 wxMenu *wxCurrentPopupMenu = NULL;
169 #endif // wxUSE_MENUS_NATIVE
170
171 extern const wxChar *wxCanvasClassName;
172
173 // true if we had already created the std colour map, used by
174 // wxGetStdColourMap() and wxWindow::OnSysColourChanged() (FIXME-MT)
175 static bool gs_hasStdCmap = FALSE;
176
177 // ---------------------------------------------------------------------------
178 // private functions
179 // ---------------------------------------------------------------------------
180
181 // the window proc for all our windows
182 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
183 WPARAM wParam, LPARAM lParam);
184
185
186 #ifdef __WXDEBUG__
187 const char *wxGetMessageName(int message);
188 #endif //__WXDEBUG__
189
190 void wxRemoveHandleAssociation(wxWindowMSW *win);
191 extern void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win);
192 wxWindow *wxFindWinFromHandle(WXHWND hWnd);
193
194 // this magical function is used to translate VK_APPS key presses to right
195 // mouse clicks
196 static void TranslateKbdEventToMouse(wxWindowMSW *win,
197 int *x, int *y, WPARAM *flags);
198
199 // get the text metrics for the current font
200 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win);
201
202 // find the window for the mouse event at the specified position
203 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y); //TW:REQ:Univ
204
205 // wrapper around BringWindowToTop() API
206 static inline void wxBringWindowToTop(HWND hwnd)
207 {
208 #ifdef __WXMICROWIN__
209 // It seems that MicroWindows brings the _parent_ of the window to the top,
210 // which can be the wrong one.
211
212 // activate (set focus to) specified window
213 ::SetFocus(hwnd);
214 #endif
215
216 // raise top level parent to top of z order
217 if (!::SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE))
218 {
219 wxLogLastError(_T("SetWindowPos"));
220 }
221 }
222
223 // ---------------------------------------------------------------------------
224 // event tables
225 // ---------------------------------------------------------------------------
226
227 // in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
228 // method
229 #ifdef __WXUNIVERSAL__
230 IMPLEMENT_ABSTRACT_CLASS(wxWindowMSW, wxWindowBase)
231 #else // __WXMSW__
232 IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
233 #endif // __WXUNIVERSAL__/__WXMSW__
234
235 BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
236 EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
237 EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
238 EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
239 END_EVENT_TABLE()
240
241 // ===========================================================================
242 // implementation
243 // ===========================================================================
244
245 // ---------------------------------------------------------------------------
246 // wxWindow utility functions
247 // ---------------------------------------------------------------------------
248
249 // Find an item given the MS Windows id
250 wxWindow *wxWindowMSW::FindItem(long id) const
251 {
252 #if wxUSE_CONTROLS
253 wxControl *item = wxDynamicCastThis(wxControl);
254 if ( item )
255 {
256 // is it we or one of our "internal" children?
257 if ( item->GetId() == id
258 #ifndef __WXUNIVERSAL__
259 || (item->GetSubcontrols().Index(id) != wxNOT_FOUND)
260 #endif // __WXUNIVERSAL__
261 )
262 {
263 return item;
264 }
265 }
266 #endif // wxUSE_CONTROLS
267
268 wxWindowList::compatibility_iterator current = GetChildren().GetFirst();
269 while (current)
270 {
271 wxWindow *childWin = current->GetData();
272
273 wxWindow *wnd = childWin->FindItem(id);
274 if ( wnd )
275 return wnd;
276
277 current = current->GetNext();
278 }
279
280 return NULL;
281 }
282
283 // Find an item given the MS Windows handle
284 wxWindow *wxWindowMSW::FindItemByHWND(WXHWND hWnd, bool controlOnly) const
285 {
286 wxWindowList::compatibility_iterator current = GetChildren().GetFirst();
287 while (current)
288 {
289 wxWindow *parent = current->GetData();
290
291 // Do a recursive search.
292 wxWindow *wnd = parent->FindItemByHWND(hWnd);
293 if ( wnd )
294 return wnd;
295
296 if ( !controlOnly
297 #if wxUSE_CONTROLS
298 || parent->IsKindOf(CLASSINFO(wxControl))
299 #endif // wxUSE_CONTROLS
300 )
301 {
302 wxWindow *item = current->GetData();
303 if ( item->GetHWND() == hWnd )
304 return item;
305 else
306 {
307 if ( item->ContainsHWND(hWnd) )
308 return item;
309 }
310 }
311
312 current = current->GetNext();
313 }
314 return NULL;
315 }
316
317 // Default command handler
318 bool wxWindowMSW::MSWCommand(WXUINT WXUNUSED(param), WXWORD WXUNUSED(id))
319 {
320 return FALSE;
321 }
322
323 // ----------------------------------------------------------------------------
324 // constructors and such
325 // ----------------------------------------------------------------------------
326
327 void wxWindowMSW::Init()
328 {
329 // generic
330 InitBase();
331
332 // MSW specific
333 m_isBeingDeleted = FALSE;
334 m_oldWndProc = NULL;
335 m_mouseInWindow = FALSE;
336 m_lastKeydownProcessed = FALSE;
337
338 m_childrenDisabled = NULL;
339
340 // wxWnd
341 m_hMenu = 0;
342
343 m_hWnd = 0;
344
345 m_xThumbSize = 0;
346 m_yThumbSize = 0;
347
348 // as all windows are created with WS_VISIBLE style...
349 m_isShown = TRUE;
350
351 #if wxUSE_MOUSEEVENT_HACK
352 m_lastMouseX =
353 m_lastMouseY = -1;
354 m_lastMouseEvent = -1;
355 #endif // wxUSE_MOUSEEVENT_HACK
356 }
357
358 // Destructor
359 wxWindowMSW::~wxWindowMSW()
360 {
361 m_isBeingDeleted = TRUE;
362
363 #ifndef __WXUNIVERSAL__
364 // VS: make sure there's no wxFrame with last focus set to us:
365 for ( wxWindow *win = GetParent(); win; win = win->GetParent() )
366 {
367 wxTopLevelWindow *frame = wxDynamicCast(win, wxTopLevelWindow);
368 if ( frame )
369 {
370 if ( frame->GetLastFocus() == this )
371 {
372 frame->SetLastFocus(NULL);
373 }
374 break;
375 }
376 }
377 #endif // __WXUNIVERSAL__
378
379 // VS: destroy children first and _then_ detach *this from its parent.
380 // If we'd do it the other way around, children wouldn't be able
381 // find their parent frame (see above).
382 DestroyChildren();
383
384 if ( m_parent )
385 m_parent->RemoveChild(this);
386
387 if ( m_hWnd )
388 {
389 // VZ: test temp removed to understand what really happens here
390 //if (::IsWindow(GetHwnd()))
391 {
392 if ( !::DestroyWindow(GetHwnd()) )
393 wxLogLastError(wxT("DestroyWindow"));
394 }
395
396 // remove hWnd <-> wxWindow association
397 wxRemoveHandleAssociation(this);
398 }
399
400 delete m_childrenDisabled;
401 }
402
403 // real construction (Init() must have been called before!)
404 bool wxWindowMSW::Create(wxWindow *parent,
405 wxWindowID id,
406 const wxPoint& pos,
407 const wxSize& size,
408 long style,
409 const wxString& name)
410 {
411 wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
412
413 if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
414 return FALSE;
415
416 parent->AddChild(this);
417
418 WXDWORD exstyle;
419 DWORD msflags = MSWGetCreateWindowFlags(&exstyle);
420
421 #ifdef __WXUNIVERSAL__
422 // no borders, we draw them ourselves
423 exstyle &= ~(WS_EX_DLGMODALFRAME |
424 WS_EX_STATICEDGE |
425 WS_EX_CLIENTEDGE |
426 WS_EX_WINDOWEDGE);
427 msflags &= ~WS_BORDER;
428 #endif // wxUniversal
429
430 // all windows are created visible by default except popup ones (which are
431 // like the wxTopLevelWindows in this aspect)
432 if ( style & wxPOPUP_WINDOW )
433 {
434 msflags &= ~WS_VISIBLE;
435 m_isShown = FALSE;
436 }
437 else
438 {
439 msflags |= WS_VISIBLE;
440 }
441
442 return MSWCreate(wxCanvasClassName, NULL, pos, size, msflags, exstyle);
443 }
444
445 // ---------------------------------------------------------------------------
446 // basic operations
447 // ---------------------------------------------------------------------------
448
449 void wxWindowMSW::SetFocus()
450 {
451 HWND hWnd = GetHwnd();
452 wxCHECK_RET( hWnd, _T("can't set focus to invalid window") );
453
454 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
455 ::SetLastError(0);
456 #endif
457
458 if ( !::SetFocus(hWnd) )
459 {
460 #if defined(__WXDEBUG__) && !defined(__WXMICROWIN__)
461 // was there really an error?
462 DWORD dwRes = ::GetLastError();
463 if ( dwRes )
464 {
465 HWND hwndFocus = ::GetFocus();
466 if ( hwndFocus != hWnd )
467 {
468 wxLogApiError(_T("SetFocus"), dwRes);
469 }
470 }
471 #endif // Debug
472 }
473 }
474
475 void wxWindowMSW::SetFocusFromKbd()
476 {
477 // when the focus is given to the control with DLGC_HASSETSEL style from
478 // keyboard its contents should be entirely selected: this is what
479 // ::IsDialogMessage() does and so we should do it as well to provide the
480 // same LNF as the native programs
481 if ( ::SendMessage(GetHwnd(), WM_GETDLGCODE, 0, 0) & DLGC_HASSETSEL )
482 {
483 ::SendMessage(GetHwnd(), EM_SETSEL, 0, -1);
484 }
485
486 // do this after (maybe) setting the selection as like this when
487 // wxEVT_SET_FOCUS handler is called, the selection would have been already
488 // set correctly -- this may be important
489 wxWindowBase::SetFocusFromKbd();
490 }
491
492 // Get the window with the focus
493 wxWindow *wxWindowBase::FindFocus()
494 {
495 HWND hWnd = ::GetFocus();
496 if ( hWnd )
497 {
498 return wxGetWindowFromHWND((WXHWND)hWnd);
499 }
500
501 return NULL;
502 }
503
504 bool wxWindowMSW::Enable(bool enable)
505 {
506 if ( !wxWindowBase::Enable(enable) )
507 return FALSE;
508
509 HWND hWnd = GetHwnd();
510 if ( hWnd )
511 ::EnableWindow(hWnd, (BOOL)enable);
512
513 // the logic below doesn't apply to the top level windows -- otherwise
514 // showing a modal dialog would result in total greying out (and ungreying
515 // out later) of everything which would be really ugly
516 if ( IsTopLevel() )
517 return TRUE;
518
519 // when the parent is disabled, all of its children should be disabled as
520 // well but when it is enabled back, only those of the children which
521 // hadn't been already disabled in the beginning should be enabled again,
522 // so we have to keep the list of those children
523 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
524 node;
525 node = node->GetNext() )
526 {
527 wxWindow *child = node->GetData();
528 if ( child->IsTopLevel() )
529 {
530 // the logic below doesn't apply to top level children
531 continue;
532 }
533
534 if ( enable )
535 {
536 // enable the child back unless it had been disabled before us
537 if ( !m_childrenDisabled || !m_childrenDisabled->Find(child) )
538 child->Enable();
539 }
540 else // we're being disabled
541 {
542 if ( child->IsEnabled() )
543 {
544 // disable it as children shouldn't stay enabled while the
545 // parent is not
546 child->Disable();
547 }
548 else // child already disabled, remember it
549 {
550 // have we created the list of disabled children already?
551 if ( !m_childrenDisabled )
552 m_childrenDisabled = new wxWindowList;
553
554 m_childrenDisabled->Append(child);
555 }
556 }
557 }
558
559 if ( enable && m_childrenDisabled )
560 {
561 // we don't need this list any more, don't keep unused memory
562 delete m_childrenDisabled;
563 m_childrenDisabled = NULL;
564 }
565
566 return TRUE;
567 }
568
569 bool wxWindowMSW::Show(bool show)
570 {
571 if ( !wxWindowBase::Show(show) )
572 return FALSE;
573
574 HWND hWnd = GetHwnd();
575 int cshow = show ? SW_SHOW : SW_HIDE;
576 ::ShowWindow(hWnd, cshow);
577
578 if ( show && IsTopLevel() )
579 {
580 wxBringWindowToTop(hWnd);
581 }
582
583 return TRUE;
584 }
585
586 // Raise the window to the top of the Z order
587 void wxWindowMSW::Raise()
588 {
589 wxBringWindowToTop(GetHwnd());
590 }
591
592 // Lower the window to the bottom of the Z order
593 void wxWindowMSW::Lower()
594 {
595 ::SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0,
596 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
597 }
598
599 void wxWindowMSW::SetTitle( const wxString& title)
600 {
601 SetWindowText(GetHwnd(), title.c_str());
602 }
603
604 wxString wxWindowMSW::GetTitle() const
605 {
606 return wxGetWindowText(GetHWND());
607 }
608
609 void wxWindowMSW::DoCaptureMouse()
610 {
611 HWND hWnd = GetHwnd();
612 if ( hWnd )
613 {
614 ::SetCapture(hWnd);
615 }
616 }
617
618 void wxWindowMSW::DoReleaseMouse()
619 {
620 if ( !::ReleaseCapture() )
621 {
622 wxLogLastError(_T("ReleaseCapture"));
623 }
624 }
625
626 /* static */ wxWindow *wxWindowBase::GetCapture()
627 {
628 HWND hwnd = ::GetCapture();
629 return hwnd ? wxFindWinFromHandle((WXHWND)hwnd) : (wxWindow *)NULL;
630 }
631
632 bool wxWindowMSW::SetFont(const wxFont& font)
633 {
634 if ( !wxWindowBase::SetFont(font) )
635 {
636 // nothing to do
637 return FALSE;
638 }
639
640 HWND hWnd = GetHwnd();
641 if ( hWnd != 0 )
642 {
643 WXHANDLE hFont = m_font.GetResourceHandle();
644
645 wxASSERT_MSG( hFont, wxT("should have valid font") );
646
647 ::SendMessage(hWnd, WM_SETFONT, (WPARAM)hFont, MAKELPARAM(TRUE, 0));
648 }
649
650 return TRUE;
651 }
652 bool wxWindowMSW::SetCursor(const wxCursor& cursor)
653 {
654 if ( !wxWindowBase::SetCursor(cursor) )
655 {
656 // no change
657 return FALSE;
658 }
659
660 if ( m_cursor.Ok() )
661 {
662 HWND hWnd = GetHwnd();
663
664 // Change the cursor NOW if we're within the correct window
665 POINT point;
666 ::GetCursorPos(&point);
667
668 RECT rect = wxGetWindowRect(hWnd);
669
670 if ( ::PtInRect(&rect, point) && !wxIsBusy() )
671 ::SetCursor(GetHcursorOf(m_cursor));
672 }
673
674 return TRUE;
675 }
676
677 void wxWindowMSW::WarpPointer (int x, int y)
678 {
679 ClientToScreen(&x, &y);
680
681 if ( !::SetCursorPos(x, y) )
682 {
683 wxLogLastError(_T("SetCursorPos"));
684 }
685 }
686
687 #if WXWIN_COMPATIBILITY
688 void wxWindowMSW::MSWDeviceToLogical (float *x, float *y) const
689 {
690 }
691 #endif // WXWIN_COMPATIBILITY
692
693 // ---------------------------------------------------------------------------
694 // scrolling stuff
695 // ---------------------------------------------------------------------------
696
697 // convert wxHORIZONTAL/wxVERTICAL to SB_HORZ/SB_VERT
698 static inline int wxDirToWinStyle(int orient)
699 {
700 return orient == wxHORIZONTAL ? SB_HORZ : SB_VERT;
701 }
702
703 #if WXWIN_COMPATIBILITY
704 void wxWindowMSW::SetScrollRange(int orient, int range, bool refresh)
705 {
706 int range1 = range;
707
708 // Try to adjust the range to cope with page size > 1
709 // - a Windows API quirk
710 int pageSize = GetScrollPage(orient);
711 if ( pageSize > 1 && range > 0)
712 {
713 range1 += (pageSize - 1);
714 }
715
716 WinStruct<SCROLLINFO> info;
717 info.nPage = pageSize; // Have to set this, or scrollbar goes awry
718 info.nMin = 0;
719 info.nMax = range1;
720 info.fMask = SIF_RANGE | SIF_PAGE;
721
722 HWND hWnd = GetHwnd();
723 if ( hWnd )
724 ::SetScrollInfo(hWnd, wxDirToWinStyle(orient), &info, refresh);
725 }
726
727 void wxWindowMSW::SetScrollPage(int orient, int page, bool refresh)
728 {
729 WinStruct<SCROLLINFO> info;
730 info.nPage = page;
731 info.fMask = SIF_PAGE;
732
733 HWND hWnd = GetHwnd();
734 if ( hWnd )
735 ::SetScrollInfo(hWnd, wxDirToWinStyle(orient), &info, refresh);
736 }
737
738 int wxWindowMSW::GetScrollPage(int orient) const
739 {
740 return orient == wxHORIZONTAL ? m_xThumbSize : m_yThumbSize;
741 }
742
743 #endif // WXWIN_COMPATIBILITY
744
745 inline int GetScrollPosition(HWND hWnd, int wOrient)
746 {
747 #ifdef __WXMICROWIN__
748 return ::GetScrollPosWX(hWnd, wOrient);
749 #else
750 SCROLLINFO scrollInfo;
751 scrollInfo.cbSize = sizeof(SCROLLINFO);
752 scrollInfo.fMask = SIF_POS;
753 if ( !::GetScrollInfo(hWnd,
754 wOrient,
755 &scrollInfo) )
756 {
757 wxLogLastError(_T("GetScrollInfo"));
758 }
759 return scrollInfo.nPos;
760 // return ::GetScrollPos(hWnd, wOrient);
761 #endif
762 }
763
764 int wxWindowMSW::GetScrollPos(int orient) const
765 {
766 HWND hWnd = GetHwnd();
767 wxCHECK_MSG( hWnd, 0, _T("no HWND in GetScrollPos") );
768
769 return GetScrollPosition(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT);
770 }
771
772 // This now returns the whole range, not just the number
773 // of positions that we can scroll.
774 int wxWindowMSW::GetScrollRange(int orient) const
775 {
776 int maxPos;
777 HWND hWnd = GetHwnd();
778 if ( !hWnd )
779 return 0;
780 #if 0
781 ::GetScrollRange(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
782 &minPos, &maxPos);
783 #endif
784 SCROLLINFO scrollInfo;
785 scrollInfo.fMask = SIF_RANGE;
786 if ( !::GetScrollInfo(hWnd,
787 orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
788 &scrollInfo) )
789 {
790 wxLogLastError(_T("GetScrollInfo"));
791 }
792 maxPos = scrollInfo.nMax;
793
794 // undo "range - 1" done in SetScrollbar()
795 return maxPos + 1;
796 }
797
798 int wxWindowMSW::GetScrollThumb(int orient) const
799 {
800 return orient == wxHORIZONTAL ? m_xThumbSize : m_yThumbSize;
801 }
802
803 void wxWindowMSW::SetScrollPos(int orient, int pos, bool refresh)
804 {
805 HWND hWnd = GetHwnd();
806 wxCHECK_RET( hWnd, _T("SetScrollPos: no HWND") );
807
808 WinStruct<SCROLLINFO> info;
809 info.nPage = 0;
810 info.nMin = 0;
811 info.nPos = pos;
812 info.fMask = SIF_POS;
813 if ( HasFlag(wxALWAYS_SHOW_SB) )
814 {
815 // disable scrollbar instead of removing it then
816 info.fMask |= SIF_DISABLENOSCROLL;
817 }
818
819 ::SetScrollInfo(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
820 &info, refresh);
821 }
822
823 // New function that will replace some of the above.
824 void wxWindowMSW::SetScrollbar(int orient,
825 int pos,
826 int pageSize,
827 int range,
828 bool refresh)
829 {
830 WinStruct<SCROLLINFO> info;
831 info.nPage = pageSize;
832 info.nMin = 0; // range is nMax - nMin + 1
833 info.nMax = range - 1; // as both nMax and nMax are inclusive
834 info.nPos = pos;
835 info.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
836 if ( HasFlag(wxALWAYS_SHOW_SB) )
837 {
838 // disable scrollbar instead of removing it then
839 info.fMask |= SIF_DISABLENOSCROLL;
840 }
841
842 HWND hWnd = GetHwnd();
843 if ( hWnd )
844 {
845 ::SetScrollInfo(hWnd, orient == wxHORIZONTAL ? SB_HORZ : SB_VERT,
846 &info, refresh);
847 }
848
849 *(orient == wxHORIZONTAL ? &m_xThumbSize : &m_yThumbSize) = pageSize;
850 }
851
852 void wxWindowMSW::ScrollWindow(int dx, int dy, const wxRect *prect)
853 {
854 RECT rect;
855 RECT *pr;
856 if ( prect )
857 {
858 rect.left = prect->x;
859 rect.top = prect->y;
860 rect.right = prect->x + prect->width;
861 rect.bottom = prect->y + prect->height;
862 pr = &rect;
863 }
864 else
865 {
866 pr = NULL;
867 }
868
869 #ifdef __WXWINCE__
870 // FIXME: is this the exact equivalent of the line below?
871 ::ScrollWindowEx(GetHwnd(), dx, dy, pr, pr, 0, 0, SW_ERASE|SW_INVALIDATE);
872 #else
873 ::ScrollWindow(GetHwnd(), dx, dy, pr, pr);
874 #endif
875 }
876
877 static bool ScrollVertically(HWND hwnd, int kind, int count)
878 {
879 int posStart = GetScrollPosition(hwnd, SB_VERT);
880
881 int pos = posStart;
882 for ( int n = 0; n < count; n++ )
883 {
884 ::SendMessage(hwnd, WM_VSCROLL, kind, 0);
885
886 int posNew = GetScrollPosition(hwnd, SB_VERT);
887 if ( posNew == pos )
888 {
889 // don't bother to continue, we're already at top/bottom
890 break;
891 }
892
893 pos = posNew;
894 }
895
896 return pos != posStart;
897 }
898
899 bool wxWindowMSW::ScrollLines(int lines)
900 {
901 bool down = lines > 0;
902
903 return ScrollVertically(GetHwnd(),
904 down ? SB_LINEDOWN : SB_LINEUP,
905 down ? lines : -lines);
906 }
907
908 bool wxWindowMSW::ScrollPages(int pages)
909 {
910 bool down = pages > 0;
911
912 return ScrollVertically(GetHwnd(),
913 down ? SB_PAGEDOWN : SB_PAGEUP,
914 down ? pages : -pages);
915 }
916
917 // ---------------------------------------------------------------------------
918 // subclassing
919 // ---------------------------------------------------------------------------
920
921 void wxWindowMSW::SubclassWin(WXHWND hWnd)
922 {
923 wxASSERT_MSG( !m_oldWndProc, wxT("subclassing window twice?") );
924
925 HWND hwnd = (HWND)hWnd;
926 wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in SubclassWin") );
927
928 wxAssociateWinWithHandle(hwnd, this);
929
930 m_oldWndProc = (WXFARPROC)::GetWindowLong((HWND)hWnd, GWL_WNDPROC);
931
932 // we don't need to subclass the window of our own class (in the Windows
933 // sense of the word)
934 if ( !wxCheckWindowWndProc(hWnd, (WXFARPROC)wxWndProc) )
935 {
936 ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) wxWndProc);
937 }
938 else
939 {
940 // don't bother restoring it neither: this also makes it easy to
941 // implement IsOfStandardClass() method which returns TRUE for the
942 // standard controls and FALSE for the wxWindows own windows as it can
943 // simply check m_oldWndProc
944 m_oldWndProc = NULL;
945 }
946 }
947
948 void wxWindowMSW::UnsubclassWin()
949 {
950 wxRemoveHandleAssociation(this);
951
952 // Restore old Window proc
953 HWND hwnd = GetHwnd();
954 if ( hwnd )
955 {
956 m_hWnd = 0;
957
958 wxCHECK_RET( ::IsWindow(hwnd), wxT("invalid HWND in UnsubclassWin") );
959
960 if ( m_oldWndProc )
961 {
962 if ( !wxCheckWindowWndProc((WXHWND)hwnd, m_oldWndProc) )
963 {
964 ::SetWindowLong(hwnd, GWL_WNDPROC, (LONG) m_oldWndProc);
965 }
966
967 m_oldWndProc = NULL;
968 }
969 }
970 }
971
972 bool wxCheckWindowWndProc(WXHWND hWnd, WXFARPROC wndProc)
973 {
974 // Unicows note: the code below works, but only because WNDCLASS contains
975 // original window handler rather that the unicows fake one. This may not
976 // be on purpose, though; if it stops working with future versions of
977 // unicows.dll, we can override unicows hooks by setting
978 // Unicows_{Set,Get}WindowLong and Unicows_RegisterClass to our own
979 // versions that keep track of fake<->real wnd proc mapping.
980
981 // On WinCE (at least), the wndproc comparison doesn't work,
982 // so have to use something like this.
983 #ifdef __WXWINCE__
984 extern const wxChar *wxCanvasClassName;
985 extern const wxChar *wxCanvasClassNameNR;
986 extern const wxChar *wxMDIFrameClassName;
987 extern const wxChar *wxMDIFrameClassNameNoRedraw;
988 extern const wxChar *wxMDIChildFrameClassName;
989 extern const wxChar *wxMDIChildFrameClassNameNoRedraw;
990 wxString str(wxGetWindowClass(hWnd));
991 if (str == wxCanvasClassName ||
992 str == wxCanvasClassNameNR ||
993 str == wxMDIFrameClassName ||
994 str == wxMDIFrameClassNameNoRedraw ||
995 str == wxMDIChildFrameClassName ||
996 str == wxMDIChildFrameClassNameNoRedraw ||
997 str == _T("wxTLWHiddenParent"))
998 return TRUE; // Effectively means don't subclass
999 else
1000 return FALSE;
1001 #else
1002 WNDCLASS cls;
1003 if ( !::GetClassInfo(wxGetInstance(), wxGetWindowClass(hWnd), &cls) )
1004 {
1005 wxLogLastError(_T("GetClassInfo"));
1006
1007 return FALSE;
1008 }
1009
1010 return wndProc == (WXFARPROC)cls.lpfnWndProc;
1011 #endif
1012 }
1013
1014 // ----------------------------------------------------------------------------
1015 // Style handling
1016 // ----------------------------------------------------------------------------
1017
1018 void wxWindowMSW::SetWindowStyleFlag(long flags)
1019 {
1020 long flagsOld = GetWindowStyleFlag();
1021 if ( flags == flagsOld )
1022 return;
1023
1024 // update the internal variable
1025 wxWindowBase::SetWindowStyleFlag(flags);
1026
1027 // now update the Windows style as well if needed - and if the window had
1028 // been already created
1029 if ( !GetHwnd() )
1030 return;
1031
1032 WXDWORD exstyle, exstyleOld;
1033 long style = MSWGetStyle(flags, &exstyle),
1034 styleOld = MSWGetStyle(flagsOld, &exstyleOld);
1035
1036 if ( style != styleOld )
1037 {
1038 // some flags (e.g. WS_VISIBLE or WS_DISABLED) should not be changed by
1039 // this function so instead of simply setting the style to the new
1040 // value we clear the bits which were set in styleOld but are set in
1041 // the new one and set the ones which were not set before
1042 long styleReal = ::GetWindowLong(GetHwnd(), GWL_STYLE);
1043 styleReal &= ~styleOld;
1044 styleReal |= style;
1045
1046 ::SetWindowLong(GetHwnd(), GWL_STYLE, styleReal);
1047 }
1048
1049 // and the extended style
1050 if ( exstyle != exstyleOld )
1051 {
1052 long exstyleReal = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
1053 exstyleReal &= ~exstyleOld;
1054 exstyleReal |= exstyle;
1055
1056 ::SetWindowLong(GetHwnd(), GWL_EXSTYLE, exstyleReal);
1057
1058 // we must call SetWindowPos() to flash the cached extended style and
1059 // also to make the change to wxSTAY_ON_TOP style take effect: just
1060 // setting the style simply doesn't work
1061 if ( !::SetWindowPos(GetHwnd(),
1062 exstyleReal & WS_EX_TOPMOST ? HWND_TOPMOST
1063 : HWND_NOTOPMOST,
1064 0, 0, 0, 0,
1065 SWP_NOMOVE | SWP_NOSIZE) )
1066 {
1067 wxLogLastError(_T("SetWindowPos"));
1068 }
1069 }
1070 }
1071
1072 WXDWORD wxWindowMSW::MSWGetStyle(long flags, WXDWORD *exstyle) const
1073 {
1074 // translate the style
1075 WXDWORD style = WS_CHILD | WS_VISIBLE;
1076
1077 if ( flags & wxCLIP_CHILDREN )
1078 style |= WS_CLIPCHILDREN;
1079
1080 if ( flags & wxCLIP_SIBLINGS )
1081 style |= WS_CLIPSIBLINGS;
1082
1083 if ( flags & wxVSCROLL )
1084 style |= WS_VSCROLL;
1085
1086 if ( flags & wxHSCROLL )
1087 style |= WS_HSCROLL;
1088
1089 const wxBorder border = GetBorder(flags);
1090
1091 // WS_BORDER is only required for wxBORDER_SIMPLE
1092 if ( border == wxBORDER_SIMPLE )
1093 style |= WS_BORDER;
1094
1095 // now deal with ext style if the caller wants it
1096 if ( exstyle )
1097 {
1098 *exstyle = 0;
1099
1100 #ifndef __WXWINCE__
1101 if ( flags & wxTRANSPARENT_WINDOW )
1102 *exstyle |= WS_EX_TRANSPARENT;
1103 #endif
1104
1105 switch ( border )
1106 {
1107 default:
1108 case wxBORDER_DEFAULT:
1109 wxFAIL_MSG( _T("unknown border style") );
1110 // fall through
1111
1112 case wxBORDER_NONE:
1113 case wxBORDER_SIMPLE:
1114 break;
1115
1116 case wxBORDER_STATIC:
1117 *exstyle |= WS_EX_STATICEDGE;
1118 break;
1119
1120 case wxBORDER_RAISED:
1121 *exstyle |= WS_EX_DLGMODALFRAME;
1122 break;
1123
1124 case wxBORDER_SUNKEN:
1125 *exstyle |= WS_EX_CLIENTEDGE;
1126 style &= ~WS_BORDER;
1127 break;
1128
1129 case wxBORDER_DOUBLE:
1130 *exstyle |= WS_EX_DLGMODALFRAME;
1131 break;
1132 }
1133
1134 // wxUniv doesn't use Windows dialog navigation functions at all
1135 #if !defined(__WXUNIVERSAL__) && !defined(__WXWINCE__)
1136 // to make the dialog navigation work with the nested panels we must
1137 // use this style (top level windows such as dialogs don't need it)
1138 if ( (flags & wxTAB_TRAVERSAL) && !IsTopLevel() )
1139 {
1140 *exstyle |= WS_EX_CONTROLPARENT;
1141 }
1142 #endif // __WXUNIVERSAL__
1143 }
1144
1145 return style;
1146 }
1147
1148 #if WXWIN_COMPATIBILITY
1149 // If nothing defined for this, try the parent.
1150 // E.g. we may be a button loaded from a resource, with no callback function
1151 // defined.
1152 void wxWindowMSW::OnCommand(wxWindow& win, wxCommandEvent& event)
1153 {
1154 if ( GetEventHandler()->ProcessEvent(event) )
1155 return;
1156 if ( m_parent )
1157 m_parent->GetEventHandler()->OnCommand(win, event);
1158 }
1159 #endif // WXWIN_COMPATIBILITY_2
1160
1161 #if WXWIN_COMPATIBILITY
1162 wxObject* wxWindowMSW::GetChild(int number) const
1163 {
1164 // Return a pointer to the Nth object in the Panel
1165 wxNode *node = GetChildren().First();
1166 int n = number;
1167 while (node && n--)
1168 node = node->Next();
1169 if ( node )
1170 {
1171 wxObject *obj = (wxObject *)node->Data();
1172 return(obj);
1173 }
1174 else
1175 return NULL;
1176 }
1177 #endif // WXWIN_COMPATIBILITY
1178
1179 // Setup background and foreground colours correctly
1180 void wxWindowMSW::SetupColours()
1181 {
1182 if ( GetParent() )
1183 SetBackgroundColour(GetParent()->GetBackgroundColour());
1184 }
1185
1186 bool wxWindowMSW::IsMouseInWindow() const
1187 {
1188 // get the mouse position
1189 POINT pt;
1190 ::GetCursorPos(&pt);
1191
1192 // find the window which currently has the cursor and go up the window
1193 // chain until we find this window - or exhaust it
1194 HWND hwnd = ::WindowFromPoint(pt);
1195 while ( hwnd && (hwnd != GetHwnd()) )
1196 hwnd = ::GetParent(hwnd);
1197
1198 return hwnd != NULL;
1199 }
1200
1201 void wxWindowMSW::OnInternalIdle()
1202 {
1203 // Check if we need to send a LEAVE event
1204 if ( m_mouseInWindow )
1205 {
1206 // note that we should generate the leave event whether the window has
1207 // or doesn't have mouse capture
1208 if ( !IsMouseInWindow() )
1209 {
1210 // Generate a LEAVE event
1211 m_mouseInWindow = FALSE;
1212
1213 // Unfortunately the mouse button and keyboard state may have
1214 // changed by the time the OnInternalIdle function is called, so 'state'
1215 // may be meaningless.
1216 int state = 0;
1217 if ( wxIsShiftDown() )
1218 state |= MK_SHIFT;
1219 if ( wxIsCtrlDown() )
1220 state |= MK_CONTROL;
1221 if ( GetKeyState( VK_LBUTTON ) )
1222 state |= MK_LBUTTON;
1223 if ( GetKeyState( VK_MBUTTON ) )
1224 state |= MK_MBUTTON;
1225 if ( GetKeyState( VK_RBUTTON ) )
1226 state |= MK_RBUTTON;
1227
1228 POINT pt;
1229 if ( !::GetCursorPos(&pt) )
1230 {
1231 wxLogLastError(_T("GetCursorPos"));
1232 }
1233
1234 // we need to have client coordinates here for symmetry with
1235 // wxEVT_ENTER_WINDOW
1236 RECT rect = wxGetWindowRect(GetHwnd());
1237 pt.x -= rect.left;
1238 pt.y -= rect.top;
1239
1240 wxMouseEvent event2(wxEVT_LEAVE_WINDOW);
1241 InitMouseEvent(event2, pt.x, pt.y, state);
1242
1243 (void)GetEventHandler()->ProcessEvent(event2);
1244 }
1245 }
1246
1247 if (wxUpdateUIEvent::CanUpdate(this))
1248 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1249 }
1250
1251 // Set this window to be the child of 'parent'.
1252 bool wxWindowMSW::Reparent(wxWindowBase *parent)
1253 {
1254 if ( !wxWindowBase::Reparent(parent) )
1255 return FALSE;
1256
1257 HWND hWndChild = GetHwnd();
1258 HWND hWndParent = GetParent() ? GetWinHwnd(GetParent()) : (HWND)0;
1259
1260 ::SetParent(hWndChild, hWndParent);
1261
1262 return TRUE;
1263 }
1264
1265 void wxWindowMSW::Clear()
1266 {
1267 wxClientDC dc((wxWindow *)this);
1268 wxBrush brush(GetBackgroundColour(), wxSOLID);
1269 dc.SetBackground(brush);
1270 dc.Clear();
1271 }
1272
1273 static inline void SendSetRedraw(HWND hwnd, bool on)
1274 {
1275 #ifndef __WXMICROWIN__
1276 ::SendMessage(hwnd, WM_SETREDRAW, (WPARAM)on, 0);
1277 #endif
1278 }
1279
1280 void wxWindowMSW::Freeze()
1281 {
1282 SendSetRedraw(GetHwnd(), FALSE);
1283 }
1284
1285 void wxWindowMSW::Thaw()
1286 {
1287 SendSetRedraw(GetHwnd(), TRUE);
1288
1289 // we need to refresh everything or otherwise he invalidated area is not
1290 // repainted
1291 Refresh();
1292 }
1293
1294 void wxWindowMSW::Refresh(bool eraseBack, const wxRect *rect)
1295 {
1296 HWND hWnd = GetHwnd();
1297 if ( hWnd )
1298 {
1299 if ( rect )
1300 {
1301 RECT mswRect;
1302 mswRect.left = rect->x;
1303 mswRect.top = rect->y;
1304 mswRect.right = rect->x + rect->width;
1305 mswRect.bottom = rect->y + rect->height;
1306
1307 ::InvalidateRect(hWnd, &mswRect, eraseBack);
1308 }
1309 else
1310 ::InvalidateRect(hWnd, NULL, eraseBack);
1311 }
1312 }
1313
1314 void wxWindowMSW::Update()
1315 {
1316 if ( !::UpdateWindow(GetHwnd()) )
1317 {
1318 wxLogLastError(_T("UpdateWindow"));
1319 }
1320
1321 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
1322 // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
1323 // handler needs to be really drawn right now
1324 (void)::GdiFlush();
1325 #endif // __WIN32__
1326 }
1327
1328 // ---------------------------------------------------------------------------
1329 // drag and drop
1330 // ---------------------------------------------------------------------------
1331
1332
1333 #if wxUSE_DRAG_AND_DROP
1334 void wxWindowMSW::SetDropTarget(wxDropTarget *pDropTarget)
1335 {
1336 if ( m_dropTarget != 0 ) {
1337 m_dropTarget->Revoke(m_hWnd);
1338 delete m_dropTarget;
1339 }
1340
1341 m_dropTarget = pDropTarget;
1342 if ( m_dropTarget != 0 )
1343 m_dropTarget->Register(m_hWnd);
1344 }
1345 #endif // wxUSE_DRAG_AND_DROP
1346
1347 // old style file-manager drag&drop support: we retain the old-style
1348 // DragAcceptFiles in parallel with SetDropTarget.
1349 void wxWindowMSW::DragAcceptFiles(bool accept)
1350 {
1351 #if !defined(__WXWINCE__)
1352 HWND hWnd = GetHwnd();
1353 if ( hWnd )
1354 ::DragAcceptFiles(hWnd, (BOOL)accept);
1355 #endif
1356 }
1357
1358 // ----------------------------------------------------------------------------
1359 // tooltips
1360 // ----------------------------------------------------------------------------
1361
1362 #if wxUSE_TOOLTIPS
1363
1364 void wxWindowMSW::DoSetToolTip(wxToolTip *tooltip)
1365 {
1366 wxWindowBase::DoSetToolTip(tooltip);
1367
1368 if ( m_tooltip )
1369 m_tooltip->SetWindow((wxWindow *)this);
1370 }
1371
1372 #endif // wxUSE_TOOLTIPS
1373
1374 // ---------------------------------------------------------------------------
1375 // moving and resizing
1376 // ---------------------------------------------------------------------------
1377
1378 // Get total size
1379 void wxWindowMSW::DoGetSize(int *x, int *y) const
1380 {
1381 RECT rect = wxGetWindowRect(GetHwnd());
1382
1383 if ( x )
1384 *x = rect.right - rect.left;
1385 if ( y )
1386 *y = rect.bottom - rect.top;
1387 }
1388
1389 // Get size *available for subwindows* i.e. excluding menu bar etc.
1390 void wxWindowMSW::DoGetClientSize(int *x, int *y) const
1391 {
1392 RECT rect = wxGetClientRect(GetHwnd());
1393
1394 if ( x )
1395 *x = rect.right;
1396 if ( y )
1397 *y = rect.bottom;
1398 }
1399
1400 void wxWindowMSW::DoGetPosition(int *x, int *y) const
1401 {
1402 RECT rect = wxGetWindowRect(GetHwnd());
1403
1404 POINT point;
1405 point.x = rect.left;
1406 point.y = rect.top;
1407
1408 // we do the adjustments with respect to the parent only for the "real"
1409 // children, not for the dialogs/frames
1410 if ( !IsTopLevel() )
1411 {
1412 HWND hParentWnd = 0;
1413 wxWindow *parent = GetParent();
1414 if ( parent )
1415 hParentWnd = GetWinHwnd(parent);
1416
1417 // Since we now have the absolute screen coords, if there's a parent we
1418 // must subtract its top left corner
1419 if ( hParentWnd )
1420 {
1421 ::ScreenToClient(hParentWnd, &point);
1422 }
1423
1424 if ( parent )
1425 {
1426 // We may be faking the client origin. So a window that's really at (0,
1427 // 30) may appear (to wxWin apps) to be at (0, 0).
1428 wxPoint pt(parent->GetClientAreaOrigin());
1429 point.x -= pt.x;
1430 point.y -= pt.y;
1431 }
1432 }
1433
1434 if ( x )
1435 *x = point.x;
1436 if ( y )
1437 *y = point.y;
1438 }
1439
1440 void wxWindowMSW::DoScreenToClient(int *x, int *y) const
1441 {
1442 POINT pt;
1443 if ( x )
1444 pt.x = *x;
1445 if ( y )
1446 pt.y = *y;
1447
1448 ::ScreenToClient(GetHwnd(), &pt);
1449
1450 if ( x )
1451 *x = pt.x;
1452 if ( y )
1453 *y = pt.y;
1454 }
1455
1456 void wxWindowMSW::DoClientToScreen(int *x, int *y) const
1457 {
1458 POINT pt;
1459 if ( x )
1460 pt.x = *x;
1461 if ( y )
1462 pt.y = *y;
1463
1464 ::ClientToScreen(GetHwnd(), &pt);
1465
1466 if ( x )
1467 *x = pt.x;
1468 if ( y )
1469 *y = pt.y;
1470 }
1471
1472 void wxWindowMSW::DoMoveWindow(int x, int y, int width, int height)
1473 {
1474 // TODO: is this consistent with other platforms?
1475 // Still, negative width or height shouldn't be allowed
1476 if (width < 0)
1477 width = 0;
1478 if (height < 0)
1479 height = 0;
1480 if ( !::MoveWindow(GetHwnd(), x, y, width, height, TRUE) )
1481 {
1482 wxLogLastError(wxT("MoveWindow"));
1483 }
1484 }
1485
1486 // set the size of the window: if the dimensions are positive, just use them,
1487 // but if any of them is equal to -1, it means that we must find the value for
1488 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
1489 // which case -1 is a valid value for x and y)
1490 //
1491 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
1492 // the width/height to best suit our contents, otherwise we reuse the current
1493 // width/height
1494 void wxWindowMSW::DoSetSize(int x, int y, int width, int height, int sizeFlags)
1495 {
1496 // get the current size and position...
1497 int currentX, currentY;
1498 GetPosition(&currentX, &currentY);
1499 int currentW,currentH;
1500 GetSize(&currentW, &currentH);
1501
1502 // ... and don't do anything (avoiding flicker) if it's already ok
1503 if ( x == currentX && y == currentY &&
1504 width == currentW && height == currentH )
1505 {
1506 return;
1507 }
1508
1509 if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1510 x = currentX;
1511 if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1512 y = currentY;
1513
1514 AdjustForParentClientOrigin(x, y, sizeFlags);
1515
1516 wxSize size(-1, -1);
1517 if ( width == -1 )
1518 {
1519 if ( sizeFlags & wxSIZE_AUTO_WIDTH )
1520 {
1521 size = DoGetBestSize();
1522 width = size.x;
1523 }
1524 else
1525 {
1526 // just take the current one
1527 width = currentW;
1528 }
1529 }
1530
1531 if ( height == -1 )
1532 {
1533 if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
1534 {
1535 if ( size.x == -1 )
1536 {
1537 size = DoGetBestSize();
1538 }
1539 //else: already called DoGetBestSize() above
1540
1541 height = size.y;
1542 }
1543 else
1544 {
1545 // just take the current one
1546 height = currentH;
1547 }
1548 }
1549
1550 DoMoveWindow(x, y, width, height);
1551 }
1552
1553 void wxWindowMSW::DoSetClientSize(int width, int height)
1554 {
1555 // setting the client size is less obvious than it it could have been
1556 // because in the result of changing the total size the window scrollbar
1557 // may [dis]appear and/or its menubar may [un]wrap and so the client size
1558 // will not be correct as the difference between the total and client size
1559 // changes - so we keep changing it until we get it right
1560 //
1561 // normally this loop shouldn't take more than 3 iterations (usually 1 but
1562 // if scrollbars [dis]appear as the result of the first call, then 2 and it
1563 // may become 3 if the window had 0 size originally and so we didn't
1564 // calculate the scrollbar correction correctly during the first iteration)
1565 // but just to be on the safe side we check for it instead of making it an
1566 // "infinite" loop (i.e. leaving break inside as the only way to get out)
1567 for ( int i = 0; i < 4; i++ )
1568 {
1569 RECT rectClient;
1570 ::GetClientRect(GetHwnd(), &rectClient);
1571
1572 // if the size is already ok, stop here (rectClient.left = top = 0)
1573 if ( (rectClient.right == width || width == -1) &&
1574 (rectClient.bottom == height || height == -1) )
1575 {
1576 break;
1577 }
1578
1579 int widthClient = width,
1580 heightClient = height;
1581
1582 // Find the difference between the entire window (title bar and all)
1583 // and the client area; add this to the new client size to move the
1584 // window
1585 RECT rectWin;
1586 ::GetWindowRect(GetHwnd(), &rectWin);
1587
1588 widthClient += rectWin.right - rectWin.left - rectClient.right;
1589 heightClient += rectWin.bottom - rectWin.top - rectClient.bottom;
1590
1591 POINT point;
1592 point.x = rectWin.left;
1593 point.y = rectWin.top;
1594
1595 // MoveWindow positions the child windows relative to the parent, so
1596 // adjust if necessary
1597 if ( !IsTopLevel() )
1598 {
1599 wxWindow *parent = GetParent();
1600 if ( parent )
1601 {
1602 ::ScreenToClient(GetHwndOf(parent), &point);
1603 }
1604 }
1605
1606 DoMoveWindow(point.x, point.y, widthClient, heightClient);
1607 }
1608 }
1609
1610 // For implementation purposes - sometimes decorations make the client area
1611 // smaller
1612 wxPoint wxWindowMSW::GetClientAreaOrigin() const
1613 {
1614 return wxPoint(0, 0);
1615 }
1616
1617 // ---------------------------------------------------------------------------
1618 // text metrics
1619 // ---------------------------------------------------------------------------
1620
1621 int wxWindowMSW::GetCharHeight() const
1622 {
1623 return wxGetTextMetrics(this).tmHeight;
1624 }
1625
1626 int wxWindowMSW::GetCharWidth() const
1627 {
1628 // +1 is needed because Windows apparently adds it when calculating the
1629 // dialog units size in pixels
1630 #if wxDIALOG_UNIT_COMPATIBILITY
1631 return wxGetTextMetrics(this).tmAveCharWidth;
1632 #else
1633 return wxGetTextMetrics(this).tmAveCharWidth + 1;
1634 #endif
1635 }
1636
1637 void wxWindowMSW::GetTextExtent(const wxString& string,
1638 int *x, int *y,
1639 int *descent, int *externalLeading,
1640 const wxFont *theFont) const
1641 {
1642 const wxFont *fontToUse = theFont;
1643 if ( !fontToUse )
1644 fontToUse = &m_font;
1645
1646 HWND hWnd = GetHwnd();
1647 HDC dc = ::GetDC(hWnd);
1648
1649 HFONT fnt = 0;
1650 HFONT hfontOld = 0;
1651 if ( fontToUse && fontToUse->Ok() )
1652 {
1653 fnt = (HFONT)((wxFont *)fontToUse)->GetResourceHandle(); // const_cast
1654 if ( fnt )
1655 hfontOld = (HFONT)SelectObject(dc,fnt);
1656 }
1657
1658 SIZE sizeRect;
1659 TEXTMETRIC tm;
1660 GetTextExtentPoint(dc, string, (int)string.Length(), &sizeRect);
1661 GetTextMetrics(dc, &tm);
1662
1663 if ( fontToUse && fnt && hfontOld )
1664 SelectObject(dc, hfontOld);
1665
1666 ReleaseDC(hWnd, dc);
1667
1668 if ( x )
1669 *x = sizeRect.cx;
1670 if ( y )
1671 *y = sizeRect.cy;
1672 if ( descent )
1673 *descent = tm.tmDescent;
1674 if ( externalLeading )
1675 *externalLeading = tm.tmExternalLeading;
1676 }
1677
1678 #if wxUSE_CARET && WXWIN_COMPATIBILITY
1679 // ---------------------------------------------------------------------------
1680 // Caret manipulation
1681 // ---------------------------------------------------------------------------
1682
1683 void wxWindowMSW::CreateCaret(int w, int h)
1684 {
1685 SetCaret(new wxCaret(this, w, h));
1686 }
1687
1688 void wxWindowMSW::CreateCaret(const wxBitmap *WXUNUSED(bitmap))
1689 {
1690 wxFAIL_MSG("not implemented");
1691 }
1692
1693 void wxWindowMSW::ShowCaret(bool show)
1694 {
1695 wxCHECK_RET( m_caret, "no caret to show" );
1696
1697 m_caret->Show(show);
1698 }
1699
1700 void wxWindowMSW::DestroyCaret()
1701 {
1702 SetCaret(NULL);
1703 }
1704
1705 void wxWindowMSW::SetCaretPos(int x, int y)
1706 {
1707 wxCHECK_RET( m_caret, "no caret to move" );
1708
1709 m_caret->Move(x, y);
1710 }
1711
1712 void wxWindowMSW::GetCaretPos(int *x, int *y) const
1713 {
1714 wxCHECK_RET( m_caret, "no caret to get position of" );
1715
1716 m_caret->GetPosition(x, y);
1717 }
1718 #endif // wxUSE_CARET
1719
1720 // ---------------------------------------------------------------------------
1721 // popup menu
1722 // ---------------------------------------------------------------------------
1723
1724 #if wxUSE_MENUS_NATIVE
1725
1726 // yield for WM_COMMAND events only, i.e. process all WM_COMMANDs in the queue
1727 // immediately, without waiting for the next event loop iteration
1728 //
1729 // NB: this function should probably be made public later as it can almost
1730 // surely replace wxYield() elsewhere as well
1731 static void wxYieldForCommandsOnly()
1732 {
1733 // peek all WM_COMMANDs (it will always return WM_QUIT too but we don't
1734 // want to process it here)
1735 MSG msg;
1736 while ( ::PeekMessage(&msg, (HWND)0, WM_COMMAND, WM_COMMAND, PM_REMOVE)
1737 && msg.message != WM_QUIT )
1738 {
1739 wxTheApp->DoMessage((WXMSG *)&msg);
1740 }
1741
1742 // If we retrieved a WM_QUIT, insert back into the message queue.
1743 if (msg.message == WM_QUIT)
1744 ::PostQuitMessage(0);
1745 }
1746
1747 bool wxWindowMSW::DoPopupMenu(wxMenu *menu, int x, int y)
1748 {
1749 menu->SetInvokingWindow(this);
1750 menu->UpdateUI();
1751
1752 HWND hWnd = GetHwnd();
1753 HMENU hMenu = GetHmenuOf(menu);
1754 POINT point;
1755 point.x = x;
1756 point.y = y;
1757 ::ClientToScreen(hWnd, &point);
1758 wxCurrentPopupMenu = menu;
1759 UINT flags = 0;
1760 #if !defined(__WXWINCE__)
1761 flags = TPM_RIGHTBUTTON;
1762 #endif
1763 ::TrackPopupMenu(hMenu, flags, point.x, point.y, 0, hWnd, NULL);
1764
1765 // we need to do it righ now as otherwise the events are never going to be
1766 // sent to wxCurrentPopupMenu from HandleCommand()
1767 //
1768 // note that even eliminating (ugly) wxCurrentPopupMenu global wouldn't
1769 // help and we'd still need wxYieldForCommandsOnly() as the menu may be
1770 // destroyed as soon as we return (it can be a local variable in the caller
1771 // for example) and so we do need to process the event immediately
1772 wxYieldForCommandsOnly();
1773
1774 wxCurrentPopupMenu = NULL;
1775
1776 menu->SetInvokingWindow(NULL);
1777
1778 return TRUE;
1779 }
1780
1781 #endif // wxUSE_MENUS_NATIVE
1782
1783 // ===========================================================================
1784 // pre/post message processing
1785 // ===========================================================================
1786
1787 long wxWindowMSW::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1788 {
1789 if ( m_oldWndProc )
1790 return ::CallWindowProc(CASTWNDPROC m_oldWndProc, GetHwnd(), (UINT) nMsg, (WPARAM) wParam, (LPARAM) lParam);
1791 else
1792 return ::DefWindowProc(GetHwnd(), nMsg, wParam, lParam);
1793 }
1794
1795 bool wxWindowMSW::MSWProcessMessage(WXMSG* pMsg)
1796 {
1797 // wxUniversal implements tab traversal itself
1798 #ifndef __WXUNIVERSAL__
1799 if ( m_hWnd != 0 && (GetWindowStyleFlag() & wxTAB_TRAVERSAL) )
1800 {
1801 // intercept dialog navigation keys
1802 MSG *msg = (MSG *)pMsg;
1803
1804 // here we try to do all the job which ::IsDialogMessage() usually does
1805 // internally
1806 #if 1
1807 if ( msg->message == WM_KEYDOWN )
1808 {
1809 bool bCtrlDown = wxIsCtrlDown();
1810 bool bShiftDown = wxIsShiftDown();
1811
1812 // WM_GETDLGCODE: ask the control if it wants the key for itself,
1813 // don't process it if it's the case (except for Ctrl-Tab/Enter
1814 // combinations which are always processed)
1815 LONG lDlgCode = 0;
1816 if ( !bCtrlDown )
1817 {
1818 lDlgCode = ::SendMessage(msg->hwnd, WM_GETDLGCODE, 0, 0);
1819
1820 // surprizingly, DLGC_WANTALLKEYS bit mask doesn't contain the
1821 // DLGC_WANTTAB nor DLGC_WANTARROWS bits although, logically,
1822 // it, of course, implies them
1823 if ( lDlgCode & DLGC_WANTALLKEYS )
1824 {
1825 lDlgCode |= DLGC_WANTTAB | DLGC_WANTARROWS;
1826 }
1827 }
1828
1829 bool bForward = TRUE,
1830 bWindowChange = FALSE;
1831
1832 // should we process this message specially?
1833 bool bProcess = TRUE;
1834 switch ( msg->wParam )
1835 {
1836 case VK_TAB:
1837 // assume that nobody wants Shift-TAB for himself - if we
1838 // don't do it there is no easy way for a control to grab
1839 // TABs but still let Shift-TAB work as navugation key
1840 if ( (lDlgCode & DLGC_WANTTAB) && !bShiftDown ) {
1841 bProcess = FALSE;
1842 }
1843 else {
1844 // Ctrl-Tab cycles thru notebook pages
1845 bWindowChange = bCtrlDown;
1846 bForward = !bShiftDown;
1847 }
1848 break;
1849
1850 case VK_UP:
1851 case VK_LEFT:
1852 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1853 bProcess = FALSE;
1854 else
1855 bForward = FALSE;
1856 break;
1857
1858 case VK_DOWN:
1859 case VK_RIGHT:
1860 if ( (lDlgCode & DLGC_WANTARROWS) || bCtrlDown )
1861 bProcess = FALSE;
1862 break;
1863
1864 case VK_RETURN:
1865 {
1866 if ( (lDlgCode & DLGC_WANTMESSAGE) && !bCtrlDown )
1867 {
1868 // control wants to process Enter itself, don't
1869 // call IsDialogMessage() which would interpret
1870 // it
1871 return FALSE;
1872 }
1873 else if ( lDlgCode & DLGC_BUTTON )
1874 {
1875 // let IsDialogMessage() handle this for all
1876 // buttons except the owner-drawn ones which it
1877 // just seems to ignore
1878 long style = ::GetWindowLong(msg->hwnd, GWL_STYLE);
1879 if ( (style & BS_OWNERDRAW) == BS_OWNERDRAW )
1880 {
1881 // emulate the button click
1882 wxWindow *btn = wxFindWinFromHandle((WXHWND)msg->hwnd);
1883 if ( btn )
1884 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
1885 }
1886
1887 bProcess = FALSE;
1888 }
1889 // FIXME: this should be handled by
1890 // wxNavigationKeyEvent handler and not here!!
1891 else
1892 {
1893 #if wxUSE_BUTTON
1894 wxButton *btn = wxDynamicCast(GetDefaultItem(),
1895 wxButton);
1896 if ( btn && btn->IsEnabled() )
1897 {
1898 // if we do have a default button, do press it
1899 btn->MSWCommand(BN_CLICKED, 0 /* unused */);
1900
1901 return TRUE;
1902 }
1903 else // no default button
1904 {
1905 #endif // wxUSE_BUTTON
1906 // this is a quick and dirty test for a text
1907 // control
1908 if ( !(lDlgCode & DLGC_HASSETSEL) )
1909 {
1910 // don't process Enter, the control might
1911 // need it for itself and don't let
1912 // ::IsDialogMessage() have it as it can
1913 // eat the Enter events sometimes
1914 return FALSE;
1915 }
1916 else if (!IsTopLevel())
1917 {
1918 // if not a top level window, let parent
1919 // handle it
1920 return FALSE;
1921 }
1922 //else: treat Enter as TAB: pass to the next
1923 // control as this is the best thing to do
1924 // if the text doesn't handle Enter itself
1925 }
1926 }
1927 }
1928 break;
1929
1930 default:
1931 bProcess = FALSE;
1932 }
1933
1934 if ( bProcess )
1935 {
1936 wxNavigationKeyEvent event;
1937 event.SetDirection(bForward);
1938 event.SetWindowChange(bWindowChange);
1939 event.SetEventObject(this);
1940
1941 if ( GetEventHandler()->ProcessEvent(event) )
1942 {
1943 return TRUE;
1944 }
1945 }
1946 }
1947 #else // 0
1948 // let ::IsDialogMessage() do almost everything and handle just the
1949 // things it doesn't here: Ctrl-TAB for switching notebook pages
1950 if ( msg->message == WM_KEYDOWN )
1951 {
1952 // don't process system keys here
1953 if ( !(HIWORD(msg->lParam) & KF_ALTDOWN) )
1954 {
1955 if ( (msg->wParam == VK_TAB) && wxIsCtrlDown() )
1956 {
1957 // find the first notebook parent and change its page
1958 wxWindow *win = this;
1959 wxNotebook *nbook = NULL;
1960 while ( win && !nbook )
1961 {
1962 nbook = wxDynamicCast(win, wxNotebook);
1963 win = win->GetParent();
1964 }
1965
1966 if ( nbook )
1967 {
1968 bool forward = !wxIsShiftDown();
1969
1970 nbook->AdvanceSelection(forward);
1971 }
1972 }
1973 }
1974 }
1975 #endif // 1/0
1976
1977 // we handle VK_ESCAPE ourselves in wxDialog::OnCharHook() and we
1978 // shouldn't let IsDialogMessage() get it as it _always_ eats the
1979 // message even when there is no cancel button and when the message is
1980 // needed by the control itself: in particular, it prevents the tree in
1981 // place edit control from being closed with Escape in a dialog
1982 if ( msg->message != WM_KEYDOWN || msg->wParam != VK_ESCAPE )
1983 {
1984 // ::IsDialogMessage() is broken and may sometimes hang the
1985 // application by going into an infinite loop, so we try to detect
1986 // [some of] the situatations when this may happen and not call it
1987 // then
1988
1989 // assume we can call it by default
1990 bool canSafelyCallIsDlgMsg = TRUE;
1991
1992 HWND hwndFocus = ::GetFocus();
1993
1994 // if the currently focused window itself has WS_EX_CONTROLPARENT style, ::IsDialogMessage() will also enter
1995 // an infinite loop, because it will recursively check the child
1996 // windows but not the window itself and so if none of the children
1997 // accepts focus it loops forever (as it only stops when it gets
1998 // back to the window it started from)
1999 //
2000 // while it is very unusual that a window with WS_EX_CONTROLPARENT
2001 // style has the focus, it can happen. One such possibility is if
2002 // all windows are either toplevel, wxDialog, wxPanel or static
2003 // controls and no window can actually accept keyboard input.
2004 #if !defined(__WXWINCE__)
2005 if ( ::GetWindowLong(hwndFocus, GWL_EXSTYLE) & WS_EX_CONTROLPARENT )
2006 {
2007 // passimistic by default
2008 canSafelyCallIsDlgMsg = FALSE;
2009 for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
2010 node;
2011 node = node->GetNext() )
2012 {
2013 wxWindow * const win = node->GetData();
2014 if ( win->AcceptsFocus() &&
2015 !(::GetWindowLong(GetHwndOf(win), GWL_EXSTYLE) &
2016 WS_EX_CONTROLPARENT) )
2017 {
2018 // it shouldn't hang...
2019 canSafelyCallIsDlgMsg = TRUE;
2020
2021 break;
2022 }
2023 }
2024 }
2025 #endif // !__WXWINCE__
2026
2027 if ( canSafelyCallIsDlgMsg )
2028 {
2029 // ::IsDialogMessage() can enter in an infinite loop when the
2030 // currently focused window is disabled or hidden and its
2031 // parent has WS_EX_CONTROLPARENT style, so don't call it in
2032 // this case
2033 while ( hwndFocus )
2034 {
2035 if ( !::IsWindowEnabled(hwndFocus) ||
2036 !::IsWindowVisible(hwndFocus) )
2037 {
2038 // it would enter an infinite loop if we do this!
2039 canSafelyCallIsDlgMsg = FALSE;
2040
2041 break;
2042 }
2043
2044 if ( !(::GetWindowLong(hwndFocus, GWL_STYLE) & WS_CHILD) )
2045 {
2046 // it's a top level window, don't go further -- e.g. even
2047 // if the parent of a dialog is disabled, this doesn't
2048 // break navigation inside the dialog
2049 break;
2050 }
2051
2052 hwndFocus = ::GetParent(hwndFocus);
2053 }
2054 }
2055
2056 // let IsDialogMessage() have the message if it's safe to call it
2057 if ( canSafelyCallIsDlgMsg && ::IsDialogMessage(GetHwnd(), msg) )
2058 {
2059 // IsDialogMessage() did something...
2060 return TRUE;
2061 }
2062 }
2063 }
2064 #endif // __WXUNIVERSAL__
2065
2066 #if wxUSE_TOOLTIPS
2067 if ( m_tooltip )
2068 {
2069 // relay mouse move events to the tooltip control
2070 MSG *msg = (MSG *)pMsg;
2071 if ( msg->message == WM_MOUSEMOVE )
2072 m_tooltip->RelayEvent(pMsg);
2073 }
2074 #endif // wxUSE_TOOLTIPS
2075
2076 return FALSE;
2077 }
2078
2079 bool wxWindowMSW::MSWTranslateMessage(WXMSG* pMsg)
2080 {
2081 #if wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
2082 return m_acceleratorTable.Translate(this, pMsg);
2083 #else
2084 (void) pMsg;
2085 return FALSE;
2086 #endif // wxUSE_ACCEL
2087 }
2088
2089 bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
2090 {
2091 // preprocess all messages by default
2092 return TRUE;
2093 }
2094
2095 // ---------------------------------------------------------------------------
2096 // message params unpackers
2097 // ---------------------------------------------------------------------------
2098
2099 void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
2100 WORD *id, WXHWND *hwnd, WORD *cmd)
2101 {
2102 *id = LOWORD(wParam);
2103 *hwnd = (WXHWND)lParam;
2104 *cmd = HIWORD(wParam);
2105 }
2106
2107 void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
2108 WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
2109 {
2110 *state = LOWORD(wParam);
2111 *minimized = HIWORD(wParam);
2112 *hwnd = (WXHWND)lParam;
2113 }
2114
2115 void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
2116 WXWORD *code, WXWORD *pos, WXHWND *hwnd)
2117 {
2118 *code = LOWORD(wParam);
2119 *pos = HIWORD(wParam);
2120 *hwnd = (WXHWND)lParam;
2121 }
2122
2123 void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
2124 WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
2125 {
2126 #ifndef __WXMICROWIN__
2127 *nCtlColor = CTLCOLOR_BTN;
2128 *hwnd = (WXHWND)lParam;
2129 *hdc = (WXHDC)wParam;
2130 #endif
2131 }
2132
2133 void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
2134 WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
2135 {
2136 *item = (WXWORD)wParam;
2137 *flags = HIWORD(wParam);
2138 *hmenu = (WXHMENU)lParam;
2139 }
2140
2141 // ---------------------------------------------------------------------------
2142 // Main wxWindows window proc and the window proc for wxWindow
2143 // ---------------------------------------------------------------------------
2144
2145 // Hook for new window just as it's being created, when the window isn't yet
2146 // associated with the handle
2147 static wxWindowMSW *gs_winBeingCreated = NULL;
2148
2149 // implementation of wxWindowCreationHook class: it just sets gs_winBeingCreated to the
2150 // window being created and insures that it's always unset back later
2151 wxWindowCreationHook::wxWindowCreationHook(wxWindowMSW *winBeingCreated)
2152 {
2153 gs_winBeingCreated = winBeingCreated;
2154 }
2155
2156 wxWindowCreationHook::~wxWindowCreationHook()
2157 {
2158 gs_winBeingCreated = NULL;
2159 }
2160
2161 // Main window proc
2162 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
2163 {
2164 // trace all messages - useful for the debugging
2165 #ifdef __WXDEBUG__
2166 wxLogTrace(wxTraceMessages,
2167 wxT("Processing %s(hWnd=%08lx, wParam=%8lx, lParam=%8lx)"),
2168 wxGetMessageName(message), (long)hWnd, (long)wParam, lParam);
2169 #endif // __WXDEBUG__
2170
2171 wxWindowMSW *wnd = wxFindWinFromHandle((WXHWND) hWnd);
2172
2173 // when we get the first message for the HWND we just created, we associate
2174 // it with wxWindow stored in gs_winBeingCreated
2175 if ( !wnd && gs_winBeingCreated )
2176 {
2177 wxAssociateWinWithHandle(hWnd, gs_winBeingCreated);
2178 wnd = gs_winBeingCreated;
2179 gs_winBeingCreated = NULL;
2180 wnd->SetHWND((WXHWND)hWnd);
2181 }
2182
2183 LRESULT rc;
2184
2185 if ( wnd )
2186 rc = wnd->MSWWindowProc(message, wParam, lParam);
2187 else
2188 rc = ::DefWindowProc(hWnd, message, wParam, lParam);
2189
2190 return rc;
2191 }
2192
2193 long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
2194 {
2195 // did we process the message?
2196 bool processed = FALSE;
2197
2198 // the return value
2199 union
2200 {
2201 bool allow;
2202 long result;
2203 WXHICON hIcon;
2204 WXHBRUSH hBrush;
2205 } rc;
2206
2207 // for most messages we should return 0 when we do process the message
2208 rc.result = 0;
2209
2210 switch ( message )
2211 {
2212 case WM_CREATE:
2213 {
2214 bool mayCreate;
2215 processed = HandleCreate((WXLPCREATESTRUCT)lParam, &mayCreate);
2216 if ( processed )
2217 {
2218 // return 0 to allow window creation
2219 rc.result = mayCreate ? 0 : -1;
2220 }
2221 }
2222 break;
2223
2224 case WM_DESTROY:
2225 // never set processed to TRUE and *always* pass WM_DESTROY to
2226 // DefWindowProc() as Windows may do some internal cleanup when
2227 // processing it and failing to pass the message along may cause
2228 // memory and resource leaks!
2229 (void)HandleDestroy();
2230 break;
2231
2232 case WM_MOVE:
2233 processed = HandleMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2234 break;
2235
2236 #if !defined(__WXWINCE__)
2237 case WM_MOVING:
2238 {
2239 LPRECT pRect = (LPRECT)lParam;
2240 wxRect rc;
2241 rc.SetLeft(pRect->left);
2242 rc.SetTop(pRect->top);
2243 rc.SetRight(pRect->right);
2244 rc.SetBottom(pRect->bottom);
2245 processed = HandleMoving(rc);
2246 if (processed) {
2247 pRect->left = rc.GetLeft();
2248 pRect->top = rc.GetTop();
2249 pRect->right = rc.GetRight();
2250 pRect->bottom = rc.GetBottom();
2251 }
2252 }
2253 break;
2254 #endif
2255
2256 case WM_SIZE:
2257 switch ( wParam )
2258 {
2259 case SIZE_MAXHIDE:
2260 case SIZE_MAXSHOW:
2261 // we're not interested in these messages at all
2262 break;
2263
2264 case SIZE_MINIMIZED:
2265 // we shouldn't send sizev events for these messages as the
2266 // client size may be negative which breaks existing code
2267 //
2268 // OTOH we might send another (wxMinimizedEvent?) one or
2269 // add an additional parameter to wxSizeEvent if this is
2270 // useful to anybody
2271 break;
2272
2273 default:
2274 wxFAIL_MSG( _T("unexpected WM_SIZE parameter") );
2275 // fall through nevertheless
2276
2277 case SIZE_MAXIMIZED:
2278 case SIZE_RESTORED:
2279 processed = HandleSize(LOWORD(lParam), HIWORD(lParam),
2280 wParam);
2281 }
2282 break;
2283
2284 #if !defined(__WXWINCE__)
2285 case WM_SIZING:
2286 {
2287 LPRECT pRect = (LPRECT)lParam;
2288 wxRect rc;
2289 rc.SetLeft(pRect->left);
2290 rc.SetTop(pRect->top);
2291 rc.SetRight(pRect->right);
2292 rc.SetBottom(pRect->bottom);
2293 processed = HandleSizing(rc);
2294 if (processed) {
2295 pRect->left = rc.GetLeft();
2296 pRect->top = rc.GetTop();
2297 pRect->right = rc.GetRight();
2298 pRect->bottom = rc.GetBottom();
2299 }
2300 }
2301 break;
2302 #endif
2303
2304 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
2305 case WM_ACTIVATEAPP:
2306 wxTheApp->SetActive(wParam != 0, FindFocus());
2307 break;
2308 #endif
2309
2310 case WM_ACTIVATE:
2311 {
2312 WXWORD state, minimized;
2313 WXHWND hwnd;
2314 UnpackActivate(wParam, lParam, &state, &minimized, &hwnd);
2315
2316 processed = HandleActivate(state, minimized != 0, (WXHWND)hwnd);
2317 }
2318 break;
2319
2320 case WM_SETFOCUS:
2321 processed = HandleSetFocus((WXHWND)(HWND)wParam);
2322 break;
2323
2324 case WM_KILLFOCUS:
2325 processed = HandleKillFocus((WXHWND)(HWND)wParam);
2326 break;
2327
2328 case WM_PAINT:
2329 processed = HandlePaint();
2330 break;
2331
2332 case WM_CLOSE:
2333 #ifdef __WXUNIVERSAL__
2334 // Universal uses its own wxFrame/wxDialog, so we don't receive
2335 // close events unless we have this.
2336 Close();
2337 processed = TRUE;
2338 rc.result = TRUE;
2339 #else
2340 // don't let the DefWindowProc() destroy our window - we'll do it
2341 // ourselves in ~wxWindow
2342 processed = TRUE;
2343 rc.result = TRUE;
2344 #endif
2345 break;
2346
2347 case WM_SHOWWINDOW:
2348 processed = HandleShow(wParam != 0, (int)lParam);
2349 break;
2350
2351 case WM_MOUSEMOVE:
2352 processed = HandleMouseMove(GET_X_LPARAM(lParam),
2353 GET_Y_LPARAM(lParam),
2354 wParam);
2355 break;
2356
2357 #if wxUSE_MOUSEWHEEL
2358 case WM_MOUSEWHEEL:
2359 processed = HandleMouseWheel(wParam, lParam);
2360 break;
2361 #endif
2362
2363 case WM_LBUTTONDOWN:
2364 case WM_LBUTTONUP:
2365 case WM_LBUTTONDBLCLK:
2366 case WM_RBUTTONDOWN:
2367 case WM_RBUTTONUP:
2368 case WM_RBUTTONDBLCLK:
2369 case WM_MBUTTONDOWN:
2370 case WM_MBUTTONUP:
2371 case WM_MBUTTONDBLCLK:
2372 {
2373 #ifdef __WXMICROWIN__
2374 // MicroWindows seems to ignore the fact that a window is
2375 // disabled. So catch mouse events and throw them away if
2376 // necessary.
2377 wxWindowMSW* win = this;
2378 for ( ;; )
2379 {
2380 if (!win->IsEnabled())
2381 {
2382 processed = TRUE;
2383 break;
2384 }
2385
2386 win = win->GetParent();
2387 if ( !win || win->IsTopLevel() )
2388 break;
2389 }
2390
2391 if ( processed )
2392 break;
2393
2394 #endif // __WXMICROWIN__
2395 int x = GET_X_LPARAM(lParam),
2396 y = GET_Y_LPARAM(lParam);
2397
2398 // redirect the event to a static control if necessary by
2399 // finding one under mouse
2400 wxWindowMSW *win;
2401 if ( GetCapture() == this )
2402 {
2403 // but don't do it if the mouse is captured by this window
2404 // because then it should really get this event itself
2405 win = this;
2406 }
2407 else
2408 {
2409 win = FindWindowForMouseEvent(this, &x, &y);
2410
2411 // this should never happen
2412 wxCHECK_MSG( win, 0,
2413 _T("FindWindowForMouseEvent() returned NULL") );
2414
2415 // for the standard classes their WndProc sets the focus to
2416 // them anyhow and doing it from here results in some weird
2417 // problems, but for our windows we want them to acquire
2418 // focus when clicked
2419 if ( !win->IsOfStandardClass() )
2420 {
2421 if ( message == WM_LBUTTONDOWN && win->AcceptsFocus() )
2422 win->SetFocus();
2423 }
2424 }
2425
2426 processed = win->HandleMouseEvent(message, x, y, wParam);
2427 }
2428 break;
2429
2430 #ifdef MM_JOY1MOVE
2431 case MM_JOY1MOVE:
2432 case MM_JOY2MOVE:
2433 case MM_JOY1ZMOVE:
2434 case MM_JOY2ZMOVE:
2435 case MM_JOY1BUTTONDOWN:
2436 case MM_JOY2BUTTONDOWN:
2437 case MM_JOY1BUTTONUP:
2438 case MM_JOY2BUTTONUP:
2439 processed = HandleJoystickEvent(message,
2440 GET_X_LPARAM(lParam),
2441 GET_Y_LPARAM(lParam),
2442 wParam);
2443 break;
2444 #endif // __WXMICROWIN__
2445
2446 case WM_SYSCOMMAND:
2447 processed = HandleSysCommand(wParam, lParam);
2448 break;
2449
2450 case WM_COMMAND:
2451 {
2452 WORD id, cmd;
2453 WXHWND hwnd;
2454 UnpackCommand(wParam, lParam, &id, &hwnd, &cmd);
2455
2456 processed = HandleCommand(id, cmd, hwnd);
2457 }
2458 break;
2459
2460 case WM_NOTIFY:
2461 processed = HandleNotify((int)wParam, lParam, &rc.result);
2462 break;
2463
2464 // for these messages we must return TRUE if process the message
2465 #ifdef WM_DRAWITEM
2466 case WM_DRAWITEM:
2467 case WM_MEASUREITEM:
2468 {
2469 int idCtrl = (UINT)wParam;
2470 if ( message == WM_DRAWITEM )
2471 {
2472 processed = MSWOnDrawItem(idCtrl,
2473 (WXDRAWITEMSTRUCT *)lParam);
2474 }
2475 else
2476 {
2477 processed = MSWOnMeasureItem(idCtrl,
2478 (WXMEASUREITEMSTRUCT *)lParam);
2479 }
2480
2481 if ( processed )
2482 rc.result = TRUE;
2483 }
2484 break;
2485 #endif // defined(WM_DRAWITEM)
2486
2487 case WM_GETDLGCODE:
2488 if ( !IsOfStandardClass() )
2489 {
2490 // we always want to get the char events
2491 rc.result = DLGC_WANTCHARS;
2492
2493 if ( GetWindowStyleFlag() & wxWANTS_CHARS )
2494 {
2495 // in fact, we want everything
2496 rc.result |= DLGC_WANTARROWS |
2497 DLGC_WANTTAB |
2498 DLGC_WANTALLKEYS;
2499 }
2500
2501 processed = TRUE;
2502 }
2503 //else: get the dlg code from the DefWindowProc()
2504 break;
2505
2506 case WM_SYSKEYDOWN:
2507 case WM_KEYDOWN:
2508 // If this has been processed by an event handler, return 0 now
2509 // (we've handled it).
2510 m_lastKeydownProcessed = HandleKeyDown((WORD) wParam, lParam);
2511 if ( m_lastKeydownProcessed )
2512 {
2513 processed = TRUE;
2514 }
2515
2516 if ( !processed )
2517 {
2518 switch ( wParam )
2519 {
2520 // we consider these message "not interesting" to OnChar, so
2521 // just don't do anything more with them
2522 case VK_SHIFT:
2523 case VK_CONTROL:
2524 case VK_MENU:
2525 case VK_CAPITAL:
2526 case VK_NUMLOCK:
2527 case VK_SCROLL:
2528 processed = TRUE;
2529 break;
2530
2531 // avoid duplicate messages to OnChar for these ASCII keys:
2532 // they will be translated by TranslateMessage() and received
2533 // in WM_CHAR
2534 case VK_ESCAPE:
2535 case VK_SPACE:
2536 case VK_RETURN:
2537 case VK_BACK:
2538 case VK_TAB:
2539 case VK_ADD:
2540 case VK_SUBTRACT:
2541 case VK_MULTIPLY:
2542 case VK_DIVIDE:
2543 case VK_OEM_1:
2544 case VK_OEM_2:
2545 case VK_OEM_3:
2546 case VK_OEM_4:
2547 case VK_OEM_5:
2548 case VK_OEM_6:
2549 case VK_OEM_7:
2550 case VK_OEM_PLUS:
2551 case VK_OEM_COMMA:
2552 case VK_OEM_MINUS:
2553 case VK_OEM_PERIOD:
2554 // but set processed to FALSE, not TRUE to still pass them
2555 // to the control's default window proc - otherwise
2556 // built-in keyboard handling won't work
2557 processed = FALSE;
2558 break;
2559
2560 #ifdef VK_APPS
2561 // special case of VK_APPS: treat it the same as right mouse
2562 // click because both usually pop up a context menu
2563 case VK_APPS:
2564 {
2565 WPARAM flags;
2566 int x, y;
2567
2568 TranslateKbdEventToMouse(this, &x, &y, &flags);
2569 processed = HandleMouseEvent(WM_RBUTTONDOWN, x, y, flags);
2570 }
2571 break;
2572 #endif // VK_APPS
2573
2574 default:
2575 // do generate a CHAR event
2576 processed = HandleChar((WORD)wParam, lParam);
2577 }
2578 }
2579 if (message == WM_SYSKEYDOWN) // Let Windows still handle the SYSKEYs
2580 processed = FALSE;
2581 break;
2582
2583 case WM_SYSKEYUP:
2584 case WM_KEYUP:
2585 #ifdef VK_APPS
2586 // special case of VK_APPS: treat it the same as right mouse button
2587 if ( wParam == VK_APPS )
2588 {
2589 WPARAM flags;
2590 int x, y;
2591
2592 TranslateKbdEventToMouse(this, &x, &y, &flags);
2593 processed = HandleMouseEvent(WM_RBUTTONUP, x, y, flags);
2594 }
2595 else
2596 #endif // VK_APPS
2597 {
2598 processed = HandleKeyUp((WORD) wParam, lParam);
2599 }
2600 break;
2601
2602 case WM_SYSCHAR:
2603 case WM_CHAR: // Always an ASCII character
2604 if ( m_lastKeydownProcessed )
2605 {
2606 // The key was handled in the EVT_KEY_DOWN and handling
2607 // a key in an EVT_KEY_DOWN handler is meant, by
2608 // design, to prevent EVT_CHARs from happening
2609 m_lastKeydownProcessed = FALSE;
2610 processed = TRUE;
2611 }
2612 else
2613 {
2614 processed = HandleChar((WORD)wParam, lParam, TRUE);
2615 }
2616 break;
2617
2618 #if wxUSE_HOTKEY
2619 case WM_HOTKEY:
2620 processed = HandleHotKey((WORD)wParam, lParam);
2621 break;
2622 #endif // wxUSE_HOTKEY
2623
2624 case WM_HSCROLL:
2625 case WM_VSCROLL:
2626 {
2627 WXWORD code, pos;
2628 WXHWND hwnd;
2629 UnpackScroll(wParam, lParam, &code, &pos, &hwnd);
2630
2631 processed = MSWOnScroll(message == WM_HSCROLL ? wxHORIZONTAL
2632 : wxVERTICAL,
2633 code, pos, hwnd);
2634 }
2635 break;
2636
2637 // CTLCOLOR messages are sent by children to query the parent for their
2638 // colors#ifndef __WXMICROWIN__
2639 #ifndef __WXMICROWIN__
2640 case WM_CTLCOLORMSGBOX:
2641 case WM_CTLCOLOREDIT:
2642 case WM_CTLCOLORLISTBOX:
2643 case WM_CTLCOLORBTN:
2644 case WM_CTLCOLORDLG:
2645 case WM_CTLCOLORSCROLLBAR:
2646 case WM_CTLCOLORSTATIC:
2647 {
2648 WXWORD nCtlColor;
2649 WXHDC hdc;
2650 WXHWND hwnd;
2651 UnpackCtlColor(wParam, lParam, &nCtlColor, &hdc, &hwnd);
2652
2653 processed = HandleCtlColor(&rc.hBrush,
2654 (WXHDC)hdc,
2655 (WXHWND)hwnd,
2656 nCtlColor,
2657 message,
2658 wParam,
2659 lParam);
2660 }
2661 break;
2662 #endif // !__WXMICROWIN__
2663
2664 case WM_SYSCOLORCHANGE:
2665 // the return value for this message is ignored
2666 processed = HandleSysColorChange();
2667 break;
2668
2669 #if !defined(__WXWINCE__)
2670 case WM_DISPLAYCHANGE:
2671 processed = HandleDisplayChange();
2672 break;
2673 #endif
2674
2675 case WM_PALETTECHANGED:
2676 processed = HandlePaletteChanged((WXHWND) (HWND) wParam);
2677 break;
2678
2679 case WM_CAPTURECHANGED:
2680 processed = HandleCaptureChanged((WXHWND) (HWND) lParam);
2681 break;
2682
2683 case WM_QUERYNEWPALETTE:
2684 processed = HandleQueryNewPalette();
2685 break;
2686
2687 case WM_ERASEBKGND:
2688 processed = HandleEraseBkgnd((WXHDC)(HDC)wParam);
2689 if ( processed )
2690 {
2691 // we processed the message, i.e. erased the background
2692 rc.result = TRUE;
2693 }
2694 break;
2695
2696 #if !defined(__WXWINCE__)
2697 case WM_DROPFILES:
2698 processed = HandleDropFiles(wParam);
2699 break;
2700 #endif
2701
2702 case WM_INITDIALOG:
2703 processed = HandleInitDialog((WXHWND)(HWND)wParam);
2704
2705 if ( processed )
2706 {
2707 // we never set focus from here
2708 rc.result = FALSE;
2709 }
2710 break;
2711
2712 #if !defined(__WXWINCE__)
2713 case WM_QUERYENDSESSION:
2714 processed = HandleQueryEndSession(lParam, &rc.allow);
2715 break;
2716
2717 case WM_ENDSESSION:
2718 processed = HandleEndSession(wParam != 0, lParam);
2719 break;
2720
2721 case WM_GETMINMAXINFO:
2722 processed = HandleGetMinMaxInfo((MINMAXINFO*)lParam);
2723 break;
2724 #endif
2725
2726 case WM_SETCURSOR:
2727 processed = HandleSetCursor((WXHWND)(HWND)wParam,
2728 LOWORD(lParam), // hit test
2729 HIWORD(lParam)); // mouse msg
2730
2731 if ( processed )
2732 {
2733 // returning TRUE stops the DefWindowProc() from further
2734 // processing this message - exactly what we need because we've
2735 // just set the cursor.
2736 rc.result = TRUE;
2737 }
2738 break;
2739
2740 #if wxUSE_ACCESSIBILITY
2741 case WM_GETOBJECT:
2742 {
2743 //WPARAM dwFlags = (WPARAM) (DWORD) wParam;
2744 LPARAM dwObjId = (LPARAM) (DWORD) lParam;
2745
2746 if (dwObjId == OBJID_CLIENT && GetOrCreateAccessible())
2747 {
2748 return LresultFromObject(IID_IAccessible, wParam, (IUnknown*) GetAccessible()->GetIAccessible());
2749 }
2750 break;
2751 }
2752 #endif
2753
2754 #if defined(WM_HELP)
2755 case WM_HELP:
2756 {
2757 // HELPINFO doesn't seem to be supported on WinCE.
2758 #ifndef __WXWINCE__
2759 HELPINFO* info = (HELPINFO*) lParam;
2760 // Don't yet process menu help events, just windows
2761 if (info->iContextType == HELPINFO_WINDOW)
2762 {
2763 #endif
2764 wxWindowMSW* subjectOfHelp = this;
2765 bool eventProcessed = FALSE;
2766 while (subjectOfHelp && !eventProcessed)
2767 {
2768 wxHelpEvent helpEvent(wxEVT_HELP,
2769 subjectOfHelp->GetId(),
2770 #ifdef __WXWINCE__
2771 wxPoint(0, 0)
2772 #else
2773 wxPoint(info->MousePos.x, info->MousePos.y)
2774 #endif
2775 );
2776
2777 helpEvent.SetEventObject(this);
2778 eventProcessed =
2779 GetEventHandler()->ProcessEvent(helpEvent);
2780
2781 // Go up the window hierarchy until the event is
2782 // handled (or not)
2783 subjectOfHelp = subjectOfHelp->GetParent();
2784 }
2785
2786 processed = eventProcessed;
2787 #ifndef __WXWINCE__
2788 }
2789 else if (info->iContextType == HELPINFO_MENUITEM)
2790 {
2791 wxHelpEvent helpEvent(wxEVT_HELP, info->iCtrlId);
2792 helpEvent.SetEventObject(this);
2793 processed = GetEventHandler()->ProcessEvent(helpEvent);
2794
2795 }
2796 //else: processed is already FALSE
2797 #endif
2798 }
2799 break;
2800 #endif
2801
2802 #if !defined(__WXWINCE__)
2803 case WM_CONTEXTMENU:
2804 {
2805 // we don't convert from screen to client coordinates as
2806 // the event may be handled by a parent window
2807 wxPoint pt(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2808
2809 wxContextMenuEvent evtCtx(wxEVT_CONTEXT_MENU, GetId(), pt);
2810 processed = GetEventHandler()->ProcessEvent(evtCtx);
2811 }
2812 break;
2813 #endif
2814
2815 case WM_MENUCHAR:
2816 // we're only interested in our own menus, not MF_SYSMENU
2817 if ( HIWORD(wParam) == MF_POPUP )
2818 {
2819 // handle menu chars for ownerdrawn menu items
2820 int i = HandleMenuChar(toupper(LOWORD(wParam)), lParam);
2821 if ( i != wxNOT_FOUND )
2822 {
2823 rc.result = MAKELRESULT(i, MNC_EXECUTE);
2824 processed = TRUE;
2825 }
2826 }
2827 break;
2828 }
2829
2830 if ( !processed )
2831 {
2832 #ifdef __WXDEBUG__
2833 wxLogTrace(wxTraceMessages, wxT("Forwarding %s to DefWindowProc."),
2834 wxGetMessageName(message));
2835 #endif // __WXDEBUG__
2836 rc.result = MSWDefWindowProc(message, wParam, lParam);
2837 }
2838
2839 return rc.result;
2840 }
2841
2842 // ----------------------------------------------------------------------------
2843 // wxWindow <-> HWND map
2844 // ----------------------------------------------------------------------------
2845
2846 wxWinHashTable *wxWinHandleHash = NULL;
2847
2848 wxWindow *wxFindWinFromHandle(WXHWND hWnd)
2849 {
2850 return wxWinHandleHash->Get((long)hWnd);
2851 }
2852
2853 void wxAssociateWinWithHandle(HWND hWnd, wxWindowMSW *win)
2854 {
2855 // adding NULL hWnd is (first) surely a result of an error and
2856 // (secondly) breaks menu command processing
2857 wxCHECK_RET( hWnd != (HWND)NULL,
2858 wxT("attempt to add a NULL hWnd to window list ignored") );
2859
2860 wxWindow *oldWin = wxFindWinFromHandle((WXHWND) hWnd);
2861 #ifdef __WXDEBUG__
2862 if ( oldWin && (oldWin != win) )
2863 {
2864 wxLogDebug(wxT("HWND %X already associated with another window (%s)"),
2865 (int) hWnd, win->GetClassInfo()->GetClassName());
2866 }
2867 else
2868 #endif // __WXDEBUG__
2869 if (!oldWin)
2870 {
2871 wxWinHandleHash->Put((long)hWnd, (wxWindow *)win);
2872 }
2873 }
2874
2875 void wxRemoveHandleAssociation(wxWindowMSW *win)
2876 {
2877 wxWinHandleHash->Delete((long)win->GetHWND());
2878 }
2879
2880 // ----------------------------------------------------------------------------
2881 // various MSW speciic class dependent functions
2882 // ----------------------------------------------------------------------------
2883
2884 // Default destroyer - override if you destroy it in some other way
2885 // (e.g. with MDI child windows)
2886 void wxWindowMSW::MSWDestroyWindow()
2887 {
2888 }
2889
2890 bool wxWindowMSW::MSWGetCreateWindowCoords(const wxPoint& pos,
2891 const wxSize& size,
2892 int& x, int& y,
2893 int& w, int& h) const
2894 {
2895 static const int DEFAULT_Y = 200;
2896 static const int DEFAULT_H = 250;
2897
2898 bool nonDefault = FALSE;
2899
2900 if ( pos.x == -1 )
2901 {
2902 // if set x to CW_USEDEFAULT, y parameter is ignored anyhow so we can
2903 // just as well set it to CW_USEDEFAULT as well
2904 x =
2905 y = CW_USEDEFAULT;
2906 }
2907 else
2908 {
2909 // OTOH, if x is not set to CW_USEDEFAULT, y shouldn't be set to it
2910 // neither because it is not handled as a special value by Windows then
2911 // and so we have to choose some default value for it
2912 x = pos.x;
2913 y = pos.y == -1 ? DEFAULT_Y : pos.y;
2914
2915 nonDefault = TRUE;
2916 }
2917
2918 /*
2919 NB: there used to be some code here which set the initial size of the
2920 window to the client size of the parent if no explicit size was
2921 specified. This was wrong because wxWindows programs often assume
2922 that they get a WM_SIZE (EVT_SIZE) upon creation, however this broke
2923 it. To see why, you should understand that Windows sends WM_SIZE from
2924 inside ::CreateWindow() anyhow. However, ::CreateWindow() is called
2925 from some base class ctor and so this WM_SIZE is not processed in the
2926 real class' OnSize() (because it's not fully constructed yet and the
2927 event goes to some base class OnSize() instead). So the WM_SIZE we
2928 rely on is the one sent when the parent frame resizes its children
2929 but here is the problem: if the child already has just the right
2930 size, nothing will happen as both wxWindows and Windows check for
2931 this and ignore any attempts to change the window size to the size it
2932 already has - so no WM_SIZE would be sent.
2933 */
2934 if ( size.x == -1 )
2935 {
2936 // as above, h is not used at all in this case anyhow
2937 w =
2938 h = CW_USEDEFAULT;
2939 }
2940 else
2941 {
2942 // and, again as above, we can't set the height to CW_USEDEFAULT here
2943 w = size.x;
2944 h = size.y == -1 ? DEFAULT_H : size.y;
2945
2946 nonDefault = TRUE;
2947 }
2948
2949 return nonDefault;
2950 }
2951
2952 WXHWND wxWindowMSW::MSWGetParent() const
2953 {
2954 return m_parent ? m_parent->GetHWND() : WXHWND(NULL);
2955 }
2956
2957 bool wxWindowMSW::MSWCreate(const wxChar *wclass,
2958 const wxChar *title,
2959 const wxPoint& pos,
2960 const wxSize& size,
2961 WXDWORD style,
2962 WXDWORD extendedStyle)
2963 {
2964 // choose the position/size for the new window
2965 int x, y, w, h;
2966 (void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
2967
2968 // controlId is menu handle for the top level windows, so set it to 0
2969 // unless we're creating a child window
2970 int controlId = style & WS_CHILD ? GetId() : 0;
2971
2972 // for each class "Foo" we have we also have "FooNR" ("no repaint") class
2973 // which is the same but without CS_[HV]REDRAW class styles so using it
2974 // ensures that the window is not fully repainted on each resize
2975 wxString className(wclass);
2976 if ( GetWindowStyleFlag() & wxNO_FULL_REPAINT_ON_RESIZE )
2977 {
2978 className += wxT("NR");
2979 }
2980
2981 // do create the window
2982 wxWindowCreationHook hook(this);
2983
2984 #ifdef __WXWINCE__
2985 if (extendedStyle == 0)
2986 {
2987 m_hWnd = (WXHWND)::CreateWindow
2988 (
2989 className,
2990 title ? title : wxEmptyString,
2991 style,
2992 x, y, w, h,
2993 (HWND)MSWGetParent(),
2994 (HMENU)controlId,
2995 wxGetInstance(),
2996 NULL // no extra data
2997 );
2998 }
2999 else
3000 #endif
3001 {
3002 m_hWnd = (WXHWND)::CreateWindowEx
3003 (
3004 extendedStyle,
3005 className,
3006 title ? title : wxEmptyString,
3007 style,
3008 x, y, w, h,
3009 (HWND)MSWGetParent(),
3010 (HMENU)controlId,
3011 wxGetInstance(),
3012 NULL // no extra data
3013 );
3014 }
3015
3016 if ( !m_hWnd )
3017 {
3018 wxLogSysError(_("Can't create window of class %s"), wclass);
3019
3020 return FALSE;
3021 }
3022
3023 SubclassWin(m_hWnd);
3024
3025 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
3026
3027 return TRUE;
3028 }
3029
3030 // ===========================================================================
3031 // MSW message handlers
3032 // ===========================================================================
3033
3034 // ---------------------------------------------------------------------------
3035 // WM_NOTIFY
3036 // ---------------------------------------------------------------------------
3037
3038 #ifdef __WIN95__
3039
3040 bool wxWindowMSW::HandleNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
3041 {
3042 #ifndef __WXMICROWIN__
3043 LPNMHDR hdr = (LPNMHDR)lParam;
3044 HWND hWnd = hdr->hwndFrom;
3045 wxWindow *win = wxFindWinFromHandle((WXHWND)hWnd);
3046
3047 // if the control is one of our windows, let it handle the message itself
3048 if ( win )
3049 {
3050 return win->MSWOnNotify(idCtrl, lParam, result);
3051 }
3052
3053 // VZ: why did we do it? normally this is unnecessary and, besides, it
3054 // breaks the message processing for the toolbars because the tooltip
3055 // notifications were being forwarded to the toolbar child controls
3056 // (if it had any) before being passed to the toolbar itself, so in my
3057 // example the tooltip for the combobox was always shown instead of the
3058 // correct button tooltips
3059 #if 0
3060 // try all our children
3061 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3062 while ( node )
3063 {
3064 wxWindow *child = node->GetData();
3065 if ( child->MSWOnNotify(idCtrl, lParam, result) )
3066 {
3067 return TRUE;
3068 }
3069
3070 node = node->GetNext();
3071 }
3072 #endif // 0
3073
3074 // by default, handle it ourselves
3075 return MSWOnNotify(idCtrl, lParam, result);
3076 #else // __WXMICROWIN__
3077 return FALSE;
3078 #endif
3079 }
3080
3081 #if wxUSE_TOOLTIPS
3082
3083 bool wxWindowMSW::HandleTooltipNotify(WXUINT code,
3084 WXLPARAM lParam,
3085 const wxString& ttip)
3086 {
3087 // I don't know why it happens, but the versions of comctl32.dll starting
3088 // from 4.70 sometimes send TTN_NEEDTEXTW even to ANSI programs (normally,
3089 // this message is supposed to be sent to Unicode programs only) -- hence
3090 // we need to handle it as well, otherwise no tooltips will be shown in
3091 // this case
3092 #ifndef __WXWINCE__
3093 if ( !(code == (WXUINT) TTN_NEEDTEXTA || code == (WXUINT) TTN_NEEDTEXTW) || ttip.empty() )
3094 {
3095 // not a tooltip message or no tooltip to show anyhow
3096 return FALSE;
3097 }
3098 #endif
3099
3100 LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
3101
3102 #if !wxUSE_UNICODE
3103 if ( code == (WXUINT) TTN_NEEDTEXTA )
3104 {
3105 // we pass just the pointer as we store the string internally anyhow
3106 ttText->lpszText = (char *)ttip.c_str();
3107 }
3108 else // TTN_NEEDTEXTW
3109 #endif // !Unicode
3110 {
3111 #if wxUSE_UNICODE
3112 // in Unicode mode this is just what we need
3113 ttText->lpszText = (wxChar *)ttip.c_str();
3114 #else // !Unicode
3115 MultiByteToWideChar(CP_ACP, 0, ttip, ttip.length()+1,
3116 (wchar_t *)ttText->szText,
3117 sizeof(ttText->szText) / sizeof(wchar_t));
3118 #endif // Unicode/!Unicode
3119 }
3120
3121 return TRUE;
3122 }
3123
3124 #endif // wxUSE_TOOLTIPS
3125
3126 bool wxWindowMSW::MSWOnNotify(int WXUNUSED(idCtrl),
3127 WXLPARAM lParam,
3128 WXLPARAM* WXUNUSED(result))
3129 {
3130 #if wxUSE_TOOLTIPS
3131 if ( m_tooltip )
3132 {
3133 NMHDR* hdr = (NMHDR *)lParam;
3134 if ( HandleTooltipNotify(hdr->code, lParam, m_tooltip->GetTip()))
3135 {
3136 // processed
3137 return TRUE;
3138 }
3139 }
3140 #endif // wxUSE_TOOLTIPS
3141
3142 return FALSE;
3143 }
3144
3145 #endif // __WIN95__
3146
3147 // ---------------------------------------------------------------------------
3148 // end session messages
3149 // ---------------------------------------------------------------------------
3150
3151 bool wxWindowMSW::HandleQueryEndSession(long logOff, bool *mayEnd)
3152 {
3153 #ifndef __WXWINCE__
3154 wxCloseEvent event(wxEVT_QUERY_END_SESSION, -1);
3155 event.SetEventObject(wxTheApp);
3156 event.SetCanVeto(TRUE);
3157 event.SetLoggingOff(logOff == (long)ENDSESSION_LOGOFF);
3158
3159 bool rc = wxTheApp->ProcessEvent(event);
3160
3161 if ( rc )
3162 {
3163 // we may end only if the app didn't veto session closing (double
3164 // negation...)
3165 *mayEnd = !event.GetVeto();
3166 }
3167
3168 return rc;
3169 #else
3170 return FALSE;
3171 #endif
3172 }
3173
3174 bool wxWindowMSW::HandleEndSession(bool endSession, long logOff)
3175 {
3176 #ifndef __WXWINCE__
3177 // do nothing if the session isn't ending
3178 if ( !endSession )
3179 return FALSE;
3180
3181 // only send once
3182 if ( (this != wxTheApp->GetTopWindow()) )
3183 return FALSE;
3184
3185 wxCloseEvent event(wxEVT_END_SESSION, -1);
3186 event.SetEventObject(wxTheApp);
3187 event.SetCanVeto(FALSE);
3188 event.SetLoggingOff( (logOff == (long)ENDSESSION_LOGOFF) );
3189
3190 return wxTheApp->ProcessEvent(event);
3191 #else
3192 return FALSE;
3193 #endif
3194 }
3195
3196 // ---------------------------------------------------------------------------
3197 // window creation/destruction
3198 // ---------------------------------------------------------------------------
3199
3200 bool wxWindowMSW::HandleCreate(WXLPCREATESTRUCT cs, bool *mayCreate)
3201 {
3202 // if we have WS_EX_CONTROLPARENT flag we absolutely *must* set it for our
3203 // parent as well as otherwise several Win32 functions using
3204 // GetNextDlgTabItem() to iterate over all controls such as
3205 // IsDialogMessage() or DefDlgProc() would enter an infinite loop: indeed,
3206 // all of them iterate over all the controls starting from the focus and
3207 // stop iterating when they get back to the focus but unless all parents
3208 // have WS_EX_CONTROLPARENT bit set, they would never get back to focus
3209 #ifndef __WXWINCE__
3210 if ( ((CREATESTRUCT *)cs)->dwExStyle & WS_EX_CONTROLPARENT )
3211 {
3212 // there is no need to do anything for the top level windows
3213 const wxWindow *parent = GetParent();
3214 while ( parent && !parent->IsTopLevel() )
3215 {
3216 LONG exStyle = ::GetWindowLong(GetHwndOf(parent), GWL_EXSTYLE);
3217 if ( !(exStyle & WS_EX_CONTROLPARENT) )
3218 {
3219 // force the parent to have this style
3220 ::SetWindowLong(GetHwndOf(parent), GWL_EXSTYLE,
3221 exStyle | WS_EX_CONTROLPARENT);
3222 }
3223
3224 parent = parent->GetParent();
3225 }
3226 }
3227 #endif
3228
3229 // TODO: should generate this event from WM_NCCREATE
3230 wxWindowCreateEvent event((wxWindow *)this);
3231 (void)GetEventHandler()->ProcessEvent(event);
3232
3233 *mayCreate = TRUE;
3234
3235 return TRUE;
3236 }
3237
3238 bool wxWindowMSW::HandleDestroy()
3239 {
3240 SendDestroyEvent();
3241
3242 // delete our drop target if we've got one
3243 #if wxUSE_DRAG_AND_DROP
3244 if ( m_dropTarget != NULL )
3245 {
3246 m_dropTarget->Revoke(m_hWnd);
3247
3248 delete m_dropTarget;
3249 m_dropTarget = NULL;
3250 }
3251 #endif // wxUSE_DRAG_AND_DROP
3252
3253 // WM_DESTROY handled
3254 return TRUE;
3255 }
3256
3257 // ---------------------------------------------------------------------------
3258 // activation/focus
3259 // ---------------------------------------------------------------------------
3260
3261 bool wxWindowMSW::HandleActivate(int state,
3262 bool WXUNUSED(minimized),
3263 WXHWND WXUNUSED(activate))
3264 {
3265 wxActivateEvent event(wxEVT_ACTIVATE,
3266 (state == WA_ACTIVE) || (state == WA_CLICKACTIVE),
3267 m_windowId);
3268 event.SetEventObject(this);
3269
3270 return GetEventHandler()->ProcessEvent(event);
3271 }
3272
3273 bool wxWindowMSW::HandleSetFocus(WXHWND hwnd)
3274 {
3275 // notify the parent keeping track of focus for the kbd navigation
3276 // purposes that we got it
3277 wxChildFocusEvent eventFocus((wxWindow *)this);
3278 (void)GetEventHandler()->ProcessEvent(eventFocus);
3279
3280 #if wxUSE_CARET
3281 // Deal with caret
3282 if ( m_caret )
3283 {
3284 m_caret->OnSetFocus();
3285 }
3286 #endif // wxUSE_CARET
3287
3288 #if wxUSE_TEXTCTRL
3289 // If it's a wxTextCtrl don't send the event as it will be done
3290 // after the control gets to process it from EN_FOCUS handler
3291 if ( wxDynamicCastThis(wxTextCtrl) )
3292 {
3293 return FALSE;
3294 }
3295 #endif // wxUSE_TEXTCTRL
3296
3297 wxFocusEvent event(wxEVT_SET_FOCUS, m_windowId);
3298 event.SetEventObject(this);
3299
3300 // wxFindWinFromHandle() may return NULL, it is ok
3301 event.SetWindow(wxFindWinFromHandle(hwnd));
3302
3303 return GetEventHandler()->ProcessEvent(event);
3304 }
3305
3306 bool wxWindowMSW::HandleKillFocus(WXHWND hwnd)
3307 {
3308 #if wxUSE_CARET
3309 // Deal with caret
3310 if ( m_caret )
3311 {
3312 m_caret->OnKillFocus();
3313 }
3314 #endif // wxUSE_CARET
3315
3316 #if wxUSE_TEXTCTRL
3317 // If it's a wxTextCtrl don't send the event as it will be done
3318 // after the control gets to process it.
3319 wxTextCtrl *ctrl = wxDynamicCastThis(wxTextCtrl);
3320 if ( ctrl )
3321 {
3322 return FALSE;
3323 }
3324 #endif
3325
3326 // Don't send the event when in the process of being deleted. This can
3327 // only cause problems if the event handler tries to access the object.
3328 if ( m_isBeingDeleted )
3329 {
3330 return FALSE;
3331 }
3332
3333 wxFocusEvent event(wxEVT_KILL_FOCUS, m_windowId);
3334 event.SetEventObject(this);
3335
3336 // wxFindWinFromHandle() may return NULL, it is ok
3337 event.SetWindow(wxFindWinFromHandle(hwnd));
3338
3339 return GetEventHandler()->ProcessEvent(event);
3340 }
3341
3342 // ---------------------------------------------------------------------------
3343 // miscellaneous
3344 // ---------------------------------------------------------------------------
3345
3346 bool wxWindowMSW::HandleShow(bool show, int WXUNUSED(status))
3347 {
3348 wxShowEvent event(GetId(), show);
3349 event.m_eventObject = this;
3350
3351 return GetEventHandler()->ProcessEvent(event);
3352 }
3353
3354 bool wxWindowMSW::HandleInitDialog(WXHWND WXUNUSED(hWndFocus))
3355 {
3356 wxInitDialogEvent event(GetId());
3357 event.m_eventObject = this;
3358
3359 return GetEventHandler()->ProcessEvent(event);
3360 }
3361
3362 bool wxWindowMSW::HandleDropFiles(WXWPARAM wParam)
3363 {
3364 #if defined (__WXMICROWIN__) || defined(__WXWINCE__)
3365 return FALSE;
3366 #else // __WXMICROWIN__
3367 HDROP hFilesInfo = (HDROP) wParam;
3368
3369 // Get the total number of files dropped
3370 UINT gwFilesDropped = ::DragQueryFile
3371 (
3372 (HDROP)hFilesInfo,
3373 (UINT)-1,
3374 (LPTSTR)0,
3375 (UINT)0
3376 );
3377
3378 wxString *files = new wxString[gwFilesDropped];
3379 for ( UINT wIndex = 0; wIndex < gwFilesDropped; wIndex++ )
3380 {
3381 // first get the needed buffer length (+1 for terminating NUL)
3382 size_t len = ::DragQueryFile(hFilesInfo, wIndex, NULL, 0) + 1;
3383
3384 // and now get the file name
3385 ::DragQueryFile(hFilesInfo, wIndex,
3386 files[wIndex].GetWriteBuf(len), len);
3387
3388 files[wIndex].UngetWriteBuf();
3389 }
3390 DragFinish (hFilesInfo);
3391
3392 wxDropFilesEvent event(wxEVT_DROP_FILES, gwFilesDropped, files);
3393 event.m_eventObject = this;
3394
3395 POINT dropPoint;
3396 DragQueryPoint(hFilesInfo, (LPPOINT) &dropPoint);
3397 event.m_pos.x = dropPoint.x;
3398 event.m_pos.y = dropPoint.y;
3399
3400 return GetEventHandler()->ProcessEvent(event);
3401 #endif
3402 }
3403
3404
3405 bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
3406 short nHitTest,
3407 int WXUNUSED(mouseMsg))
3408 {
3409 #ifndef __WXMICROWIN__
3410 // the logic is as follows:
3411 // -1. don't set cursor for non client area, including but not limited to
3412 // the title bar, scrollbars, &c
3413 // 0. allow the user to override default behaviour by using EVT_SET_CURSOR
3414 // 1. if we have the cursor set it unless wxIsBusy()
3415 // 2. if we're a top level window, set some cursor anyhow
3416 // 3. if wxIsBusy(), set the busy cursor, otherwise the global one
3417
3418 if ( nHitTest != HTCLIENT )
3419 {
3420 return FALSE;
3421 }
3422
3423 HCURSOR hcursor = 0;
3424
3425 // first ask the user code - it may wish to set the cursor in some very
3426 // specific way (for example, depending on the current position)
3427 POINT pt;
3428 if ( !::GetCursorPos(&pt) )
3429 {
3430 wxLogLastError(wxT("GetCursorPos"));
3431 }
3432
3433 int x = pt.x,
3434 y = pt.y;
3435 ScreenToClient(&x, &y);
3436 wxSetCursorEvent event(x, y);
3437
3438 bool processedEvtSetCursor = GetEventHandler()->ProcessEvent(event);
3439 if ( processedEvtSetCursor && event.HasCursor() )
3440 {
3441 hcursor = GetHcursorOf(event.GetCursor());
3442 }
3443
3444 if ( !hcursor )
3445 {
3446 bool isBusy = wxIsBusy();
3447
3448 // the test for processedEvtSetCursor is here to prevent using m_cursor
3449 // if the user code caught EVT_SET_CURSOR() and returned nothing from
3450 // it - this is a way to say that our cursor shouldn't be used for this
3451 // point
3452 if ( !processedEvtSetCursor && m_cursor.Ok() )
3453 {
3454 hcursor = GetHcursorOf(m_cursor);
3455 }
3456
3457 if ( !GetParent() )
3458 {
3459 if ( isBusy )
3460 {
3461 hcursor = wxGetCurrentBusyCursor();
3462 }
3463 else if ( !hcursor )
3464 {
3465 const wxCursor *cursor = wxGetGlobalCursor();
3466 if ( cursor && cursor->Ok() )
3467 {
3468 hcursor = GetHcursorOf(*cursor);
3469 }
3470 }
3471 }
3472 }
3473
3474 if ( hcursor )
3475 {
3476 // wxLogDebug("HandleSetCursor: Setting cursor %ld", (long) hcursor);
3477
3478 ::SetCursor(hcursor);
3479
3480 // cursor set, stop here
3481 return TRUE;
3482 }
3483 #endif // __WXMICROWIN__
3484
3485 // pass up the window chain
3486 return FALSE;
3487 }
3488
3489 // ---------------------------------------------------------------------------
3490 // owner drawn stuff
3491 // ---------------------------------------------------------------------------
3492
3493 bool wxWindowMSW::MSWOnDrawItem(int id, WXDRAWITEMSTRUCT *itemStruct)
3494 {
3495 #if wxUSE_OWNER_DRAWN
3496
3497 #if wxUSE_MENUS_NATIVE
3498 // is it a menu item?
3499 DRAWITEMSTRUCT *pDrawStruct = (DRAWITEMSTRUCT *)itemStruct;
3500 if ( id == 0 && pDrawStruct->CtlType == ODT_MENU )
3501 {
3502 wxMenuItem *pMenuItem = (wxMenuItem *)(pDrawStruct->itemData);
3503
3504 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3505
3506 // prepare to call OnDrawItem(): notice using of wxDCTemp to prevent
3507 // the DC from being released
3508 wxDCTemp dc((WXHDC)pDrawStruct->hDC);
3509 wxRect rect(pDrawStruct->rcItem.left, pDrawStruct->rcItem.top,
3510 pDrawStruct->rcItem.right - pDrawStruct->rcItem.left,
3511 pDrawStruct->rcItem.bottom - pDrawStruct->rcItem.top);
3512
3513 return pMenuItem->OnDrawItem
3514 (
3515 dc,
3516 rect,
3517 (wxOwnerDrawn::wxODAction)pDrawStruct->itemAction,
3518 (wxOwnerDrawn::wxODStatus)pDrawStruct->itemState
3519 );
3520 }
3521 #endif // wxUSE_MENUS_NATIVE
3522
3523 #endif // USE_OWNER_DRAWN
3524
3525 #if wxUSE_CONTROLS
3526
3527 #if wxUSE_OWNER_DRAWN
3528 wxWindow *item = FindItem(id);
3529 if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
3530 return ((wxControl *)item)->MSWOnDraw(itemStruct);
3531 #elif !defined(__WXUNIVERSAL__)
3532 // we may still have owner-drawn buttons internally because we have to make
3533 // them owner-drawn to support colour change
3534 wxWindow *item = FindItem(id);
3535 if ( item && item->IsKindOf(CLASSINFO(wxButton)) )
3536 return ((wxButton *)item)->MSWOnDraw(itemStruct);
3537 #endif // USE_OWNER_DRAWN
3538
3539 #endif // wxUSE_CONTROLS
3540
3541 return FALSE;
3542 }
3543
3544 bool wxWindowMSW::MSWOnMeasureItem(int id, WXMEASUREITEMSTRUCT *itemStruct)
3545 {
3546 #if wxUSE_OWNER_DRAWN
3547 // is it a menu item?
3548 MEASUREITEMSTRUCT *pMeasureStruct = (MEASUREITEMSTRUCT *)itemStruct;
3549 if ( id == 0 && pMeasureStruct->CtlType == ODT_MENU )
3550 {
3551 wxMenuItem *pMenuItem = (wxMenuItem *)(pMeasureStruct->itemData);
3552
3553 wxCHECK( pMenuItem->IsKindOf(CLASSINFO(wxMenuItem)), FALSE );
3554
3555 return pMenuItem->OnMeasureItem(&pMeasureStruct->itemWidth,
3556 &pMeasureStruct->itemHeight);
3557 }
3558
3559 wxWindow *item = FindItem(id);
3560 if ( item && item->IsKindOf(CLASSINFO(wxControl)) )
3561 {
3562 return ((wxControl *)item)->MSWOnMeasure(itemStruct);
3563 }
3564 #endif // owner-drawn menus
3565 return FALSE;
3566 }
3567
3568 // ---------------------------------------------------------------------------
3569 // colours and palettes
3570 // ---------------------------------------------------------------------------
3571
3572 bool wxWindowMSW::HandleSysColorChange()
3573 {
3574 wxSysColourChangedEvent event;
3575 event.SetEventObject(this);
3576
3577 (void)GetEventHandler()->ProcessEvent(event);
3578
3579 // always let the system carry on the default processing to allow the
3580 // native controls to react to the colours update
3581 return FALSE;
3582 }
3583
3584 bool wxWindowMSW::HandleDisplayChange()
3585 {
3586 wxDisplayChangedEvent event;
3587 event.SetEventObject(this);
3588
3589 return GetEventHandler()->ProcessEvent(event);
3590 }
3591
3592 bool wxWindowMSW::HandleCtlColor(WXHBRUSH *brush,
3593 WXHDC pDC,
3594 WXHWND pWnd,
3595 WXUINT nCtlColor,
3596 WXUINT message,
3597 WXWPARAM wParam,
3598 WXLPARAM lParam)
3599 {
3600 #ifndef __WXMICROWIN__
3601 WXHBRUSH hBrush = 0;
3602
3603 #ifdef __WXWINCE__
3604 if (FALSE)
3605 #else
3606 if ( nCtlColor == CTLCOLOR_DLG )
3607 #endif
3608 {
3609 hBrush = OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3610 }
3611 #if wxUSE_CONTROLS
3612 else
3613 {
3614 wxControl *item = (wxControl *)FindItemByHWND(pWnd, TRUE);
3615 if ( item )
3616 hBrush = item->OnCtlColor(pDC, pWnd, nCtlColor, message, wParam, lParam);
3617 }
3618 #endif // wxUSE_CONTROLS
3619
3620 if ( hBrush )
3621 *brush = hBrush;
3622
3623 return hBrush != 0;
3624 #else // __WXMICROWIN__
3625 return FALSE;
3626 #endif
3627 }
3628
3629 // Define for each class of dialog and control
3630 WXHBRUSH wxWindowMSW::OnCtlColor(WXHDC WXUNUSED(hDC),
3631 WXHWND WXUNUSED(hWnd),
3632 WXUINT WXUNUSED(nCtlColor),
3633 WXUINT WXUNUSED(message),
3634 WXWPARAM WXUNUSED(wParam),
3635 WXLPARAM WXUNUSED(lParam))
3636 {
3637 return (WXHBRUSH)0;
3638 }
3639
3640 bool wxWindowMSW::HandlePaletteChanged(WXHWND hWndPalChange)
3641 {
3642 #if wxUSE_PALETTE
3643 // same as below except we don't respond to our own messages
3644 if ( hWndPalChange != GetHWND() )
3645 {
3646 // check to see if we our our parents have a custom palette
3647 wxWindowMSW *win = this;
3648 while ( win && !win->HasCustomPalette() )
3649 {
3650 win = win->GetParent();
3651 }
3652
3653 if ( win && win->HasCustomPalette() )
3654 {
3655 // realize the palette to see whether redrawing is needed
3656 HDC hdc = ::GetDC((HWND) hWndPalChange);
3657 win->m_palette.SetHPALETTE((WXHPALETTE)
3658 ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3659
3660 int result = ::RealizePalette(hdc);
3661
3662 // restore the palette (before releasing the DC)
3663 win->m_palette.SetHPALETTE((WXHPALETTE)
3664 ::SelectPalette(hdc, GetHpaletteOf(win->m_palette), FALSE));
3665 ::RealizePalette(hdc);
3666 ::ReleaseDC((HWND) hWndPalChange, hdc);
3667
3668 // now check for the need to redraw
3669 if (result > 0)
3670 InvalidateRect((HWND) hWndPalChange, NULL, TRUE);
3671 }
3672
3673 }
3674 #endif // wxUSE_PALETTE
3675
3676 wxPaletteChangedEvent event(GetId());
3677 event.SetEventObject(this);
3678 event.SetChangedWindow(wxFindWinFromHandle(hWndPalChange));
3679
3680 return GetEventHandler()->ProcessEvent(event);
3681 }
3682
3683 bool wxWindowMSW::HandleCaptureChanged(WXHWND hWndGainedCapture)
3684 {
3685 wxMouseCaptureChangedEvent event(GetId(), wxFindWinFromHandle(hWndGainedCapture));
3686 event.SetEventObject(this);
3687
3688 return GetEventHandler()->ProcessEvent(event);
3689 }
3690
3691 bool wxWindowMSW::HandleQueryNewPalette()
3692 {
3693
3694 #if wxUSE_PALETTE
3695 // check to see if we our our parents have a custom palette
3696 wxWindowMSW *win = this;
3697 while (!win->HasCustomPalette() && win->GetParent()) win = win->GetParent();
3698 if (win->HasCustomPalette()) {
3699 /* realize the palette to see whether redrawing is needed */
3700 HDC hdc = GetDC((HWND) GetHWND());
3701 win->m_palette.SetHPALETTE( (WXHPALETTE)
3702 ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), FALSE) );
3703
3704 int result = ::RealizePalette(hdc);
3705 /* restore the palette (before releasing the DC) */
3706 win->m_palette.SetHPALETTE( (WXHPALETTE)
3707 ::SelectPalette(hdc, (HPALETTE) win->m_palette.GetHPALETTE(), TRUE) );
3708 ::RealizePalette(hdc);
3709 ::ReleaseDC((HWND) GetHWND(), hdc);
3710 /* now check for the need to redraw */
3711 if (result > 0)
3712 ::InvalidateRect((HWND) GetHWND(), NULL, TRUE);
3713 }
3714 #endif // wxUSE_PALETTE
3715
3716 wxQueryNewPaletteEvent event(GetId());
3717 event.SetEventObject(this);
3718
3719 return GetEventHandler()->ProcessEvent(event) && event.GetPaletteRealized();
3720 }
3721
3722 // Responds to colour changes: passes event on to children.
3723 void wxWindowMSW::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
3724 {
3725 // the top level window also reset the standard colour map as it might have
3726 // changed (there is no need to do it for the non top level windows as we
3727 // only have to do it once)
3728 if ( IsTopLevel() )
3729 {
3730 // FIXME-MT
3731 gs_hasStdCmap = FALSE;
3732 }
3733 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
3734 while ( node )
3735 {
3736 // Only propagate to non-top-level windows because Windows already
3737 // sends this event to all top-level ones
3738 wxWindow *win = node->GetData();
3739 if ( !win->IsTopLevel() )
3740 {
3741 // we need to send the real WM_SYSCOLORCHANGE and not just trigger
3742 // EVT_SYS_COLOUR_CHANGED call because the latter wouldn't work for
3743 // the standard controls
3744 ::SendMessage(GetHwndOf(win), WM_SYSCOLORCHANGE, 0, 0);
3745 }
3746
3747 node = node->GetNext();
3748 }
3749
3750 // update the colours we use if they were not set explicitly by the user:
3751 // this must be done or OnCtlColor() would continue to use the old colours
3752 if ( !m_hasFgCol )
3753 {
3754 m_foregroundColour = wxSystemSettings::
3755 GetSystemColour(wxSYS_COLOUR_WINDOWTEXT);
3756 }
3757
3758 if ( !m_hasBgCol )
3759 {
3760 m_backgroundColour = wxSystemSettings::
3761 GetSystemColour(wxSYS_COLOUR_BTNFACE);
3762 }
3763 }
3764
3765 extern wxCOLORMAP *wxGetStdColourMap()
3766 {
3767 static COLORREF s_stdColours[wxSTD_COL_MAX];
3768 static wxCOLORMAP s_cmap[wxSTD_COL_MAX];
3769
3770 if ( !gs_hasStdCmap )
3771 {
3772 static bool s_coloursInit = FALSE;
3773
3774 if ( !s_coloursInit )
3775 {
3776 // When a bitmap is loaded, the RGB values can change (apparently
3777 // because Windows adjusts them to care for the old programs always
3778 // using 0xc0c0c0 while the transparent colour for the new Windows
3779 // versions is different). But we do this adjustment ourselves so
3780 // we want to avoid Windows' "help" and for this we need to have a
3781 // reference bitmap which can tell us what the RGB values change
3782 // to.
3783 wxBitmap stdColourBitmap(_T("wxBITMAP_STD_COLOURS"));
3784 if ( stdColourBitmap.Ok() )
3785 {
3786 // the pixels in the bitmap must correspond to wxSTD_COL_XXX!
3787 wxASSERT_MSG( stdColourBitmap.GetWidth() == wxSTD_COL_MAX,
3788 _T("forgot to update wxBITMAP_STD_COLOURS!") );
3789
3790 wxMemoryDC memDC;
3791 memDC.SelectObject(stdColourBitmap);
3792
3793 wxColour colour;
3794 for ( size_t i = 0; i < WXSIZEOF(s_stdColours); i++ )
3795 {
3796 memDC.GetPixel(i, 0, &colour);
3797 s_stdColours[i] = wxColourToRGB(colour);
3798 }
3799 }
3800 else // wxBITMAP_STD_COLOURS couldn't be loaded
3801 {
3802 s_stdColours[0] = RGB(000,000,000); // black
3803 s_stdColours[1] = RGB(128,128,128); // dark grey
3804 s_stdColours[2] = RGB(192,192,192); // light grey
3805 s_stdColours[3] = RGB(255,255,255); // white
3806 //s_stdColours[4] = RGB(000,000,255); // blue
3807 //s_stdColours[5] = RGB(255,000,255); // magenta
3808 }
3809
3810 s_coloursInit = TRUE;
3811 }
3812
3813 gs_hasStdCmap = TRUE;
3814
3815 // create the colour map
3816 #define INIT_CMAP_ENTRY(col) \
3817 s_cmap[wxSTD_COL_##col].from = s_stdColours[wxSTD_COL_##col]; \
3818 s_cmap[wxSTD_COL_##col].to = ::GetSysColor(COLOR_##col)
3819
3820 INIT_CMAP_ENTRY(BTNTEXT);
3821 INIT_CMAP_ENTRY(BTNSHADOW);
3822 INIT_CMAP_ENTRY(BTNFACE);
3823 INIT_CMAP_ENTRY(BTNHIGHLIGHT);
3824
3825 #undef INIT_CMAP_ENTRY
3826 }
3827
3828 return s_cmap;
3829 }
3830
3831 // ---------------------------------------------------------------------------
3832 // painting
3833 // ---------------------------------------------------------------------------
3834
3835 bool wxWindowMSW::HandlePaint()
3836 {
3837 // if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3838 // return FALSE;
3839
3840 HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
3841 if ( !hRegion )
3842 wxLogLastError(wxT("CreateRectRgn"));
3843 if ( ::GetUpdateRgn(GetHwnd(), hRegion, FALSE) == ERROR )
3844 wxLogLastError(wxT("GetUpdateRgn"));
3845
3846 m_updateRegion = wxRegion((WXHRGN) hRegion);
3847
3848 wxPaintEvent event(m_windowId);
3849 event.SetEventObject(this);
3850
3851 bool processed = GetEventHandler()->ProcessEvent(event);
3852
3853 // note that we must generate NC event after the normal one as otherwise
3854 // BeginPaint() will happily overwrite our decorations with the background
3855 // colour
3856 wxNcPaintEvent eventNc(m_windowId);
3857 eventNc.SetEventObject(this);
3858 GetEventHandler()->ProcessEvent(eventNc);
3859
3860 return processed;
3861 }
3862
3863 // Can be called from an application's OnPaint handler
3864 void wxWindowMSW::OnPaint(wxPaintEvent& event)
3865 {
3866 #ifdef __WXUNIVERSAL__
3867 event.Skip();
3868 #else
3869 HDC hDC = (HDC) wxPaintDC::FindDCInCache((wxWindow*) event.GetEventObject());
3870 if (hDC != 0)
3871 {
3872 MSWDefWindowProc(WM_PAINT, (WPARAM) hDC, 0);
3873 }
3874 #endif
3875 }
3876
3877 bool wxWindowMSW::HandleEraseBkgnd(WXHDC hdc)
3878 {
3879 // Prevents flicker when dragging
3880 if ( ::IsIconic(GetHwnd()) )
3881 return TRUE;
3882
3883 #if 0
3884 if (GetParent() && GetParent()->GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3885 {
3886 return FALSE;
3887 }
3888
3889 if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
3890 {
3891 if (wxUxThemeEngine::Get())
3892 {
3893 WXHTHEME hTheme = wxUxThemeEngine::Get()->m_pfnOpenThemeData(GetHWND(), L"TAB");
3894 if (hTheme)
3895 {
3896 WXURECT rect;
3897 ::GetClientRect((HWND) GetHWND(), (RECT*) & rect);
3898 wxUxThemeEngine::Get()->m_pfnDrawThemeBackground(hTheme, hdc, 10 /* TABP_BODY */, 0, &rect, &rect);
3899 wxUxThemeEngine::Get()->m_pfnCloseThemeData(hTheme);
3900 return TRUE;
3901 }
3902 }
3903 }
3904 #endif
3905
3906 wxDCTemp dc(hdc);
3907
3908 dc.SetHDC(hdc);
3909 dc.SetWindow((wxWindow *)this);
3910 dc.BeginDrawing();
3911
3912 wxEraseEvent event(m_windowId, &dc);
3913 event.SetEventObject(this);
3914 bool rc = GetEventHandler()->ProcessEvent(event);
3915
3916 dc.EndDrawing();
3917
3918 // must be called manually as ~wxDC doesn't do anything for wxDCTemp
3919 dc.SelectOldObjects(hdc);
3920
3921 return rc;
3922 }
3923
3924 void wxWindowMSW::OnEraseBackground(wxEraseEvent& event)
3925 {
3926 RECT rect;
3927 ::GetClientRect(GetHwnd(), &rect);
3928
3929 COLORREF ref = PALETTERGB(m_backgroundColour.Red(),
3930 m_backgroundColour.Green(),
3931 m_backgroundColour.Blue());
3932 HBRUSH hBrush = ::CreateSolidBrush(ref);
3933 if ( !hBrush )
3934 wxLogLastError(wxT("CreateSolidBrush"));
3935
3936 HDC hdc = (HDC)event.GetDC()->GetHDC();
3937
3938 #ifndef __WXWINCE__
3939 int mode = ::SetMapMode(hdc, MM_TEXT);
3940 #endif
3941
3942 ::FillRect(hdc, &rect, hBrush);
3943 ::DeleteObject(hBrush);
3944
3945 #ifndef __WXWINCE__
3946 ::SetMapMode(hdc, mode);
3947 #endif
3948 }
3949
3950 // ---------------------------------------------------------------------------
3951 // moving and resizing
3952 // ---------------------------------------------------------------------------
3953
3954 bool wxWindowMSW::HandleMinimize()
3955 {
3956 wxIconizeEvent event(m_windowId);
3957 event.SetEventObject(this);
3958
3959 return GetEventHandler()->ProcessEvent(event);
3960 }
3961
3962 bool wxWindowMSW::HandleMaximize()
3963 {
3964 wxMaximizeEvent event(m_windowId);
3965 event.SetEventObject(this);
3966
3967 return GetEventHandler()->ProcessEvent(event);
3968 }
3969
3970 bool wxWindowMSW::HandleMove(int x, int y)
3971 {
3972 wxMoveEvent event(wxPoint(x, y), m_windowId);
3973 event.SetEventObject(this);
3974
3975 return GetEventHandler()->ProcessEvent(event);
3976 }
3977
3978 bool wxWindowMSW::HandleMoving(wxRect& rect)
3979 {
3980 wxMoveEvent event(rect, m_windowId);
3981 event.SetEventObject(this);
3982
3983 bool rc = GetEventHandler()->ProcessEvent(event);
3984 if (rc)
3985 rect = event.GetRect();
3986 return rc;
3987 }
3988
3989 bool wxWindowMSW::HandleSize(int WXUNUSED(w), int WXUNUSED(h),
3990 WXUINT WXUNUSED(flag))
3991 {
3992 // don't use w and h parameters as they specify the client size while
3993 // according to the docs EVT_SIZE handler is supposed to receive the total
3994 // size
3995 wxSizeEvent event(GetSize(), m_windowId);
3996 event.SetEventObject(this);
3997
3998 return GetEventHandler()->ProcessEvent(event);
3999 }
4000
4001 bool wxWindowMSW::HandleSizing(wxRect& rect)
4002 {
4003 wxSizeEvent event(rect, m_windowId);
4004 event.SetEventObject(this);
4005
4006 bool rc = GetEventHandler()->ProcessEvent(event);
4007 if (rc)
4008 rect = event.GetRect();
4009 return rc;
4010 }
4011
4012 bool wxWindowMSW::HandleGetMinMaxInfo(void *mmInfo)
4013 {
4014 #ifdef __WXWINCE__
4015 return FALSE;
4016 #else
4017 MINMAXINFO *info = (MINMAXINFO *)mmInfo;
4018
4019 bool rc = FALSE;
4020
4021 int minWidth = GetMinWidth(),
4022 minHeight = GetMinHeight(),
4023 maxWidth = GetMaxWidth(),
4024 maxHeight = GetMaxHeight();
4025
4026 if ( minWidth != -1 )
4027 {
4028 info->ptMinTrackSize.x = minWidth;
4029 rc = TRUE;
4030 }
4031
4032 if ( minHeight != -1 )
4033 {
4034 info->ptMinTrackSize.y = minHeight;
4035 rc = TRUE;
4036 }
4037
4038 if ( maxWidth != -1 )
4039 {
4040 info->ptMaxTrackSize.x = maxWidth;
4041 rc = TRUE;
4042 }
4043
4044 if ( maxHeight != -1 )
4045 {
4046 info->ptMaxTrackSize.y = maxHeight;
4047 rc = TRUE;
4048 }
4049
4050 return rc;
4051 #endif
4052 }
4053
4054 // ---------------------------------------------------------------------------
4055 // command messages
4056 // ---------------------------------------------------------------------------
4057
4058 bool wxWindowMSW::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
4059 {
4060 #if wxUSE_MENUS_NATIVE
4061 if ( !cmd && wxCurrentPopupMenu )
4062 {
4063 wxMenu *popupMenu = wxCurrentPopupMenu;
4064 wxCurrentPopupMenu = NULL;
4065
4066 return popupMenu->MSWCommand(cmd, id);
4067 }
4068 #endif // wxUSE_MENUS_NATIVE
4069
4070 wxWindow *win = NULL;
4071
4072 // first try to find it from HWND - this works even with the broken
4073 // programs using the same ids for different controls
4074 if ( control )
4075 {
4076 win = wxFindWinFromHandle(control);
4077 }
4078
4079 // try the id
4080 if ( !win )
4081 {
4082 // must cast to a signed type before comparing with other ids!
4083 win = FindItem((signed short)id);
4084 }
4085
4086 if ( win )
4087 {
4088 return win->MSWCommand(cmd, id);
4089 }
4090
4091 // the messages sent from the in-place edit control used by the treectrl
4092 // for label editing have id == 0, but they should _not_ be treated as menu
4093 // messages (they are EN_XXX ones, in fact) so don't translate anything
4094 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
4095 if ( !control )
4096 {
4097 // If no child window, it may be an accelerator, e.g. for a popup menu
4098 // command
4099
4100 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
4101 event.SetEventObject(this);
4102 event.SetId(id);
4103 event.SetInt(id);
4104
4105 return GetEventHandler()->ProcessEvent(event);
4106 }
4107 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4108 else
4109 {
4110 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
4111 // notifications to its parent which we want to reflect back to
4112 // wxSpinCtrl
4113 wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
4114 if ( spin && spin->ProcessTextCommand(cmd, id) )
4115 return TRUE;
4116 }
4117 #endif // wxUSE_SPINCTRL
4118
4119 return FALSE;
4120 }
4121
4122 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
4123 {
4124 #ifndef __WXWINCE__
4125 // 4 bits are reserved
4126 switch ( wParam & 0xFFFFFFF0 )
4127 {
4128 case SC_MAXIMIZE:
4129 return HandleMaximize();
4130
4131 case SC_MINIMIZE:
4132 return HandleMinimize();
4133 }
4134 #endif
4135
4136 return FALSE;
4137 }
4138
4139 // ---------------------------------------------------------------------------
4140 // mouse events
4141 // ---------------------------------------------------------------------------
4142
4143 void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
4144 int x, int y,
4145 WXUINT flags)
4146 {
4147 // our client coords are not quite the same as Windows ones
4148 wxPoint pt = GetClientAreaOrigin();
4149 event.m_x = x - pt.x;
4150 event.m_y = y - pt.y;
4151
4152 event.m_shiftDown = (flags & MK_SHIFT) != 0;
4153 event.m_controlDown = (flags & MK_CONTROL) != 0;
4154 event.m_leftDown = (flags & MK_LBUTTON) != 0;
4155 event.m_middleDown = (flags & MK_MBUTTON) != 0;
4156 event.m_rightDown = (flags & MK_RBUTTON) != 0;
4157 // event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
4158 // Returns different negative values on WinME and WinNT,
4159 // so simply test for negative value.
4160 event.m_altDown = ::GetKeyState(VK_MENU) < 0;
4161
4162 event.SetTimestamp(s_currentMsg.time);
4163 event.m_eventObject = this;
4164 event.SetId(GetId());
4165
4166 #if wxUSE_MOUSEEVENT_HACK
4167 m_lastMouseX = x;
4168 m_lastMouseY = y;
4169 m_lastMouseEvent = event.GetEventType();
4170 #endif // wxUSE_MOUSEEVENT_HACK
4171 }
4172
4173 // Windows doesn't send the mouse events to the static controls (which are
4174 // transparent in the sense that their WM_NCHITTEST handler returns
4175 // HTTRANSPARENT) at all but we want all controls to receive the mouse events
4176 // and so we manually check if we don't have a child window under mouse and if
4177 // we do, send the event to it instead of the window Windows had sent WM_XXX
4178 // to.
4179 //
4180 // Notice that this is not done for the mouse move events because this could
4181 // (would?) be too slow, but only for clicks which means that the static texts
4182 // still don't get move, enter nor leave events.
4183 static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //TW:REQ:Univ
4184 {
4185 wxCHECK_MSG( x && y, win, _T("NULL pointer in FindWindowForMouseEvent") );
4186
4187 // first try to find a non transparent child: this allows us to send events
4188 // to a static text which is inside a static box, for example
4189 POINT pt = { *x, *y };
4190 HWND hwnd = GetHwndOf(win),
4191 hwndUnderMouse;
4192
4193 #ifdef __WXWINCE__
4194 hwndUnderMouse = ::ChildWindowFromPoint
4195 (
4196 hwnd,
4197 pt
4198 );
4199 #else
4200 hwndUnderMouse = ::ChildWindowFromPointEx
4201 (
4202 hwnd,
4203 pt,
4204 CWP_SKIPINVISIBLE |
4205 CWP_SKIPDISABLED |
4206 CWP_SKIPTRANSPARENT
4207 );
4208 #endif
4209
4210 if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
4211 {
4212 // now try any child window at all
4213 hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
4214 }
4215
4216 // check that we have a child window which is susceptible to receive mouse
4217 // events: for this it must be shown and enabled
4218 if ( hwndUnderMouse &&
4219 hwndUnderMouse != hwnd &&
4220 ::IsWindowVisible(hwndUnderMouse) &&
4221 ::IsWindowEnabled(hwndUnderMouse) )
4222 {
4223 wxWindow *winUnderMouse = wxFindWinFromHandle((WXHWND)hwndUnderMouse);
4224 if ( winUnderMouse )
4225 {
4226 // translate the mouse coords to the other window coords
4227 win->ClientToScreen(x, y);
4228 winUnderMouse->ScreenToClient(x, y);
4229
4230 win = winUnderMouse;
4231 }
4232 }
4233
4234 return win;
4235 }
4236
4237 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
4238 {
4239 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
4240 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
4241 // from the message id and take the value in the table to get wxWin event
4242 // id
4243 static const wxEventType eventsMouse[] =
4244 {
4245 wxEVT_MOTION,
4246 wxEVT_LEFT_DOWN,
4247 wxEVT_LEFT_UP,
4248 wxEVT_LEFT_DCLICK,
4249 wxEVT_RIGHT_DOWN,
4250 wxEVT_RIGHT_UP,
4251 wxEVT_RIGHT_DCLICK,
4252 wxEVT_MIDDLE_DOWN,
4253 wxEVT_MIDDLE_UP,
4254 wxEVT_MIDDLE_DCLICK
4255 };
4256
4257 wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
4258 InitMouseEvent(event, x, y, flags);
4259
4260 return GetEventHandler()->ProcessEvent(event);
4261 }
4262
4263 bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
4264 {
4265 if ( !m_mouseInWindow )
4266 {
4267 // it would be wrong to assume that just because we get a mouse move
4268 // event that the mouse is inside the window: although this is usually
4269 // true, it is not if we had captured the mouse, so we need to check
4270 // the mouse coordinates here
4271 if ( !HasCapture() || IsMouseInWindow() )
4272 {
4273 // Generate an ENTER event
4274 m_mouseInWindow = TRUE;
4275
4276 wxMouseEvent event(wxEVT_ENTER_WINDOW);
4277 InitMouseEvent(event, x, y, flags);
4278
4279 (void)GetEventHandler()->ProcessEvent(event);
4280 }
4281 }
4282
4283 #if wxUSE_MOUSEEVENT_HACK
4284 // Window gets a click down message followed by a mouse move message even
4285 // if position isn't changed! We want to discard the trailing move event
4286 // if x and y are the same.
4287 if ( (m_lastMouseEvent == wxEVT_RIGHT_DOWN ||
4288 m_lastMouseEvent == wxEVT_LEFT_DOWN ||
4289 m_lastMouseEvent == wxEVT_MIDDLE_DOWN) &&
4290 (m_lastMouseX == x && m_lastMouseY == y) )
4291 {
4292 m_lastMouseEvent = wxEVT_MOTION;
4293
4294 return FALSE;
4295 }
4296 #endif // wxUSE_MOUSEEVENT_HACK
4297
4298 return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
4299 }
4300
4301
4302 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
4303 {
4304 #if wxUSE_MOUSEWHEEL
4305 wxMouseEvent event(wxEVT_MOUSEWHEEL);
4306 InitMouseEvent(event,
4307 GET_X_LPARAM(lParam),
4308 GET_Y_LPARAM(lParam),
4309 LOWORD(wParam));
4310 event.m_wheelRotation = (short)HIWORD(wParam);
4311 event.m_wheelDelta = WHEEL_DELTA;
4312
4313 static int s_linesPerRotation = -1;
4314 if ( s_linesPerRotation == -1 )
4315 {
4316 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
4317 &s_linesPerRotation, 0))
4318 {
4319 // this is not supposed to happen
4320 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
4321
4322 // the default is 3, so use it if SystemParametersInfo() failed
4323 s_linesPerRotation = 3;
4324 }
4325 }
4326
4327 event.m_linesPerAction = s_linesPerRotation;
4328 return GetEventHandler()->ProcessEvent(event);
4329
4330 #else
4331 (void) wParam;
4332 (void) lParam;
4333
4334 return FALSE;
4335 #endif
4336 }
4337
4338
4339 // ---------------------------------------------------------------------------
4340 // keyboard handling
4341 // ---------------------------------------------------------------------------
4342
4343 // create the key event of the given type for the given key - used by
4344 // HandleChar and HandleKeyDown/Up
4345 wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
4346 int id,
4347 WXLPARAM lParam,
4348 WXWPARAM wParam) const
4349 {
4350 wxKeyEvent event(evType);
4351 event.SetId(GetId());
4352 event.m_shiftDown = wxIsShiftDown();
4353 event.m_controlDown = wxIsCtrlDown();
4354 event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
4355
4356 event.m_eventObject = (wxWindow *)this; // const_cast
4357 event.m_keyCode = id;
4358 event.m_rawCode = (wxUint32) wParam;
4359 event.m_rawFlags = (wxUint32) lParam;
4360 event.SetTimestamp(s_currentMsg.time);
4361
4362 // translate the position to client coords
4363 POINT pt;
4364 GetCursorPos(&pt);
4365 RECT rect;
4366 GetWindowRect(GetHwnd(),&rect);
4367 pt.x -= rect.left;
4368 pt.y -= rect.top;
4369
4370 event.m_x = pt.x;
4371 event.m_y = pt.y;
4372
4373 return event;
4374 }
4375
4376 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
4377 // WM_KEYDOWN one
4378 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
4379 {
4380 bool ctrlDown = FALSE;
4381
4382 int id;
4383 if ( isASCII )
4384 {
4385 // If 1 -> 26, translate to either special keycode or just set
4386 // ctrlDown. IOW, Ctrl-C should result in keycode == 3 and
4387 // ControlDown() == TRUE.
4388 id = wParam;
4389 if ( (id > 0) && (id < 27) )
4390 {
4391 switch (id)
4392 {
4393 case 13:
4394 id = WXK_RETURN;
4395 break;
4396
4397 case 8:
4398 id = WXK_BACK;
4399 break;
4400
4401 case 9:
4402 id = WXK_TAB;
4403 break;
4404
4405 default:
4406 ctrlDown = TRUE;
4407 break;
4408 }
4409 }
4410 }
4411 else // we're called from WM_KEYDOWN
4412 {
4413 id = wxCharCodeMSWToWX(wParam);
4414 if ( id == 0 )
4415 {
4416 // it's ASCII and will be processed here only when called from
4417 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
4418 return FALSE;
4419 }
4420 }
4421
4422 wxKeyEvent event(CreateKeyEvent(wxEVT_CHAR, id, lParam, wParam));
4423
4424 // the alphanumeric keys produced by pressing AltGr+something on European
4425 // keyboards have both Ctrl and Alt modifiers which may confuse the user
4426 // code as, normally, keys with Ctrl and/or Alt don't result in anything
4427 // alphanumeric, so pretend that there are no modifiers at all (the
4428 // KEY_DOWN event would still have the correct modifiers if they're really
4429 // needed)
4430 if ( event.m_controlDown && event.m_altDown &&
4431 (id >= 32 && id < 256) )
4432 {
4433 event.m_controlDown =
4434 event.m_altDown = FALSE;
4435 }
4436
4437 return GetEventHandler()->ProcessEvent(event);
4438 }
4439
4440 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
4441 {
4442 int id = wxCharCodeMSWToWX(wParam);
4443
4444 if ( !id )
4445 {
4446 // normal ASCII char
4447 id = wParam;
4448 }
4449
4450 if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4451 {
4452 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam, wParam));
4453 if ( GetEventHandler()->ProcessEvent(event) )
4454 {
4455 return TRUE;
4456 }
4457 }
4458
4459 return FALSE;
4460 }
4461
4462 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
4463 {
4464 int id = wxCharCodeMSWToWX(wParam);
4465
4466 if ( !id )
4467 {
4468 // normal ASCII char
4469 id = wParam;
4470 }
4471
4472 if ( id != -1 ) // VZ: does this ever happen (FIXME)?
4473 {
4474 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam, wParam));
4475 if ( GetEventHandler()->ProcessEvent(event) )
4476 return TRUE;
4477 }
4478
4479 return FALSE;
4480 }
4481
4482 int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
4483 {
4484 // FIXME: implement GetMenuItemCount for WinCE, possibly
4485 // in terms of GetMenuItemInfo
4486 #ifndef __WXWINCE__
4487 const HMENU hmenu = (HMENU)lParam;
4488
4489 MENUITEMINFO mii;
4490 wxZeroMemory(mii);
4491 mii.cbSize = sizeof(MENUITEMINFO);
4492 mii.fMask = MIIM_TYPE | MIIM_DATA;
4493
4494 // find if we have this letter in any owner drawn item
4495 const int count = ::GetMenuItemCount(hmenu);
4496 for ( int i = 0; i < count; i++ )
4497 {
4498 if ( ::GetMenuItemInfo(hmenu, i, TRUE, &mii) )
4499 {
4500 if ( mii.fType == MFT_OWNERDRAW )
4501 {
4502 // dwItemData member of the MENUITEMINFO is a
4503 // pointer to the associated wxMenuItem -- see the
4504 // menu creation code
4505 wxMenuItem *item = (wxMenuItem*)mii.dwItemData;
4506
4507 const wxChar *p = wxStrchr(item->GetText(), _T('&'));
4508 while ( p++ )
4509 {
4510 if ( *p == _T('&') )
4511 {
4512 // this is not the accel char, find the real one
4513 p = wxStrchr(p + 1, _T('&'));
4514 }
4515 else // got the accel char
4516 {
4517 // FIXME-UNICODE: this comparison doesn't risk to work
4518 // for non ASCII accelerator characters I'm afraid, but
4519 // what can we do?
4520 if ( wxToupper(*p) == chAccel )
4521 {
4522 return i;
4523 }
4524 else
4525 {
4526 // this one doesn't match
4527 break;
4528 }
4529 }
4530 }
4531 }
4532 }
4533 else // failed to get the menu text?
4534 {
4535 // it's not fatal, so don't show error, but still log
4536 // it
4537 wxLogLastError(_T("GetMenuItemInfo"));
4538 }
4539 }
4540 #endif
4541 return wxNOT_FOUND;
4542 }
4543
4544 // ---------------------------------------------------------------------------
4545 // joystick
4546 // ---------------------------------------------------------------------------
4547
4548 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
4549 {
4550 #ifdef JOY_BUTTON1
4551 int change = 0;
4552 if ( flags & JOY_BUTTON1CHG )
4553 change = wxJOY_BUTTON1;
4554 if ( flags & JOY_BUTTON2CHG )
4555 change = wxJOY_BUTTON2;
4556 if ( flags & JOY_BUTTON3CHG )
4557 change = wxJOY_BUTTON3;
4558 if ( flags & JOY_BUTTON4CHG )
4559 change = wxJOY_BUTTON4;
4560
4561 int buttons = 0;
4562 if ( flags & JOY_BUTTON1 )
4563 buttons |= wxJOY_BUTTON1;
4564 if ( flags & JOY_BUTTON2 )
4565 buttons |= wxJOY_BUTTON2;
4566 if ( flags & JOY_BUTTON3 )
4567 buttons |= wxJOY_BUTTON3;
4568 if ( flags & JOY_BUTTON4 )
4569 buttons |= wxJOY_BUTTON4;
4570
4571 // the event ids aren't consecutive so we can't use table based lookup
4572 int joystick;
4573 wxEventType eventType;
4574 switch ( msg )
4575 {
4576 case MM_JOY1MOVE:
4577 joystick = 1;
4578 eventType = wxEVT_JOY_MOVE;
4579 break;
4580
4581 case MM_JOY2MOVE:
4582 joystick = 2;
4583 eventType = wxEVT_JOY_MOVE;
4584 break;
4585
4586 case MM_JOY1ZMOVE:
4587 joystick = 1;
4588 eventType = wxEVT_JOY_ZMOVE;
4589 break;
4590
4591 case MM_JOY2ZMOVE:
4592 joystick = 2;
4593 eventType = wxEVT_JOY_ZMOVE;
4594 break;
4595
4596 case MM_JOY1BUTTONDOWN:
4597 joystick = 1;
4598 eventType = wxEVT_JOY_BUTTON_DOWN;
4599 break;
4600
4601 case MM_JOY2BUTTONDOWN:
4602 joystick = 2;
4603 eventType = wxEVT_JOY_BUTTON_DOWN;
4604 break;
4605
4606 case MM_JOY1BUTTONUP:
4607 joystick = 1;
4608 eventType = wxEVT_JOY_BUTTON_UP;
4609 break;
4610
4611 case MM_JOY2BUTTONUP:
4612 joystick = 2;
4613 eventType = wxEVT_JOY_BUTTON_UP;
4614 break;
4615
4616 default:
4617 wxFAIL_MSG(wxT("no such joystick event"));
4618
4619 return FALSE;
4620 }
4621
4622 wxJoystickEvent event(eventType, buttons, joystick, change);
4623 event.SetPosition(wxPoint(x, y));
4624 event.SetEventObject(this);
4625
4626 return GetEventHandler()->ProcessEvent(event);
4627 #else
4628 return FALSE;
4629 #endif
4630 }
4631
4632 // ---------------------------------------------------------------------------
4633 // scrolling
4634 // ---------------------------------------------------------------------------
4635
4636 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
4637 WXWORD pos, WXHWND control)
4638 {
4639 if ( control )
4640 {
4641 wxWindow *child = wxFindWinFromHandle(control);
4642 if ( child )
4643 return child->MSWOnScroll(orientation, wParam, pos, control);
4644 }
4645
4646 wxScrollWinEvent event;
4647 event.SetPosition(pos);
4648 event.SetOrientation(orientation);
4649 event.m_eventObject = this;
4650
4651 switch ( wParam )
4652 {
4653 case SB_TOP:
4654 event.m_eventType = wxEVT_SCROLLWIN_TOP;
4655 break;
4656
4657 case SB_BOTTOM:
4658 event.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
4659 break;
4660
4661 case SB_LINEUP:
4662 event.m_eventType = wxEVT_SCROLLWIN_LINEUP;
4663 break;
4664
4665 case SB_LINEDOWN:
4666 event.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
4667 break;
4668
4669 case SB_PAGEUP:
4670 event.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
4671 break;
4672
4673 case SB_PAGEDOWN:
4674 event.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
4675 break;
4676
4677 case SB_THUMBPOSITION:
4678 case SB_THUMBTRACK:
4679 // under Win32, the scrollbar range and position are 32 bit integers,
4680 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4681 // explicitly query the scrollbar for the correct position (this must
4682 // be done only for these two SB_ events as they are the only one
4683 // carrying the scrollbar position)
4684 {
4685 WinStruct<SCROLLINFO> scrollInfo;
4686 scrollInfo.fMask = SIF_TRACKPOS;
4687
4688 if ( !::GetScrollInfo(GetHwnd(),
4689 orientation == wxHORIZONTAL ? SB_HORZ
4690 : SB_VERT,
4691 &scrollInfo) )
4692 {
4693 wxLogLastError(_T("GetScrollInfo"));
4694 }
4695
4696 event.SetPosition(scrollInfo.nTrackPos);
4697 }
4698
4699 event.m_eventType = wParam == SB_THUMBPOSITION
4700 ? wxEVT_SCROLLWIN_THUMBRELEASE
4701 : wxEVT_SCROLLWIN_THUMBTRACK;
4702 break;
4703
4704 default:
4705 return FALSE;
4706 }
4707
4708 return GetEventHandler()->ProcessEvent(event);
4709 }
4710
4711 // ===========================================================================
4712 // global functions
4713 // ===========================================================================
4714
4715 void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
4716 {
4717 TEXTMETRIC tm;
4718 HDC dc = ::GetDC((HWND) wnd);
4719 HFONT fnt =0;
4720 HFONT was = 0;
4721 if ( the_font )
4722 {
4723 // the_font->UseResource();
4724 // the_font->RealizeResource();
4725 fnt = (HFONT)((wxFont *)the_font)->GetResourceHandle(); // const_cast
4726 if ( fnt )
4727 was = (HFONT) SelectObject(dc,fnt);
4728 }
4729 GetTextMetrics(dc, &tm);
4730 if ( the_font && fnt && was )
4731 {
4732 SelectObject(dc,was);
4733 }
4734 ReleaseDC((HWND)wnd, dc);
4735
4736 if ( x )
4737 *x = tm.tmAveCharWidth;
4738 if ( y )
4739 *y = tm.tmHeight + tm.tmExternalLeading;
4740
4741 // if ( the_font )
4742 // the_font->ReleaseResource();
4743 }
4744
4745 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4746 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4747 int wxCharCodeMSWToWX(int keySym)
4748 {
4749 int id;
4750 switch (keySym)
4751 {
4752 case VK_CANCEL: id = WXK_CANCEL; break;
4753 case VK_BACK: id = WXK_BACK; break;
4754 case VK_TAB: id = WXK_TAB; break;
4755 case VK_CLEAR: id = WXK_CLEAR; break;
4756 case VK_RETURN: id = WXK_RETURN; break;
4757 case VK_SHIFT: id = WXK_SHIFT; break;
4758 case VK_CONTROL: id = WXK_CONTROL; break;
4759 case VK_MENU : id = WXK_MENU; break;
4760 case VK_PAUSE: id = WXK_PAUSE; break;
4761 case VK_CAPITAL: id = WXK_CAPITAL; break;
4762 case VK_SPACE: id = WXK_SPACE; break;
4763 case VK_ESCAPE: id = WXK_ESCAPE; break;
4764 case VK_PRIOR: id = WXK_PRIOR; break;
4765 case VK_NEXT : id = WXK_NEXT; break;
4766 case VK_END: id = WXK_END; break;
4767 case VK_HOME : id = WXK_HOME; break;
4768 case VK_LEFT : id = WXK_LEFT; break;
4769 case VK_UP: id = WXK_UP; break;
4770 case VK_RIGHT: id = WXK_RIGHT; break;
4771 case VK_DOWN : id = WXK_DOWN; break;
4772 case VK_SELECT: id = WXK_SELECT; break;
4773 case VK_PRINT: id = WXK_PRINT; break;
4774 case VK_EXECUTE: id = WXK_EXECUTE; break;
4775 case VK_INSERT: id = WXK_INSERT; break;
4776 case VK_DELETE: id = WXK_DELETE; break;
4777 case VK_HELP : id = WXK_HELP; break;
4778 case VK_NUMPAD0: id = WXK_NUMPAD0; break;
4779 case VK_NUMPAD1: id = WXK_NUMPAD1; break;
4780 case VK_NUMPAD2: id = WXK_NUMPAD2; break;
4781 case VK_NUMPAD3: id = WXK_NUMPAD3; break;
4782 case VK_NUMPAD4: id = WXK_NUMPAD4; break;
4783 case VK_NUMPAD5: id = WXK_NUMPAD5; break;
4784 case VK_NUMPAD6: id = WXK_NUMPAD6; break;
4785 case VK_NUMPAD7: id = WXK_NUMPAD7; break;
4786 case VK_NUMPAD8: id = WXK_NUMPAD8; break;
4787 case VK_NUMPAD9: id = WXK_NUMPAD9; break;
4788 case VK_MULTIPLY: id = WXK_NUMPAD_MULTIPLY; break;
4789 case VK_ADD: id = WXK_NUMPAD_ADD; break;
4790 case VK_SUBTRACT: id = WXK_NUMPAD_SUBTRACT; break;
4791 case VK_DECIMAL: id = WXK_NUMPAD_DECIMAL; break;
4792 case VK_DIVIDE: id = WXK_NUMPAD_DIVIDE; break;
4793 case VK_F1: id = WXK_F1; break;
4794 case VK_F2: id = WXK_F2; break;
4795 case VK_F3: id = WXK_F3; break;
4796 case VK_F4: id = WXK_F4; break;
4797 case VK_F5: id = WXK_F5; break;
4798 case VK_F6: id = WXK_F6; break;
4799 case VK_F7: id = WXK_F7; break;
4800 case VK_F8: id = WXK_F8; break;
4801 case VK_F9: id = WXK_F9; break;
4802 case VK_F10: id = WXK_F10; break;
4803 case VK_F11: id = WXK_F11; break;
4804 case VK_F12: id = WXK_F12; break;
4805 case VK_F13: id = WXK_F13; break;
4806 case VK_F14: id = WXK_F14; break;
4807 case VK_F15: id = WXK_F15; break;
4808 case VK_F16: id = WXK_F16; break;
4809 case VK_F17: id = WXK_F17; break;
4810 case VK_F18: id = WXK_F18; break;
4811 case VK_F19: id = WXK_F19; break;
4812 case VK_F20: id = WXK_F20; break;
4813 case VK_F21: id = WXK_F21; break;
4814 case VK_F22: id = WXK_F22; break;
4815 case VK_F23: id = WXK_F23; break;
4816 case VK_F24: id = WXK_F24; break;
4817 case VK_NUMLOCK: id = WXK_NUMLOCK; break;
4818 case VK_SCROLL: id = WXK_SCROLL; break;
4819
4820 case VK_OEM_1: id = ';'; break;
4821 case VK_OEM_PLUS: id = '+'; break;
4822 case VK_OEM_COMMA: id = ','; break;
4823 case VK_OEM_MINUS: id = '-'; break;
4824 case VK_OEM_PERIOD: id = '.'; break;
4825 case VK_OEM_2: id = '/'; break;
4826 case VK_OEM_3: id = '~'; break;
4827 case VK_OEM_4: id = '['; break;
4828 case VK_OEM_5: id = '\\'; break;
4829 case VK_OEM_6: id = ']'; break;
4830 case VK_OEM_7: id = '\''; break;
4831
4832 #ifdef VK_APPS
4833 case VK_LWIN: id = WXK_WINDOWS_LEFT; break;
4834 case VK_RWIN: id = WXK_WINDOWS_RIGHT; break;
4835 case VK_APPS: id = WXK_WINDOWS_MENU; break;
4836 #endif // VK_APPS defined
4837
4838 default:
4839 id = 0;
4840 }
4841
4842 return id;
4843 }
4844
4845 int wxCharCodeWXToMSW(int id, bool *isVirtual)
4846 {
4847 *isVirtual = TRUE;
4848 int keySym = 0;
4849 switch (id)
4850 {
4851 case WXK_CANCEL: keySym = VK_CANCEL; break;
4852 case WXK_CLEAR: keySym = VK_CLEAR; break;
4853 case WXK_SHIFT: keySym = VK_SHIFT; break;
4854 case WXK_CONTROL: keySym = VK_CONTROL; break;
4855 case WXK_MENU : keySym = VK_MENU; break;
4856 case WXK_PAUSE: keySym = VK_PAUSE; break;
4857 case WXK_PRIOR: keySym = VK_PRIOR; break;
4858 case WXK_NEXT : keySym = VK_NEXT; break;
4859 case WXK_END: keySym = VK_END; break;
4860 case WXK_HOME : keySym = VK_HOME; break;
4861 case WXK_LEFT : keySym = VK_LEFT; break;
4862 case WXK_UP: keySym = VK_UP; break;
4863 case WXK_RIGHT: keySym = VK_RIGHT; break;
4864 case WXK_DOWN : keySym = VK_DOWN; break;
4865 case WXK_SELECT: keySym = VK_SELECT; break;
4866 case WXK_PRINT: keySym = VK_PRINT; break;
4867 case WXK_EXECUTE: keySym = VK_EXECUTE; break;
4868 case WXK_INSERT: keySym = VK_INSERT; break;
4869 case WXK_DELETE: keySym = VK_DELETE; break;
4870 case WXK_HELP : keySym = VK_HELP; break;
4871 case WXK_NUMPAD0: keySym = VK_NUMPAD0; break;
4872 case WXK_NUMPAD1: keySym = VK_NUMPAD1; break;
4873 case WXK_NUMPAD2: keySym = VK_NUMPAD2; break;
4874 case WXK_NUMPAD3: keySym = VK_NUMPAD3; break;
4875 case WXK_NUMPAD4: keySym = VK_NUMPAD4; break;
4876 case WXK_NUMPAD5: keySym = VK_NUMPAD5; break;
4877 case WXK_NUMPAD6: keySym = VK_NUMPAD6; break;
4878 case WXK_NUMPAD7: keySym = VK_NUMPAD7; break;
4879 case WXK_NUMPAD8: keySym = VK_NUMPAD8; break;
4880 case WXK_NUMPAD9: keySym = VK_NUMPAD9; break;
4881 case WXK_NUMPAD_MULTIPLY: keySym = VK_MULTIPLY; break;
4882 case WXK_NUMPAD_ADD: keySym = VK_ADD; break;
4883 case WXK_NUMPAD_SUBTRACT: keySym = VK_SUBTRACT; break;
4884 case WXK_NUMPAD_DECIMAL: keySym = VK_DECIMAL; break;
4885 case WXK_NUMPAD_DIVIDE: keySym = VK_DIVIDE; break;
4886 case WXK_F1: keySym = VK_F1; break;
4887 case WXK_F2: keySym = VK_F2; break;
4888 case WXK_F3: keySym = VK_F3; break;
4889 case WXK_F4: keySym = VK_F4; break;
4890 case WXK_F5: keySym = VK_F5; break;
4891 case WXK_F6: keySym = VK_F6; break;
4892 case WXK_F7: keySym = VK_F7; break;
4893 case WXK_F8: keySym = VK_F8; break;
4894 case WXK_F9: keySym = VK_F9; break;
4895 case WXK_F10: keySym = VK_F10; break;
4896 case WXK_F11: keySym = VK_F11; break;
4897 case WXK_F12: keySym = VK_F12; break;
4898 case WXK_F13: keySym = VK_F13; break;
4899 case WXK_F14: keySym = VK_F14; break;
4900 case WXK_F15: keySym = VK_F15; break;
4901 case WXK_F16: keySym = VK_F16; break;
4902 case WXK_F17: keySym = VK_F17; break;
4903 case WXK_F18: keySym = VK_F18; break;
4904 case WXK_F19: keySym = VK_F19; break;
4905 case WXK_F20: keySym = VK_F20; break;
4906 case WXK_F21: keySym = VK_F21; break;
4907 case WXK_F22: keySym = VK_F22; break;
4908 case WXK_F23: keySym = VK_F23; break;
4909 case WXK_F24: keySym = VK_F24; break;
4910 case WXK_NUMLOCK: keySym = VK_NUMLOCK; break;
4911 case WXK_SCROLL: keySym = VK_SCROLL; break;
4912 default:
4913 {
4914 *isVirtual = FALSE;
4915 keySym = id;
4916 break;
4917 }
4918 }
4919 return keySym;
4920 }
4921
4922 wxWindow *wxGetActiveWindow()
4923 {
4924 HWND hWnd = GetActiveWindow();
4925 if ( hWnd != 0 )
4926 {
4927 return wxFindWinFromHandle((WXHWND) hWnd);
4928 }
4929 return NULL;
4930 }
4931
4932 extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
4933 {
4934 HWND hwnd = (HWND)hWnd;
4935
4936 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4937 // by code in msw/radiobox.cpp), for all the others we just search up the
4938 // window hierarchy
4939 wxWindow *win = (wxWindow *)NULL;
4940 if ( hwnd )
4941 {
4942 win = wxFindWinFromHandle((WXHWND)hwnd);
4943 if ( !win )
4944 {
4945 #if wxUSE_RADIOBOX
4946 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4947 // wxWindow class which overrides WM_GETDLGCODE processing to
4948 // do it as well, win would be already non NULL
4949 if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
4950 {
4951 win = (wxWindow *)::GetWindowLong(hwnd, GWL_USERDATA);
4952 }
4953 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4954 #endif // wxUSE_RADIOBOX
4955
4956 // spin control text buddy window should be mapped to spin ctrl
4957 // itself so try it too
4958 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4959 if ( !win )
4960 {
4961 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
4962 }
4963 #endif // wxUSE_SPINCTRL
4964 }
4965 }
4966
4967 while ( hwnd && !win )
4968 {
4969 // this is a really ugly hack needed to avoid mistakenly returning the
4970 // parent frame wxWindow for the find/replace modeless dialog HWND -
4971 // this, in turn, is needed to call IsDialogMessage() from
4972 // wxApp::ProcessMessage() as for this we must return NULL from here
4973 //
4974 // FIXME: this is clearly not the best way to do it but I think we'll
4975 // need to change HWND <-> wxWindow code more heavily than I can
4976 // do it now to fix it
4977 #ifndef __WXMICROWIN__
4978 if ( ::GetWindow(hwnd, GW_OWNER) )
4979 {
4980 // it's a dialog box, don't go upwards
4981 break;
4982 }
4983 #endif
4984
4985 hwnd = ::GetParent(hwnd);
4986 win = wxFindWinFromHandle((WXHWND)hwnd);
4987 }
4988
4989 return win;
4990 }
4991
4992 #if !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
4993
4994 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4995 // in active frames and dialogs, regardless of where the focus is.
4996 static HHOOK wxTheKeyboardHook = 0;
4997 static FARPROC wxTheKeyboardHookProc = 0;
4998 int APIENTRY _EXPORT
4999 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
5000
5001 void wxSetKeyboardHook(bool doIt)
5002 {
5003 if ( doIt )
5004 {
5005 wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
5006 wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
5007
5008 GetCurrentThreadId()
5009 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
5010 );
5011 }
5012 else
5013 {
5014 UnhookWindowsHookEx(wxTheKeyboardHook);
5015 }
5016 }
5017
5018 int APIENTRY _EXPORT
5019 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
5020 {
5021 DWORD hiWord = HIWORD(lParam);
5022 if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
5023 {
5024 int id = wxCharCodeMSWToWX(wParam);
5025 if ( id != 0 )
5026 {
5027 wxKeyEvent event(wxEVT_CHAR_HOOK);
5028 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
5029 event.m_altDown = TRUE;
5030
5031 event.m_eventObject = NULL;
5032 event.m_keyCode = id;
5033 event.m_shiftDown = wxIsShiftDown();
5034 event.m_controlDown = wxIsCtrlDown();
5035 event.SetTimestamp(s_currentMsg.time);
5036
5037 wxWindow *win = wxGetActiveWindow();
5038 wxEvtHandler *handler;
5039 if ( win )
5040 {
5041 handler = win->GetEventHandler();
5042 event.SetId(win->GetId());
5043 }
5044 else
5045 {
5046 handler = wxTheApp;
5047 event.SetId(-1);
5048 }
5049
5050 if ( handler && handler->ProcessEvent(event) )
5051 {
5052 // processed
5053 return 1;
5054 }
5055 }
5056 }
5057
5058 return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
5059 }
5060
5061 #endif // !__WXMICROWIN__
5062
5063 #ifdef __WXDEBUG__
5064 const char *wxGetMessageName(int message)
5065 {
5066 switch ( message )
5067 {
5068 case 0x0000: return "WM_NULL";
5069 case 0x0001: return "WM_CREATE";
5070 case 0x0002: return "WM_DESTROY";
5071 case 0x0003: return "WM_MOVE";
5072 case 0x0005: return "WM_SIZE";
5073 case 0x0006: return "WM_ACTIVATE";
5074 case 0x0007: return "WM_SETFOCUS";
5075 case 0x0008: return "WM_KILLFOCUS";
5076 case 0x000A: return "WM_ENABLE";
5077 case 0x000B: return "WM_SETREDRAW";
5078 case 0x000C: return "WM_SETTEXT";
5079 case 0x000D: return "WM_GETTEXT";
5080 case 0x000E: return "WM_GETTEXTLENGTH";
5081 case 0x000F: return "WM_PAINT";
5082 case 0x0010: return "WM_CLOSE";
5083 case 0x0011: return "WM_QUERYENDSESSION";
5084 case 0x0012: return "WM_QUIT";
5085 case 0x0013: return "WM_QUERYOPEN";
5086 case 0x0014: return "WM_ERASEBKGND";
5087 case 0x0015: return "WM_SYSCOLORCHANGE";
5088 case 0x0016: return "WM_ENDSESSION";
5089 case 0x0017: return "WM_SYSTEMERROR";
5090 case 0x0018: return "WM_SHOWWINDOW";
5091 case 0x0019: return "WM_CTLCOLOR";
5092 case 0x001A: return "WM_WININICHANGE";
5093 case 0x001B: return "WM_DEVMODECHANGE";
5094 case 0x001C: return "WM_ACTIVATEAPP";
5095 case 0x001D: return "WM_FONTCHANGE";
5096 case 0x001E: return "WM_TIMECHANGE";
5097 case 0x001F: return "WM_CANCELMODE";
5098 case 0x0020: return "WM_SETCURSOR";
5099 case 0x0021: return "WM_MOUSEACTIVATE";
5100 case 0x0022: return "WM_CHILDACTIVATE";
5101 case 0x0023: return "WM_QUEUESYNC";
5102 case 0x0024: return "WM_GETMINMAXINFO";
5103 case 0x0026: return "WM_PAINTICON";
5104 case 0x0027: return "WM_ICONERASEBKGND";
5105 case 0x0028: return "WM_NEXTDLGCTL";
5106 case 0x002A: return "WM_SPOOLERSTATUS";
5107 case 0x002B: return "WM_DRAWITEM";
5108 case 0x002C: return "WM_MEASUREITEM";
5109 case 0x002D: return "WM_DELETEITEM";
5110 case 0x002E: return "WM_VKEYTOITEM";
5111 case 0x002F: return "WM_CHARTOITEM";
5112 case 0x0030: return "WM_SETFONT";
5113 case 0x0031: return "WM_GETFONT";
5114 case 0x0037: return "WM_QUERYDRAGICON";
5115 case 0x0039: return "WM_COMPAREITEM";
5116 case 0x0041: return "WM_COMPACTING";
5117 case 0x0044: return "WM_COMMNOTIFY";
5118 case 0x0046: return "WM_WINDOWPOSCHANGING";
5119 case 0x0047: return "WM_WINDOWPOSCHANGED";
5120 case 0x0048: return "WM_POWER";
5121
5122 case 0x004A: return "WM_COPYDATA";
5123 case 0x004B: return "WM_CANCELJOURNAL";
5124 case 0x004E: return "WM_NOTIFY";
5125 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
5126 case 0x0051: return "WM_INPUTLANGCHANGE";
5127 case 0x0052: return "WM_TCARD";
5128 case 0x0053: return "WM_HELP";
5129 case 0x0054: return "WM_USERCHANGED";
5130 case 0x0055: return "WM_NOTIFYFORMAT";
5131 case 0x007B: return "WM_CONTEXTMENU";
5132 case 0x007C: return "WM_STYLECHANGING";
5133 case 0x007D: return "WM_STYLECHANGED";
5134 case 0x007E: return "WM_DISPLAYCHANGE";
5135 case 0x007F: return "WM_GETICON";
5136 case 0x0080: return "WM_SETICON";
5137
5138 case 0x0081: return "WM_NCCREATE";
5139 case 0x0082: return "WM_NCDESTROY";
5140 case 0x0083: return "WM_NCCALCSIZE";
5141 case 0x0084: return "WM_NCHITTEST";
5142 case 0x0085: return "WM_NCPAINT";
5143 case 0x0086: return "WM_NCACTIVATE";
5144 case 0x0087: return "WM_GETDLGCODE";
5145 case 0x00A0: return "WM_NCMOUSEMOVE";
5146 case 0x00A1: return "WM_NCLBUTTONDOWN";
5147 case 0x00A2: return "WM_NCLBUTTONUP";
5148 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
5149 case 0x00A4: return "WM_NCRBUTTONDOWN";
5150 case 0x00A5: return "WM_NCRBUTTONUP";
5151 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
5152 case 0x00A7: return "WM_NCMBUTTONDOWN";
5153 case 0x00A8: return "WM_NCMBUTTONUP";
5154 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
5155 case 0x0100: return "WM_KEYDOWN";
5156 case 0x0101: return "WM_KEYUP";
5157 case 0x0102: return "WM_CHAR";
5158 case 0x0103: return "WM_DEADCHAR";
5159 case 0x0104: return "WM_SYSKEYDOWN";
5160 case 0x0105: return "WM_SYSKEYUP";
5161 case 0x0106: return "WM_SYSCHAR";
5162 case 0x0107: return "WM_SYSDEADCHAR";
5163 case 0x0108: return "WM_KEYLAST";
5164
5165 case 0x010D: return "WM_IME_STARTCOMPOSITION";
5166 case 0x010E: return "WM_IME_ENDCOMPOSITION";
5167 case 0x010F: return "WM_IME_COMPOSITION";
5168
5169 case 0x0110: return "WM_INITDIALOG";
5170 case 0x0111: return "WM_COMMAND";
5171 case 0x0112: return "WM_SYSCOMMAND";
5172 case 0x0113: return "WM_TIMER";
5173 case 0x0114: return "WM_HSCROLL";
5174 case 0x0115: return "WM_VSCROLL";
5175 case 0x0116: return "WM_INITMENU";
5176 case 0x0117: return "WM_INITMENUPOPUP";
5177 case 0x011F: return "WM_MENUSELECT";
5178 case 0x0120: return "WM_MENUCHAR";
5179 case 0x0121: return "WM_ENTERIDLE";
5180 case 0x0200: return "WM_MOUSEMOVE";
5181 case 0x0201: return "WM_LBUTTONDOWN";
5182 case 0x0202: return "WM_LBUTTONUP";
5183 case 0x0203: return "WM_LBUTTONDBLCLK";
5184 case 0x0204: return "WM_RBUTTONDOWN";
5185 case 0x0205: return "WM_RBUTTONUP";
5186 case 0x0206: return "WM_RBUTTONDBLCLK";
5187 case 0x0207: return "WM_MBUTTONDOWN";
5188 case 0x0208: return "WM_MBUTTONUP";
5189 case 0x0209: return "WM_MBUTTONDBLCLK";
5190 case 0x020A: return "WM_MOUSEWHEEL";
5191 case 0x0210: return "WM_PARENTNOTIFY";
5192 case 0x0211: return "WM_ENTERMENULOOP";
5193 case 0x0212: return "WM_EXITMENULOOP";
5194
5195 case 0x0213: return "WM_NEXTMENU";
5196 case 0x0214: return "WM_SIZING";
5197 case 0x0215: return "WM_CAPTURECHANGED";
5198 case 0x0216: return "WM_MOVING";
5199 case 0x0218: return "WM_POWERBROADCAST";
5200 case 0x0219: return "WM_DEVICECHANGE";
5201
5202 case 0x0220: return "WM_MDICREATE";
5203 case 0x0221: return "WM_MDIDESTROY";
5204 case 0x0222: return "WM_MDIACTIVATE";
5205 case 0x0223: return "WM_MDIRESTORE";
5206 case 0x0224: return "WM_MDINEXT";
5207 case 0x0225: return "WM_MDIMAXIMIZE";
5208 case 0x0226: return "WM_MDITILE";
5209 case 0x0227: return "WM_MDICASCADE";
5210 case 0x0228: return "WM_MDIICONARRANGE";
5211 case 0x0229: return "WM_MDIGETACTIVE";
5212 case 0x0230: return "WM_MDISETMENU";
5213 case 0x0233: return "WM_DROPFILES";
5214
5215 case 0x0281: return "WM_IME_SETCONTEXT";
5216 case 0x0282: return "WM_IME_NOTIFY";
5217 case 0x0283: return "WM_IME_CONTROL";
5218 case 0x0284: return "WM_IME_COMPOSITIONFULL";
5219 case 0x0285: return "WM_IME_SELECT";
5220 case 0x0286: return "WM_IME_CHAR";
5221 case 0x0290: return "WM_IME_KEYDOWN";
5222 case 0x0291: return "WM_IME_KEYUP";
5223
5224 case 0x0300: return "WM_CUT";
5225 case 0x0301: return "WM_COPY";
5226 case 0x0302: return "WM_PASTE";
5227 case 0x0303: return "WM_CLEAR";
5228 case 0x0304: return "WM_UNDO";
5229 case 0x0305: return "WM_RENDERFORMAT";
5230 case 0x0306: return "WM_RENDERALLFORMATS";
5231 case 0x0307: return "WM_DESTROYCLIPBOARD";
5232 case 0x0308: return "WM_DRAWCLIPBOARD";
5233 case 0x0309: return "WM_PAINTCLIPBOARD";
5234 case 0x030A: return "WM_VSCROLLCLIPBOARD";
5235 case 0x030B: return "WM_SIZECLIPBOARD";
5236 case 0x030C: return "WM_ASKCBFORMATNAME";
5237 case 0x030D: return "WM_CHANGECBCHAIN";
5238 case 0x030E: return "WM_HSCROLLCLIPBOARD";
5239 case 0x030F: return "WM_QUERYNEWPALETTE";
5240 case 0x0310: return "WM_PALETTEISCHANGING";
5241 case 0x0311: return "WM_PALETTECHANGED";
5242 #if wxUSE_HOTKEY
5243 case 0x0312: return "WM_HOTKEY";
5244 #endif
5245
5246 // common controls messages - although they're not strictly speaking
5247 // standard, it's nice to decode them nevertheless
5248
5249 // listview
5250 case 0x1000 + 0: return "LVM_GETBKCOLOR";
5251 case 0x1000 + 1: return "LVM_SETBKCOLOR";
5252 case 0x1000 + 2: return "LVM_GETIMAGELIST";
5253 case 0x1000 + 3: return "LVM_SETIMAGELIST";
5254 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
5255 case 0x1000 + 5: return "LVM_GETITEMA";
5256 case 0x1000 + 75: return "LVM_GETITEMW";
5257 case 0x1000 + 6: return "LVM_SETITEMA";
5258 case 0x1000 + 76: return "LVM_SETITEMW";
5259 case 0x1000 + 7: return "LVM_INSERTITEMA";
5260 case 0x1000 + 77: return "LVM_INSERTITEMW";
5261 case 0x1000 + 8: return "LVM_DELETEITEM";
5262 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
5263 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
5264 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
5265 case 0x1000 + 12: return "LVM_GETNEXTITEM";
5266 case 0x1000 + 13: return "LVM_FINDITEMA";
5267 case 0x1000 + 83: return "LVM_FINDITEMW";
5268 case 0x1000 + 14: return "LVM_GETITEMRECT";
5269 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
5270 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
5271 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
5272 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
5273 case 0x1000 + 18: return "LVM_HITTEST";
5274 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
5275 case 0x1000 + 20: return "LVM_SCROLL";
5276 case 0x1000 + 21: return "LVM_REDRAWITEMS";
5277 case 0x1000 + 22: return "LVM_ARRANGE";
5278 case 0x1000 + 23: return "LVM_EDITLABELA";
5279 case 0x1000 + 118: return "LVM_EDITLABELW";
5280 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
5281 case 0x1000 + 25: return "LVM_GETCOLUMNA";
5282 case 0x1000 + 95: return "LVM_GETCOLUMNW";
5283 case 0x1000 + 26: return "LVM_SETCOLUMNA";
5284 case 0x1000 + 96: return "LVM_SETCOLUMNW";
5285 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
5286 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
5287 case 0x1000 + 28: return "LVM_DELETECOLUMN";
5288 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
5289 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
5290 case 0x1000 + 31: return "LVM_GETHEADER";
5291 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
5292 case 0x1000 + 34: return "LVM_GETVIEWRECT";
5293 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
5294 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
5295 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
5296 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
5297 case 0x1000 + 39: return "LVM_GETTOPINDEX";
5298 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
5299 case 0x1000 + 41: return "LVM_GETORIGIN";
5300 case 0x1000 + 42: return "LVM_UPDATE";
5301 case 0x1000 + 43: return "LVM_SETITEMSTATE";
5302 case 0x1000 + 44: return "LVM_GETITEMSTATE";
5303 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
5304 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
5305 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
5306 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
5307 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
5308 case 0x1000 + 48: return "LVM_SORTITEMS";
5309 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
5310 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
5311 case 0x1000 + 51: return "LVM_GETITEMSPACING";
5312 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
5313 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
5314 case 0x1000 + 53: return "LVM_SETICONSPACING";
5315 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
5316 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
5317 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
5318 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
5319 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
5320 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
5321 case 0x1000 + 60: return "LVM_SETHOTITEM";
5322 case 0x1000 + 61: return "LVM_GETHOTITEM";
5323 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
5324 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
5325 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
5326 case 0x1000 + 65: return "LVM_SETWORKAREA";
5327
5328 // tree view
5329 case 0x1100 + 0: return "TVM_INSERTITEMA";
5330 case 0x1100 + 50: return "TVM_INSERTITEMW";
5331 case 0x1100 + 1: return "TVM_DELETEITEM";
5332 case 0x1100 + 2: return "TVM_EXPAND";
5333 case 0x1100 + 4: return "TVM_GETITEMRECT";
5334 case 0x1100 + 5: return "TVM_GETCOUNT";
5335 case 0x1100 + 6: return "TVM_GETINDENT";
5336 case 0x1100 + 7: return "TVM_SETINDENT";
5337 case 0x1100 + 8: return "TVM_GETIMAGELIST";
5338 case 0x1100 + 9: return "TVM_SETIMAGELIST";
5339 case 0x1100 + 10: return "TVM_GETNEXTITEM";
5340 case 0x1100 + 11: return "TVM_SELECTITEM";
5341 case 0x1100 + 12: return "TVM_GETITEMA";
5342 case 0x1100 + 62: return "TVM_GETITEMW";
5343 case 0x1100 + 13: return "TVM_SETITEMA";
5344 case 0x1100 + 63: return "TVM_SETITEMW";
5345 case 0x1100 + 14: return "TVM_EDITLABELA";
5346 case 0x1100 + 65: return "TVM_EDITLABELW";
5347 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
5348 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
5349 case 0x1100 + 17: return "TVM_HITTEST";
5350 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
5351 case 0x1100 + 19: return "TVM_SORTCHILDREN";
5352 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
5353 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
5354 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
5355 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
5356 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
5357 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
5358 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
5359
5360 // header
5361 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
5362 case 0x1200 + 1: return "HDM_INSERTITEMA";
5363 case 0x1200 + 10: return "HDM_INSERTITEMW";
5364 case 0x1200 + 2: return "HDM_DELETEITEM";
5365 case 0x1200 + 3: return "HDM_GETITEMA";
5366 case 0x1200 + 11: return "HDM_GETITEMW";
5367 case 0x1200 + 4: return "HDM_SETITEMA";
5368 case 0x1200 + 12: return "HDM_SETITEMW";
5369 case 0x1200 + 5: return "HDM_LAYOUT";
5370 case 0x1200 + 6: return "HDM_HITTEST";
5371 case 0x1200 + 7: return "HDM_GETITEMRECT";
5372 case 0x1200 + 8: return "HDM_SETIMAGELIST";
5373 case 0x1200 + 9: return "HDM_GETIMAGELIST";
5374 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
5375 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
5376 case 0x1200 + 17: return "HDM_GETORDERARRAY";
5377 case 0x1200 + 18: return "HDM_SETORDERARRAY";
5378 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
5379
5380 // tab control
5381 case 0x1300 + 2: return "TCM_GETIMAGELIST";
5382 case 0x1300 + 3: return "TCM_SETIMAGELIST";
5383 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
5384 case 0x1300 + 5: return "TCM_GETITEMA";
5385 case 0x1300 + 60: return "TCM_GETITEMW";
5386 case 0x1300 + 6: return "TCM_SETITEMA";
5387 case 0x1300 + 61: return "TCM_SETITEMW";
5388 case 0x1300 + 7: return "TCM_INSERTITEMA";
5389 case 0x1300 + 62: return "TCM_INSERTITEMW";
5390 case 0x1300 + 8: return "TCM_DELETEITEM";
5391 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
5392 case 0x1300 + 10: return "TCM_GETITEMRECT";
5393 case 0x1300 + 11: return "TCM_GETCURSEL";
5394 case 0x1300 + 12: return "TCM_SETCURSEL";
5395 case 0x1300 + 13: return "TCM_HITTEST";
5396 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
5397 case 0x1300 + 40: return "TCM_ADJUSTRECT";
5398 case 0x1300 + 41: return "TCM_SETITEMSIZE";
5399 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
5400 case 0x1300 + 43: return "TCM_SETPADDING";
5401 case 0x1300 + 44: return "TCM_GETROWCOUNT";
5402 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
5403 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
5404 case 0x1300 + 47: return "TCM_GETCURFOCUS";
5405 case 0x1300 + 48: return "TCM_SETCURFOCUS";
5406 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
5407 case 0x1300 + 50: return "TCM_DESELECTALL";
5408
5409 // toolbar
5410 case WM_USER+1: return "TB_ENABLEBUTTON";
5411 case WM_USER+2: return "TB_CHECKBUTTON";
5412 case WM_USER+3: return "TB_PRESSBUTTON";
5413 case WM_USER+4: return "TB_HIDEBUTTON";
5414 case WM_USER+5: return "TB_INDETERMINATE";
5415 case WM_USER+9: return "TB_ISBUTTONENABLED";
5416 case WM_USER+10: return "TB_ISBUTTONCHECKED";
5417 case WM_USER+11: return "TB_ISBUTTONPRESSED";
5418 case WM_USER+12: return "TB_ISBUTTONHIDDEN";
5419 case WM_USER+13: return "TB_ISBUTTONINDETERMINATE";
5420 case WM_USER+17: return "TB_SETSTATE";
5421 case WM_USER+18: return "TB_GETSTATE";
5422 case WM_USER+19: return "TB_ADDBITMAP";
5423 case WM_USER+20: return "TB_ADDBUTTONS";
5424 case WM_USER+21: return "TB_INSERTBUTTON";
5425 case WM_USER+22: return "TB_DELETEBUTTON";
5426 case WM_USER+23: return "TB_GETBUTTON";
5427 case WM_USER+24: return "TB_BUTTONCOUNT";
5428 case WM_USER+25: return "TB_COMMANDTOINDEX";
5429 case WM_USER+26: return "TB_SAVERESTOREA";
5430 case WM_USER+76: return "TB_SAVERESTOREW";
5431 case WM_USER+27: return "TB_CUSTOMIZE";
5432 case WM_USER+28: return "TB_ADDSTRINGA";
5433 case WM_USER+77: return "TB_ADDSTRINGW";
5434 case WM_USER+29: return "TB_GETITEMRECT";
5435 case WM_USER+30: return "TB_BUTTONSTRUCTSIZE";
5436 case WM_USER+31: return "TB_SETBUTTONSIZE";
5437 case WM_USER+32: return "TB_SETBITMAPSIZE";
5438 case WM_USER+33: return "TB_AUTOSIZE";
5439 case WM_USER+35: return "TB_GETTOOLTIPS";
5440 case WM_USER+36: return "TB_SETTOOLTIPS";
5441 case WM_USER+37: return "TB_SETPARENT";
5442 case WM_USER+39: return "TB_SETROWS";
5443 case WM_USER+40: return "TB_GETROWS";
5444 case WM_USER+42: return "TB_SETCMDID";
5445 case WM_USER+43: return "TB_CHANGEBITMAP";
5446 case WM_USER+44: return "TB_GETBITMAP";
5447 case WM_USER+45: return "TB_GETBUTTONTEXTA";
5448 case WM_USER+75: return "TB_GETBUTTONTEXTW";
5449 case WM_USER+46: return "TB_REPLACEBITMAP";
5450 case WM_USER+47: return "TB_SETINDENT";
5451 case WM_USER+48: return "TB_SETIMAGELIST";
5452 case WM_USER+49: return "TB_GETIMAGELIST";
5453 case WM_USER+50: return "TB_LOADIMAGES";
5454 case WM_USER+51: return "TB_GETRECT";
5455 case WM_USER+52: return "TB_SETHOTIMAGELIST";
5456 case WM_USER+53: return "TB_GETHOTIMAGELIST";
5457 case WM_USER+54: return "TB_SETDISABLEDIMAGELIST";
5458 case WM_USER+55: return "TB_GETDISABLEDIMAGELIST";
5459 case WM_USER+56: return "TB_SETSTYLE";
5460 case WM_USER+57: return "TB_GETSTYLE";
5461 case WM_USER+58: return "TB_GETBUTTONSIZE";
5462 case WM_USER+59: return "TB_SETBUTTONWIDTH";
5463 case WM_USER+60: return "TB_SETMAXTEXTROWS";
5464 case WM_USER+61: return "TB_GETTEXTROWS";
5465 case WM_USER+41: return "TB_GETBITMAPFLAGS";
5466
5467 default:
5468 static char s_szBuf[128];
5469 sprintf(s_szBuf, "<unknown message = %d>", message);
5470 return s_szBuf;
5471 }
5472 }
5473 #endif //__WXDEBUG__
5474
5475 static void TranslateKbdEventToMouse(wxWindowMSW *win,
5476 int *x, int *y, WPARAM *flags)
5477 {
5478 // construct the key mask
5479 WPARAM& fwKeys = *flags;
5480
5481 fwKeys = MK_RBUTTON;
5482 if ( wxIsCtrlDown() )
5483 fwKeys |= MK_CONTROL;
5484 if ( wxIsShiftDown() )
5485 fwKeys |= MK_SHIFT;
5486
5487 // simulate right mouse button click
5488 DWORD dwPos = ::GetMessagePos();
5489 *x = GET_X_LPARAM(dwPos);
5490 *y = GET_Y_LPARAM(dwPos);
5491
5492 win->ScreenToClient(x, y);
5493 }
5494
5495 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
5496 {
5497 // prepare the DC
5498 TEXTMETRIC tm;
5499 HWND hwnd = GetHwndOf(win);
5500 HDC hdc = ::GetDC(hwnd);
5501
5502 #if !wxDIALOG_UNIT_COMPATIBILITY
5503 // and select the current font into it
5504 HFONT hfont = GetHfontOf(win->GetFont());
5505 if ( hfont )
5506 {
5507 hfont = (HFONT)::SelectObject(hdc, hfont);
5508 }
5509 #endif
5510
5511 // finally retrieve the text metrics from it
5512 GetTextMetrics(hdc, &tm);
5513
5514 #if !wxDIALOG_UNIT_COMPATIBILITY
5515 // and clean up
5516 if ( hfont )
5517 {
5518 (void)::SelectObject(hdc, hfont);
5519 }
5520 #endif
5521
5522 ::ReleaseDC(hwnd, hdc);
5523
5524 return tm;
5525 }
5526
5527 // Find the wxWindow at the current mouse position, returning the mouse
5528 // position.
5529 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
5530 {
5531 pt = wxGetMousePosition();
5532 return wxFindWindowAtPoint(pt);
5533 }
5534
5535 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
5536 {
5537 POINT pt2;
5538 pt2.x = pt.x;
5539 pt2.y = pt.y;
5540 HWND hWndHit = ::WindowFromPoint(pt2);
5541
5542 wxWindow* win = wxFindWinFromHandle((WXHWND) hWndHit) ;
5543 HWND hWnd = hWndHit;
5544
5545 // Try to find a window with a wxWindow associated with it
5546 while (!win && (hWnd != 0))
5547 {
5548 hWnd = ::GetParent(hWnd);
5549 win = wxFindWinFromHandle((WXHWND) hWnd) ;
5550 }
5551 return win;
5552 }
5553
5554 // Get the current mouse position.
5555 wxPoint wxGetMousePosition()
5556 {
5557 POINT pt;
5558 GetCursorPos( & pt );
5559
5560 return wxPoint(pt.x, pt.y);
5561 }
5562
5563 #if wxUSE_HOTKEY
5564
5565 bool wxWindowMSW::RegisterHotKey(int hotkeyId, int modifiers, int keycode)
5566 {
5567 UINT win_modifiers=0;
5568 if ( modifiers & wxMOD_ALT )
5569 win_modifiers |= MOD_ALT;
5570 if ( modifiers & wxMOD_SHIFT )
5571 win_modifiers |= MOD_SHIFT;
5572 if ( modifiers & wxMOD_CONTROL )
5573 win_modifiers |= MOD_CONTROL;
5574 if ( modifiers & wxMOD_WIN )
5575 win_modifiers |= MOD_WIN;
5576
5577 if ( !::RegisterHotKey(GetHwnd(), hotkeyId, win_modifiers, keycode) )
5578 {
5579 wxLogLastError(_T("RegisterHotKey"));
5580
5581 return FALSE;
5582 }
5583
5584 return TRUE;
5585 }
5586
5587 bool wxWindowMSW::UnregisterHotKey(int hotkeyId)
5588 {
5589 if ( !::UnregisterHotKey(GetHwnd(), hotkeyId) )
5590 {
5591 wxLogLastError(_T("UnregisterHotKey"));
5592
5593 return FALSE;
5594 }
5595
5596 return TRUE;
5597 }
5598
5599 bool wxWindowMSW::HandleHotKey(WXWPARAM wParam, WXLPARAM lParam)
5600 {
5601 int hotkeyId = wParam;
5602 int virtualKey = HIWORD(lParam);
5603 int win_modifiers = LOWORD(lParam);
5604
5605 wxKeyEvent event(CreateKeyEvent(wxEVT_HOTKEY, virtualKey, wParam, lParam));
5606 event.SetId(hotkeyId);
5607 event.m_shiftDown = (win_modifiers & MOD_SHIFT) != 0;
5608 event.m_controlDown = (win_modifiers & MOD_CONTROL) != 0;
5609 event.m_altDown = (win_modifiers & MOD_ALT) != 0;
5610 event.m_metaDown = (win_modifiers & MOD_WIN) != 0;
5611
5612 return GetEventHandler()->ProcessEvent(event);
5613 }
5614
5615 #endif // wxUSE_HOTKEY
5616