]> git.saurik.com Git - wxWidgets.git/blob - src/msw/window.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixed bug introduced earlier today in wxTempFile::Open()
[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 if ( cmd == 0 || cmd == 1 ) // menu or accel - use id
3540 {
3541 // must cast to a signed type before comparing with other ids!
3542 win = FindItem((signed short)id);
3543 }
3544
3545 if ( !win && control )
3546 {
3547 // find it from HWND - this works even with the broken programs using
3548 // the same ids for different controls
3549 win = wxFindWinFromHandle(control);
3550 }
3551
3552 if ( win )
3553 {
3554 return win->MSWCommand(cmd, id);
3555 }
3556
3557 // the messages sent from the in-place edit control used by the treectrl
3558 // for label editing have id == 0, but they should _not_ be treated as menu
3559 // messages (they are EN_XXX ones, in fact) so don't translate anything
3560 // coming from a control to wxEVT_COMMAND_MENU_SELECTED
3561 if ( !control )
3562 {
3563 // If no child window, it may be an accelerator, e.g. for a popup menu
3564 // command
3565
3566 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
3567 event.SetEventObject(this);
3568 event.SetId(id);
3569 event.SetInt(id);
3570
3571 return GetEventHandler()->ProcessEvent(event);
3572 }
3573 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
3574 else
3575 {
3576 // the text ctrl which is logically part of wxSpinCtrl sends WM_COMMAND
3577 // notifications to its parent which we want to reflect back to
3578 // wxSpinCtrl
3579 wxSpinCtrl *spin = wxSpinCtrl::GetSpinForTextCtrl(control);
3580 if ( spin && spin->ProcessTextCommand(cmd, id) )
3581 return TRUE;
3582 }
3583 #endif // wxUSE_SPINCTRL
3584
3585 return FALSE;
3586 }
3587
3588 bool wxWindowMSW::HandleSysCommand(WXWPARAM wParam, WXLPARAM WXUNUSED(lParam))
3589 {
3590 // 4 bits are reserved
3591 switch ( wParam & 0xFFFFFFF0 )
3592 {
3593 case SC_MAXIMIZE:
3594 return HandleMaximize();
3595
3596 case SC_MINIMIZE:
3597 return HandleMinimize();
3598 }
3599
3600 return FALSE;
3601 }
3602
3603 // ---------------------------------------------------------------------------
3604 // mouse events
3605 // ---------------------------------------------------------------------------
3606
3607 void wxWindowMSW::InitMouseEvent(wxMouseEvent& event,
3608 int x, int y,
3609 WXUINT flags)
3610 {
3611 // our client coords are not quite the same as Windows ones
3612 wxPoint pt = GetClientAreaOrigin();
3613 event.m_x = x - pt.x;
3614 event.m_y = y - pt.y;
3615
3616 event.m_shiftDown = (flags & MK_SHIFT) != 0;
3617 event.m_controlDown = (flags & MK_CONTROL) != 0;
3618 event.m_leftDown = (flags & MK_LBUTTON) != 0;
3619 event.m_middleDown = (flags & MK_MBUTTON) != 0;
3620 event.m_rightDown = (flags & MK_RBUTTON) != 0;
3621 event.m_altDown = (::GetKeyState(VK_MENU) & 0x80000000) != 0;
3622
3623 event.SetTimestamp(s_currentMsg.time);
3624 event.m_eventObject = this;
3625
3626 #if wxUSE_MOUSEEVENT_HACK
3627 m_lastMouseX = x;
3628 m_lastMouseY = y;
3629 m_lastMouseEvent = event.GetEventType();
3630 #endif // wxUSE_MOUSEEVENT_HACK
3631 }
3632
3633 bool wxWindowMSW::HandleMouseEvent(WXUINT msg, int x, int y, WXUINT flags)
3634 {
3635 // the mouse events take consecutive IDs from WM_MOUSEFIRST to
3636 // WM_MOUSELAST, so it's enough to substract WM_MOUSEMOVE == WM_MOUSEFIRST
3637 // from the message id and take the value in the table to get wxWin event
3638 // id
3639 static const wxEventType eventsMouse[] =
3640 {
3641 wxEVT_MOTION,
3642 wxEVT_LEFT_DOWN,
3643 wxEVT_LEFT_UP,
3644 wxEVT_LEFT_DCLICK,
3645 wxEVT_RIGHT_DOWN,
3646 wxEVT_RIGHT_UP,
3647 wxEVT_RIGHT_DCLICK,
3648 wxEVT_MIDDLE_DOWN,
3649 wxEVT_MIDDLE_UP,
3650 wxEVT_MIDDLE_DCLICK
3651 };
3652
3653 wxMouseEvent event(eventsMouse[msg - WM_MOUSEMOVE]);
3654 InitMouseEvent(event, x, y, flags);
3655
3656 return GetEventHandler()->ProcessEvent(event);
3657 }
3658
3659 bool wxWindowMSW::HandleMouseMove(int x, int y, WXUINT flags)
3660 {
3661 if ( !m_mouseInWindow )
3662 {
3663 // it would be wrong to assume that just because we get a mouse move
3664 // event that the mouse is inside the window: although this is usually
3665 // true, it is not if we had captured the mouse, so we need to check
3666 // the mouse coordinates here
3667 if ( !HasCapture() || IsMouseInWindow() )
3668 {
3669 // Generate an ENTER event
3670 m_mouseInWindow = TRUE;
3671
3672 wxMouseEvent event(wxEVT_ENTER_WINDOW);
3673 InitMouseEvent(event, x, y, flags);
3674
3675 (void)GetEventHandler()->ProcessEvent(event);
3676 }
3677 }
3678
3679 #if wxUSE_MOUSEEVENT_HACK
3680 // Window gets a click down message followed by a mouse move message even
3681 // if position isn't changed! We want to discard the trailing move event
3682 // if x and y are the same.
3683 if ( (m_lastMouseEvent == wxEVT_RIGHT_DOWN ||
3684 m_lastMouseEvent == wxEVT_LEFT_DOWN ||
3685 m_lastMouseEvent == wxEVT_MIDDLE_DOWN) &&
3686 (m_lastMouseX == x && m_lastMouseY == y) )
3687 {
3688 m_lastMouseEvent = wxEVT_MOTION;
3689
3690 return FALSE;
3691 }
3692 #endif // wxUSE_MOUSEEVENT_HACK
3693
3694 return HandleMouseEvent(WM_MOUSEMOVE, x, y, flags);
3695 }
3696
3697
3698 bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
3699 {
3700 #if wxUSE_MOUSEWHEEL
3701 wxMouseEvent event(wxEVT_MOUSEWHEEL);
3702 InitMouseEvent(event,
3703 GET_X_LPARAM(lParam),
3704 GET_Y_LPARAM(lParam),
3705 LOWORD(wParam));
3706 event.m_wheelRotation = (short)HIWORD(wParam);
3707 event.m_wheelDelta = WHEEL_DELTA;
3708
3709 #ifdef __WIN32__
3710 static int s_linesPerRotation = -1;
3711 if ( s_linesPerRotation == -1 )
3712 {
3713 if ( !::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0,
3714 &s_linesPerRotation, 0))
3715 {
3716 // this is not supposed to happen
3717 wxLogLastError(_T("SystemParametersInfo(GETWHEELSCROLLLINES)"));
3718
3719 // the default is 3, so use it if SystemParametersInfo() failed
3720 s_linesPerRotation = 3;
3721 }
3722 }
3723 #else // Win16
3724 // no SystemParametersInfo() under Win16
3725 static const int s_linesPerRotation = 3;
3726 #endif
3727
3728 event.m_linesPerAction = s_linesPerRotation;
3729 return GetEventHandler()->ProcessEvent(event);
3730
3731 #else
3732 (void) wParam;
3733 (void) lParam;
3734
3735 return FALSE;
3736 #endif
3737 }
3738
3739
3740 // ---------------------------------------------------------------------------
3741 // keyboard handling
3742 // ---------------------------------------------------------------------------
3743
3744 // create the key event of the given type for the given key - used by
3745 // HandleChar and HandleKeyDown/Up
3746 wxKeyEvent wxWindowMSW::CreateKeyEvent(wxEventType evType,
3747 int id,
3748 WXLPARAM lParam) const
3749 {
3750 wxKeyEvent event(evType);
3751 event.SetId(GetId());
3752 event.m_shiftDown = wxIsShiftDown();
3753 event.m_controlDown = wxIsCtrlDown();
3754 event.m_altDown = (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN;
3755
3756 event.m_eventObject = (wxWindow *)this; // const_cast
3757 event.m_keyCode = id;
3758 event.SetTimestamp(s_currentMsg.time);
3759
3760 // translate the position to client coords
3761 POINT pt;
3762 GetCursorPos(&pt);
3763 RECT rect;
3764 GetWindowRect(GetHwnd(),&rect);
3765 pt.x -= rect.left;
3766 pt.y -= rect.top;
3767
3768 event.m_x = pt.x;
3769 event.m_y = pt.y;
3770
3771 return event;
3772 }
3773
3774 // isASCII is TRUE only when we're called from WM_CHAR handler and not from
3775 // WM_KEYDOWN one
3776 bool wxWindowMSW::HandleChar(WXWPARAM wParam, WXLPARAM lParam, bool isASCII)
3777 {
3778 bool ctrlDown = FALSE;
3779
3780 int id;
3781 if ( isASCII )
3782 {
3783 // If 1 -> 26, translate to CTRL plus a letter.
3784 id = wParam;
3785 if ( (id > 0) && (id < 27) )
3786 {
3787 switch (id)
3788 {
3789 case 13:
3790 id = WXK_RETURN;
3791 break;
3792
3793 case 8:
3794 id = WXK_BACK;
3795 break;
3796
3797 case 9:
3798 id = WXK_TAB;
3799 break;
3800
3801 default:
3802 ctrlDown = TRUE;
3803 id = id + 96;
3804 }
3805 }
3806 }
3807 else if ( (id = wxCharCodeMSWToWX(wParam)) == 0 )
3808 {
3809 // it's ASCII and will be processed here only when called from
3810 // WM_CHAR (i.e. when isASCII = TRUE), don't process it now
3811 id = -1;
3812 }
3813
3814 if ( id != -1 )
3815 {
3816 wxKeyEvent event(CreateKeyEvent(wxEVT_CHAR, id, lParam));
3817 if ( ctrlDown )
3818 {
3819 event.m_controlDown = TRUE;
3820 }
3821
3822 if ( GetEventHandler()->ProcessEvent(event) )
3823 return TRUE;
3824 }
3825
3826 return FALSE;
3827 }
3828
3829 bool wxWindowMSW::HandleKeyDown(WXWPARAM wParam, WXLPARAM lParam)
3830 {
3831 int id = wxCharCodeMSWToWX(wParam);
3832
3833 if ( !id )
3834 {
3835 // normal ASCII char
3836 id = wParam;
3837 }
3838
3839 if ( id != -1 ) // VZ: does this ever happen (FIXME)?
3840 {
3841 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_DOWN, id, lParam));
3842 if ( GetEventHandler()->ProcessEvent(event) )
3843 {
3844 return TRUE;
3845 }
3846 }
3847
3848 return FALSE;
3849 }
3850
3851 bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
3852 {
3853 int id = wxCharCodeMSWToWX(wParam);
3854
3855 if ( !id )
3856 {
3857 // normal ASCII char
3858 id = wParam;
3859 }
3860
3861 if ( id != -1 ) // VZ: does this ever happen (FIXME)?
3862 {
3863 wxKeyEvent event(CreateKeyEvent(wxEVT_KEY_UP, id, lParam));
3864 if ( GetEventHandler()->ProcessEvent(event) )
3865 return TRUE;
3866 }
3867
3868 return FALSE;
3869 }
3870
3871 // ---------------------------------------------------------------------------
3872 // joystick
3873 // ---------------------------------------------------------------------------
3874
3875 bool wxWindowMSW::HandleJoystickEvent(WXUINT msg, int x, int y, WXUINT flags)
3876 {
3877 #ifdef JOY_BUTTON1
3878 int change = 0;
3879 if ( flags & JOY_BUTTON1CHG )
3880 change = wxJOY_BUTTON1;
3881 if ( flags & JOY_BUTTON2CHG )
3882 change = wxJOY_BUTTON2;
3883 if ( flags & JOY_BUTTON3CHG )
3884 change = wxJOY_BUTTON3;
3885 if ( flags & JOY_BUTTON4CHG )
3886 change = wxJOY_BUTTON4;
3887
3888 int buttons = 0;
3889 if ( flags & JOY_BUTTON1 )
3890 buttons |= wxJOY_BUTTON1;
3891 if ( flags & JOY_BUTTON2 )
3892 buttons |= wxJOY_BUTTON2;
3893 if ( flags & JOY_BUTTON3 )
3894 buttons |= wxJOY_BUTTON3;
3895 if ( flags & JOY_BUTTON4 )
3896 buttons |= wxJOY_BUTTON4;
3897
3898 // the event ids aren't consecutive so we can't use table based lookup
3899 int joystick;
3900 wxEventType eventType;
3901 switch ( msg )
3902 {
3903 case MM_JOY1MOVE:
3904 joystick = 1;
3905 eventType = wxEVT_JOY_MOVE;
3906 break;
3907
3908 case MM_JOY2MOVE:
3909 joystick = 2;
3910 eventType = wxEVT_JOY_MOVE;
3911 break;
3912
3913 case MM_JOY1ZMOVE:
3914 joystick = 1;
3915 eventType = wxEVT_JOY_ZMOVE;
3916 break;
3917
3918 case MM_JOY2ZMOVE:
3919 joystick = 2;
3920 eventType = wxEVT_JOY_ZMOVE;
3921 break;
3922
3923 case MM_JOY1BUTTONDOWN:
3924 joystick = 1;
3925 eventType = wxEVT_JOY_BUTTON_DOWN;
3926 break;
3927
3928 case MM_JOY2BUTTONDOWN:
3929 joystick = 2;
3930 eventType = wxEVT_JOY_BUTTON_DOWN;
3931 break;
3932
3933 case MM_JOY1BUTTONUP:
3934 joystick = 1;
3935 eventType = wxEVT_JOY_BUTTON_UP;
3936 break;
3937
3938 case MM_JOY2BUTTONUP:
3939 joystick = 2;
3940 eventType = wxEVT_JOY_BUTTON_UP;
3941 break;
3942
3943 default:
3944 wxFAIL_MSG(wxT("no such joystick event"));
3945
3946 return FALSE;
3947 }
3948
3949 wxJoystickEvent event(eventType, buttons, joystick, change);
3950 event.SetPosition(wxPoint(x, y));
3951 event.SetEventObject(this);
3952
3953 return GetEventHandler()->ProcessEvent(event);
3954 #else
3955 return FALSE;
3956 #endif
3957 }
3958
3959 // ---------------------------------------------------------------------------
3960 // scrolling
3961 // ---------------------------------------------------------------------------
3962
3963 bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
3964 WXWORD pos, WXHWND control)
3965 {
3966 if ( control )
3967 {
3968 wxWindow *child = wxFindWinFromHandle(control);
3969 if ( child )
3970 return child->MSWOnScroll(orientation, wParam, pos, control);
3971 }
3972
3973 wxScrollWinEvent event;
3974 event.SetPosition(pos);
3975 event.SetOrientation(orientation);
3976 event.m_eventObject = this;
3977
3978 switch ( wParam )
3979 {
3980 case SB_TOP:
3981 event.m_eventType = wxEVT_SCROLLWIN_TOP;
3982 break;
3983
3984 case SB_BOTTOM:
3985 event.m_eventType = wxEVT_SCROLLWIN_BOTTOM;
3986 break;
3987
3988 case SB_LINEUP:
3989 event.m_eventType = wxEVT_SCROLLWIN_LINEUP;
3990 break;
3991
3992 case SB_LINEDOWN:
3993 event.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
3994 break;
3995
3996 case SB_PAGEUP:
3997 event.m_eventType = wxEVT_SCROLLWIN_PAGEUP;
3998 break;
3999
4000 case SB_PAGEDOWN:
4001 event.m_eventType = wxEVT_SCROLLWIN_PAGEDOWN;
4002 break;
4003
4004 case SB_THUMBPOSITION:
4005 case SB_THUMBTRACK:
4006 #ifdef __WIN32__
4007 // under Win32, the scrollbar range and position are 32 bit integers,
4008 // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
4009 // explicitly query the scrollbar for the correct position (this must
4010 // be done only for these two SB_ events as they are the only one
4011 // carrying the scrollbar position)
4012 {
4013 SCROLLINFO scrollInfo;
4014 wxZeroMemory(scrollInfo);
4015 scrollInfo.cbSize = sizeof(SCROLLINFO);
4016 scrollInfo.fMask = SIF_TRACKPOS;
4017
4018 if ( !::GetScrollInfo(GetHwnd(),
4019 orientation == wxHORIZONTAL ? SB_HORZ
4020 : SB_VERT,
4021 &scrollInfo) )
4022 {
4023 wxLogLastError(_T("GetScrollInfo"));
4024 }
4025
4026 event.SetPosition(scrollInfo.nTrackPos);
4027 }
4028 #endif // Win32
4029
4030 event.m_eventType = wParam == SB_THUMBPOSITION
4031 ? wxEVT_SCROLLWIN_THUMBRELEASE
4032 : wxEVT_SCROLLWIN_THUMBTRACK;
4033 break;
4034
4035 default:
4036 return FALSE;
4037 }
4038
4039 return GetEventHandler()->ProcessEvent(event);
4040 }
4041
4042 // ===========================================================================
4043 // global functions
4044 // ===========================================================================
4045
4046 void wxGetCharSize(WXHWND wnd, int *x, int *y, const wxFont *the_font)
4047 {
4048 TEXTMETRIC tm;
4049 HDC dc = ::GetDC((HWND) wnd);
4050 HFONT fnt =0;
4051 HFONT was = 0;
4052 if ( the_font )
4053 {
4054 // the_font->UseResource();
4055 // the_font->RealizeResource();
4056 fnt = (HFONT)((wxFont *)the_font)->GetResourceHandle(); // const_cast
4057 if ( fnt )
4058 was = (HFONT) SelectObject(dc,fnt);
4059 }
4060 GetTextMetrics(dc, &tm);
4061 if ( the_font && fnt && was )
4062 {
4063 SelectObject(dc,was);
4064 }
4065 ReleaseDC((HWND)wnd, dc);
4066
4067 if ( x )
4068 *x = tm.tmAveCharWidth;
4069 if ( y )
4070 *y = tm.tmHeight + tm.tmExternalLeading;
4071
4072 // if ( the_font )
4073 // the_font->ReleaseResource();
4074 }
4075
4076 // Returns 0 if was a normal ASCII value, not a special key. This indicates that
4077 // the key should be ignored by WM_KEYDOWN and processed by WM_CHAR instead.
4078 int wxCharCodeMSWToWX(int keySym)
4079 {
4080 int id;
4081 switch (keySym)
4082 {
4083 case VK_CANCEL: id = WXK_CANCEL; break;
4084 case VK_BACK: id = WXK_BACK; break;
4085 case VK_TAB: id = WXK_TAB; break;
4086 case VK_CLEAR: id = WXK_CLEAR; break;
4087 case VK_RETURN: id = WXK_RETURN; break;
4088 case VK_SHIFT: id = WXK_SHIFT; break;
4089 case VK_CONTROL: id = WXK_CONTROL; break;
4090 case VK_MENU : id = WXK_MENU; break;
4091 case VK_PAUSE: id = WXK_PAUSE; break;
4092 case VK_SPACE: id = WXK_SPACE; break;
4093 case VK_ESCAPE: id = WXK_ESCAPE; break;
4094 case VK_PRIOR: id = WXK_PRIOR; break;
4095 case VK_NEXT : id = WXK_NEXT; break;
4096 case VK_END: id = WXK_END; break;
4097 case VK_HOME : id = WXK_HOME; break;
4098 case VK_LEFT : id = WXK_LEFT; break;
4099 case VK_UP: id = WXK_UP; break;
4100 case VK_RIGHT: id = WXK_RIGHT; break;
4101 case VK_DOWN : id = WXK_DOWN; break;
4102 case VK_SELECT: id = WXK_SELECT; break;
4103 case VK_PRINT: id = WXK_PRINT; break;
4104 case VK_EXECUTE: id = WXK_EXECUTE; break;
4105 case VK_INSERT: id = WXK_INSERT; break;
4106 case VK_DELETE: id = WXK_DELETE; break;
4107 case VK_HELP : id = WXK_HELP; break;
4108 case VK_NUMPAD0: id = WXK_NUMPAD0; break;
4109 case VK_NUMPAD1: id = WXK_NUMPAD1; break;
4110 case VK_NUMPAD2: id = WXK_NUMPAD2; break;
4111 case VK_NUMPAD3: id = WXK_NUMPAD3; break;
4112 case VK_NUMPAD4: id = WXK_NUMPAD4; break;
4113 case VK_NUMPAD5: id = WXK_NUMPAD5; break;
4114 case VK_NUMPAD6: id = WXK_NUMPAD6; break;
4115 case VK_NUMPAD7: id = WXK_NUMPAD7; break;
4116 case VK_NUMPAD8: id = WXK_NUMPAD8; break;
4117 case VK_NUMPAD9: id = WXK_NUMPAD9; break;
4118 case VK_MULTIPLY: id = WXK_NUMPAD_MULTIPLY; break;
4119 case VK_ADD: id = WXK_NUMPAD_ADD; break;
4120 case VK_SUBTRACT: id = WXK_NUMPAD_SUBTRACT; break;
4121 case VK_DECIMAL: id = WXK_NUMPAD_DECIMAL; break;
4122 case VK_DIVIDE: id = WXK_NUMPAD_DIVIDE; break;
4123 case VK_F1: id = WXK_F1; break;
4124 case VK_F2: id = WXK_F2; break;
4125 case VK_F3: id = WXK_F3; break;
4126 case VK_F4: id = WXK_F4; break;
4127 case VK_F5: id = WXK_F5; break;
4128 case VK_F6: id = WXK_F6; break;
4129 case VK_F7: id = WXK_F7; break;
4130 case VK_F8: id = WXK_F8; break;
4131 case VK_F9: id = WXK_F9; break;
4132 case VK_F10: id = WXK_F10; break;
4133 case VK_F11: id = WXK_F11; break;
4134 case VK_F12: id = WXK_F12; break;
4135 case VK_F13: id = WXK_F13; break;
4136 case VK_F14: id = WXK_F14; break;
4137 case VK_F15: id = WXK_F15; break;
4138 case VK_F16: id = WXK_F16; break;
4139 case VK_F17: id = WXK_F17; break;
4140 case VK_F18: id = WXK_F18; break;
4141 case VK_F19: id = WXK_F19; break;
4142 case VK_F20: id = WXK_F20; break;
4143 case VK_F21: id = WXK_F21; break;
4144 case VK_F22: id = WXK_F22; break;
4145 case VK_F23: id = WXK_F23; break;
4146 case VK_F24: id = WXK_F24; break;
4147 case VK_NUMLOCK: id = WXK_NUMLOCK; break;
4148 case VK_SCROLL: id = WXK_SCROLL; break;
4149 default:
4150 id = 0;
4151 }
4152
4153 return id;
4154 }
4155
4156 int wxCharCodeWXToMSW(int id, bool *isVirtual)
4157 {
4158 *isVirtual = TRUE;
4159 int keySym = 0;
4160 switch (id)
4161 {
4162 case WXK_CANCEL: keySym = VK_CANCEL; break;
4163 case WXK_CLEAR: keySym = VK_CLEAR; break;
4164 case WXK_SHIFT: keySym = VK_SHIFT; break;
4165 case WXK_CONTROL: keySym = VK_CONTROL; break;
4166 case WXK_MENU : keySym = VK_MENU; break;
4167 case WXK_PAUSE: keySym = VK_PAUSE; break;
4168 case WXK_PRIOR: keySym = VK_PRIOR; break;
4169 case WXK_NEXT : keySym = VK_NEXT; break;
4170 case WXK_END: keySym = VK_END; break;
4171 case WXK_HOME : keySym = VK_HOME; break;
4172 case WXK_LEFT : keySym = VK_LEFT; break;
4173 case WXK_UP: keySym = VK_UP; break;
4174 case WXK_RIGHT: keySym = VK_RIGHT; break;
4175 case WXK_DOWN : keySym = VK_DOWN; break;
4176 case WXK_SELECT: keySym = VK_SELECT; break;
4177 case WXK_PRINT: keySym = VK_PRINT; break;
4178 case WXK_EXECUTE: keySym = VK_EXECUTE; break;
4179 case WXK_INSERT: keySym = VK_INSERT; break;
4180 case WXK_DELETE: keySym = VK_DELETE; break;
4181 case WXK_HELP : keySym = VK_HELP; break;
4182 case WXK_NUMPAD0: keySym = VK_NUMPAD0; break;
4183 case WXK_NUMPAD1: keySym = VK_NUMPAD1; break;
4184 case WXK_NUMPAD2: keySym = VK_NUMPAD2; break;
4185 case WXK_NUMPAD3: keySym = VK_NUMPAD3; break;
4186 case WXK_NUMPAD4: keySym = VK_NUMPAD4; break;
4187 case WXK_NUMPAD5: keySym = VK_NUMPAD5; break;
4188 case WXK_NUMPAD6: keySym = VK_NUMPAD6; break;
4189 case WXK_NUMPAD7: keySym = VK_NUMPAD7; break;
4190 case WXK_NUMPAD8: keySym = VK_NUMPAD8; break;
4191 case WXK_NUMPAD9: keySym = VK_NUMPAD9; break;
4192 case WXK_NUMPAD_MULTIPLY: keySym = VK_MULTIPLY; break;
4193 case WXK_NUMPAD_ADD: keySym = VK_ADD; break;
4194 case WXK_NUMPAD_SUBTRACT: keySym = VK_SUBTRACT; break;
4195 case WXK_NUMPAD_DECIMAL: keySym = VK_DECIMAL; break;
4196 case WXK_NUMPAD_DIVIDE: keySym = VK_DIVIDE; break;
4197 case WXK_F1: keySym = VK_F1; break;
4198 case WXK_F2: keySym = VK_F2; break;
4199 case WXK_F3: keySym = VK_F3; break;
4200 case WXK_F4: keySym = VK_F4; break;
4201 case WXK_F5: keySym = VK_F5; break;
4202 case WXK_F6: keySym = VK_F6; break;
4203 case WXK_F7: keySym = VK_F7; break;
4204 case WXK_F8: keySym = VK_F8; break;
4205 case WXK_F9: keySym = VK_F9; break;
4206 case WXK_F10: keySym = VK_F10; break;
4207 case WXK_F11: keySym = VK_F11; break;
4208 case WXK_F12: keySym = VK_F12; break;
4209 case WXK_F13: keySym = VK_F13; break;
4210 case WXK_F14: keySym = VK_F14; break;
4211 case WXK_F15: keySym = VK_F15; break;
4212 case WXK_F16: keySym = VK_F16; break;
4213 case WXK_F17: keySym = VK_F17; break;
4214 case WXK_F18: keySym = VK_F18; break;
4215 case WXK_F19: keySym = VK_F19; break;
4216 case WXK_F20: keySym = VK_F20; break;
4217 case WXK_F21: keySym = VK_F21; break;
4218 case WXK_F22: keySym = VK_F22; break;
4219 case WXK_F23: keySym = VK_F23; break;
4220 case WXK_F24: keySym = VK_F24; break;
4221 case WXK_NUMLOCK: keySym = VK_NUMLOCK; break;
4222 case WXK_SCROLL: keySym = VK_SCROLL; break;
4223 default:
4224 {
4225 *isVirtual = FALSE;
4226 keySym = id;
4227 break;
4228 }
4229 }
4230 return keySym;
4231 }
4232
4233 wxWindow *wxGetActiveWindow()
4234 {
4235 HWND hWnd = GetActiveWindow();
4236 if ( hWnd != 0 )
4237 {
4238 return wxFindWinFromHandle((WXHWND) hWnd);
4239 }
4240 return NULL;
4241 }
4242
4243 extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
4244 {
4245 HWND hwnd = (HWND)hWnd;
4246
4247 // For a radiobutton, we get the radiobox from GWL_USERDATA (which is set
4248 // by code in msw/radiobox.cpp), for all the others we just search up the
4249 // window hierarchy
4250 wxWindow *win = (wxWindow *)NULL;
4251 if ( hwnd )
4252 {
4253 win = wxFindWinFromHandle((WXHWND)hwnd);
4254 if ( !win )
4255 {
4256 // all these hacks only work under Win32 anyhow
4257 #ifdef __WIN32__
4258
4259 #if wxUSE_RADIOBOX
4260 // native radiobuttons return DLGC_RADIOBUTTON here and for any
4261 // wxWindow class which overrides WM_GETDLGCODE processing to
4262 // do it as well, win would be already non NULL
4263 if ( ::SendMessage(hwnd, WM_GETDLGCODE, 0, 0) & DLGC_RADIOBUTTON )
4264 {
4265 win = (wxWindow *)::GetWindowLong(hwnd, GWL_USERDATA);
4266 }
4267 //else: it's a wxRadioButton, not a radiobutton from wxRadioBox
4268 #endif // wxUSE_RADIOBOX
4269
4270 // spin control text buddy window should be mapped to spin ctrl
4271 // itself so try it too
4272 #if wxUSE_SPINCTRL && !defined(__WXUNIVERSAL__)
4273 if ( !win )
4274 {
4275 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
4276 }
4277 #endif // wxUSE_SPINCTRL
4278
4279 #endif // Win32
4280 }
4281 }
4282
4283 while ( hwnd && !win )
4284 {
4285 // this is a really ugly hack needed to avoid mistakenly returning the
4286 // parent frame wxWindow for the find/replace modeless dialog HWND -
4287 // this, in turn, is needed to call IsDialogMessage() from
4288 // wxApp::ProcessMessage() as for this we must return NULL from here
4289 //
4290 // FIXME: this is clearly not the best way to do it but I think we'll
4291 // need to change HWND <-> wxWindow code more heavily than I can
4292 // do it now to fix it
4293 #ifndef __WXMICROWIN__
4294 if ( ::GetWindow(hwnd, GW_OWNER) )
4295 {
4296 // it's a dialog box, don't go upwards
4297 break;
4298 }
4299 #endif
4300
4301 hwnd = ::GetParent(hwnd);
4302 win = wxFindWinFromHandle((WXHWND)hwnd);
4303 }
4304
4305 return win;
4306 }
4307
4308 #ifndef __WXMICROWIN__
4309
4310 // Windows keyboard hook. Allows interception of e.g. F1, ESCAPE
4311 // in active frames and dialogs, regardless of where the focus is.
4312 static HHOOK wxTheKeyboardHook = 0;
4313 static FARPROC wxTheKeyboardHookProc = 0;
4314 int APIENTRY _EXPORT
4315 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam);
4316
4317 void wxSetKeyboardHook(bool doIt)
4318 {
4319 if ( doIt )
4320 {
4321 wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
4322 wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
4323
4324 #if defined(__WIN32__) && !defined(__TWIN32__)
4325 GetCurrentThreadId()
4326 // (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
4327 #else
4328 GetCurrentTask()
4329 #endif
4330 );
4331 }
4332 else
4333 {
4334 UnhookWindowsHookEx(wxTheKeyboardHook);
4335
4336 // avoids warning about statement with no effect (FreeProcInstance
4337 // doesn't do anything under Win32)
4338 #if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32__) && !defined(__NT__) && !defined(__GNUWIN32__)
4339 FreeProcInstance(wxTheKeyboardHookProc);
4340 #endif
4341 }
4342 }
4343
4344 int APIENTRY _EXPORT
4345 wxKeyboardHook(int nCode, WORD wParam, DWORD lParam)
4346 {
4347 DWORD hiWord = HIWORD(lParam);
4348 if ( nCode != HC_NOREMOVE && ((hiWord & KF_UP) == 0) )
4349 {
4350 int id = wxCharCodeMSWToWX(wParam);
4351 if ( id != 0 )
4352 {
4353 wxKeyEvent event(wxEVT_CHAR_HOOK);
4354 if ( (HIWORD(lParam) & KF_ALTDOWN) == KF_ALTDOWN )
4355 event.m_altDown = TRUE;
4356
4357 event.m_eventObject = NULL;
4358 event.m_keyCode = id;
4359 event.m_shiftDown = wxIsShiftDown();
4360 event.m_controlDown = wxIsCtrlDown();
4361 event.SetTimestamp(s_currentMsg.time);
4362
4363 wxWindow *win = wxGetActiveWindow();
4364 wxEvtHandler *handler;
4365 if ( win )
4366 {
4367 handler = win->GetEventHandler();
4368 event.SetId(win->GetId());
4369 }
4370 else
4371 {
4372 handler = wxTheApp;
4373 event.SetId(-1);
4374 }
4375
4376 if ( handler && handler->ProcessEvent(event) )
4377 {
4378 // processed
4379 return 1;
4380 }
4381 }
4382 }
4383
4384 return (int)CallNextHookEx(wxTheKeyboardHook, nCode, wParam, lParam);
4385 }
4386
4387 #endif // !__WXMICROWIN__
4388
4389 #ifdef __WXDEBUG__
4390 const char *wxGetMessageName(int message)
4391 {
4392 switch ( message )
4393 {
4394 case 0x0000: return "WM_NULL";
4395 case 0x0001: return "WM_CREATE";
4396 case 0x0002: return "WM_DESTROY";
4397 case 0x0003: return "WM_MOVE";
4398 case 0x0005: return "WM_SIZE";
4399 case 0x0006: return "WM_ACTIVATE";
4400 case 0x0007: return "WM_SETFOCUS";
4401 case 0x0008: return "WM_KILLFOCUS";
4402 case 0x000A: return "WM_ENABLE";
4403 case 0x000B: return "WM_SETREDRAW";
4404 case 0x000C: return "WM_SETTEXT";
4405 case 0x000D: return "WM_GETTEXT";
4406 case 0x000E: return "WM_GETTEXTLENGTH";
4407 case 0x000F: return "WM_PAINT";
4408 case 0x0010: return "WM_CLOSE";
4409 case 0x0011: return "WM_QUERYENDSESSION";
4410 case 0x0012: return "WM_QUIT";
4411 case 0x0013: return "WM_QUERYOPEN";
4412 case 0x0014: return "WM_ERASEBKGND";
4413 case 0x0015: return "WM_SYSCOLORCHANGE";
4414 case 0x0016: return "WM_ENDSESSION";
4415 case 0x0017: return "WM_SYSTEMERROR";
4416 case 0x0018: return "WM_SHOWWINDOW";
4417 case 0x0019: return "WM_CTLCOLOR";
4418 case 0x001A: return "WM_WININICHANGE";
4419 case 0x001B: return "WM_DEVMODECHANGE";
4420 case 0x001C: return "WM_ACTIVATEAPP";
4421 case 0x001D: return "WM_FONTCHANGE";
4422 case 0x001E: return "WM_TIMECHANGE";
4423 case 0x001F: return "WM_CANCELMODE";
4424 case 0x0020: return "WM_SETCURSOR";
4425 case 0x0021: return "WM_MOUSEACTIVATE";
4426 case 0x0022: return "WM_CHILDACTIVATE";
4427 case 0x0023: return "WM_QUEUESYNC";
4428 case 0x0024: return "WM_GETMINMAXINFO";
4429 case 0x0026: return "WM_PAINTICON";
4430 case 0x0027: return "WM_ICONERASEBKGND";
4431 case 0x0028: return "WM_NEXTDLGCTL";
4432 case 0x002A: return "WM_SPOOLERSTATUS";
4433 case 0x002B: return "WM_DRAWITEM";
4434 case 0x002C: return "WM_MEASUREITEM";
4435 case 0x002D: return "WM_DELETEITEM";
4436 case 0x002E: return "WM_VKEYTOITEM";
4437 case 0x002F: return "WM_CHARTOITEM";
4438 case 0x0030: return "WM_SETFONT";
4439 case 0x0031: return "WM_GETFONT";
4440 case 0x0037: return "WM_QUERYDRAGICON";
4441 case 0x0039: return "WM_COMPAREITEM";
4442 case 0x0041: return "WM_COMPACTING";
4443 case 0x0044: return "WM_COMMNOTIFY";
4444 case 0x0046: return "WM_WINDOWPOSCHANGING";
4445 case 0x0047: return "WM_WINDOWPOSCHANGED";
4446 case 0x0048: return "WM_POWER";
4447
4448 #ifdef __WIN32__
4449 case 0x004A: return "WM_COPYDATA";
4450 case 0x004B: return "WM_CANCELJOURNAL";
4451 case 0x004E: return "WM_NOTIFY";
4452 case 0x0050: return "WM_INPUTLANGCHANGEREQUEST";
4453 case 0x0051: return "WM_INPUTLANGCHANGE";
4454 case 0x0052: return "WM_TCARD";
4455 case 0x0053: return "WM_HELP";
4456 case 0x0054: return "WM_USERCHANGED";
4457 case 0x0055: return "WM_NOTIFYFORMAT";
4458 case 0x007B: return "WM_CONTEXTMENU";
4459 case 0x007C: return "WM_STYLECHANGING";
4460 case 0x007D: return "WM_STYLECHANGED";
4461 case 0x007E: return "WM_DISPLAYCHANGE";
4462 case 0x007F: return "WM_GETICON";
4463 case 0x0080: return "WM_SETICON";
4464 #endif //WIN32
4465
4466 case 0x0081: return "WM_NCCREATE";
4467 case 0x0082: return "WM_NCDESTROY";
4468 case 0x0083: return "WM_NCCALCSIZE";
4469 case 0x0084: return "WM_NCHITTEST";
4470 case 0x0085: return "WM_NCPAINT";
4471 case 0x0086: return "WM_NCACTIVATE";
4472 case 0x0087: return "WM_GETDLGCODE";
4473 case 0x00A0: return "WM_NCMOUSEMOVE";
4474 case 0x00A1: return "WM_NCLBUTTONDOWN";
4475 case 0x00A2: return "WM_NCLBUTTONUP";
4476 case 0x00A3: return "WM_NCLBUTTONDBLCLK";
4477 case 0x00A4: return "WM_NCRBUTTONDOWN";
4478 case 0x00A5: return "WM_NCRBUTTONUP";
4479 case 0x00A6: return "WM_NCRBUTTONDBLCLK";
4480 case 0x00A7: return "WM_NCMBUTTONDOWN";
4481 case 0x00A8: return "WM_NCMBUTTONUP";
4482 case 0x00A9: return "WM_NCMBUTTONDBLCLK";
4483 case 0x0100: return "WM_KEYDOWN";
4484 case 0x0101: return "WM_KEYUP";
4485 case 0x0102: return "WM_CHAR";
4486 case 0x0103: return "WM_DEADCHAR";
4487 case 0x0104: return "WM_SYSKEYDOWN";
4488 case 0x0105: return "WM_SYSKEYUP";
4489 case 0x0106: return "WM_SYSCHAR";
4490 case 0x0107: return "WM_SYSDEADCHAR";
4491 case 0x0108: return "WM_KEYLAST";
4492
4493 #ifdef __WIN32__
4494 case 0x010D: return "WM_IME_STARTCOMPOSITION";
4495 case 0x010E: return "WM_IME_ENDCOMPOSITION";
4496 case 0x010F: return "WM_IME_COMPOSITION";
4497 #endif //WIN32
4498
4499 case 0x0110: return "WM_INITDIALOG";
4500 case 0x0111: return "WM_COMMAND";
4501 case 0x0112: return "WM_SYSCOMMAND";
4502 case 0x0113: return "WM_TIMER";
4503 case 0x0114: return "WM_HSCROLL";
4504 case 0x0115: return "WM_VSCROLL";
4505 case 0x0116: return "WM_INITMENU";
4506 case 0x0117: return "WM_INITMENUPOPUP";
4507 case 0x011F: return "WM_MENUSELECT";
4508 case 0x0120: return "WM_MENUCHAR";
4509 case 0x0121: return "WM_ENTERIDLE";
4510 case 0x0200: return "WM_MOUSEMOVE";
4511 case 0x0201: return "WM_LBUTTONDOWN";
4512 case 0x0202: return "WM_LBUTTONUP";
4513 case 0x0203: return "WM_LBUTTONDBLCLK";
4514 case 0x0204: return "WM_RBUTTONDOWN";
4515 case 0x0205: return "WM_RBUTTONUP";
4516 case 0x0206: return "WM_RBUTTONDBLCLK";
4517 case 0x0207: return "WM_MBUTTONDOWN";
4518 case 0x0208: return "WM_MBUTTONUP";
4519 case 0x0209: return "WM_MBUTTONDBLCLK";
4520 case 0x020A: return "WM_MOUSEWHEEL";
4521 case 0x0210: return "WM_PARENTNOTIFY";
4522 case 0x0211: return "WM_ENTERMENULOOP";
4523 case 0x0212: return "WM_EXITMENULOOP";
4524
4525 #ifdef __WIN32__
4526 case 0x0213: return "WM_NEXTMENU";
4527 case 0x0214: return "WM_SIZING";
4528 case 0x0215: return "WM_CAPTURECHANGED";
4529 case 0x0216: return "WM_MOVING";
4530 case 0x0218: return "WM_POWERBROADCAST";
4531 case 0x0219: return "WM_DEVICECHANGE";
4532 #endif //WIN32
4533
4534 case 0x0220: return "WM_MDICREATE";
4535 case 0x0221: return "WM_MDIDESTROY";
4536 case 0x0222: return "WM_MDIACTIVATE";
4537 case 0x0223: return "WM_MDIRESTORE";
4538 case 0x0224: return "WM_MDINEXT";
4539 case 0x0225: return "WM_MDIMAXIMIZE";
4540 case 0x0226: return "WM_MDITILE";
4541 case 0x0227: return "WM_MDICASCADE";
4542 case 0x0228: return "WM_MDIICONARRANGE";
4543 case 0x0229: return "WM_MDIGETACTIVE";
4544 case 0x0230: return "WM_MDISETMENU";
4545 case 0x0233: return "WM_DROPFILES";
4546
4547 #ifdef __WIN32__
4548 case 0x0281: return "WM_IME_SETCONTEXT";
4549 case 0x0282: return "WM_IME_NOTIFY";
4550 case 0x0283: return "WM_IME_CONTROL";
4551 case 0x0284: return "WM_IME_COMPOSITIONFULL";
4552 case 0x0285: return "WM_IME_SELECT";
4553 case 0x0286: return "WM_IME_CHAR";
4554 case 0x0290: return "WM_IME_KEYDOWN";
4555 case 0x0291: return "WM_IME_KEYUP";
4556 #endif //WIN32
4557
4558 case 0x0300: return "WM_CUT";
4559 case 0x0301: return "WM_COPY";
4560 case 0x0302: return "WM_PASTE";
4561 case 0x0303: return "WM_CLEAR";
4562 case 0x0304: return "WM_UNDO";
4563 case 0x0305: return "WM_RENDERFORMAT";
4564 case 0x0306: return "WM_RENDERALLFORMATS";
4565 case 0x0307: return "WM_DESTROYCLIPBOARD";
4566 case 0x0308: return "WM_DRAWCLIPBOARD";
4567 case 0x0309: return "WM_PAINTCLIPBOARD";
4568 case 0x030A: return "WM_VSCROLLCLIPBOARD";
4569 case 0x030B: return "WM_SIZECLIPBOARD";
4570 case 0x030C: return "WM_ASKCBFORMATNAME";
4571 case 0x030D: return "WM_CHANGECBCHAIN";
4572 case 0x030E: return "WM_HSCROLLCLIPBOARD";
4573 case 0x030F: return "WM_QUERYNEWPALETTE";
4574 case 0x0310: return "WM_PALETTEISCHANGING";
4575 case 0x0311: return "WM_PALETTECHANGED";
4576
4577 #ifdef __WIN32__
4578 // common controls messages - although they're not strictly speaking
4579 // standard, it's nice to decode them nevertheless
4580
4581 // listview
4582 case 0x1000 + 0: return "LVM_GETBKCOLOR";
4583 case 0x1000 + 1: return "LVM_SETBKCOLOR";
4584 case 0x1000 + 2: return "LVM_GETIMAGELIST";
4585 case 0x1000 + 3: return "LVM_SETIMAGELIST";
4586 case 0x1000 + 4: return "LVM_GETITEMCOUNT";
4587 case 0x1000 + 5: return "LVM_GETITEMA";
4588 case 0x1000 + 75: return "LVM_GETITEMW";
4589 case 0x1000 + 6: return "LVM_SETITEMA";
4590 case 0x1000 + 76: return "LVM_SETITEMW";
4591 case 0x1000 + 7: return "LVM_INSERTITEMA";
4592 case 0x1000 + 77: return "LVM_INSERTITEMW";
4593 case 0x1000 + 8: return "LVM_DELETEITEM";
4594 case 0x1000 + 9: return "LVM_DELETEALLITEMS";
4595 case 0x1000 + 10: return "LVM_GETCALLBACKMASK";
4596 case 0x1000 + 11: return "LVM_SETCALLBACKMASK";
4597 case 0x1000 + 12: return "LVM_GETNEXTITEM";
4598 case 0x1000 + 13: return "LVM_FINDITEMA";
4599 case 0x1000 + 83: return "LVM_FINDITEMW";
4600 case 0x1000 + 14: return "LVM_GETITEMRECT";
4601 case 0x1000 + 15: return "LVM_SETITEMPOSITION";
4602 case 0x1000 + 16: return "LVM_GETITEMPOSITION";
4603 case 0x1000 + 17: return "LVM_GETSTRINGWIDTHA";
4604 case 0x1000 + 87: return "LVM_GETSTRINGWIDTHW";
4605 case 0x1000 + 18: return "LVM_HITTEST";
4606 case 0x1000 + 19: return "LVM_ENSUREVISIBLE";
4607 case 0x1000 + 20: return "LVM_SCROLL";
4608 case 0x1000 + 21: return "LVM_REDRAWITEMS";
4609 case 0x1000 + 22: return "LVM_ARRANGE";
4610 case 0x1000 + 23: return "LVM_EDITLABELA";
4611 case 0x1000 + 118: return "LVM_EDITLABELW";
4612 case 0x1000 + 24: return "LVM_GETEDITCONTROL";
4613 case 0x1000 + 25: return "LVM_GETCOLUMNA";
4614 case 0x1000 + 95: return "LVM_GETCOLUMNW";
4615 case 0x1000 + 26: return "LVM_SETCOLUMNA";
4616 case 0x1000 + 96: return "LVM_SETCOLUMNW";
4617 case 0x1000 + 27: return "LVM_INSERTCOLUMNA";
4618 case 0x1000 + 97: return "LVM_INSERTCOLUMNW";
4619 case 0x1000 + 28: return "LVM_DELETECOLUMN";
4620 case 0x1000 + 29: return "LVM_GETCOLUMNWIDTH";
4621 case 0x1000 + 30: return "LVM_SETCOLUMNWIDTH";
4622 case 0x1000 + 31: return "LVM_GETHEADER";
4623 case 0x1000 + 33: return "LVM_CREATEDRAGIMAGE";
4624 case 0x1000 + 34: return "LVM_GETVIEWRECT";
4625 case 0x1000 + 35: return "LVM_GETTEXTCOLOR";
4626 case 0x1000 + 36: return "LVM_SETTEXTCOLOR";
4627 case 0x1000 + 37: return "LVM_GETTEXTBKCOLOR";
4628 case 0x1000 + 38: return "LVM_SETTEXTBKCOLOR";
4629 case 0x1000 + 39: return "LVM_GETTOPINDEX";
4630 case 0x1000 + 40: return "LVM_GETCOUNTPERPAGE";
4631 case 0x1000 + 41: return "LVM_GETORIGIN";
4632 case 0x1000 + 42: return "LVM_UPDATE";
4633 case 0x1000 + 43: return "LVM_SETITEMSTATE";
4634 case 0x1000 + 44: return "LVM_GETITEMSTATE";
4635 case 0x1000 + 45: return "LVM_GETITEMTEXTA";
4636 case 0x1000 + 115: return "LVM_GETITEMTEXTW";
4637 case 0x1000 + 46: return "LVM_SETITEMTEXTA";
4638 case 0x1000 + 116: return "LVM_SETITEMTEXTW";
4639 case 0x1000 + 47: return "LVM_SETITEMCOUNT";
4640 case 0x1000 + 48: return "LVM_SORTITEMS";
4641 case 0x1000 + 49: return "LVM_SETITEMPOSITION32";
4642 case 0x1000 + 50: return "LVM_GETSELECTEDCOUNT";
4643 case 0x1000 + 51: return "LVM_GETITEMSPACING";
4644 case 0x1000 + 52: return "LVM_GETISEARCHSTRINGA";
4645 case 0x1000 + 117: return "LVM_GETISEARCHSTRINGW";
4646 case 0x1000 + 53: return "LVM_SETICONSPACING";
4647 case 0x1000 + 54: return "LVM_SETEXTENDEDLISTVIEWSTYLE";
4648 case 0x1000 + 55: return "LVM_GETEXTENDEDLISTVIEWSTYLE";
4649 case 0x1000 + 56: return "LVM_GETSUBITEMRECT";
4650 case 0x1000 + 57: return "LVM_SUBITEMHITTEST";
4651 case 0x1000 + 58: return "LVM_SETCOLUMNORDERARRAY";
4652 case 0x1000 + 59: return "LVM_GETCOLUMNORDERARRAY";
4653 case 0x1000 + 60: return "LVM_SETHOTITEM";
4654 case 0x1000 + 61: return "LVM_GETHOTITEM";
4655 case 0x1000 + 62: return "LVM_SETHOTCURSOR";
4656 case 0x1000 + 63: return "LVM_GETHOTCURSOR";
4657 case 0x1000 + 64: return "LVM_APPROXIMATEVIEWRECT";
4658 case 0x1000 + 65: return "LVM_SETWORKAREA";
4659
4660 // tree view
4661 case 0x1100 + 0: return "TVM_INSERTITEMA";
4662 case 0x1100 + 50: return "TVM_INSERTITEMW";
4663 case 0x1100 + 1: return "TVM_DELETEITEM";
4664 case 0x1100 + 2: return "TVM_EXPAND";
4665 case 0x1100 + 4: return "TVM_GETITEMRECT";
4666 case 0x1100 + 5: return "TVM_GETCOUNT";
4667 case 0x1100 + 6: return "TVM_GETINDENT";
4668 case 0x1100 + 7: return "TVM_SETINDENT";
4669 case 0x1100 + 8: return "TVM_GETIMAGELIST";
4670 case 0x1100 + 9: return "TVM_SETIMAGELIST";
4671 case 0x1100 + 10: return "TVM_GETNEXTITEM";
4672 case 0x1100 + 11: return "TVM_SELECTITEM";
4673 case 0x1100 + 12: return "TVM_GETITEMA";
4674 case 0x1100 + 62: return "TVM_GETITEMW";
4675 case 0x1100 + 13: return "TVM_SETITEMA";
4676 case 0x1100 + 63: return "TVM_SETITEMW";
4677 case 0x1100 + 14: return "TVM_EDITLABELA";
4678 case 0x1100 + 65: return "TVM_EDITLABELW";
4679 case 0x1100 + 15: return "TVM_GETEDITCONTROL";
4680 case 0x1100 + 16: return "TVM_GETVISIBLECOUNT";
4681 case 0x1100 + 17: return "TVM_HITTEST";
4682 case 0x1100 + 18: return "TVM_CREATEDRAGIMAGE";
4683 case 0x1100 + 19: return "TVM_SORTCHILDREN";
4684 case 0x1100 + 20: return "TVM_ENSUREVISIBLE";
4685 case 0x1100 + 21: return "TVM_SORTCHILDRENCB";
4686 case 0x1100 + 22: return "TVM_ENDEDITLABELNOW";
4687 case 0x1100 + 23: return "TVM_GETISEARCHSTRINGA";
4688 case 0x1100 + 64: return "TVM_GETISEARCHSTRINGW";
4689 case 0x1100 + 24: return "TVM_SETTOOLTIPS";
4690 case 0x1100 + 25: return "TVM_GETTOOLTIPS";
4691
4692 // header
4693 case 0x1200 + 0: return "HDM_GETITEMCOUNT";
4694 case 0x1200 + 1: return "HDM_INSERTITEMA";
4695 case 0x1200 + 10: return "HDM_INSERTITEMW";
4696 case 0x1200 + 2: return "HDM_DELETEITEM";
4697 case 0x1200 + 3: return "HDM_GETITEMA";
4698 case 0x1200 + 11: return "HDM_GETITEMW";
4699 case 0x1200 + 4: return "HDM_SETITEMA";
4700 case 0x1200 + 12: return "HDM_SETITEMW";
4701 case 0x1200 + 5: return "HDM_LAYOUT";
4702 case 0x1200 + 6: return "HDM_HITTEST";
4703 case 0x1200 + 7: return "HDM_GETITEMRECT";
4704 case 0x1200 + 8: return "HDM_SETIMAGELIST";
4705 case 0x1200 + 9: return "HDM_GETIMAGELIST";
4706 case 0x1200 + 15: return "HDM_ORDERTOINDEX";
4707 case 0x1200 + 16: return "HDM_CREATEDRAGIMAGE";
4708 case 0x1200 + 17: return "HDM_GETORDERARRAY";
4709 case 0x1200 + 18: return "HDM_SETORDERARRAY";
4710 case 0x1200 + 19: return "HDM_SETHOTDIVIDER";
4711
4712 // tab control
4713 case 0x1300 + 2: return "TCM_GETIMAGELIST";
4714 case 0x1300 + 3: return "TCM_SETIMAGELIST";
4715 case 0x1300 + 4: return "TCM_GETITEMCOUNT";
4716 case 0x1300 + 5: return "TCM_GETITEMA";
4717 case 0x1300 + 60: return "TCM_GETITEMW";
4718 case 0x1300 + 6: return "TCM_SETITEMA";
4719 case 0x1300 + 61: return "TCM_SETITEMW";
4720 case 0x1300 + 7: return "TCM_INSERTITEMA";
4721 case 0x1300 + 62: return "TCM_INSERTITEMW";
4722 case 0x1300 + 8: return "TCM_DELETEITEM";
4723 case 0x1300 + 9: return "TCM_DELETEALLITEMS";
4724 case 0x1300 + 10: return "TCM_GETITEMRECT";
4725 case 0x1300 + 11: return "TCM_GETCURSEL";
4726 case 0x1300 + 12: return "TCM_SETCURSEL";
4727 case 0x1300 + 13: return "TCM_HITTEST";
4728 case 0x1300 + 14: return "TCM_SETITEMEXTRA";
4729 case 0x1300 + 40: return "TCM_ADJUSTRECT";
4730 case 0x1300 + 41: return "TCM_SETITEMSIZE";
4731 case 0x1300 + 42: return "TCM_REMOVEIMAGE";
4732 case 0x1300 + 43: return "TCM_SETPADDING";
4733 case 0x1300 + 44: return "TCM_GETROWCOUNT";
4734 case 0x1300 + 45: return "TCM_GETTOOLTIPS";
4735 case 0x1300 + 46: return "TCM_SETTOOLTIPS";
4736 case 0x1300 + 47: return "TCM_GETCURFOCUS";
4737 case 0x1300 + 48: return "TCM_SETCURFOCUS";
4738 case 0x1300 + 49: return "TCM_SETMINTABWIDTH";
4739 case 0x1300 + 50: return "TCM_DESELECTALL";
4740
4741 // toolbar
4742 case WM_USER+1: return "TB_ENABLEBUTTON";
4743 case WM_USER+2: return "TB_CHECKBUTTON";
4744 case WM_USER+3: return "TB_PRESSBUTTON";
4745 case WM_USER+4: return "TB_HIDEBUTTON";
4746 case WM_USER+5: return "TB_INDETERMINATE";
4747 case WM_USER+9: return "TB_ISBUTTONENABLED";
4748 case WM_USER+10: return "TB_ISBUTTONCHECKED";
4749 case WM_USER+11: return "TB_ISBUTTONPRESSED";
4750 case WM_USER+12: return "TB_ISBUTTONHIDDEN";
4751 case WM_USER+13: return "TB_ISBUTTONINDETERMINATE";
4752 case WM_USER+17: return "TB_SETSTATE";
4753 case WM_USER+18: return "TB_GETSTATE";
4754 case WM_USER+19: return "TB_ADDBITMAP";
4755 case WM_USER+20: return "TB_ADDBUTTONS";
4756 case WM_USER+21: return "TB_INSERTBUTTON";
4757 case WM_USER+22: return "TB_DELETEBUTTON";
4758 case WM_USER+23: return "TB_GETBUTTON";
4759 case WM_USER+24: return "TB_BUTTONCOUNT";
4760 case WM_USER+25: return "TB_COMMANDTOINDEX";
4761 case WM_USER+26: return "TB_SAVERESTOREA";
4762 case WM_USER+76: return "TB_SAVERESTOREW";
4763 case WM_USER+27: return "TB_CUSTOMIZE";
4764 case WM_USER+28: return "TB_ADDSTRINGA";
4765 case WM_USER+77: return "TB_ADDSTRINGW";
4766 case WM_USER+29: return "TB_GETITEMRECT";
4767 case WM_USER+30: return "TB_BUTTONSTRUCTSIZE";
4768 case WM_USER+31: return "TB_SETBUTTONSIZE";
4769 case WM_USER+32: return "TB_SETBITMAPSIZE";
4770 case WM_USER+33: return "TB_AUTOSIZE";
4771 case WM_USER+35: return "TB_GETTOOLTIPS";
4772 case WM_USER+36: return "TB_SETTOOLTIPS";
4773 case WM_USER+37: return "TB_SETPARENT";
4774 case WM_USER+39: return "TB_SETROWS";
4775 case WM_USER+40: return "TB_GETROWS";
4776 case WM_USER+42: return "TB_SETCMDID";
4777 case WM_USER+43: return "TB_CHANGEBITMAP";
4778 case WM_USER+44: return "TB_GETBITMAP";
4779 case WM_USER+45: return "TB_GETBUTTONTEXTA";
4780 case WM_USER+75: return "TB_GETBUTTONTEXTW";
4781 case WM_USER+46: return "TB_REPLACEBITMAP";
4782 case WM_USER+47: return "TB_SETINDENT";
4783 case WM_USER+48: return "TB_SETIMAGELIST";
4784 case WM_USER+49: return "TB_GETIMAGELIST";
4785 case WM_USER+50: return "TB_LOADIMAGES";
4786 case WM_USER+51: return "TB_GETRECT";
4787 case WM_USER+52: return "TB_SETHOTIMAGELIST";
4788 case WM_USER+53: return "TB_GETHOTIMAGELIST";
4789 case WM_USER+54: return "TB_SETDISABLEDIMAGELIST";
4790 case WM_USER+55: return "TB_GETDISABLEDIMAGELIST";
4791 case WM_USER+56: return "TB_SETSTYLE";
4792 case WM_USER+57: return "TB_GETSTYLE";
4793 case WM_USER+58: return "TB_GETBUTTONSIZE";
4794 case WM_USER+59: return "TB_SETBUTTONWIDTH";
4795 case WM_USER+60: return "TB_SETMAXTEXTROWS";
4796 case WM_USER+61: return "TB_GETTEXTROWS";
4797 case WM_USER+41: return "TB_GETBITMAPFLAGS";
4798
4799 #endif //WIN32
4800
4801 default:
4802 static char s_szBuf[128];
4803 sprintf(s_szBuf, "<unknown message = %d>", message);
4804 return s_szBuf;
4805 }
4806 }
4807 #endif //__WXDEBUG__
4808
4809 static void TranslateKbdEventToMouse(wxWindowMSW *win,
4810 int *x, int *y, WPARAM *flags)
4811 {
4812 // construct the key mask
4813 WPARAM& fwKeys = *flags;
4814
4815 fwKeys = MK_RBUTTON;
4816 if ( wxIsCtrlDown() )
4817 fwKeys |= MK_CONTROL;
4818 if ( wxIsShiftDown() )
4819 fwKeys |= MK_SHIFT;
4820
4821 // simulate right mouse button click
4822 DWORD dwPos = ::GetMessagePos();
4823 *x = GET_X_LPARAM(dwPos);
4824 *y = GET_Y_LPARAM(dwPos);
4825
4826 win->ScreenToClient(x, y);
4827 }
4828
4829 static TEXTMETRIC wxGetTextMetrics(const wxWindowMSW *win)
4830 {
4831 // prepare the DC
4832 TEXTMETRIC tm;
4833 HWND hwnd = GetHwndOf(win);
4834 HDC hdc = ::GetDC(hwnd);
4835
4836 #if !wxDIALOG_UNIT_COMPATIBILITY
4837 // and select the current font into it
4838 HFONT hfont = GetHfontOf(win->GetFont());
4839 if ( hfont )
4840 {
4841 hfont = (HFONT)::SelectObject(hdc, hfont);
4842 }
4843 #endif
4844
4845 // finally retrieve the text metrics from it
4846 GetTextMetrics(hdc, &tm);
4847
4848 #if !wxDIALOG_UNIT_COMPATIBILITY
4849 // and clean up
4850 if ( hfont )
4851 {
4852 (void)::SelectObject(hdc, hfont);
4853 }
4854 #endif
4855
4856 ::ReleaseDC(hwnd, hdc);
4857
4858 return tm;
4859 }
4860
4861 // Find the wxWindow at the current mouse position, returning the mouse
4862 // position.
4863 wxWindow* wxFindWindowAtPointer(wxPoint& WXUNUSED(pt))
4864 {
4865 return wxFindWindowAtPoint(wxGetMousePosition());
4866 }
4867
4868 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
4869 {
4870 POINT pt2;
4871 pt2.x = pt.x;
4872 pt2.y = pt.y;
4873 HWND hWndHit = ::WindowFromPoint(pt2);
4874
4875 wxWindow* win = wxFindWinFromHandle((WXHWND) hWndHit) ;
4876 HWND hWnd = hWndHit;
4877
4878 // Try to find a window with a wxWindow associated with it
4879 while (!win && (hWnd != 0))
4880 {
4881 hWnd = ::GetParent(hWnd);
4882 win = wxFindWinFromHandle((WXHWND) hWnd) ;
4883 }
4884 return win;
4885 }
4886
4887 // Get the current mouse position.
4888 wxPoint wxGetMousePosition()
4889 {
4890 POINT pt;
4891 GetCursorPos( & pt );
4892 return wxPoint(pt.x, pt.y);
4893 }
4894
wxWidgets (Impactor)