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


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