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