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


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