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