]> git.saurik.com Git - wxWidgets.git/blob - src/msw/window.cpp
projects / wxWidgets.git / blob
? search:


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